前言
这个简短的系列一一讲解一下.Net下测试的相关知识，希望对初学者有所帮助。
在这个系列第一篇中从测试工具入手推荐TestDriven.NET。官方下载TestDriven.NET-2.14.2190
Beta版(直接下载)和TestDriven.NET-2.13.2184正式版(直接下载)。第二篇中我选择了最为经典的NUnit单元测试框架来介绍TestDriven.NET所支持的一些重要的属性。这一篇继续使用这个框架，介绍单元测试的核心——断言Assert。
概述
在测试框架中，断言是单元测试的核心，我们在测试中要对其程序断言，如果某个断言失败，方法的调用不会返回值，并且会报告一个错误。如果一个测试包含多个断言，那些紧跟失败断言的那些断言都不会执行，因此每个测试方法最好只有一个断言。
下面看看NUnit框架吧，来2张图：
断言
现在，我们使用经典的NUnit框架的最新版本，可以用三种方法来写我们的断言：
- 标准模式：过去比较经典的写法。这些方法在NUnit.Framework命名空间下的Assert类中以静态方法提供，对其不同的类型（字符串、集合、文件）NUnit.Framework框架还提供了字符串断言、集合断言、文件断言。
- 约束模式：全新的写法，使用Assert.That()方法来约束扩展所有的断言，使用新增NUnit.Framework.SyntaxHelpers命名空间下提供的方法调用NUnit.Framework.Constraints命名空间下的各种约束。
- 继承模式：只要把测试的类继承NUnit.Framework.AssertionHelper类，可以使用Expect()方法来替换Assert.That()方法。
在这里，我把Assert方法分为：同等断言、一致性断言、比较断言、类型断言、条件测试、工具方法这6类，另外还有字符串断言、集合断言、文件断言。
当然按照约束方式，也可以大致分为Equal Constraint、Same As Constraint、Condition Constraints、Comparison Constraints、Type Constraints、String Constraints、Collection Constraints、Property Constraint、Compound Constraints、Custom Constraints、List Mapper等。
下面我依次介绍一下断言，使用三种方式来写自己的断言。
- Equality Asserts(同等断言)
- Identity Asserts(一致性断言)
- Comparison Asserts(比较断言)
- Type Asserts(类型断言)
- Condition tests(条件测试)
- Utility methods(工具方法)
- StringAssert(字符串断言)
- CollectionAssert(集合断言)
- FileAssert(文件断言)
- 其他约束
1.Equality Asserts、Equal Constraint
NUnit.Framework提供了Assert.AreEqual()、Assert.AreNotEqual()方法测试两个对象是否相等。方法支持相同类型，不同类型，多维数组，嵌套数组，集合类相互比较。
NUnit.Framework.AssertionHelper命名空间下提供了Is.EqualTo(object)方法使用同等约束条件来测试两个对象是否相等。当然了，我们继承NUnit.Framework.AssertionHelper类，可以使用Expect()方法来替换Assert.That()方法。下面给出这个例子：
注意：需要引用NUnit.Framework，NUnit.Framework.AssertionHelper，NUnit.Framework.Constraints命名空间，并把测试类继承AssertionHelper。
[Test]
public void EqualTest()
{
//定义一些变量
var i3 = new int[] { 1, 2, 3 };
var d3 = new double[] { 1.0, 2.0, 3.0 };
var iunequal = new int[] { 1, 3, 2 };
var array2x2 = new int[,] { { 1, 2 }, { 3, 4 } };
var array4 = new int[] { 1, 2, 3, 4 };
var actual = new string[] { "HELLO", "world" };
var expected = new string[] { "Hello", "World" };
//经典语法
Assert.AreEqual(4, 2 + 2);
Assert.AreEqual(i3, d3);
Assert.AreNotEqual(5, 2 + 2);
Assert.AreNotEqual(i3, iunequal);
//约束语法
Assert.That(2 + 2, Is.EqualTo(4));
Assert.That(2 + 2 == 4);
Assert.That(2 + 2, Is.Not.EqualTo(5));
Assert.That(2 + 2 != 5);
Assert.That(5.0, Is.EqualTo(5));
Assert.That(2.1 + 1.2, Is.EqualTo(3.3).Within(.0005));
Assert.That(double.PositiveInfinity, Is.EqualTo(double.PositiveInfinity));
Assert.That(double.NaN, Is.EqualTo(double.NaN));
Assert.That(i3, Is.EqualTo(d3));
Assert.That(i3, Is.Not.EqualTo(iunequal));
Assert.That(array2x2, Is.EqualTo(array4).AsCollection); //成功
Assert.That("Hello!", Is.EqualTo("HELLO!").IgnoreCase);
Assert.That(actual, Is.EqualTo(expected).IgnoreCase);
//使用继承语法
Expect(2 + 2, EqualTo(4));
Expect(2 + 2 == 4);
Expect(i3, EqualTo(d3));
Expect(2 + 2, Not.EqualTo(5));
Expect(i3, Not.EqualTo(iunequal));
}
2.Identity Asserts、Same As Constraint
Assert.AreSame()和Assert.AreNotSame()方法测试两个对象是否是同一个对象。Assert.Contains方法用来测试在一个数组或列表里是否包含该对象。
NUnit.Framework.AssertionHelper命名空间下提供了Is.SameAs(object)方法使用Same As约束条件来测试两个对象是否是相同对象。使用继承也是如此。
[Test]
public void SameAsTest()
{
//定义变量
var ex1 = new Exception();
var ex2 = ex1;
var ex3 = new Exception();
//约束语法
Assert.That(ex2, Is.SameAs(ex1));
Assert.That(ex3, Is.Not.SameAs(ex1));
//使用继承语法
Expect(ex2, SameAs(ex1));
Expect(ex3, Not.SameAs(ex1));
}
3.Comparison Asserts、Comparison Constraints
NUnit.Framework框架为我们提供了下面四个方法：
- Assert.Greater(x, y)方法用于测试一个对象是否大于另外一个对象。
- Assert.GreaterOrEqual(x, y)方法用于测试一个对象是否大于等于另外一个对象。
- Assert.Less(x, y)方法用于测试一个对象是否小于另外一个对象。
- Assert.LessOrEqual(x, y)方法用于测试一个对象是否小于等于另外一个对象。
NUnit.Framework.AssertionHelper命名空间下提供了Is.GreaterThan(IComparable)、Is.GreaterThanOrEqualTo(IComparable)、Is.AtLeast(IComparable)、 Is.LessThan(IComparable)、Is.LessThanOrEqualTo(IComparable)、Is.AtMost(IComparable)方法使用比较约束条件来测试比较两个对象。使用继承也是如此。
[Test]
public void ComparisonTest()
{
//经典语法
Assert.Greater(7, 3);
Assert.GreaterOrEqual(7, 3);
Assert.GreaterOrEqual(7, 7);
Assert.Less(3, 7);
Assert.LessOrEqual(3, 7);
Assert.LessOrEqual(3, 3);
//约束语法
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));
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));
//使用继承语法
Expect(7, GreaterThan(3));
Expect(7, GreaterThanOrEqualTo(3));
Expect(7, AtLeast(3));
Expect(7, GreaterThanOrEqualTo(7));
Expect(7, AtLeast(7));
Expect(3, LessThan(7));
Expect(3, LessThanOrEqualTo(7));
Expect(3, AtMost(7));
Expect(3, LessThanOrEqualTo(3));
Expect(3, AtMost(3));
}
4.Type Asserts、Type Constraints
Assert.IsAssignableFrom()，Assert.IsNotAssignableFrom()，Assert.IsInstanceOfType()，Assert.IsNotInstanceOfType()方法让我们可以构造一些关于对象类型的断言。
同理，NUnit.Framework.AssertionHelper命名空间下提供了Is.TypeOf(Type)、Is.InstanceOfType(Type)、Is.AssignableFrom(Type)方法使用类型约束条件来测试对象类型。使用继承也是如此。
[Test]
public void TypeTest()
{
//经典语法
Assert.AreEqual(typeof(string), "Hello".GetType());
Assert.AreEqual("System.String", "Hello".GetType().FullName);
Assert.AreNotEqual(typeof(int), "Hello".GetType());
Assert.AreNotEqual("System.Int32", "Hello".GetType().FullName);
Assert.IsInstanceOfType(typeof(string), "Hello");
Assert.IsNotInstanceOfType(typeof(string), 5);
Assert.IsAssignableFrom(typeof(string), "Hello");
Assert.IsNotAssignableFrom(typeof(string), 5);
//约束语法
Assert.That("Hello", Is.TypeOf(typeof(string)));
Assert.That("Hello", Is.Not.TypeOf(typeof(int)));
Assert.That("Hello", Is.InstanceOfType(typeof(string)));
Assert.That(5, Is.Not.InstanceOfType(typeof(string)));
Assert.That("Hello", Is.AssignableFrom(typeof(string)));
Assert.That(5, Is.Not.AssignableFrom(typeof(string)));
//使用继承语法
Expect("Hello", TypeOf(typeof(string)));
Expect("Hello", Not.TypeOf(typeof(int)));
Expect("Hello", InstanceOfType(typeof(string)));
Expect(5, Not.InstanceOfType(typeof(string)));
Expect("Hello", AssignableFrom(typeof(string)));
Expect(5, Not.AssignableFrom(typeof(string)));
}
5.Condition Tests、Condition Constraints
测试框架提供了Assert.IsTrue，Assert.IsFalse，Assert.IsNaN，Assert.IsEmpty、Assert.IsNotEmpty，Assert.IsNull、Assert.IsNotNull方法分别用于测试两个对象是否正确，错误，非数字，（字符串或集合）空、非空，引用为空、引用不为空。
而NUnit.Framework.AssertionHelper命名空间也提供相类似的方法使用条件约束测试对象。直接看例子：
[Test]
public void ConditionTest()
{
//定义变量
double d = double.NaN;
//经典语法
Assert.IsNull(null);
Assert.IsNotNull(42);
Assert.IsTrue(2 + 2 == 4);
Assert.IsFalse(2 + 2 == 5);
Assert.IsNaN(d);
Assert.IsEmpty("");
Assert.IsNotEmpty("Hello!");
Assert.IsEmpty(new bool[0]);
Assert.IsNotEmpty(new int[] { 1, 2, 3 });
//约束语法
Assert.That(null, Is.Null);
Assert.That(42, Is.Not.Null);
Assert.That(2 + 2 == 4, Is.True);
Assert.That(2 + 2 == 4);
Assert.That(2 + 2 == 5, Is.False);
Assert.That(d, Is.NaN);
Assert.That("", Is.Empty);
Assert.That("Hello!", Is.Not.Empty);
Assert.That(new bool[0], Is.Empty);
Assert.That(new int[] { 1, 2, 3 }, Is.Not.Empty);
//使用继承语法
Expect(null, Null);
Expect(42, Not.Null);
Expect(2 + 2 == 4, True);
Expect(2 + 2 == 4);
Expect(2 + 2 == 5, False);
Expect(d, NaN);
Expect("", Empty);
Expect("Hello!", Not.Empty);
Expect(new bool[0], Empty);
Expect(new int[] { 1, 2, 3 }, Not.Empty);
}
6.Utility methods
我们想对测试有自定义控制，测试框架提供了两个实用方法：Assert.Fail()和Assert.Ignore()方法。这对于开发你自己的特定项目的断言，例如用于判断中它非常有用。
Assert.Fail()方法表示这个测试方法是一个失败方法，这个失败是基于其他方法没有封装的测试。
Assert.Ignore()方法表示这个测试方法是一个忽略的方法，在测试过程中，将忽略这个测试。
7.StringAssert、String Constraints
StringAssert类提供许多AreEqualIgnoringCase、Contains、StartsWith、EndsWith、IsMatch、Equals、ReferenceEquals方法，这些方法在检查字符串值时是有用的。
而NUnit.Framework.AssertionHelper命名空间也提供相类似的Text.Contains(string)、Text.DoesNotContain(string)、Text.StartsWith(string)、Text.DoesNotStartWith(string)、Text.EndsWith(string)、Text.DoesNotEndWith(string)、Text.Matches(string)、Text.DoesNotMatch(string) 方法使用字符串约束检查字符串。直接看例子：
[Test]
public void StringTest()
{
//定义变量
var phrase = "Hello World!";
var array = new string[] { "abc", "bad", "dba" };
var greetings = new string[] { "Hello!", "Hi!", "Hola!" };
var passage = "Now is the time for all good men to come to the aid of their country.";
var quotes = new string[] { "Never say never", "It‘s never too late", "Nevermore!" };
//经典语法
StringAssert.Contains("World", phrase);
StringAssert.StartsWith("Hello", phrase);
StringAssert.EndsWith("!", phrase);
StringAssert.AreEqualIgnoringCase("hello world!", phrase);
StringAssert.IsMatch("all good men", passage);
StringAssert.IsMatch("Now.*come", passage);
//约束语法
//测试是否包含"World"
Assert.That(phrase, Text.Contains("World"));
Assert.That(phrase, Text.DoesNotContain("goodbye"));
Assert.That(phrase, Text.Contains("WORLD").IgnoreCase);
Assert.That(phrase, Text.DoesNotContain("BYE").IgnoreCase);
Assert.That(array, Text.All.Contains("b"));
//测试字符串是否以"Hello"开始
Assert.That(phrase, Text.StartsWith("Hello"));
Assert.That(phrase, Text.DoesNotStartWith("Hi!"));
Assert.That(phrase, Text.StartsWith("HeLLo").IgnoreCase);
Assert.That(phrase, Text.DoesNotStartWith("HI").IgnoreCase);
Assert.That(greetings, Text.All.StartsWith("h").IgnoreCase);
//测试字符串是否以"!"结束
Assert.That(phrase, Text.EndsWith("!"));
Assert.That(phrase, Text.DoesNotEndWith("?"));
Assert.That(phrase, Text.EndsWith("WORLD!").IgnoreCase);
Assert.That(greetings, Text.All.EndsWith("!"));
Assert.That(phrase, Is.EqualTo("hello world!").IgnoreCase);
Assert.That(phrase, Is.Not.EqualTo("goodbye world!").IgnoreCase);
Assert.That(new string[] { "Hello", "World" },
Is.EqualTo(new object[] { "HELLO", "WORLD" }).IgnoreCase);
Assert.That(new string[] { "HELLO", "Hello", "hello" },
Is.All.EqualTo("hello").IgnoreCase);
//测试字符串是否同"all good men"相配
Assert.That(passage, Text.Matches("all good men"));
Assert.That(passage, Text.Matches("Now.*come"));
Assert.That(passage, Text.DoesNotMatch("all.*men.*good"));
Assert.That(passage, Text.Matches("ALL").IgnoreCase);
Assert.That(quotes, Text.All.Matches("never").IgnoreCase);
//使用继承语法
//测试是否包含"World"
Expect(phrase, Contains("World"));
Expect(phrase, Not.Contains("goodbye"));
Expect(phrase, Contains("WORLD").IgnoreCase);
Expect(phrase, Not.Contains("BYE").IgnoreCase);
Expect(array, All.Contains("b"));
//测试字符串是否以"Hello"开始
Expect(phrase, StartsWith("Hello"));
Expect(phrase, Not.StartsWith("Hi!"));
Expect(phrase, StartsWith("HeLLo").IgnoreCase);
Expect(phrase, Not.StartsWith("HI").IgnoreCase);
Expect(greetings, All.StartsWith("h").IgnoreCase);
//测试字符串是否以"!"结束
Expect(phrase, EndsWith("!"));
Expect(phrase, Not.EndsWith("?"));
Expect(phrase, EndsWith("WORLD!").IgnoreCase);
Expect(greetings, All.EndsWith("!"));
Expect(phrase, EqualTo("hello world!").IgnoreCase);
Expect(phrase, Not.EqualTo("goodbye world!").IgnoreCase);
Expect(new string[] { "Hello", "World" },
EqualTo(new object[] { "HELLO", "WORLD" }).IgnoreCase);
Expect(new string[] { "HELLO", "Hello", "hello" },
All.EqualTo("hello").IgnoreCase);
//测试字符串是否同"all good men"相配
Expect(passage, Matches("all good men"));
Expect(passage, Matches("Now.*come"));
Expect(passage, Not.Matches("all.*men.*good"));
Expect(passage, Matches("ALL").IgnoreCase);
Expect(quotes, All.Matches("never").IgnoreCase);
}
8.CollectionAssert、Collection Constraints
CollectionAssert类提供许多方法，像AllItemsAreInstancesOfType、AllItemsAreNotNull、AllItemsAreUnique、AreEqual(相同对象和次序)、AreEquivalent(相同对象次序不同)、AreNotEqual、AreNotEquivalent、Contains、DoesNotContain、IsEmpty、IsNotEmpty、IsNotSubsetOf、IsSubsetOf、ReferenceEquals。这些方法在检查集合值和比较两个集合时是有用的。集合参数必须实现IEnumerable接口。
而NUnit.Framework.AssertionHelper命名空间也提供相类似的方法使用集合约束检查集合。下面用例子说明，一看就明白。
[Test]
public void AllItemsTests()
{
//定义3个集合
object[] ints = new object[] { 1, 2, 3, 4 };
object[] doubles = new object[] { 0.99, 2.1, 3.0, 4.05 };
object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
//经典语法
CollectionAssert.AllItemsAreNotNull(ints);//ints集合所有项不为空
CollectionAssert.AllItemsAreInstancesOfType(ints, typeof(int));//ints集合所有项类型为int
CollectionAssert.AllItemsAreInstancesOfType(strings, typeof(string));
CollectionAssert.AllItemsAreUnique(ints);//ints集合所有项都是唯一的
//Helper语法
Assert.That(ints, Is.All.Not.Null);
Assert.That(ints, Has.None.Null);
Assert.That(ints, Is.All.InstanceOfType(typeof(int)));
Assert.That(ints, Has.All.InstanceOfType(typeof(int)));
Assert.That(strings, Is.All.InstanceOfType(typeof(string)));
Assert.That(strings, Has.All.InstanceOfType(typeof(string)));
Assert.That(ints, Is.Unique);
Assert.That(strings, Is.Not.Unique);
Assert.That(ints, Is.All.GreaterThan(0));
Assert.That(ints, Has.All.GreaterThan(0));
Assert.That(ints, Has.None.LessThanOrEqualTo(0));
Assert.That(strings, Text.All.Contains("a"));
Assert.That(strings, Has.All.Contains("a"));
Assert.That(strings, Has.Some.StartsWith("ba"));
Assert.That(strings, Has.Some.Property("Length", 3));
Assert.That(strings, Has.Some.StartsWith("BA").IgnoreCase);
Assert.That(doubles, Has.Some.EqualTo(1.0).Within(.05));
//使用继承语法
Expect(ints, All.Not.Null);
Expect(ints, None.Null);
Expect(ints, All.InstanceOfType(typeof(int)));
Expect(strings, All.InstanceOfType(typeof(string)));
Expect(ints, Unique);
Expect(strings, Not.Unique);
Expect(ints, All.GreaterThan(0));
Expect(ints, None.LessThanOrEqualTo(0));
Expect(strings, All.Contains("a"));
Expect(strings, Some.StartsWith("ba"));
Expect(strings, Some.StartsWith("BA").IgnoreCase);
Expect(doubles, Some.EqualTo(1.0).Within(.05));
}
9.FileAssert
FileAssert类提供AreEqual、AreNotEqual方法来比较两个文件，文件可以作为Stream、FileInfo、指定的文件路径来操作。
10.其他约束
这些约束都是新增的，由于和经典的断言没有一致的分类，我把它们单独列出来了，也在这里说说。
10-1.Property Constraint
属性约束。由主要测试对象的属性。
[Test]
public void PropertyTest()
{
//定义变量
string[] array = { "abc", "bca", "xyz", "qrs" };
string[] array2 = { "a", "ab", "abc" };
ArrayList list = new ArrayList(array);
//约束语法
Assert.That(list, Has.Property("Count"));//是否有Count属性
Assert.That(list, Has.No.Property("Length"));//是否没有Length属性
Assert.That("Hello", Has.Property("Length", 5));//"Hello"的Length属性是否是5
Assert.That("Hello", Has.Length(5));//"Hello"的Length属性是否是5
Assert.That("Hello", Has.Property("Length").EqualTo(5));//"Hello"的Length属性是否是5
Assert.That("Hello", Has.Property("Length").GreaterThan(3));//"Hello"的Length属性是否大于3
Assert.That(array, Has.Property("Length", 4));
Assert.That(array, Has.Length(4));
Assert.That(array, Has.Property("Length").LessThan(10));
Assert.That(array, Has.All.Property("Length", 3));//所有项Length属性是否是3
Assert.That(array, Has.All.Length(3));
Assert.That(array, Is.All.Length(3));
Assert.That(array, Has.All.Property("Length").EqualTo(3));
Assert.That(array, Is.All.Property("Length").EqualTo(3));
Assert.That(array2, Has.Some.Property("Length", 2));
Assert.That(array2, Has.Some.Length(2));
Assert.That(array2, Has.Some.Property("Length").GreaterThan(2));
Assert.That(array2, Is.Not.Property("Length", 4));
Assert.That(array2, Is.Not.Length(4));
Assert.That(array2, Has.No.Property("Length").GreaterThan(3));
Assert.That(List.Map(array2).Property("Length"), Is.EqualTo(new int[] { 1, 2, 3 }));
Assert.That(List.Map(array2).Property("Length"), Is.EquivalentTo(new int[] { 3, 2, 1 }));
Assert.That(List.Map(array2).Property("Length"), Is.SubsetOf(new int[] { 1, 2, 3, 4, 5 }));
Assert.That(List.Map(array2).Property("Length"), Is.Unique);
Assert.That(list, Has.Count(4));
//继承语法
Expect(list, Property("Count"));
Expect(list, Not.Property("Nada"));
Expect("Hello", Property("Length", 5));
Expect("Hello", Length(5));
Expect("Hello", Property("Length").EqualTo(5));
Expect("Hello", Property("Length").GreaterThan(0));
Expect(array, Property("Length", 4));
Expect(array, Length(4));
Expect(array, Property("Length").LessThan(10));
Expect(array, All.Property("Length", 3));
Expect(array, All.Length(3));
Expect(array, All.Property("Length").EqualTo(3));
Expect(array2, Some.Property("Length", 2));
Expect(array2, Some.Length(2));
Expect(array2, Some.Property("Length").GreaterThan(2));
Expect(array2, None.Property("Length", 4));
Expect(array2, None.Length(4));
Expect(array2, None.Property("Length").GreaterThan(3));
Expect(Map(array2).Property("Length"), EqualTo(new int[] { 1, 2, 3 }));
Expect(Map(array2).Property("Length"), EquivalentTo(new int[] { 3, 2, 1 }));
Expect(Map(array2).Property("Length"), SubsetOf(new int[] { 1, 2, 3, 4, 5 }));
Expect(Map(array2).Property("Length"), Unique);
Expect(list, Count(4));
}
10-2.Compound Constraints
进行对象间的比较。由几个方法复合作用。
[Test]
public void CompoundTest()
{
//约束语法
Assert.That(2 + 2, Is.Not.EqualTo(5));
Assert.That(new int[] { 1, 2, 3 }, Is.All.GreaterThan(0));
Assert.That(2.3, Is.GreaterThan(2.0) & Is.LessThan(3.0));
Assert.That(3, Is.LessThan(5) | Is.GreaterThan(10));
//继承语法
Expect(2 + 2, Not.EqualTo(5));
Expect(2.3, GreaterThan(2.0) & LessThan(3.0));
}
10-3.List Mapper
集合映射，比如下面的例子，测试strings数组对应项的Length属性是否为lengths对应项的值。
[Test]
public void ListMapperTest()
{
//定义2个数组
string[] strings = new string[] { "a", "ab", "abc" };
int[] lengths = new int[] { 1, 2, 3 };
//约束语法
Assert.That(List.Map(strings).Property("Length"),
Is.EqualTo(lengths));
Assert.That(new ListMapper(strings).Property("Length"),
Is.EqualTo(lengths));
//继承语法
Expect(Map(strings).Property("Length"), EqualTo(lengths));
}
结束语
关于这篇测试语法断言介绍，由于断言很多，很难在一篇文章中把所有的断言学习到。之前，我也想考虑分为经典模式和约束模式来介绍，发现大致相同，也浪费大量时间，所以千思万想，把这些属性整合在一起综合介绍，带着丰富的例子，相信可以掌握这些断言。考虑到本节代码过多，还有一部分还没有贴出来，提供下载。地址为：YJingLee.Test.zip（VS2008项目，如果你是VS2005只需复制其中的测试文件到你的项目中即可）
版权声明：本文为博主http://www.zuiniusn.com原创文章，未经博主允许不得转载。
时间： 2024-10-18 22:14:01