NUnit.Framework.Assert.IsInstanceOf(System.Type, object)

Here are the examples of the csharp api class NUnit.Framework.Assert.IsInstanceOf(System.Type, object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

115 Examples 7

1. Example

Project: ContinuousTests
Source File: TypeAssertTest.cs
View license
[Test]
		public void IsInstanceOf()
		{
            ApplicationException ex = new ApplicationException();

			Assert.IsInstanceOf(typeof(System.Exception), ex );
            Expect( ex, InstanceOf(typeof(Exception)));
#if CLR_2_0 || CLR_4_0
            Assert.IsInstanceOf<Exception>( ex );
#endif
		}

2. Example

Project: ContinuousTests
Source File: TypeAssertTest.cs
View license
[Test]
		public void IsInstanceOf()
		{
            ApplicationException ex = new ApplicationException();

			Assert.IsInstanceOf(typeof(System.Exception), ex );
            Expect( ex, InstanceOf(typeof(Exception)));
#if NET_2_0
            Assert.IsInstanceOf<Exception>( ex );
#endif
		}

3. Example

Project: ContinuousTests
Source File: TypeAssertTest.cs
View license
[Test]
		public void IsInstanceOf()
		{
            ApplicationException ex = new ApplicationException();

			Assert.IsInstanceOf(typeof(System.Exception), ex );
            Expect( ex, InstanceOf(typeof(Exception)));
#if NET_2_0
            Assert.IsInstanceOf<Exception>( ex );
#endif
		}

4. Example

View license
public static void IsInstanceOfType(Type t, object instance)
        {
#if NETFX_CORE
            if (!instance.GetType().IsAssignableFrom(t))
                throw new Exception("Not instance of type");
#else
            Assert.IsInstanceOf(t, instance);
#endif
        }

5. Example

View license
public static void IsInstanceOf(Type type, object target) {
            Assert.IsInstanceOf(type, target);
        }

6. Example

View license
public static void ShouldBeOfType(this object actual, Type expected)
    {
        Assert.IsInstanceOf(expected, actual);
    }

7. Example

Project: Json.Net.Unity3D
Source File: TestFixtureBase.cs
View license
public static void IsInstanceOfType(Type t, object instance)
        {
#if NETFX_CORE
            if (!instance.GetType().IsAssignableFrom(t))
                throw new Exception("Not instance of type");
#else
            Assert.IsInstanceOf(t, instance);
#endif
        }

8. Example

Project: GEDKeeper
Source File: IocContainerTests.cs
View license
[Test]
        public void Test_ExceptionIfNotRegistered()
        {
            var container = new IocContainer();

            Exception exception = null;
            try
            {
                container.Resolve<ITypeToResolve>();
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            Assert.IsInstanceOf(typeof(TypeNotRegisteredException), exception);
        }

9. Example

View license
[Test]
        public void ThrowsCannotLoadObjectTypeExceptionOnInvalidTypename()
        {
          try
          {
            MockApplicationContext myContext = new MockApplicationContext("myContext");
            DefaultListableObjectFactory objectFactory = (DefaultListableObjectFactory)myContext.ObjectFactory;
            XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(objectFactory);
            reader.LoadObjectDefinitions(new StringResource(
                                           @"<?xml version='1.0' encoding='UTF-8' ?>
<objects xmlns='http://www.springframework.net'>  
	<object id='test2' type='DOESNOTEXIST' />
</objects>
"));      
            myContext.Refresh();
          }
          catch (Exception e)
          {
//            Console.WriteLine(e);
            Assert.IsInstanceOf(typeof(CannotLoadObjectTypeException), e);
          }
        }

10. Example

View license
public static void IsInstanceOf<T>(this object obj)
        {
            Assert.IsInstanceOf(typeof(T), obj);
        }

11. Example

Project: objectflow
Source File: AssertionExtensions.cs
View license
public static void IsInstanceOf<T>(this object obj)
    {
        Assert.IsInstanceOf(typeof(T), obj);
    }

12. Example

Project: AutoTest.Net
Source File: TypeAssertTest.cs
View license
[Test]
		public void IsInstanceOf()
		{
            ApplicationException ex = new ApplicationException();

			Assert.IsInstanceOf(typeof(System.Exception), ex );
            Expect( ex, InstanceOf(typeof(Exception)));
#if CLR_2_0 || CLR_4_0
            Assert.IsInstanceOf<Exception>( ex );
#endif
		}

13. Example

Project: AutoTest.Net
Source File: TypeAssertTest.cs
View license
[Test]
		public void IsInstanceOf()
		{
            ApplicationException ex = new ApplicationException();

			Assert.IsInstanceOf(typeof(System.Exception), ex );
            Expect( ex, InstanceOf(typeof(Exception)));
#if NET_2_0
            Assert.IsInstanceOf<Exception>( ex );
#endif
		}

14. Example

Project: AutoTest.Net
Source File: TypeAssertTest.cs
View license
[Test]
		public void IsInstanceOf()
		{
            ApplicationException ex = new ApplicationException();

			Assert.IsInstanceOf(typeof(System.Exception), ex );
            Expect( ex, InstanceOf(typeof(Exception)));
#if NET_2_0
            Assert.IsInstanceOf<Exception>( ex );
#endif
		}

15. Example

View license
[Test]
        public void CanConvertArrayToDenseVector()
        {
            var array = new[] {new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1)};
            var vector = (DenseVector) array;
            Assert.IsInstanceOf(typeof (DenseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

16. Example

View license
[Test]
        public void CanConvertDenseVectorToArray()
        {
            var vector = new DenseVector(Data);
            var array = (double[])vector;
            Assert.IsInstanceOf(typeof(double[]), array);
            CollectionAssert.AreEqual(vector, array);
        }

17. Example

View license
[Test]
        public void CanConvertDenseVectorToArray()
        {
            var vector = new DenseVector(Data);
            var array = (Complex[]) vector;
            Assert.IsInstanceOf(typeof (Complex[]), array);
            CollectionAssert.AreEqual(vector, array);
        }

18. Example

View license
[Test]
        public void CanConvertDenseVectorToArray()
        {
            var vector = new DenseVector(Data);
            var array = (float[]) vector;
            Assert.IsInstanceOf(typeof (float[]), array);
            CollectionAssert.AreEqual(vector, array);
        }

19. Example

View license
[Test]
        public void CanConvertArrayToDenseVector()
        {
            var array = new[] {new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1)};
            var vector = (DenseVector) array;
            Assert.IsInstanceOf(typeof (DenseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

20. Example

View license
[Test]
        public void CanConvertDenseVectorToArray()
        {
            var vector = new DenseVector(Data);
            var array = (Complex32[]) vector;
            Assert.IsInstanceOf(typeof (Complex32[]), array);
            CollectionAssert.AreEqual(vector, array);
        }

21. Example

View license
[Test]
        public void CanConvertArrayToDenseVector()
        {
            var array = new[] {0.0f, 1.0f, 2.0f, 3.0f, 4.0f};
            var vector = (DenseVector) array;
            Assert.IsInstanceOf(typeof (DenseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

22. Example

View license
[Test]
        public void CanConvertArrayToDenseVector()
        {
            var array = new[] { 0.0, 1.0, 2.0, 3.0, 4.0 };
            var vector = (DenseVector)array;
            Assert.IsInstanceOf(typeof(DenseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

23. Example

Project: Pash
Source File: Ast.Tests.cs
View license
[Test]
            public void IncorrectExponentPartPattern()
            {
                // The grammar incorrectly accepted 1|2 as a real literal, but
                // would generate an OverflowException for it. Thus, we test
                // that the grammar does not even attempt to parse it as a real
                // literal and gives us the expected PipelineAst instead.
                ScriptBlockAst ast = ParseInput("1|2");
                Assert.IsInstanceOf(typeof(PipelineAst), ast.EndBlock.Statements[0]);
            }

24. Example

Project: Lean
Source File: SliceTests.cs
View license
[Test]
        public void AccessesTicksBySymbol()
        {
            Tick tick1 = new Tick(DateTime.Now, Symbols.SPY, 1, 2);
            Tick tick2 = new Tick(DateTime.Now, Symbols.SPY, 1.1m, 2.1m);
            Slice slice = new Slice(DateTime.Now, new[] { tick1, tick2 });

            List<Tick> data = slice[tick1.Symbol];
            Assert.IsInstanceOf(typeof(List<Tick>), data);
            Assert.AreEqual(2, data.Count);
        }

25. Example

Project: Lean
Source File: ComposerTests.cs
View license
[Test]
        public void GetsInstanceUsingPredicate()
        {
            var instance = Composer.Instance.Single<IExport>(x => x.Id == 3);
            Assert.IsNotNull(instance);
            Assert.IsInstanceOf(typeof (Export3), instance);
        }

26. Example

View license
[Test]
        public void TestDecorateClass()
        {
            var decorator = new StandardConstructorResourceDecorator();
            var resourceClass = new CodeTypeDeclaration(ResourceClassName);
            var resource = CreateResourceDiscoveryV_1_0(ResourceName, ResourceAsJson);
            decorator.DecorateClass(resource, null, resourceClass, null, ServiceClassName, null);

            Assert.AreEqual(1, resourceClass.Members.Count);
            var member = resourceClass.Members[0];

            Assert.IsInstanceOf(typeof(CodeConstructor), member);
            // Constructor is tested in TestCreateConstructor
        }

27. Example

View license
[Test]
        public void CreateResourceNameConstTest()
        {
            var decorator = new StandardResourceNameResourceDecorator();
            CodeMemberField codeField = decorator.CreateResourceNameConst("TestResourceName");

            Assert.AreEqual(ResourceBaseGenerator.ResourceNameConst, codeField.Name);
            Assert.AreEqual(typeof(string).FullName, codeField.Type.BaseType);
            Assert.IsInstanceOf(typeof(CodePrimitiveExpression), codeField.InitExpression);

            var initExpression = (CodePrimitiveExpression) codeField.InitExpression;
            Assert.AreEqual("TestResourceName", initExpression.Value);
        }

28. Example

View license
[Test]
		public void MakeByReferenceType ()
		{
			var @string = GetTypeReference (typeof (string));

			var string_byref = @string.MakeByReferenceType ();

			Assert.IsInstanceOf (typeof (ByReferenceType), string_byref);
		}

29. Example

View license
[Test]
		public void MakeSentinelType ()
		{
			var @string = GetTypeReference (typeof (string));

			var string_sentinel = @string.MakeSentinelType ();

			Assert.IsInstanceOf (typeof (SentinelType), string_sentinel);
		}

30. Example

View license
[Test]
		public void MakePointerType ()
		{
			var @string = GetTypeReference (typeof (string));

			var string_ptr = @string.MakePointerType ();

			Assert.IsInstanceOf (typeof (PointerType), string_ptr);
		}

31. Example

View license
[Test]
		public void MakePinnedType ()
		{
			var byte_array = GetTypeReference (typeof (byte []));

			var pinned_byte_array = byte_array.MakePinnedType ();

			Assert.IsInstanceOf (typeof (PinnedType), pinned_byte_array);
		}

32. Example

Project: cloudb
Source File: LoggerTest.cs
View license
[Test]
		public void ConfigureNetworkLogger() {
			ConfigSource config = new ConfigSource();
			config.SetValue("logger.network.type", "simple-console");
			
			Logger.Init(config);
			Logger logger = Logger.Network;
			Assert.IsInstanceOf(typeof(SimpleConsoleLogger), logger.BaseLogger);
		}

33. Example

Project: PeanutButter
Source File: TestRandomValueGen.cs
View license
[TestCase(typeof(int))]
        [TestCase(typeof(byte))]
        [TestCase(typeof(char))]
        [TestCase(typeof(long))]
        [TestCase(typeof(float))]
        [TestCase(typeof(double))]
        [TestCase(typeof(decimal))]
        [TestCase(typeof(DateTime))]
        [TestCase(typeof(string))]
        [TestCase(typeof(bool))]
        public void GetRandomValue_GivenPrimitiveTypeArgument_ShouldUseRegularRVGMethods(Type type)
        {
            //---------------Set up test pack-------------------

            //---------------Assert Precondition----------------

            //---------------Execute Test ----------------------
            var item = GetRandomValue(type);

            //---------------Test Result -----------------------
            Assert.IsNotNull(item);
            Assert.IsInstanceOf(type, item);
        }

34. Example

Project: PeanutButter
Source File: TestRandomValueGen.cs
View license
[TestCase(typeof(int?))]
        [TestCase(typeof(byte?))]
        [TestCase(typeof(char?))]
        [TestCase(typeof(long?))]
        [TestCase(typeof(float?))]
        [TestCase(typeof(double?))]
        [TestCase(typeof(decimal?))]
        [TestCase(typeof(DateTime?))]
        [TestCase(typeof(bool?))]
        public void GetRandomValue_GivenNullablePrimitiveTypeArgument_ShouldUseRegularRVGMethods(Type type)
        {
            //---------------Set up test pack-------------------

            //---------------Assert Precondition----------------

            //---------------Execute Test ----------------------
            var item = GetRandomValue(type);

            //---------------Test Result -----------------------
            Assert.IsNotNull(item);
            Assert.IsInstanceOf(type, item);
        }

35. Example

View license
[Test]
        public void CanConvertArrayToSparseVector()
        {
            var array = new[] {new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1)};
            var vector = SparseVector.OfEnumerable(array);
            Assert.IsInstanceOf(typeof (SparseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

36. Example

View license
[Test]
        public void CanConvertArrayToSparseVector()
        {
            var array = new[] {new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1)};
            var vector = SparseVector.OfEnumerable(array);
            Assert.IsInstanceOf(typeof (SparseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

37. Example

View license
[Test]
        public void CanConvertArrayToSparseVector()
        {
            var array = new[] {0.0, 1.0, 2.0, 3.0, 4.0};
            var vector = Vector<double>.Build.SparseOfEnumerable(array);
            Assert.IsInstanceOf(typeof (SparseVector), vector);
            CollectionAssert.AreEqual(array, array);
        }

38. Example

View license
[Test]
        public void CanConvertArrayToSparseVector()
        {
            var array = new[] {0.0f, 1.0f, 2.0f, 3.0f, 4.0f};
            var vector = SparseVector.OfEnumerable(array);
            Assert.IsInstanceOf(typeof (SparseVector), vector);
            CollectionAssert.AreEqual(vector, array);
        }

39. Example

Project: nunit-console
Source File: SettingsGroupTests.cs
View license
[TestCase("X", 5)]
        [TestCase("Y", 2.5)]
        [TestCase("NAME", "Charlie")]
        [TestCase("Flag", true)]
        [TestCase("Priority", PriorityValue.A)]
        public void WhenSettingIsInitialized_ValueIsReturned(string name, object expected)
        {
            settings.SaveSetting(name, expected);
            object actual = settings.GetSetting(name);
            Assert.AreEqual(expected, actual);
            Assert.IsInstanceOf(expected.GetType(),actual);
        }

40. Example

Project: Pash
Source File: TypeConverterTests.cs
View license
[Test]
        public void LanguagePrimitivesConvertToTypeWithTypeConverter()
        {
            var result = LanguagePrimitives.ConvertTo("abc", typeof(Custom));
        
            Assert.IsInstanceOf(typeof(Custom), result);
            Assert.AreEqual("abc", ((Custom)result).Id);
        }

41. Example

Project: Lean
Source File: ComposerTests.cs
View license
[Test]
        public void GetsMultipleInterfacesInstance()
        {
            var instance1 = Composer.Instance.Single<IOneMoreExport>(x => x.Export == 5);
            Assert.IsNotNull(instance1);
            Assert.IsInstanceOf(typeof(Export5), instance1);

            var instance2 = Composer.Instance.Single<IExport>(x => x.Id == 5);
            Assert.IsNotNull(instance2);
            Assert.IsInstanceOf(typeof(Export5), instance2);

            Assert.AreEqual(instance1, instance2);
        }

42. Example

View license
[Test]
        public void CreateChildContextFailure()
        {
            const string xmlData =
                      @"<context type='Spring.Context.Support.XmlApplicationContext, Spring.Core'>
	<resource uri='assembly://Spring.Core.Tests/DoesNotExist.xml'/>
</context>";
            CreateConfigurationElement(xmlData);

            ContextHandler ctxHandler = new ContextHandler();
            try
            {
                IApplicationContext ctx = (IApplicationContext) ctxHandler.Create(new StaticApplicationContext(), null, configurationElement);
                Assert.Fail("");
            }
            catch(ConfigurationException cfgex)
            {
                Assert.IsInstanceOf(typeof(ObjectDefinitionStoreException), cfgex.InnerException);
            }
        }

43. Example

View license
[Test]
        public void CreateRootContextFailure()
        {
            const string xmlData =
                      @"<context type='Spring.Context.Support.XmlApplicationContext, Spring.Core'>
	<resource uri='assembly://Spring.Core.Tests/DoesNotExist.xml'/>
</context>";
            CreateConfigurationElement(xmlData);

            ContextHandler ctxHandler = new ContextHandler();
            try
            {
                IApplicationContext ctx = (IApplicationContext) ctxHandler.Create(null, null, configurationElement);
                Assert.Fail("");
            }
            catch(ConfigurationException cfgex)
            {
                Assert.IsInstanceOf(typeof(ObjectDefinitionStoreException), cfgex.InnerException);
            }
        }

44. Example

View license
[Test]
        public void ConfigurationManagerCannotReadFromUrl()
        {
            try
            {
                ConfigurationManager.OpenExeConfiguration("http://localhost/something.config");
                Assert.Fail();
            }
            catch (ConfigurationErrorsException cfgex)
            {
                Assert.IsInstanceOf(typeof(ArgumentException), cfgex.InnerException);
            }
        }

45. Example

View license
[Test]
        public void TestDecorateClass()
        {
            var codeType = new CodeTypeDeclaration("TestClass");
            var decorator = new StandardConstructServiceDecorator();
            var service = CreateBuzzService();

            Assert.AreEqual(0, codeType.Members.Count);
            decorator.DecorateClass(service, codeType);

            Assert.AreEqual(1, codeType.Members.Count); // We expect one member to be added
            Assert.IsInstanceOf(typeof(CodeConstructor), codeType.Members[0]);
            var constructor = (CodeConstructor) codeType.Members[0];
            // Test that both of the add statment methods where called.
            Assert.GreaterOrEqual(constructor.Statements.Count, 9);

            //We have already tested the statment formation in the other tests.
        }

46. Example

View license
[Test]
        public void DecorateClassSubresourceTest()
        {
            // Create a top and a sub resource.
            var subJson = new JsonDictionary();
            var topJson = new JsonDictionary();
            var factory = ServiceFactory.Get(DiscoveryVersion.Version_1_0);
            var topResource = factory.CreateResource("Top", topJson);
            var subResource = factory.CreateResource("Sub", subJson);
            ((Resource)subResource).Parent = topResource;

            var decorator = new StandardResourceNameResourceDecorator();
            var decoratedClass = new CodeTypeDeclaration { Name = "Sub" };
            decorator.DecorateClass(
                subResource, "Sub", decoratedClass, null, ServiceClassName, new IResourceDecorator[0]);

            Assert.AreEqual(1, decoratedClass.Members.Count);
            Assert.IsInstanceOf(typeof(CodeMemberField), decoratedClass.Members[0]);
            var resourceField = (CodeMemberField) decoratedClass.Members[0];
            Assert.AreEqual("Top.Sub", ((CodePrimitiveExpression) resourceField.InitExpression).Value);

            CheckCompile(decoratedClass, false, "Failed To Compile StandardResourceNameResourceDecorator");
        }

47. Example

View license
[Test]
        public void TestAddResourceAssignments()
        {
            CodeMemberMethod method = new CodeMemberMethod();
            method.Name = "TestMethod";
            var decorator = new StandardConstructServiceDecorator();

            var service = CreateBuzzService();
            decorator.AddResourceAssignments(service, method);

            Assert.AreEqual(7, method.Statements.Count);
            foreach (var statment in method.Statements)
            {
                Assert.IsInstanceOf(typeof(CodeAssignStatement), statment);
                var assign = (CodeAssignStatement) statment;
                Assert.IsNotNull(assign.Left);
                Assert.IsNotNull(assign.Right);
                Assert.IsInstanceOf(typeof(CodeFieldReferenceExpression), assign.Left);
                Assert.IsInstanceOf(typeof(CodeObjectCreateExpression), assign.Right);
            }
        }

48. Example

View license
[Test]
        public void TestDecorateClass()
        {
            var decorator = new DeveloperKeyServiceDecorator();
            var service = CreateService();
            var codeType = new CodeTypeDeclaration("TestClass");

            decorator.DecorateClass(service, codeType);

            Assert.AreEqual(2, codeType.Members.Count);
            Assert.IsInstanceOf(typeof(CodeMemberField), codeType.Members[0]);
            Assert.IsInstanceOf(typeof(CodeMemberProperty), codeType.Members[1]);

            CodeMemberField devkeyField = (CodeMemberField)codeType.Members[0];
            CodeMemberProperty devkeyProperty = (CodeMemberProperty)codeType.Members[1];

            Assert.AreEqual("DeveloperKey", devkeyProperty.Name);
            Assert.AreEqual("developerKey", devkeyField.Name);
            Assert.AreEqual(typeof(string).FullName, devkeyField.Type.BaseType);
            Assert.AreEqual(typeof(string).FullName, devkeyProperty.Type.BaseType);

            CheckCompile(codeType, false, "Failed To Compile result from ServicePropertyDecoratorDecorator");
        }

49. Example

View license
[Test]
        public void TestDecorateClass()
        {
            var codeType = new CodeTypeDeclaration("TestClass");
            var decorator = new EasyConstructServiceDecorator();
            var service = CreateBuzzService();

            decorator.DecorateClass(service, codeType);

            Assert.AreEqual(3, codeType.Members.Count); // We expect two members to be added.

            // Test the empty constructor.
            Assert.IsInstanceOf(typeof(CodeConstructor), codeType.Members[0]);
            var constructor = (CodeConstructor)codeType.Members[0];
            Assert.AreEqual(0, constructor.Parameters.Count);
            Assert.AreEqual(0, constructor.Statements.Count);

            // Test the constructor taking the authenticator.
            Assert.IsInstanceOf(typeof(CodeConstructor), codeType.Members[1]);
            var constructor2 = (CodeConstructor)codeType.Members[1];
            Assert.AreEqual(1, constructor2.Parameters.Count);
            Assert.AreEqual(0, constructor2.Statements.Count);

            // Test the generated constant.
            Assert.IsInstanceOf(typeof(CodeMemberField), codeType.Members[2]);
            Assert.AreEqual(EasyConstructServiceDecorator.DiscoveryConstantName, codeType.Members[2].Name);
        }

50. Example

View license
[Test]
        public void TestDecorateClass()
        {
            var decorator = new StandardServiceFieldServiceDecorator();
            var service = CreateService();
            var codeType = new CodeTypeDeclaration("TestClass");

            decorator.DecorateClass(service, codeType);

            Assert.AreEqual(3, codeType.Members.Count);
            Assert.IsInstanceOf(typeof(CodeMemberField), codeType.Members[0]);
            Assert.IsInstanceOf(typeof(CodeMemberField), codeType.Members[1]);
            Assert.IsInstanceOf(typeof(CodeMemberProperty), codeType.Members[2]);

            CodeMemberField serviceDeclaration = (CodeMemberField) codeType.Members[0];
            CodeMemberField authenticationDeclaration = (CodeMemberField)codeType.Members[1];
            CodeMemberProperty authenticationPropertyDeclaration = (CodeMemberProperty)codeType.Members[2];

            Assert.AreEqual(ServiceClassGenerator.GenericServiceName, serviceDeclaration.Name);
            Assert.AreEqual(ServiceClassGenerator.AuthenticatorName, authenticationDeclaration.Name);
            Assert.AreEqual(typeof(IService).FullName, serviceDeclaration.Type.BaseType);
            Assert.AreEqual(typeof(IAuthenticator).FullName, authenticationDeclaration.Type.BaseType);
            Assert.AreEqual("Authenticator", authenticationPropertyDeclaration.Name);

            CheckCompile(codeType, false, "Failed To Compile result from StandardServiceFieldResourceDecorator");
        }