首页 > 代码库 > 走进 .Net 单元测试
走进 .Net 单元测试
走进 .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 }
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
单元测试参考资料
- MSDN - Microsoft.VisualStudio.TestTools.UnitTesting
- 单元测试之道
- VS2012 Unit Test 个人学习汇总（含目录）
- 单元测试的优点
- 对比MS Test与NUnit Test框架
走进 .Net 单元测试
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。