首页 > > 程序设计 > delphi >

走进 .Net 单元测试

2018-06-17 19:15:53来源：未知阅读 ()

走进 .Net 单元测试

Intro

“不会写单元测试的程序员不是合格的程序员，不写单元测试的程序员不是优秀程序员。”

—— 一只想要成为一个优秀程序员的渣逼程序猿。

那么问题来了，什么是单元测试，如何做单元测试。

单元测试定义

按照维基百科上的说法，单元测试（Unit Testing）又称为模块测试, 是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。在面向对象编程中，最小单元就是方法，包括基类、抽象类、或者派生类（子类）中的方法。按照通俗的理解，一个单元测试判断某个特定场条件下某个特定方法的行为，如斐波那契数列算法，冒泡排序算法。

单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是人为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。

—— 百度百科 http://baike.baidu.com/view/106237.htm

进行单元测试的好处

它是一种验证行为

程序中的每一项功能都是测试来验证它的正确性。

它是一种设计行为

编写单元测试将使我们从调用者观察、思考。特别是先写测试（test-first），迫使我们把程序设计成易于调用和可测试的，有利于程序的解耦和模块化。

它是一种编写文档的行为

单元测试是一种无价的文档，它是展示函数或类如何使用的最佳文档。这份文档是可编译、可运行的，并且它保持最新，永远与代码同步。

它具有回归性

自动化的单元测试避免了代码出现回归，编写完成之后，可以随时随地的快速运行测试。

高效

自动化的单元测试节省了开发上调试BUG的时间，绝大多数BUG可以通过单元测试测试出来，并且可以减少测试人员的测试时间。有时候通过写单元测试能够更好的完善自己程序的逻辑，让程序变得更加美好。

—— 单元测试的优点 http://jingyan.baidu.com/article/d713063522ab4e13fdf47533.html

单元测试的原则：

可重复运行的

持续长期有效，并且返回一致的结果

在内存中运行，没有外部依赖组件（比如说真实的数据库，真实的文件存储等）

快速返回结果

一个测试方法只测试一个问题

VS单元测试【MsTest】使用

VS单元测试的主要类：Assert、StringAssert、CollectionAssert，具体可参照 MSDN介绍

有些时候我们需要对测试的方法用到的数据或配置进行初始化，有几个特殊的测试方法。

如果需要针对测试中的所有虚拟用户迭代仅执行一次初始化操作，请使用 TestInitializeAttribute。

初始化方法的运行顺序如下：

用 AssemblyInitializeAttribute 标记的方法。
用 ClassInitializeAttribute 特性标记的方法。
用 TestInitializeAttribute 特性标记的方法。
用 TestMethodAttribute 特性标记的方法。

单元测试使用示例

  1 using Microsoft.VisualStudio.TestTools.UnitTesting;
  2 
  3 namespace ConsoleApplication1Test
  4 {
  5     [TestClass]
  6     public class MainTest
  7     {
  8         #region TestFail
  9 
 10         [TestMethod]
 11         public void TestFail0()
 12         {
 13             Assert.Fail();
 14         }
 15 
 16         [TestMethod]
 17         public void TestFail1()
 18         {
 19             Assert.Fail("Test is fail");
 20         }
 21 
 22         [TestMethod]
 23         public void TestFail2()
 24         {
 25             Assert.Fail("Test3 is fail,{0}", "hahaha");
 26         }
 27         #endregion
 28 
 29         #region TestInconclusive 忽略
 30         [TestMethod]
 31         public void TestInconclusive0()
 32         {
 33             Assert.Inconclusive();
 34         }
 35 
 36         [TestMethod]
 37         public void TestInconclusive1()
 38         {
 39             Assert.Inconclusive("Inconclusive");
 40         }
 41 
 42         [TestMethod]
 43         public void TestInconclusive2()
 44         {
 45             Assert.Inconclusive("Inconclusive,{0}", "hehehe");
 46         }
 47         #endregion
 48 
 49         #region LogicTest
 50 
 51         #region Null
 52         [TestMethod]
 53         public void IsNullTest()
 54         {
 55             Assert.IsNull(null);
 56         }
 57 
 58         [TestMethod]
 59         public void IsNotNullTest()
 60         {
 61             Assert.IsNotNull(1);
 62         } 
 63         #endregion
 64 
 65         #region True || False
 66         [TestMethod]
 67         public void IsTrueTest()
 68         {
 69             Assert.IsTrue(1 == 1);
 70         }
 71 
 72         [TestMethod]
 73         public void IsFalseTest()
 74         {
 75             Assert.IsFalse(1 > 2);
 76         } 
 77         #endregion
 78 
 79         #region AreSame
 80         [TestMethod]
 81         public void AreSameTest()
 82         {
 83             //不要向 AreSame() 传递值类型的值，因为他们转换为 Object 后永久不会相等，值类型的值比较请使用 AreEqual()
 84             Assert.AreSame(1, 1);
 85         }
 86 
 87         [TestMethod]
 88         public void AreSameTest1()
 89         {
 90             object obj = new object(), obj1 = obj;
 91             Assert.AreSame(obj, obj1, "same");
 92         }
 93 
 94         [TestMethod]
 95         public void StringAreSameTest0()
 96         {
 97             string str1 = "hello", str2 = "hello";
 98             Assert.AreSame(str1, str2);
 99         }
100 
101         [TestMethod]
102         public void StringAreSameTest1()
103         {
104             string str1 = "hello", str2 = "Hello";
105             Assert.AreSame(str1, str2);
106         }
107 
108         [TestMethod]
109         public void AreNotSameTest()
110         {
111             object obj = new object(), obj1 = new object();
112             Assert.AreNotSame(obj, obj1);
113         } 
114         #endregion
115 
116         #region AreEqual
117         [TestMethod]
118         public void AreEqualTest()
119         {
120             Assert.AreEqual(1, 1);
121         }
122 
123         [TestMethod]
124         public void AreNotEqualTest()
125         {
126             Assert.AreNotEqual(1, 2);
127         }
128 
129         [TestMethod]
130         public void AreEqualTest1()
131         {
132             object obj = new object(), obj1 = obj;
133             Assert.AreEqual(obj, obj1);
134         }
135 
136         [TestMethod]
137         public void AreNotEqualTest1()
138         {
139             object obj = new object(), obj1 = new object();
140             Assert.AreNotEqual(obj, obj1);
141         }
142 
143         [TestMethod]
144         public void AreEqualTest2()
145         {
146             object obj = new object(), obj1 = new object();
147             Assert.AreEqual(obj, obj1);
148             // Assert.Equals()不用于断言，请使用 Assert.AreEquals() 或 Assert.AreNotEquals()
149             //Assert.Equals(obj, obj1);
150         }
151 
152         [TestMethod]
153         public void StringAreEqualTest0()
154         {
155             string str = "hello", str1 = "hello";
156             Assert.AreEqual(str, str1);
157         }
158 
159         [TestMethod]
160         public void StringAreEqualTest1()
161         {
162             string str = "hello", str1 = "Hello";
163             Assert.AreEqual(str, str1, true);
164         } 
165         #endregion
166 
167         #region IsInstanceOfType
168 
169         [TestMethod]
170         public void IsInstanceOfTypeTest()
171         {
172             B b = new B();
173             Assert.IsInstanceOfType(b, typeof(A));
174         }
175 
176         [TestMethod]
177         public void IsNotInstanceOfTypeTest()
178         {
179             A a = new A();
180             Assert.IsNotInstanceOfType(a, typeof(B));
181         }
182         #endregion
183 
184         #endregion
185 
186         #region 测试初始化和清理
187         [AssemblyInitialize()]
188         public static void AssemblyInit(TestContext context)
189         {
190             System.Console.WriteLine("AssemblyInit " + context.TestName);
191         }
192 
193         [ClassInitialize()]
194         public static void ClassInit(TestContext context)
195         {
196             System.Console.WriteLine("ClassInit " + context.TestName);
197         }
198 
199         [TestInitialize]
200         public void Initialize()
201         {
202             System.Console.WriteLine("TestMethodInit");
203         }
204 
205         [TestCleanup]
206         public void Cleanup()
207         {
208             System.Console.WriteLine("TestMethodCleanup");
209         }
210 
211         [ClassCleanup]
212         public static void ClassCleanup()
213         {
214             System.Console.WriteLine("ClassCleanup");
215         }
216 
217         [AssemblyCleanup]
218         public static void AssemblyCleanup()
219         {
220             System.Console.WriteLine("AssemblyCleanup");
221         } 
222         #endregion
223     }
224 
225     public class A { }
226 
227     public class B : A { }
228 
229 }

