cpp-cli-syntax.cpp

NUnit-2.4.1-net-2.0.rar NUnit 测试用例详细的步骤

			Assert::That(2 + 2, Is::EqualTo(4));
			Assert::That(2 + 2 == 4);
			Assert::That(i3, Is::EqualTo(d3));
			Assert::That(2 + 2, Is::Not->EqualTo(5));
			Assert::That(i3, Is::Not->EqualTo(iunequal));
		
			// Inherited syntax
			Expect(2 + 2, EqualTo(4));
			Expect(2 + 2 == 4);
			Expect(i3, EqualTo(d3));
			Expect(2 + 2, Not->EqualTo(5));
			Expect(i3, Not->EqualTo(iunequal));
		}

		[Test]
		void EqualityTestsWithTolerance()
		{
			// CLassic syntax
			Assert::AreEqual(5.0, 4.99, 0.05);
			Assert::AreEqual(5.0F, 4.99F, 0.05F);

			// Helper syntax
			Assert::That(4.99L, Is::EqualTo(5.0L)->Within(0.05L));
			Assert::That(4.99f, Is::EqualTo(5.0f)->Within(0.05f));
		
			// Inherited syntax
			Expect(4.99L, EqualTo(5.0L)->Within(0.05L));
			Expect(4.99f, EqualTo(5.0f)->Within(0.05f));
		}

		[Test]
		void ComparisonTests()
		{
			// Classic Syntax
			Assert::Greater(7, 3);
			Assert::GreaterOrEqual(7, 3);
			Assert::GreaterOrEqual(7, 7);

			// Helper syntax
			Assert::That(7, Is::GreaterThan(3));
			Assert::That(7, Is::GreaterThanOrEqualTo(3));
			Assert::That(7, Is::AtLeast(3));
			Assert::That(7, Is::GreaterThanOrEqualTo(7));
			Assert::That(7, Is::AtLeast(7));

			// Inherited syntax
			Expect(7, GreaterThan(3));
			Expect(7, GreaterThanOrEqualTo(3));
			Expect(7, AtLeast(3));
			Expect(7, GreaterThanOrEqualTo(7));
			Expect(7, AtLeast(7));

			// Classic syntax
			Assert::Less(3, 7);
			Assert::LessOrEqual(3, 7);
			Assert::LessOrEqual(3, 3);

			// Helper syntax
			Assert::That(3, Is::LessThan(7));
			Assert::That(3, Is::LessThanOrEqualTo(7));
			Assert::That(3, Is::AtMost(7));
			Assert::That(3, Is::LessThanOrEqualTo(3));
			Assert::That(3, Is::AtMost(3));
		
			// Inherited syntax
			Expect(3, LessThan(7));
			Expect(3, LessThanOrEqualTo(7));
			Expect(3, AtMost(7));
			Expect(3, LessThanOrEqualTo(3));
			Expect(3, AtMost(3));
		}

		[Test]
		void AllItemsTests()
		{
			array<Object^>^ ints = { 1, 2, 3, 4 };
			array<Object^>^ strings = { "abc", "bad", "cab", "bad", "dad" };

			// Classic syntax
			CollectionAssert::AllItemsAreNotNull(ints);
			CollectionAssert::AllItemsAreInstancesOfType(ints, int::typeid);
			CollectionAssert::AllItemsAreInstancesOfType(strings, String::typeid);
			CollectionAssert::AllItemsAreUnique(ints);

			// Helper syntax
			Assert::That(ints, Is::All->Not->Null);
			Assert::That(ints, Is::All->InstanceOfType(int::typeid));
			Assert::That(strings, Is::All->InstanceOfType(String::typeid));
			Assert::That(ints, Is::Unique);
			// Only available using new syntax
			Assert::That(strings, Is::Not->Unique);
			Assert::That(ints, Is::All->GreaterThan(0));
			Assert::That(strings, Text::All->Contains( "a" ) );
			Assert::That(strings, List::Some->StartsWith( "ba" ) );
		
			// Inherited syntax
			Expect(ints, All->Not->Null);
			Expect(ints, All->InstanceOfType(int::typeid));
			Expect(strings, All->InstanceOfType(String::typeid));
			Expect(ints, Unique);
			// Only available using new syntax
			Expect(strings, Not->Unique);
			Expect(ints, All->GreaterThan(0));
			Expect(strings, All->Contains( "a" ) );
			Expect(strings, Some->StartsWith( "ba" ) );
		}

		[Test]
		void SomeItemsTests()
		{
			array<Object^>^ mixed = { 1, 2, "3", nullptr, "four", 100 };
			array<Object^>^ strings = { "abc", "bad", "cab", "bad", "dad" };

			// Not available using the classic syntax

			// Helper syntax
			Assert::That(mixed, Has::Some->Null);
			Assert::That(mixed, Has::Some->InstanceOfType(int::typeid));
			Assert::That(mixed, Has::Some->InstanceOfType(String::typeid));
			Assert::That(mixed, Has::Some->GreaterThan(99));
			Assert::That(strings, Has::Some->StartsWith( "ba" ) );
			Assert::That(strings, Has::Some->Not->StartsWith( "ba" ) );
		
			// Inherited syntax
			Expect(mixed, Some->Null);
			Expect(mixed, Some->InstanceOfType(int::typeid));
			Expect(mixed, Some->InstanceOfType(String::typeid));
			Expect(mixed, Some->GreaterThan(99));
			Expect(strings, Some->StartsWith( "ba" ) );
			Expect(strings, Some->Not->StartsWith( "ba" ) );
		}

		[Test]
		void NoItemsTests()
		{
			array<Object^>^ ints = { 1, 2, 3, 4, 5 };
			array<Object^>^ strings = { "abc", "bad", "cab", "bad", "dad" };

			// Not available using the classic syntax

			// Helper syntax
			Assert::That(ints, Has::None->Null);
			Assert::That(ints, Has::None->InstanceOfType(String::typeid));
			Assert::That(ints, Has::None->GreaterThan(99));
			Assert::That(strings, Has::None->StartsWith( "qu" ) );
		
			// Inherited syntax
			Expect(ints, None->Null);
			Expect(ints, None->InstanceOfType(String::typeid));
			Expect(ints, None->GreaterThan(99));
			Expect(strings, None->StartsWith( "qu" ) );
		}

		[Test]
		void CollectionContainsTests()
		{
			array<int>^ iarray = { 1, 2, 3 };
			array<String^>^ sarray = { "a", "b", "c" };

			// Classic syntax
			Assert::Contains(3, iarray);
			Assert::Contains("b", sarray);
			CollectionAssert::Contains(iarray, 3);
			CollectionAssert::Contains(sarray, "b");
			CollectionAssert::DoesNotContain(sarray, "x");

			// Helper syntax
			Assert::That(iarray, List::Contains(3));
			Assert::That(sarray, List::Contains("b"));
			Assert::That(sarray, List::Not->Contains("x"));
		
			// Inherited syntax
			Expect(iarray, Contains(3));
			Expect(sarray, Contains("b"));
			Expect(sarray, Not->Contains("x"));
		}

		[Test]
		void CollectionEquivalenceTests()
		{
			array<int>^ ints1to5 = { 1, 2, 3, 4, 5 };

			// Classic syntax
			CollectionAssert::AreEquivalent(gcnew array<int> { 2, 1, 4, 3, 5 }, ints1to5);
			CollectionAssert::AreNotEquivalent(gcnew array<int> { 2, 2, 4, 3, 5 }, ints1to5);
			CollectionAssert::AreNotEquivalent(gcnew array<int> { 2, 4, 3, 5 }, ints1to5);
			CollectionAssert::AreEquivalent(gcnew array<int> { 2, 2, 1, 1, 4, 3, 5 }, ints1to5);
		
			// Helper syntax
			Assert::That(gcnew array<int> { 2, 1, 4, 3, 5 }, Is::EquivalentTo(ints1to5));
			Assert::That(gcnew array<int> { 2, 2, 4, 3, 5 }, Is::Not->EquivalentTo(ints1to5));
			Assert::That(gcnew array<int> { 2, 4, 3, 5 }, Is::Not->EquivalentTo(ints1to5));
			Assert::That(gcnew array<int> { 2, 2, 1, 1, 4, 3, 5 }, Is::EquivalentTo(ints1to5));

			// Inherited syntax
			Expect(gcnew array<int> { 2, 1, 4, 3, 5 }, EquivalentTo(ints1to5));
			Expect(gcnew array<int> { 2, 2, 4, 3, 5 }, Not->EquivalentTo(ints1to5));
			Expect(gcnew array<int> { 2, 4, 3, 5 }, Not->EquivalentTo(ints1to5));
			Expect(gcnew array<int> { 2, 2, 1, 1, 4, 3, 5 }, EquivalentTo(ints1to5));
		}

		[Test]
		void SubsetTests()
		{
			array<int>^ ints1to5 = { 1, 2, 3, 4, 5 };

			// Classic syntax
			CollectionAssert::IsSubsetOf(gcnew array<int> { 1, 3, 5 }, ints1to5);
			CollectionAssert::IsSubsetOf(gcnew array<int> { 1, 2, 3, 4, 5 }, ints1to5);
			CollectionAssert::IsNotSubsetOf(gcnew array<int> { 2, 4, 6 }, ints1to5);

			// Helper syntax
			Assert::That(gcnew array<int> { 1, 3, 5 }, Is::SubsetOf(ints1to5));
			Assert::That(gcnew array<int> { 1, 2, 3, 4, 5 }, Is::SubsetOf(ints1to5));
			Assert::That(gcnew array<int> { 2, 4, 6 }, Is::Not->SubsetOf(ints1to5));
		
			// Inherited syntax
			Expect(gcnew array<int> { 1, 3, 5 }, SubsetOf(ints1to5));
			Expect(gcnew array<int> { 1, 2, 3, 4, 5 }, SubsetOf(ints1to5));
			Expect(gcnew array<int> { 2, 4, 6 }, Not->SubsetOf(ints1to5));
		}

		[Test]
		void PropertyTests()
		{
			array<String^>^ strings = { "abc", "bca", "xyz" };

			// Helper syntax
			Assert::That( "Hello", Has::Property("Length", 5) );
			Assert::That( "Hello", Has::Length( 5 ) );
			Assert::That( strings , Has::All->Property( "Length", 3 ) );
			Assert::That( strings, Has::All->Length( 3 ) );

			// Inherited syntax
			Expect( "Hello", Property("Length", 5) );
			Expect( "Hello", Length( 5 ) );
			Expect( strings, All->Property("Length", 3 ) );
			Expect( strings, All->Length( 3 ) );
		}

		[Test]
		void NotTests()
		{
			// Not available using the classic syntax

			// Helper syntax
			Assert::That(42, Is::Not->Null);
			Assert::That(42, Is::Not->True);
			Assert::That(42, Is::Not->False);
			Assert::That(2.5, Is::Not->NaN);
			Assert::That(2 + 2, Is::Not->EqualTo(3));
			Assert::That(2 + 2, Is::Not->Not->EqualTo(4));
			Assert::That(2 + 2, Is::Not->Not->Not->EqualTo(5));

			// Inherited syntax
			Expect(42, Not->Null);
			Expect(42, Not->True);
			Expect(42, Not->False);
			Expect(2.5, Not->NaN);
			Expect(2 + 2, Not->EqualTo(3));
			Expect(2 + 2, Not->Not->EqualTo(4));
			Expect(2 + 2, Not->Not->Not->EqualTo(5));
		}

		[Test]
		void NotOperator()
		{
			// The ! operator is only available in the new syntax
			Assert::That(42, !Is::Null);
			// Inherited syntax
			Expect( 42, !Null );
		}

		[Test]
		void AndOperator()
		{
			// The & operator is only available in the new syntax
			Assert::That(7, Is::GreaterThan(5) & Is::LessThan(10));
			// Inherited syntax
			Expect( 7, GreaterThan(5) & LessThan(10));
		}

		[Test]
		void OrOperator()
		{
			// The | operator is only available in the new syntax
			Assert::That(3, Is::LessThan(5) | Is::GreaterThan(10));
			Expect( 3, LessThan(5) | GreaterThan(10));
		}

		[Test]
		void ComplexTests()
		{
			Assert::That(7, Is::Not->Null & Is::Not->LessThan(5) & Is::Not->GreaterThan(10));
			Expect(7, Not->Null & Not->LessThan(5) & Not->GreaterThan(10));

			Assert::That(7, !Is::Null & !Is::LessThan(5) & !Is::GreaterThan(10));
			Expect(7, !Null & !LessThan(5) & !GreaterThan(10));
		}

		// This method contains assertions that should not compile
		// You can check by uncommenting it.
		//void WillNotCompile()
		//{
		//    Assert::That(42, Is::Not);
		//    Assert::That(42, Is::All);
		//    Assert::That(42, Is::Null->Not);
		//    Assert::That(42, Is::Not->Null->GreaterThan(10));
		//    Assert::That(42, Is::GreaterThan(10)->LessThan(99));

		//    object[] c = new object[0];
		//    Assert::That(c, Is::Null->All);
		//    Assert::That(c, Is::Not->All);
		//    Assert::That(c, Is::All->Not);
		//}
	};
}