测试语法之断言介绍（三）（转）

概述

在测试框架中，断言是单元测试的核心，我们在测试中要对其程序断言，如果某个断言失败，方法的调用不会返回值，并且会报告一个错误。如果一个测试包含多个断言，那些紧跟失败断言的那些断言都不会执行，因此每个测试方法最好只有一个断言。

下面看看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.cnblogs.com/lyj/archive/2008/09/07/1286372.html