Ms Test单元测试

MsTest 和 Nunit区别

MS Test框架是Visual Studio自带的测试框架，可以通过新建一个Unit Test Project工程，也可以建一个Class Libary，然后添加对Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll的引用。然后就是创建测试用例，进行测试即可。

NUnit Test框架是一个xUnit家族种的第4个主打产品，完全由C#语言来编写，支持所有的.Net语言。使用NUnit框架，我们需要下载安装包，安装后使用独立客户端进行使用。使用方法与MS Test类似

有一些是NUnit中的，但是MS Test框架中是没有的： - Assert.IsNaN - Assert.IsEmpty - Assert.IsNotEmpty - Assert.Greater - Assert.GreaterOrEqual - Assert.Less - Assert.LessOrEqual - Assert.IsAssignableFrom - Assert.IsNotAssignableFrom - Assert.Igore - CollectionAssert.IsEmpty - CollectionAssert.IsNotEmpty - StringAssert.AreEqualIgnoringCase - StringAssert.IsMatch - FileAssert.AreEqual - FileAssert.AreNotEqual

同时支持两种测试框架

可以通过宏判断来同时支持这两个框架，在测试前添加以下代码：

 1 #if !NUNIT 
 2 using Microsoft.VisualStudio.TestTools.UnitTesting; 
 3 using Category = Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute; 
 4 #else 
 5 using NUnit.Framework; 
 6 using TestClass = NUnit.Framework.TestFixtureAttribute; 
 7 using TestMethod = NUnit.Framework.TestAttribute; 
 8 using TestInitialize = NUnit.Framework.SetUpAttribute; 
 9 using TestCleanup = NUnit.Framework.TearDownAttribute; 
10 using TestContext = System.Object; 
11 using ClassCleanup = NUnit.Framework.TestFixtureTearDownAttribute; 
12 using ClassInitialize = NUnit.Framework.TestFixtureSetUpAttribute; 
13 #endif

