C# NUnit.Framework.GetType方法代码示例

        public void ImplicitArrayAssignmentWithSameTypes()
        {
            //Even though we don't specify types explicitly, the compiler
            //will pick one for us
            var names = new[] { "John", "Smith" };
            Assert.AreEqual (typeof(string[]), names.GetType (), "Determine the type of the array elements to improve your Karma.");

            //but only if it can. So this doesn't work
            // (Try uncommenting the line below to see how the compiler reacts)
            //var array = new[] { "John", 1 };
        }

 public void Should_emit_all_nodes_in_block()
 {
     var model = new { Name = "World" };
     var template = SyntaxTree.Block(
         SyntaxTree.WriteString("Hello "),
         SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name")),
         SyntaxTree.WriteString("!")
     );
     var result = ExecuteTemplate(template, model);
     Assert.That(result, Is.EqualTo("Hello World!"));
 }

        public void Does_encode_unicode()
        {
            string test = "<\"I get this : 􏰁􏰂􏰃􏰄􏰂􏰅􏰆􏰇􏰈􏰀􏰉􏰊􏰇􏰋􏰆􏰌􏰀􏰆􏰊􏰀􏰍􏰄􏰎􏰆􏰏􏰐􏰑􏰑􏰆􏰒􏰆􏰂􏰊􏰀";
            var obj = new { test };
            using (var mem = new System.IO.MemoryStream())
            {
                ServiceStack.Text.JsonSerializer.SerializeToStream(obj, obj.GetType(), mem);

                var encoded = System.Text.Encoding.UTF8.GetString(mem.ToArray());

                var copy1 = JsonObject.Parse(encoded);

                Assert.That(test, Is.EqualTo(copy1["test"]));

                System.Diagnostics.Debug.WriteLine(copy1["test"]);
            }
        }

		public void Object_Transformation_Dynamic()
		{
			var a = "a";
			var b = 1;
			var c = 12.0;

			var testTarget = new { a, b, c };

			var prop = new Mock<IPropertyComponent>();

			prop.Setup(s=>s.All(It.Is<object>(r=> r == testTarget)))
				.Returns(testTarget.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance));

			

			var result = _.Object.ToDynamic(testTarget);

			Assert.AreEqual(a , result.a);
			Assert.AreEqual(b , result.b);
			Assert.AreEqual(c , result.c);
		}

 public void should_return_the_nested_property_value()
 {
     var foo = new { Text = "Hello world" };
     var getter = PropertyGetter.Create(foo.GetType(), "Text.Length");
     Assert.That(getter.Get(foo), Is.EqualTo(foo.Text.Length));
 }

		public void Coalesce( )
		{
			string middleName = "Henry";
			var coalscing = new { MiddleName = middleName, FirstName = "ShouldNotBeHere", LastName = "ShouldBeHere" };
			var coalscingType = coalscing.GetType( );

			var mkprop = new Mock<IPropertyComponent>( );

			mkprop.Setup( a => a.All( typeof( Person ) ) )
				.Returns( typeof( Person ).GetProperties( BindingFlags.Instance | BindingFlags.Public ) );

			mkprop.Setup( a => a.All( typeof( Employee ) ) )
				.Returns( typeof( Employee ).GetProperties( BindingFlags.Instance | BindingFlags.Public ) );

			mkprop.Setup( a => a.All( coalscingType  ) )
				.Returns( coalscingType.GetProperties( BindingFlags.Instance | BindingFlags.Public ) );

			mkprop.Setup( a => a.All( It.IsAny<Person>( ) ) )
				.Returns( typeof( Person ).GetProperties( BindingFlags.Instance | BindingFlags.Public ) );

			mkprop.Setup( a => a.All( It.IsAny<Employee>( ) ) )
				.Returns( typeof( Employee ).GetProperties( BindingFlags.Instance | BindingFlags.Public ) );

			mkprop.Setup( a => a.All( coalscing ) )
				.Returns( coalscingType.GetProperties( BindingFlags.Instance | BindingFlags.Public ) );

			var target = new TransposeComponent( mkprop.Object );

			string title = "Mr.",
				firstName = "Charles",
				suffix = "IV",
				nickName = "Chip";

			int age = 24;

			var person = new Person
			{
				Title = title,
				FirstName = firstName,
				Suffix = suffix,
				NickName = nickName,
				Age = age,
			};

			string shouldbehere = "ShouldBeHere";
			decimal defaultedSalary = 60000m;

			var employeeWithExistingInfo = new Employee
			{
				FirstName = shouldbehere,
				LastName = shouldbehere,
				Salary = defaultedSalary
			};

			var employeeWithNoInfo = new Employee { };

			var employeeWithOnlySalary = new Employee
			{
				Salary = 60000m
			};

			var result = target.Coalesce( employeeWithExistingInfo, person );

			Assert.AreEqual( employeeWithExistingInfo, result );
			Assert.AreEqual( defaultedSalary, result.Salary );
			Assert.AreEqual( shouldbehere, result.FirstName );
			Assert.AreEqual( shouldbehere, result.LastName );

			var dm = default( decimal );
			var ml = new Employee{};
			var result3 = target.Coalesce( ml, new { Salary = 1000m } );

			// the salary should not be replaced because
			Assert.AreEqual( result3, ml );
			Assert.AreEqual( dm, ml.Salary );

			var result2 = target.Coalesce( person, coalscing );
			Assert.AreEqual    ( person, result2  );
			Assert.AreNotEqual ( "ShouldNotBeHere", result2.FirstName );
			Assert.AreEqual( "ShouldBeHere", result2.LastName );
			Assert.AreEqual( "Henry", result2.MiddleName );
			Assert.AreEqual( "IV", result2.Suffix );

			var result4 = target.Coalesce( person, coalscing, true );
			Assert.AreNotEqual( person, result4 );
			Assert.AreNotEqual( "ShouldNotBeHere", result2.FirstName );
			Assert.AreEqual( "ShouldBeHere", result2.LastName );
			Assert.AreEqual( "Henry", result2.MiddleName );
			Assert.AreEqual( "IV", result2.Suffix );

		}