assertsyntaxtests.vb

来自「NUnit-2.4.1-net-2.0.rar NUnit 测试用例详细的步骤」· VB 代码 · 共 588 行 · 第 1/2 页

            ' Only available using new syntax
            Assert.That(phrase, Text.DoesNotMatch("all.*men.*good"))
            Assert.That(phrase, Text.Matches("ALL").IgnoreCase)
            Assert.That(quotes, Text.All.Matches("never").IgnoreCase)

            ' Inherited syntax
            Expect(phrase, Matches("all good men"))
            Expect(phrase, Matches("Now.*come"))
            ' Only available using new syntax
            Expect(phrase, Text.Not.Matches("all.*men.*good"))
            Expect(phrase, Matches("ALL").IgnoreCase)
            Expect(quotes, All.Matches("never").IgnoreCase)
        End Sub

        <Test()> _
        Public Sub EqualityTests()

            Dim i3 As Integer() = {1, 2, 3}
            Dim d3 As Double() = {1.0, 2.0, 3.0}
            Dim iunequal As Integer() = {1, 3, 2}

            ' Classic Syntax
            Assert.AreEqual(4, 2 + 2)
            Assert.AreEqual(i3, d3)
            Assert.AreNotEqual(5, 2 + 2)
            Assert.AreNotEqual(i3, iunequal)

            ' Helper syntax
            Assert.That(2 + 2, Tis.EqualTo(4))
            Assert.That(2 + 2 = 4)
            Assert.That(i3, Tis.EqualTo(d3))
            Assert.That(2 + 2, Tis.Not.EqualTo(5))
            Assert.That(i3, Tis.Not.EqualTo(iunequal))

            ' Inherited syntax
            Expect(2 + 2, EqualTo(4))
            Expect(2 + 2 = 4)
            Expect(i3, EqualTo(d3))
            Expect(2 + 2, Tis.Not.EqualTo(5))
            Expect(i3, Tis.Not.EqualTo(iunequal))
        End Sub

        <Test()> _
        Public Sub EqualityTestsWithTolerance()
            ' CLassic syntax
            Assert.AreEqual(5.0R, 4.99R, 0.05R)
            Assert.AreEqual(5.0F, 4.99F, 0.05F)

            ' Helper syntax
            Assert.That(4.99R, Tis.EqualTo(5.0R).Within(0.05R))
            Assert.That(4.99F, Tis.EqualTo(5.0F).Within(0.05F))

            ' Inherited syntax
            Expect(4.99R, EqualTo(5.0R).Within(0.05R))
            Expect(4.99F, EqualTo(5.0F).Within(0.05F))
        End Sub

        <Test()> _
        Public Sub ComparisonTests()
            ' Classic Syntax
            Assert.Greater(7, 3)
            Assert.GreaterOrEqual(7, 3)
            Assert.GreaterOrEqual(7, 7)

            ' Helper syntax
            Assert.That(7, Tis.GreaterThan(3))
            Assert.That(7, Tis.GreaterThanOrEqualTo(3))
            Assert.That(7, Tis.AtLeast(3))
            Assert.That(7, Tis.GreaterThanOrEqualTo(7))
            Assert.That(7, Tis.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, Tis.LessThan(7))
            Assert.That(3, Tis.LessThanOrEqualTo(7))
            Assert.That(3, Tis.AtMost(7))
            Assert.That(3, Tis.LessThanOrEqualTo(3))
            Assert.That(3, Tis.AtMost(3))

            ' Inherited syntax
            Expect(3, LessThan(7))
            Expect(3, LessThanOrEqualTo(7))
            Expect(3, AtMost(7))
            Expect(3, LessThanOrEqualTo(3))
            Expect(3, AtMost(3))
        End Sub

        <Test()> _
        Public Sub AllItemsTests()

            Dim ints As Object() = {1, 2, 3, 4}
            Dim strings As Object() = {"abc", "bad", "cab", "bad", "dad"}

            ' Classic syntax
            CollectionAssert.AllItemsAreNotNull(ints)
            CollectionAssert.AllItemsAreInstancesOfType(ints, GetType(Integer))
            CollectionAssert.AllItemsAreInstancesOfType(strings, GetType(String))
            CollectionAssert.AllItemsAreUnique(ints)

            ' Helper syntax
            Assert.That(ints, Tis.All.Not.Null)
            Assert.That(ints, Tis.All.InstanceOfType(GetType(Integer)))
            Assert.That(strings, Tis.All.InstanceOfType(GetType(String)))
            Assert.That(ints, Tis.Unique)
            ' Only available using new syntax
            Assert.That(Strings, Tis.Not.Unique)
            Assert.That(ints, Tis.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(GetType(Integer)))
            Expect(strings, All.InstanceOfType(GetType(String)))
            Expect(ints, Unique)
            ' Only available using new syntax
            Expect(strings, Tis.Not.Unique)
            Expect(ints, All.GreaterThan(0))
            Expect(Strings, All.Contains("a"))
            Expect(Strings, Some.StartsWith("ba"))
        End Sub

        <Test()> _
       Public Sub SomeItemsTests()

            Dim mixed As Object() = {1, 2, "3", Nothing, "four", 100}
            Dim strings As Object() = {"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(GetType(Integer)))
            Assert.That(mixed, Has.Some.InstanceOfType(GetType(String)))
            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(GetType(Integer)))
            Expect(mixed, Some.InstanceOfType(GetType(String)))
            Expect(mixed, Some.GreaterThan(99))
            Expect(strings, Some.StartsWith("ba"))
            Expect(strings, Some.Not.StartsWith("ba"))
        End Sub

        <Test()> _
        Public Sub NoItemsTests()

            Dim ints As Object() = {1, 2, 3, 4, 5}
            Dim strings As Object() = {"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(GetType(String)))
            Assert.That(ints, Has.None.GreaterThan(99))
            Assert.That(Strings, Has.None.StartsWith("qu"))

            ' Inherited syntax
            Expect(ints, None.Null)
            Expect(ints, None.InstanceOfType(GetType(String)))
            Expect(ints, None.GreaterThan(99))
            Expect(Strings, None.StartsWith("qu"))
        End Sub

        <Test()> _
        Public Sub CollectionContainsTests()

            Dim iarray As Integer() = {1, 2, 3}
            Dim sarray As String() = {"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, List.Not.Contains("x"))
        End Sub

        <Test()> _
        Public Sub CollectionEquivalenceTests()

            Dim ints1to5 As Integer() = {1, 2, 3, 4, 5}

            ' Classic syntax
            CollectionAssert.AreEquivalent(New Integer() {2, 1, 4, 3, 5}, ints1to5)
            CollectionAssert.AreNotEquivalent(New Integer() {2, 2, 4, 3, 5}, ints1to5)
            CollectionAssert.AreNotEquivalent(New Integer() {2, 4, 3, 5}, ints1to5)
            CollectionAssert.AreEquivalent(New Integer() {2, 2, 1, 1, 4, 3, 5}, ints1to5)

            ' Helper syntax
            Assert.That(New Integer() {2, 1, 4, 3, 5}, Tis.EquivalentTo(ints1to5))
            Assert.That(New Integer() {2, 2, 4, 3, 5}, Tis.Not.EquivalentTo(ints1to5))
            Assert.That(New Integer() {2, 4, 3, 5}, Tis.Not.EquivalentTo(ints1to5))
            Assert.That(New Integer() {2, 2, 1, 1, 4, 3, 5}, Tis.EquivalentTo(ints1to5))

            ' Inherited syntax
            Expect(New Integer() {2, 1, 4, 3, 5}, EquivalentTo(ints1to5))
            Expect(New Integer() {2, 2, 4, 3, 5}, Tis.Not.EquivalentTo(ints1to5))
            Expect(New Integer() {2, 4, 3, 5}, Tis.Not.EquivalentTo(ints1to5))
            Expect(New Integer() {2, 2, 1, 1, 4, 3, 5}, EquivalentTo(ints1to5))
        End Sub

        <Test()> _
        Public Sub SubsetTests()

            Dim ints1to5 As Integer() = {1, 2, 3, 4, 5}

            ' Classic syntax
            CollectionAssert.IsSubsetOf(New Integer() {1, 3, 5}, ints1to5)
            CollectionAssert.IsSubsetOf(New Integer() {1, 2, 3, 4, 5}, ints1to5)
            CollectionAssert.IsNotSubsetOf(New Integer() {2, 4, 6}, ints1to5)

            ' Helper syntax
            Assert.That(New Integer() {1, 3, 5}, Tis.SubsetOf(ints1to5))
            Assert.That(New Integer() {1, 2, 3, 4, 5}, Tis.SubsetOf(ints1to5))
            Assert.That(New Integer() {2, 4, 6}, Tis.Not.SubsetOf(ints1to5))

            ' Inherited syntax
            Expect(New Integer() {1, 3, 5}, SubsetOf(ints1to5))
            Expect(New Integer() {1, 2, 3, 4, 5}, SubsetOf(ints1to5))
            Expect(New Integer() {2, 4, 6}, Tis.Not.SubsetOf(ints1to5))
        End Sub

        <Test()> _
        Public Sub PropertyTests()

            Dim array As String() = {"abc", "bca", "xyz"}

            ' Helper syntax
            Assert.That("Hello", Has.Property("Length", 5))
            Assert.That("Hello", Has.Length(5))
            Assert.That(Array, Has.All.Property("Length", 3))
            Assert.That(Array, Has.All.Length(3))

            ' Inherited syntax
            Expect("Hello", Has.Property("Length", 5))
            Expect("Hello", Length(5))
            Expect(Array, All.Property("Length", 3))
            Expect(Array, All.Length(3))
        End Sub

        <Test()> _
        Public Sub NotTests()
            ' Not available using the classic syntax

            ' Helper syntax
            Assert.That(42, Tis.Not.Null)
            Assert.That(42, Tis.Not.True)
            Assert.That(42, Tis.Not.False)
            Assert.That(2.5, Tis.Not.NaN)
            Assert.That(2 + 2, Tis.Not.EqualTo(3))
            Assert.That(2 + 2, Tis.Not.Not.EqualTo(4))
            Assert.That(2 + 2, Tis.Not.Not.Not.EqualTo(5))

            ' Inherited syntax
            Expect(42, Tis.Not.Null)
            Expect(42, Tis.Not.True)
            Expect(42, Tis.Not.False)
            Expect(2.5, Tis.Not.NaN)
            Expect(2 + 2, Tis.Not.EqualTo(3))
            Expect(2 + 2, Tis.Not.Not.EqualTo(4))
            Expect(2 + 2, Tis.Not.Not.Not.EqualTo(5))
        End Sub

    End Class

End Namespace