Nunit测试使用示例

  1 #region NUNIT
  2 
  3     /// <summary>
  4     /// This test fixture attempts to exercise all the syntactic
  5     /// variations of Assert without getting into failures, errors 
  6     /// or corner cases.Thus, some of the tests may be duplicated 
  7     /// in other fixtures.
  8     /// 
  9     /// Each test performs the same operations using the classic
 10     /// syntax(if available) and the new syntax in both the
 11     /// helper-based and inherited forms.
 12     /// 
 13     /// This Fixture will eventually be duplicated in other
 14     /// supported languages. 
 15     /// </summary>
 16     [TestFixture]
 17     public class AssertSyntaxTests : AssertionHelper
 18     {
 19         #region Simple Constraint Tests
 20         [Test]
 21         public void IsNull()
 22         {
 23             object nada = null;
 24 
 25             // Classic syntax
 26             Assert.IsNull(nada);
 27 
 28             // Constraint Syntax
 29             Assert.That(nada, Is.Null);
 30 
 31             // Inherited syntax
 32             Expect(nada, Null);
 33         }
 34 
 35         [Test]
 36         public void IsNotNull()
 37         {
 38             // Classic syntax
 39             Assert.IsNotNull(42);
 40 
 41             // Constraint Syntax
 42             Assert.That(42, Is.Not.Null);
 43 
 44             // Inherited syntax
 45             Expect(42, Not.Null);
 46         }
 47 
 48         [Test]
 49         public void IsTrue()
 50         {
 51             // Classic syntax
 52             Assert.IsTrue(2 + 2 == 4);
 53 
 54             // Constraint Syntax
 55             Assert.That(2 + 2 == 4, Is.True);
 56             Assert.That(2 + 2 == 4);
 57 
 58             // Inherited syntax
 59             Expect(2 + 2 == 4, True);
 60             Expect(2 + 2 == 4);
 61         }
 62 
 63         [Test]
 64         public void IsFalse()
 65         {
 66             // Classic syntax
 67             Assert.IsFalse(2 + 2 == 5);
 68 
 69             // Constraint Syntax
 70             Assert.That(2 + 2 == 5, Is.False);
 71 
 72             // Inherited syntax
 73             Expect(2 + 2 == 5, False);
 74         }
 75 
 76         [Test]
 77         public void IsNaN()
 78         {
 79             double d = double.NaN;
 80             float f = float.NaN;
 81 
 82             // Classic syntax
 83             Assert.IsNaN(d);
 84             Assert.IsNaN(f);
 85 
 86             // Constraint Syntax
 87             Assert.That(d, Is.NaN);
 88             Assert.That(f, Is.NaN);
 89 
 90             // Inherited syntax
 91             Expect(d, NaN);
 92             Expect(f, NaN);
 93         }
 94 
 95         [Test]
 96         public void EmptyStringTests()
 97         {
 98             // Classic syntax
 99             Assert.IsEmpty("");
100             Assert.IsNotEmpty("Hello!");
101 
102             // Constraint Syntax
103             Assert.That("", Is.Empty);
104             Assert.That("Hello!", Is.Not.Empty);
105 
106             // Inherited syntax
107             Expect("", Empty);
108             Expect("Hello!", Not.Empty);
109         }
110 
111         [Test]
112         public void EmptyCollectionTests()
113         {
114             // Classic syntax
115             Assert.IsEmpty(new bool[0]);
116             Assert.IsNotEmpty(new int[] { 1, 2, 3 });
117 
118             // Constraint Syntax
119             Assert.That(new bool[0], Is.Empty);
120             Assert.That(new int[] { 1, 2, 3 }, Is.Not.Empty);
121 
122             // Inherited syntax
123             Expect(new bool[0], Empty);
124             Expect(new int[] { 1, 2, 3 }, Not.Empty);
125         }
126         #endregion
127 
128         #region TypeConstraint Tests
129         [Test]
130         public void ExactTypeTests()
131         {
132             // Classic syntax workarounds
133             Assert.AreEqual(typeof(string), "Hello".GetType());
134             Assert.AreEqual("System.String", "Hello".GetType().FullName);
135             Assert.AreNotEqual(typeof(int), "Hello".GetType());
136             Assert.AreNotEqual("System.Int32", "Hello".GetType().FullName);
137 
138             // Constraint Syntax
139             Assert.That("Hello", Is.TypeOf(typeof(string)));
140             Assert.That("Hello", Is.Not.TypeOf(typeof(int)));
141 
142             // Inherited syntax
143             Expect("Hello", TypeOf(typeof(string)));
144             Expect("Hello", Not.TypeOf(typeof(int)));
145         }
146 
147         [Test]
148         public void InstanceOfTests()
149         {
150             // Classic syntax
151             Assert.IsInstanceOf(typeof(string), "Hello");
152             Assert.IsNotInstanceOf(typeof(string), 5);
153 
154             // Constraint Syntax
155             Assert.That("Hello", Is.InstanceOf(typeof(string)));
156             Assert.That(5, Is.Not.InstanceOf(typeof(string)));
157 
158             // Inherited syntax
159             Expect("Hello", InstanceOf(typeof(string)));
160             Expect(5, Not.InstanceOf(typeof(string)));
161         }
162 
163         [Test]
164         public void AssignableFromTypeTests()
165         {
166             // Classic syntax
167             Assert.IsAssignableFrom(typeof(string), "Hello");
168             Assert.IsNotAssignableFrom(typeof(string), 5);
169 
170             // Constraint Syntax
171             Assert.That("Hello", Is.AssignableFrom(typeof(string)));
172             Assert.That(5, Is.Not.AssignableFrom(typeof(string)));
173 
174             // Inherited syntax
175             Expect("Hello", AssignableFrom(typeof(string)));
176             Expect(5, Not.AssignableFrom(typeof(string)));
177         }
178         #endregion
179 
180         #region StringConstraint Tests
181         [Test]
182         public void SubstringTests()
183         {
184             string phrase = "Hello World!";
185             string[] array = new string[] { "abc", "bad", "dba" };
186 
187             // Classic Syntax
188             StringAssert.Contains("World", phrase);
189 
190             // Constraint Syntax
191             Assert.That(phrase, Does.Contain("World"));
192             // Only available using new syntax
193             Assert.That(phrase, Does.Not.Contain("goodbye"));
194             Assert.That(phrase, Does.Contain("WORLD").IgnoreCase);
195             Assert.That(phrase, Does.Not.Contain("BYE").IgnoreCase);
196             Assert.That(array, Is.All.Contains("b"));
197 
198             // Inherited syntax
199             Expect(phrase, Contains("World"));
200             // Only available using new syntax
201             Expect(phrase, Not.Contains("goodbye"));
202             Expect(phrase, Contains("WORLD").IgnoreCase);
203             Expect(phrase, Not.Contains("BYE").IgnoreCase);
204             Expect(array, All.Contains("b"));
205         }
206 
207         [Test]
208         public void StartsWithTests()
209         {
210             string phrase = "Hello World!";
211             string[] greetings = new string[] { "Hello!", "Hi!", "Hola!" };
212 
213             // Classic syntax
214             StringAssert.StartsWith("Hello", phrase);
215 
216             // Constraint Syntax
217             Assert.That(phrase, Does.StartWith("Hello"));
218             // Only available using new syntax
219             Assert.That(phrase, Does.Not.StartWith("Hi!"));
220             Assert.That(phrase, Does.StartWith("HeLLo").IgnoreCase);
221             Assert.That(phrase, Does.Not.StartWith("HI").IgnoreCase);
222             Assert.That(greetings, Is.All.StartsWith("h").IgnoreCase);
223 
224             // Inherited syntax
225             Expect(phrase, StartsWith("Hello"));
226             // Only available using new syntax
227             Expect(phrase, Not.StartsWith("Hi!"));
228             Expect(phrase, StartsWith("HeLLo").IgnoreCase);
229             Expect(phrase, Not.StartsWith("HI").IgnoreCase);
230             Expect(greetings, All.StartsWith("h").IgnoreCase);
231         }
232 
233         [Test]
234         public void EndsWithTests()
235         {
236             string phrase = "Hello World!";
237             string[] greetings = new string[] { "Hello!", "Hi!", "Hola!" };
238 
239             // Classic Syntax
240             StringAssert.EndsWith("!", phrase);
241 
242             // Constraint Syntax
243             Assert.That(phrase, Does.EndWith("!"));
244             // Only available using new syntax
245             Assert.That(phrase, Does.Not.EndWith("?"));
246             Assert.That(phrase, Does.EndWith("WORLD!").IgnoreCase);
247             Assert.That(greetings, Is.All.EndsWith("!"));
248 
249             // Inherited syntax
250             Expect(phrase, EndsWith("!"));
251             // Only available using new syntax
252             Expect(phrase, Not.EndsWith("?"));
253             Expect(phrase, EndsWith("WORLD!").IgnoreCase);
254             Expect(greetings, All.EndsWith("!"));
255         }
256 
257         [Test]
258         public void EqualIgnoringCaseTests()
259         {
260             string phrase = "Hello World!";
261 
262             // Classic syntax
263             StringAssert.AreEqualIgnoringCase("hello world!", phrase);
264 
265             // Constraint Syntax
266             Assert.That(phrase, Is.EqualTo("hello world!").IgnoreCase);
267             //Only available using new syntax
268             Assert.That(phrase, Is.Not.EqualTo("goodbye world!").IgnoreCase);
269             Assert.That(new string[] { "Hello", "World" },
270                 Is.EqualTo(new object[] { "HELLO", "WORLD" }).IgnoreCase);
271             Assert.That(new string[] { "HELLO", "Hello", "hello" },
272                 Is.All.EqualTo("hello").IgnoreCase);
273 
274             // Inherited syntax
275             Expect(phrase, EqualTo("hello world!").IgnoreCase);
276             //Only available using new syntax
277             Expect(phrase, Not.EqualTo("goodbye world!").IgnoreCase);
278             Expect(new string[] { "Hello", "World" },
279                 EqualTo(new object[] { "HELLO", "WORLD" }).IgnoreCase);
280             Expect(new string[] { "HELLO", "Hello", "hello" },
281                 All.EqualTo("hello").IgnoreCase);
282         }
283 
284         [Test]
285         public void RegularExpressionTests()
286         {
287             string phrase = "Now is the time for all good men to come to the aid of their country.";
288             string[] quotes = new string[] { "Never say never", "It's never too late", "Nevermore!" };
289 
290             // Classic syntax
291             StringAssert.IsMatch("all good men", phrase);
292             StringAssert.IsMatch("Now.*come", phrase);
293 
294             // Constraint Syntax
295             Assert.That(phrase, Does.Match("all good men"));
296             Assert.That(phrase, Does.Match("Now.*come"));
297             // Only available using new syntax
298             Assert.That(phrase, Does.Not.Match("all.*men.*good"));
299             Assert.That(phrase, Does.Match("ALL").IgnoreCase);
300             Assert.That(quotes, Is.All.Matches("never").IgnoreCase);
301 
302             // Inherited syntax
303             Expect(phrase, Matches("all good men"));
304             Expect(phrase, Matches("Now.*come"));
305             // Only available using new syntax
306             Expect(phrase, Not.Matches("all.*men.*good"));
307             Expect(phrase, Matches("ALL").IgnoreCase);
308             Expect(quotes, All.Matches("never").IgnoreCase);
309         }
310         #endregion
311 
312         #region Equality Tests
313         [Test]
314         public void EqualityTests()
315         {
316             int[] i3 = new int[] { 1, 2, 3 };
317             double[] d3 = new double[] { 1.0, 2.0, 3.0 };
318             int[] iunequal = new int[] { 1, 3, 2 };
319 
320             // Classic Syntax
321             Assert.AreEqual(4, 2 + 2);
322             Assert.AreEqual(i3, d3);
323             Assert.AreNotEqual(5, 2 + 2);
324             Assert.AreNotEqual(i3, iunequal);
325 
326             // Constraint Syntax
327             Assert.That(2 + 2, Is.EqualTo(4));
328             Assert.That(2 + 2 == 4);
329             Assert.That(i3, Is.EqualTo(d3));
330             Assert.That(2 + 2, Is.Not.EqualTo(5));
331             Assert.That(i3, Is.Not.EqualTo(iunequal));
332 
333             // Inherited syntax
334             Expect(2 + 2, EqualTo(4));
335             Expect(2 + 2 == 4);
336             Expect(i3, EqualTo(d3));
337             Expect(2 + 2, Not.EqualTo(5));
338             Expect(i3, Not.EqualTo(iunequal));
339         }
340 
341         [Test]
342         public void EqualityTestsWithTolerance()
343         {
344             // CLassic syntax
345             Assert.AreEqual(5.0d, 4.99d, 0.05d);
346             Assert.AreEqual(5.0f, 4.99f, 0.05f);
347 
348             // Constraint Syntax
349             Assert.That(4.99d, Is.EqualTo(5.0d).Within(0.05d));
350             Assert.That(4.0d, Is.Not.EqualTo(5.0d).Within(0.5d));
351             Assert.That(4.99f, Is.EqualTo(5.0f).Within(0.05f));
352             Assert.That(4.99m, Is.EqualTo(5.0m).Within(0.05m));
353             Assert.That(3999999999u, Is.EqualTo(4000000000u).Within(5u));
354             Assert.That(499, Is.EqualTo(500).Within(5));
355             Assert.That(4999999999L, Is.EqualTo(5000000000L).Within(5L));
356             Assert.That(5999999999ul, Is.EqualTo(6000000000ul).Within(5ul));
357 
358             // Inherited syntax
359             Expect(4.99d, EqualTo(5.0d).Within(0.05d));
360             Expect(4.0d, Not.EqualTo(5.0d).Within(0.5d));
361             Expect(4.99f, EqualTo(5.0f).Within(0.05f));
362             Expect(4.99m, EqualTo(5.0m).Within(0.05m));
363             Expect(499u, EqualTo(500u).Within(5u));
364             Expect(499, EqualTo(500).Within(5));
365             Expect(4999999999L, EqualTo(5000000000L).Within(5L));
366             Expect(5999999999ul, EqualTo(6000000000ul).Within(5ul));
367         }
368 
369         [Test]
370         public void EqualityTestsWithTolerance_MixedFloatAndDouble()
371         {
372             // Bug Fix 1743844
373             Assert.That(2.20492d, Is.EqualTo(2.2d).Within(0.01f),
374                 "Double actual, Double expected, Single tolerance");
375             Assert.That(2.20492d, Is.EqualTo(2.2f).Within(0.01d),
376                 "Double actual, Single expected, Double tolerance");
377             Assert.That(2.20492d, Is.EqualTo(2.2f).Within(0.01f),
378                 "Double actual, Single expected, Single tolerance");
379             Assert.That(2.20492f, Is.EqualTo(2.2f).Within(0.01d),
380                 "Single actual, Single expected, Double tolerance");
381             Assert.That(2.20492f, Is.EqualTo(2.2d).Within(0.01d),
382                 "Single actual, Double expected, Double tolerance");
383             Assert.That(2.20492f, Is.EqualTo(2.2d).Within(0.01f),
384                 "Single actual, Double expected, Single tolerance");
385         }
386 
387         [Test]
388         public void EqualityTestsWithTolerance_MixingTypesGenerally()
389         {
390             // Extending tolerance to all numeric types
391             Assert.That(202d, Is.EqualTo(200d).Within(2),
392                 "Double actual, Double expected, int tolerance");
393             Assert.That(4.87m, Is.EqualTo(5).Within(.25),
394                 "Decimal actual, int expected, Double tolerance");
395             Assert.That(4.87m, Is.EqualTo(5ul).Within(1),
396                 "Decimal actual, ulong expected, int tolerance");
397             Assert.That(487, Is.EqualTo(500).Within(25),
398                 "int actual, int expected, int tolerance");
399             Assert.That(487u, Is.EqualTo(500).Within(25),
400                 "uint actual, int expected, int tolerance");
401             Assert.That(487L, Is.EqualTo(500).Within(25),
402                 "long actual, int expected, int tolerance");
403             Assert.That(487ul, Is.EqualTo(500).Within(25),
404                 "ulong actual, int expected, int tolerance");
405         }
406         #endregion
407 
408         #region Comparison Tests
409         [Test]
410         public void ComparisonTests()
411         {
412             // Classic Syntax
413             Assert.Greater(7, 3);
414             Assert.GreaterOrEqual(7, 3);
415             Assert.GreaterOrEqual(7, 7);
416 
417             // Constraint Syntax
418             Assert.That(7, Is.GreaterThan(3));
419             Assert.That(7, Is.GreaterThanOrEqualTo(3));
420             Assert.That(7, Is.AtLeast(3));
421             Assert.That(7, Is.GreaterThanOrEqualTo(7));
422             Assert.That(7, Is.AtLeast(7));
423 
424             // Inherited syntax
425             Expect(7, GreaterThan(3));
426             Expect(7, GreaterThanOrEqualTo(3));
427             Expect(7, AtLeast(3));
428             Expect(7, GreaterThanOrEqualTo(7));
429             Expect(7, AtLeast(7));
430 
431             // Classic syntax
432             Assert.Less(3, 7);
433             Assert.LessOrEqual(3, 7);
434             Assert.LessOrEqual(3, 3);
435 
436             // Constraint Syntax
437             Assert.That(3, Is.LessThan(7));
438             Assert.That(3, Is.LessThanOrEqualTo(7));
439             Assert.That(3, Is.AtMost(7));
440             Assert.That(3, Is.LessThanOrEqualTo(3));
441             Assert.That(3, Is.AtMost(3));
442 
443             // Inherited syntax
444             Expect(3, LessThan(7));
445             Expect(3, LessThanOrEqualTo(7));
446             Expect(3, AtMost(7));
447             Expect(3, LessThanOrEqualTo(3));
448             Expect(3, AtMost(3));
449         }
450         #endregion
451 
452         #region Collection Tests
453         [Test]
454         public void AllItemsTests()
455         {
456             object[] ints = new object[] { 1, 2, 3, 4 };
457             object[] doubles = new object[] { 0.99, 2.1, 3.0, 4.05 };
458             object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
459 
460             // Classic syntax
461             CollectionAssert.AllItemsAreNotNull(ints);
462             CollectionAssert.AllItemsAreInstancesOfType(ints, typeof(int));
463             CollectionAssert.AllItemsAreInstancesOfType(strings, typeof(string));
464             CollectionAssert.AllItemsAreUnique(ints);
465 
466             // Constraint Syntax
467             Assert.That(ints, Is.All.Not.Null);
468             Assert.That(ints, Has.None.Null);
469             Assert.That(ints, Is.All.InstanceOf(typeof(int)));
470             Assert.That(ints, Has.All.InstanceOf(typeof(int)));
471             Assert.That(strings, Is.All.InstanceOf(typeof(string)));
472             Assert.That(strings, Has.All.InstanceOf(typeof(string)));
473             Assert.That(ints, Is.Unique);
474             // Only available using new syntax
475             Assert.That(strings, Is.Not.Unique);
476             Assert.That(ints, Is.All.GreaterThan(0));
477             Assert.That(ints, Has.All.GreaterThan(0));
478             Assert.That(ints, Has.None.LessThanOrEqualTo(0));
479             Assert.That(strings, Is.All.Contains("a"));
480             Assert.That(strings, Has.All.Contains("a"));
481             Assert.That(strings, Has.Some.StartsWith("ba"));
482             Assert.That(strings, Has.Some.Property("Length").EqualTo(3));
483             Assert.That(strings, Has.Some.StartsWith("BA").IgnoreCase);
484             Assert.That(doubles, Has.Some.EqualTo(1.0).Within(.05));
485 
486             // Inherited syntax
487             Expect(ints, All.Not.Null);
488             Expect(ints, None.Null);
489             Expect(ints, All.InstanceOf(typeof(int)));
490             Expect(strings, All.InstanceOf(typeof(string)));
491             Expect(ints, Unique);
492             // Only available using new syntax
493             Expect(strings, Not.Unique);
494             Expect(ints, All.GreaterThan(0));
495             Expect(ints, None.LessThanOrEqualTo(0));
496             Expect(strings, All.Contains("a"));
497             Expect(strings, Some.StartsWith("ba"));
498             Expect(strings, Some.StartsWith("BA").IgnoreCase);
499             Expect(doubles, Some.EqualTo(1.0).Within(.05));
500         }
501 
502         [Test]
503         public void SomeItemTests()
504         {
505             object[] mixed = new object[] { 1, 2, "3", null, "four", 100 };
506             object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
507 
508             // Not available using the classic syntax
509 
510             // Constraint Syntax
511             Assert.That(mixed, Has.Some.Null);
512             Assert.That(mixed, Has.Some.InstanceOf(typeof(int)));
513             Assert.That(mixed, Has.Some.InstanceOf(typeof(string)));
514             Assert.That(strings, Has.Some.StartsWith("ba"));
515             Assert.That(strings, Has.Some.Not.StartsWith("ba"));
516 
517             // Inherited syntax
518             Expect(mixed, Some.Null);
519             Expect(mixed, Some.InstanceOf(typeof(int)));
520             Expect(mixed, Some.InstanceOf(typeof(string)));
521             Expect(strings, Some.StartsWith("ba"));
522             Expect(strings, Some.Not.StartsWith("ba"));
523         }
524 
525         [Test]
526         public void NoItemTests()
527         {
528             object[] ints = new object[] { 1, 2, 3, 4, 5 };
529             object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
530 
531             // Not available using the classic syntax
532 
533             // Constraint Syntax
534             Assert.That(ints, Has.None.Null);
535             Assert.That(ints, Has.None.InstanceOf(typeof(string)));
536             Assert.That(ints, Has.None.GreaterThan(99));
537             Assert.That(strings, Has.None.StartsWith("qu"));
538 
539             // Inherited syntax
540             Expect(ints, None.Null);
541             Expect(ints, None.InstanceOf(typeof(string)));
542             Expect(ints, None.GreaterThan(99));
543             Expect(strings, None.StartsWith("qu"));
544         }
545 
546         [Test]
547         public void CollectionContainsTests()
548         {
549             int[] iarray = new int[] { 1, 2, 3 };
550             string[] sarray = new string[] { "a", "b", "c" };
551 
552             // Classic syntax
553             Assert.Contains(3, iarray);
554             Assert.Contains("b", sarray);
555             CollectionAssert.Contains(iarray, 3);
556             CollectionAssert.Contains(sarray, "b");
557             CollectionAssert.DoesNotContain(sarray, "x");
558             // Showing that Contains uses NUnit equality
559             CollectionAssert.Contains(iarray, 1.0d);
560 
561             // Constraint Syntax
562             Assert.That(iarray, Has.Member(3));
563             Assert.That(sarray, Has.Member("b"));
564             Assert.That(sarray, Has.No.Member("x"));
565             // Showing that Contains uses NUnit equality
566             Assert.That(iarray, Has.Member(1.0d));
567 
568             // Only available using the new syntax
569             // Note that EqualTo and SameAs do NOT give
570             // identical results to Contains because 
571             // Contains uses Object.Equals()
572             Assert.That(iarray, Has.Some.EqualTo(3));
573             Assert.That(iarray, Has.Member(3));
574             Assert.That(sarray, Has.Some.EqualTo("b"));
575             Assert.That(sarray, Has.None.EqualTo("x"));
576             Assert.That(iarray, Has.None.SameAs(1.0d));
577             Assert.That(iarray, Has.All.LessThan(10));
578             Assert.That(sarray, Has.All.Length.EqualTo(1));
579             Assert.That(sarray, Has.None.Property("Length").GreaterThan(3));
580 
581             // Inherited syntax
582             Expect(iarray, Contains(3));
583             Expect(sarray, Contains("b"));
584             Expect(sarray, Not.Contains("x"));
585 
586             // Only available using new syntax
587             // Note that EqualTo and SameAs do NOT give
588             // identical results to Contains because 
589             // Contains uses Object.Equals()
590             Expect(iarray, Some.EqualTo(3));
591             Expect(sarray, Some.EqualTo("b"));
592             Expect(sarray, None.EqualTo("x"));
593             Expect(iarray, All.LessThan(10));
594             Expect(sarray, All.Length.EqualTo(1));
595             Expect(sarray, None.Property("Length").GreaterThan(3));
596         }
597 
598         [Test]
599         public void CollectionEquivalenceTests()
600         {
601             int[] ints1to5 = new int[] { 1, 2, 3, 4, 5 };
602             int[] twothrees = new int[] { 1, 2, 3, 3, 4, 5 };
603             int[] twofours = new int[] { 1, 2, 3, 4, 4, 5 };
604 
605             // Classic syntax
606             CollectionAssert.AreEquivalent(new int[] { 2, 1, 4, 3, 5 }, ints1to5);
607             CollectionAssert.AreNotEquivalent(new int[] { 2, 2, 4, 3, 5 }, ints1to5);
608             CollectionAssert.AreNotEquivalent(new int[] { 2, 4, 3, 5 }, ints1to5);
609             CollectionAssert.AreNotEquivalent(new int[] { 2, 2, 1, 1, 4, 3, 5 }, ints1to5);
610             CollectionAssert.AreNotEquivalent(twothrees, twofours);
611 
612             // Constraint Syntax
613             Assert.That(new int[] { 2, 1, 4, 3, 5 }, Is.EquivalentTo(ints1to5));
614             Assert.That(new int[] { 2, 2, 4, 3, 5 }, Is.Not.EquivalentTo(ints1to5));
615             Assert.That(new int[] { 2, 4, 3, 5 }, Is.Not.EquivalentTo(ints1to5));
616             Assert.That(new int[] { 2, 2, 1, 1, 4, 3, 5 }, Is.Not.EquivalentTo(ints1to5));
617 
618             // Inherited syntax
619             Expect(new int[] { 2, 1, 4, 3, 5 }, EquivalentTo(ints1to5));
620             Expect(new int[] { 2, 2, 4, 3, 5 }, Not.EquivalentTo(ints1to5));
621             Expect(new int[] { 2, 4, 3, 5 }, Not.EquivalentTo(ints1to5));
622             Expect(new int[] { 2, 2, 1, 1, 4, 3, 5 }, Not.EquivalentTo(ints1to5));
623         }
624 
625         [Test]
626         public void SubsetTests()
627         {
628             int[] ints1to5 = new int[] { 1, 2, 3, 4, 5 };
629 
630             // Classic syntax
631             CollectionAssert.IsSubsetOf(new int[] { 1, 3, 5 }, ints1to5);
632             CollectionAssert.IsSubsetOf(new int[] { 1, 2, 3, 4, 5 }, ints1to5);
633             CollectionAssert.IsNotSubsetOf(new int[] { 2, 4, 6 }, ints1to5);
634             CollectionAssert.IsNotSubsetOf(new int[] { 1, 2, 2, 2, 5 }, ints1to5);
635 
636             // Constraint Syntax
637             Assert.That(new int[] { 1, 3, 5 }, Is.SubsetOf(ints1to5));
638             Assert.That(new int[] { 1, 2, 3, 4, 5 }, Is.SubsetOf(ints1to5));
639             Assert.That(new int[] { 2, 4, 6 }, Is.Not.SubsetOf(ints1to5));
640 
641             // Inherited syntax
642             Expect(new int[] { 1, 3, 5 }, SubsetOf(ints1to5));
643             Expect(new int[] { 1, 2, 3, 4, 5 }, SubsetOf(ints1to5));
644             Expect(new int[] { 2, 4, 6 }, Not.SubsetOf(ints1to5));
645         }
646         #endregion
647 
648         #region Property Tests
649         [Test]
650         public void PropertyTests()
651         {
652             string[] array = { "abc", "bca", "xyz", "qrs" };
653             string[] array2 = { "a", "ab", "abc" };
654             ArrayList list = new ArrayList(array);
655 
656             // Not available using the classic syntax
657 
658             // Constraint Syntax
659             Assert.That(list, Has.Property("Count"));
660             Assert.That(list, Has.No.Property("Length"));
661 
662             Assert.That("Hello", Has.Length.EqualTo(5));
663             Assert.That("Hello", Has.Length.LessThan(10));
664             Assert.That("Hello", Has.Property("Length").EqualTo(5));
665             Assert.That("Hello", Has.Property("Length").GreaterThan(3));
666 
667             Assert.That(array, Has.Property("Length").EqualTo(4));
668             Assert.That(array, Has.Length.EqualTo(4));
669             Assert.That(array, Has.Property("Length").LessThan(10));
670 
671             Assert.That(array, Has.All.Property("Length").EqualTo(3));
672             Assert.That(array, Has.All.Length.EqualTo(3));
673             Assert.That(array, Is.All.Length.EqualTo(3));
674             Assert.That(array, Has.All.Property("Length").EqualTo(3));
675             Assert.That(array, Is.All.Property("Length").EqualTo(3));
676 
677             Assert.That(array2, Has.Some.Property("Length").EqualTo(2));
678             Assert.That(array2, Has.Some.Length.EqualTo(2));
679             Assert.That(array2, Has.Some.Property("Length").GreaterThan(2));
680 
681             Assert.That(array2, Is.Not.Property("Length").EqualTo(4));
682             Assert.That(array2, Is.Not.Length.EqualTo(4));
683             Assert.That(array2, Has.No.Property("Length").GreaterThan(3));
684 
685             Assert.That(List.Map(array2).Property("Length"), Is.EqualTo(new int[] { 1, 2, 3 }));
686             Assert.That(List.Map(array2).Property("Length"), Is.EquivalentTo(new int[] { 3, 2, 1 }));
687             Assert.That(List.Map(array2).Property("Length"), Is.SubsetOf(new int[] { 1, 2, 3, 4, 5 }));
688             Assert.That(List.Map(array2).Property("Length"), Is.Unique);
689 
690             Assert.That(list, Has.Count.EqualTo(4));
691 
692             // Inherited syntax
693             Expect(list, Property("Count"));
694             Expect(list, Not.Property("Nada"));
695 
696             Expect("Hello", Length.EqualTo(5));
697             Expect("Hello", Property("Length").EqualTo(5));
698             Expect("Hello", Property("Length").GreaterThan(0));
699 
700             Expect(array, Property("Length").EqualTo(4));
701             Expect(array, Length.EqualTo(4));
702             Expect(array, Property("Length").LessThan(10));
703 
704             Expect(array, All.Length.EqualTo(3));
705             Expect(array, All.Property("Length").EqualTo(3));
706 
707             Expect(array2, Some.Property("Length").EqualTo(2));
708             Expect(array2, Some.Length.EqualTo(2));
709             Expect(array2, Some.Property("Length").GreaterThan(2));
710 
711             Expect(array2, None.Property("Length").EqualTo(4));
712             Expect(array2, None.Length.EqualTo(4));
713             Expect(array2, None.Property("Length").GreaterThan(3));
714 
715             Expect(Map(array2).Property("Length"), EqualTo(new int[] { 1, 2, 3 }));
716             Expect(Map(array2).Property("Length"), EquivalentTo(new int[] { 3, 2, 1 }));
717             Expect(Map(array2).Property("Length"), SubsetOf(new int[] { 1, 2, 3, 4, 5 }));
718             Expect(Map(array2).Property("Length"), Unique);
719 
720             Expect(list, Count.EqualTo(4));
721 
722         }
723         #endregion
724 
725         #region Not Tests
726         [Test]
727         public void NotTests()
728         {
729             // Not available using the classic syntax
730 
731             // Constraint Syntax
732             Assert.That(42, Is.Not.Null);
733             Assert.That(42, Is.Not.True);
734             Assert.That(42, Is.Not.False);
735             Assert.That(2.5, Is.Not.NaN);
736             Assert.That(2 + 2, Is.Not.EqualTo(3));
737             Assert.That(2 + 2, Is.Not.Not.EqualTo(4));
738             Assert.That(2 + 2, Is.Not.Not.Not.EqualTo(5));
739 
740             // Inherited syntax
741             Expect(42, Not.Null);
742             Expect(42, Not.True);
743             Expect(42, Not.False);
744             Expect(2.5, Not.NaN);
745             Expect(2 + 2, Not.EqualTo(3));
746             Expect(2 + 2, Not.Not.EqualTo(4));
747             Expect(2 + 2, Not.Not.Not.EqualTo(5));
748         }
749         #endregion
750 
751         #region Operator Tests
752         [Test]
753         public void NotOperator()
754         {
755             // The ! operator is only available in the new syntax
756             Assert.That(42, !Is.Null);
757             // Inherited syntax
758             Expect(42, !Null);
759         }
760 
761         [Test]
762         public void AndOperator()
763         {
764             // The & operator is only available in the new syntax
765             Assert.That(7, Is.GreaterThan(5) & Is.LessThan(10));
766             // Inherited syntax
767             Expect(7, GreaterThan(5) & LessThan(10));
768         }
769 
770         [Test]
771         public void OrOperator()
772         {
773             // The | operator is only available in the new syntax
774             Assert.That(3, Is.LessThan(5) | Is.GreaterThan(10));
775             Expect(3, LessThan(5) | GreaterThan(10));
776         }
777 
778         [Test]
779         public void ComplexTests()
780         {
781             Assert.That(7, Is.Not.Null & Is.Not.LessThan(5) & Is.Not.GreaterThan(10));
782             Expect(7, Not.Null & Not.LessThan(5) & Not.GreaterThan(10));
783 
784             Assert.That(7, !Is.Null & !Is.LessThan(5) & !Is.GreaterThan(10));
785             Expect(7, !Null & !LessThan(5) & !GreaterThan(10));
786 
787             // No longer works at all under 3.0
788             // TODO: Evaluate why we wanted to use null in this setting in the first place
789 #if false
790                 // TODO: Remove #if when mono compiler can handle null
791 #if MONO
792                 Constraint x = null;
793                 Assert.That(7, !x & !Is.LessThan(5) & !Is.GreaterThan(10));
794                 Expect(7, !x & !LessThan(5) & !GreaterThan(10));
795 #else
796                 Assert.That(7, !(Constraint)null & !Is.LessThan(5) & !Is.GreaterThan(10));
797                 Expect(7, !(Constraint)null & !LessThan(5) & !GreaterThan(10));
798 #endif
799 #endif
800         }
801         #endregion
802 
803         #region Invalid Code Tests
804         // This method contains assertions that should not compile
805         // You can check by uncommenting it.
806         //public void WillNotCompile()
807         //{
808         //    Assert.That(42, Is.Not);
809         //    Assert.That(42, Is.All);
810         //    Assert.That(42, Is.Null.Not);
811         //    Assert.That(42, Is.Not.Null.GreaterThan(10));
812         //    Assert.That(42, Is.GreaterThan(10).LessThan(99));
813 
814         //    object[] c = new object[0];
815         //    Assert.That(c, Is.Null.All);
816         //    Assert.That(c, Is.Not.All);
817         //    Assert.That(c, Is.All.Not);
818         //}
819         #endregion
820     }
821 
822 #endregion