加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 (https://www.lidatong.com.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 编程开发 > asp.Net > 正文

走进 .Net 单元测试

发布时间:2020-12-16 09:01:31 所属栏目:asp.Net 来源:网络整理
导读:走进 .Net 单元测试 Intro “不会写单元测试的程序员不是合格的程序员,不写单元测试的程序员不是优秀程序员。” —— 一只想要成为一个优秀程序员的渣逼程序猿。 那么问题来了,什么是单元测试,如何做单元测试。 单元测试定义 按照维基百科上的说法,单元

走进 .Net 单元测试

Intro

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

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

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

单元测试定义

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

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

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

进行单元测试的好处

  1. 它是一种验证行为

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

  2. 它是一种设计行为

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

  3. 它是一种编写文档的行为

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

  4. 它具有回归性

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

  5. 高效

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

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

单元测试的原则:

  • 可重复运行的
  • 持续长期有效,并且返回一致的结果
  • 在内存中运行,没有外部依赖组件(比如说真实的数据库,真实的文件存储等)
  • 快速返回结果
  • 一个测试方法只测试一个问题

VS单元测试 【MsTest】使用

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

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

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

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

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

#region NUNIT
  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>
    [TestFixture]
 17      AssertSyntaxTests : AssertionHelper
 19         #region Simple Constraint Tests
        [Test]
 21          IsNull()
 23             object nada =  24 
 25              Classic syntax
            Assert.IsNull(nada);
 27 
 28              Constraint Syntax
 29             Assert.That(nada,Is.Null);
 30 
 31              Inherited syntax
            Expect(nada,Null);
 34 
 35  36          IsNotNull()
 37  38              39             Assert.IsNotNull(42 40 
 41              42             Assert.That(,Is.Not.Null);
 43 
 44              45             Expect( 47 
 48  IsTrue()
 50  51              52             Assert.IsTrue(2 + 2 == 4 53 
 54              55             Assert.That( 56             Assert.That( 58              59             Expect( 60             Expect( 61  62 
 63  64          IsFalse()
 65  66              67             Assert.IsFalse(5 68 
 69              70             Assert.That( 72              73             Expect( 75 
 IsNaN()
 78  79             double d = double.NaN;
 80             float f = float 81 
 82              83             Assert.IsNaN(d);
 84             Assert.IsNaN(f);
 85 
 86                         Assert.That(d,Is.NaN);
 88             Assert.That(f,1)"> 89 
 91             Expect(d,NaN);
            Expect(f,1)"> 93  94 
 95  96          EmptyStringTests()
 97  98              99             Assert.IsEmpty(""100             Assert.IsNotEmpty(Hello!101 
102             103             Assert.That(104             Assert.That(105 
106             107             Expect(108             Expect(109 110 
111 112          EmptyCollectionTests()
114             115             Assert.IsEmpty(bool[0]);
116             Assert.IsNotEmpty(int[] { 2,1)">3 });
117 
118             119             Assert.That(],1)">120             Assert.That( },1)">121 
122             123             Expect(124             Expect(126         127 
128         #region TypeConstraint Tests
 ExactTypeTests()
 Classic syntax workarounds
133             Assert.AreEqual(typeof(string),1)">.GetType());
134             Assert.AreEqual(System.String.GetType().FullName);
135             Assert.AreNotEqual(int),1)">136             Assert.AreNotEqual(System.Int32137 
138             139             Assert.That(string)));
140             Assert.That(int141 
142             143             Expect(144             Expect(146 
148          InstanceOfTests()
149 150             151             Assert.IsInstanceOf(152             Assert.IsNotInstanceOf(153 
154             155             Assert.That(156             Assert.That(5,Is.Not.InstanceOf(157 
158             159             Expect(160             Expect(162 
163 164          AssignableFromTypeTests()
165 166             167             Assert.IsAssignableFrom(168             Assert.IsNotAssignableFrom(169 
170             171             Assert.That(172             Assert.That(173 
174             175             Expect(176             Expect(177 178         179 
180         #region StringConstraint Tests
 SubstringTests()
183 184             string phrase = Hello World!185             string[] array = string[] { abcbaddba };
186 
187              Classic Syntax
188             StringAssert.Contains(World189 
190             191             Assert.That(phrase,Does.Contain());
192              Only available using new syntax
193             Assert.That(phrase,Does.Not.Contain(goodbye194             Assert.That(phrase,1)">WORLD).IgnoreCase);
195             Assert.That(phrase,1)">BYE196             Assert.That(array,Is.All.Contains(b197 
198             199             Expect(phrase,Contains(200             201             Expect(phrase,Not.Contains(202             Expect(phrase,1)">203             Expect(phrase,1)">204             Expect(array,All.Contains(206 
208          StartsWithTests()
210             211             string[] greetings = Hi!Hola!212 
213             214             StringAssert.StartsWith(215 
216             217             Assert.That(phrase,Does.StartWith(218             219             Assert.That(phrase,Does.Not.StartWith(220             Assert.That(phrase,1)">HeLLo221             Assert.That(phrase,1)">HI222             Assert.That(greetings,Is.All.StartsWith(h223 
224             225             Expect(phrase,StartsWith(226             227             Expect(phrase,Not.StartsWith(228             Expect(phrase,1)">229             Expect(phrase,1)">230             Expect(greetings,All.StartsWith(231 232 
233 234          EndsWithTests()
235 236             237             238 
239             240             StringAssert.EndsWith(!241 
242             243             Assert.That(phrase,Does.EndWith(244             245             Assert.That(phrase,Does.Not.EndWith(?246             Assert.That(phrase,1)">WORLD!247             Assert.That(greetings,Is.All.EndsWith(248 
249             250             Expect(phrase,EndsWith(251             252             Expect(phrase,Not.EndsWith(253             Expect(phrase,1)">254             Expect(greetings,All.EndsWith(255 256 
257 258          EqualIgnoringCaseTests()
259 260             261 
262             263             StringAssert.AreEqualIgnoringCase(hello world!264 
265             266             Assert.That(phrase,Is.EqualTo(267             Only available using new syntax
268             Assert.That(phrase,Is.Not.EqualTo(goodbye world!269             Assert.That(270                 Is.EqualTo(object[] { HELLO }).IgnoreCase);
271             Assert.That(272                 Is.All.EqualTo(273 
274             275             Expect(phrase,EqualTo(276             277             Expect(phrase,Not.EqualTo(278             Expect(279                 EqualTo(280             Expect(281                 All.EqualTo(282 283 
284 285          RegularExpressionTests()
286 287             Now is the time for all good men to come to the aid of their country.288             string[] quotes = Never say neverIt's never too lateNevermore!289 
290             291             StringAssert.IsMatch(all good men292             StringAssert.IsMatch(Now.*come293 
294             295             Assert.That(phrase,Does.Match(296             Assert.That(phrase,1)">297             298             Assert.That(phrase,Does.Not.Match(all.*men.*good299             Assert.That(phrase,1)">ALL300             Assert.That(quotes,Is.All.Matches(never301 
302             303             Expect(phrase,Matches(304             Expect(phrase,1)">305             306             Expect(phrase,Not.Matches(307             Expect(phrase,1)">308             Expect(quotes,All.Matches(309 310         311 
312         #region Equality Tests
313 314          EqualityTests()
315 316             int[] i3 = 317             double[] d3 = double[] { 1.0,1)">2.0,1)">3.0318             int[] iunequal = 3,1)">319 
320             321             Assert.AreEqual(4,1)">322             Assert.AreEqual(i3,d3);
323             Assert.AreNotEqual(324             Assert.AreNotEqual(i3,iunequal);
325 
326             327             Assert.That(328             Assert.That(329             Assert.That(i3,Is.EqualTo(d3));
330             Assert.That(331 332 
333             334             Expect(335             Expect(336             Expect(i3,EqualTo(d3));
337             Expect(338 339 340 
341 342          EqualityTestsWithTolerance()
343 344              CLassic syntax
345             Assert.AreEqual(5.0d,1)">4.99d,1)">0.05d346             Assert.AreEqual(5.0f,1)">4.99f,1)">0.05f347 
348             349             Assert.That(5.0d).Within(350             Assert.That(4.0d,1)">0.5d351             Assert.That(5.0f).Within(352             Assert.That(4.99m,1)">5.0m).Within(0.05m353             Assert.That(3999999999u,1)">4000000000u).Within(5u354             Assert.That(499,1)">500).Within(355             Assert.That(4999999999L,1)">5000000000L).Within(5L356             Assert.That(5999999999ul,1)">6000000000ul).Within(5ul357 
358             359             Expect(360             Expect(361             Expect(362             Expect(363             Expect(499u,1)">500u).Within(364             Expect(365             Expect(366             Expect(367 368 
369 370          EqualityTestsWithTolerance_MixedFloatAndDouble()
371 372              Bug Fix 1743844
373             Assert.That(2.20492d,1)">2.2d).Within(0.01f),1)">374                 Double actual,Double expected,Single tolerance375             Assert.That(2.2f).Within(0.01d376                 377             Assert.That(378                 379             Assert.That(2.20492f,1)">380                 Single actual,1)">381             Assert.That(382                 383             Assert.That(384                 385 386 
387 388          EqualityTestsWithTolerance_MixingTypesGenerally()
389 390              Extending tolerance to all numeric types
391             Assert.That(202d,Is.EqualTo(200d).Within(392                 393             Assert.That(4.87m,1)">5).Within(.25394                 Decimal actual,int expected,1)">395             Assert.That(5ul).Within(396                 397             Assert.That(487,1)">398                 int actual,1)">399             Assert.That(487u,1)">400                 uint actual,1)">401             Assert.That(487L,1)">402                 long actual,1)">403             Assert.That(487ul,1)">404                 ulong actual,1)">405 406         407 
408         #region Comparison Tests
409 410          ComparisonTests()
411 412             413             Assert.Greater(7,1)">414             Assert.GreaterOrEqual(415             Assert.GreaterOrEqual(7416 
417             418             Assert.That(419             Assert.That(420             Assert.That(421             Assert.That(422             Assert.That(423 
424             425             Expect(426             Expect(427             Expect(428             Expect(429             Expect(430 
431             432             Assert.Less(433             Assert.LessOrEqual(434             Assert.LessOrEqual(435 
436             437             Assert.That(438             Assert.That(439             Assert.That(440             Assert.That(441             Assert.That(442 
443             444             Expect(445             Expect(446             Expect(447             Expect(448             Expect(449 450         451 
452         #region Collection Tests
453 454          AllItemsTests()
455 456             object[] ints = 457             object[] doubles = 0.99,1)">2.1,1)">3.0,1)">4.05458             object[] strings = cabdad459 
460             461             CollectionAssert.AllItemsAreNotNull(ints);
462             CollectionAssert.AllItemsAreInstancesOfType(ints,1)">463             CollectionAssert.AllItemsAreInstancesOfType(strings,1)">464             CollectionAssert.AllItemsAreUnique(ints);
465 
466             467             Assert.That(ints,Is.All.Not.Null);
468 469             Assert.That(ints,Is.All.InstanceOf(470             Assert.That(ints,Has.All.InstanceOf(471             Assert.That(strings,1)">472             Assert.That(strings,1)">473 474             475             Assert.That(strings,Is.Not.Unique);
476             Assert.That(ints,Is.All.GreaterThan(477             Assert.That(ints,Has.All.GreaterThan(478             Assert.That(ints,Has.None.LessThanOrEqualTo(479             Assert.That(strings,1)">a480             Assert.That(strings,Has.All.Contains(481             Assert.That(strings,Has.Some.StartsWith(ba482             Assert.That(strings,Has.Some.Property(Length").EqualTo(483             Assert.That(strings,1)">BA484             Assert.That(doubles,Has.Some.EqualTo(1.0).Within(.05485 
486             487             Expect(ints,All.Not.Null);
488 489             Expect(ints,All.InstanceOf(490             Expect(strings,1)">491 492             493             Expect(strings,Not.Unique);
494             Expect(ints,All.GreaterThan(495             Expect(ints,None.LessThanOrEqualTo(496             Expect(strings,1)">497             Expect(strings,Some.StartsWith(498             Expect(strings,1)">499             Expect(doubles,Some.EqualTo(500 501 
502 503          SomeItemTests()
504 505             object[] mixed = 3null,1)">four100506             507 
508              Not available using the classic syntax
509 
510             511             Assert.That(mixed,Has.Some.Null);
512             Assert.That(mixed,Has.Some.InstanceOf(513             Assert.That(mixed,1)">514             Assert.That(strings,1)">515             Assert.That(strings,Has.Some.Not.StartsWith(516 
517             518             Expect(mixed,Some.Null);
519             Expect(mixed,Some.InstanceOf(520             Expect(mixed,1)">521             Expect(strings,1)">522             Expect(strings,Some.Not.StartsWith(523 524 
525 526          NoItemTests()
527 528             529             530 
531             532 
533             534 535             Assert.That(ints,Has.None.InstanceOf(536             Assert.That(ints,Has.None.GreaterThan(99537             Assert.That(strings,Has.None.StartsWith(qu538 
539             540 541             Expect(ints,None.InstanceOf(542             Expect(ints,None.GreaterThan(543             Expect(strings,None.StartsWith(544 545 
546 547          CollectionContainsTests()
548 549             int[] iarray = 550             string[] sarray = c551 
552             553             Assert.Contains(554             Assert.Contains(555             CollectionAssert.Contains(iarray,1)">556             CollectionAssert.Contains(sarray,1)">557             CollectionAssert.DoesNotContain(sarray,1)">x558              Showing that Contains uses NUnit equality
559             CollectionAssert.Contains(iarray,1)">1.0d560 
561             562             Assert.That(iarray,Has.Member(563             Assert.That(sarray,1)">564             Assert.That(sarray,Has.No.Member(565             566             Assert.That(iarray,1)">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,1)">573             Assert.That(iarray,1)">574             Assert.That(sarray,1)">575             Assert.That(sarray,Has.None.EqualTo(576             Assert.That(iarray,Has.None.SameAs(577             Assert.That(iarray,Has.All.LessThan(10578             Assert.That(sarray,Has.All.Length.EqualTo(579             Assert.That(sarray,Has.None.Property(").GreaterThan(580 
581             582             Expect(iarray,1)">583             Expect(sarray,1)">584             Expect(sarray,1)">585 
586              Only available using new syntax
587             588             589             590             Expect(iarray,1)">591             Expect(sarray,1)">592             Expect(sarray,None.EqualTo(593             Expect(iarray,All.LessThan(594             Expect(sarray,All.Length.EqualTo(595             Expect(sarray,None.Property(596 597 
598 599          CollectionEquivalenceTests()
600 601             int[] ints1to5 = 602             int[] twothrees = 603             int[] twofours = 604 
605             606             CollectionAssert.AreEquivalent(607             CollectionAssert.AreNotEquivalent(608             CollectionAssert.AreNotEquivalent(609             CollectionAssert.AreNotEquivalent(610             CollectionAssert.AreNotEquivalent(twothrees,twofours);
611 
612             613             Assert.That(614             Assert.That(615             Assert.That(616             Assert.That(617 
618             619             Expect(620             Expect(621             Expect(622             Expect(623 624 
625 626          SubsetTests()
627 628             629 
630             631             CollectionAssert.IsSubsetOf(632             CollectionAssert.IsSubsetOf(633             CollectionAssert.IsNotSubsetOf(6634             CollectionAssert.IsNotSubsetOf(635 
636             637             Assert.That(638             Assert.That(639             Assert.That(640 
641             642             Expect(643             Expect(644             Expect(645 646         647 
648         #region Property Tests
649 650          PropertyTests()
651 652             string[] array = { bcaxyzqrs653             string[] array2 = { ab654             ArrayList list =  ArrayList(array);
655 
656             657 
658             659             Assert.That(list,Has.Property(Count660             Assert.That(list,Has.No.Property(661 
662             Assert.That(663             Assert.That(664             Assert.That(665             Assert.That(666 
667             Assert.That(array,1)">668             Assert.That(array,1)">669             Assert.That(array,1)">").LessThan(670 
671             Assert.That(array,Has.All.Property(672             Assert.That(array,1)">673             Assert.That(array,Is.All.Length.EqualTo(674             Assert.That(array,1)">675             Assert.That(array,Is.All.Property(676 
677             Assert.That(array2,1)">678             Assert.That(array2,Has.Some.Length.EqualTo(679             Assert.That(array2,1)">680 
681             Assert.That(array2,Is.Not.Property(682             Assert.That(array2,Is.Not.Length.EqualTo(683             Assert.That(array2,1)">684 
685             Assert.That(List.Map(array2).Property("),Is.EqualTo( }));
686             Assert.That(List.Map(array2).Property(687             Assert.That(List.Map(array2).Property(688             Assert.That(List.Map(array2).Property(689 
690             Assert.That(list,Has.Count.EqualTo(691 
692             693             Expect(list,Property(694             Expect(list,Not.Property(Nada695 
696             Expect(697             Expect(698             Expect(699 
700             Expect(array,1)">701             Expect(array,1)">702             Expect(array,1)">703 
704             Expect(array,1)">705             Expect(array,All.Property(706 
707             Expect(array2,Some.Property(708             Expect(array2,Some.Length.EqualTo(709             Expect(array2,1)">710 
711             Expect(array2,1)">712             Expect(array2,None.Length.EqualTo(713             Expect(array2,1)">714 
715             Expect(Map(array2).Property(716             Expect(Map(array2).Property(717             Expect(Map(array2).Property(718             Expect(Map(array2).Property(719 
720             Expect(list,Count.EqualTo(721 
722 723         724 
725         #region Not Tests
726 727          NotTests()
728 729             730 
731             732             Assert.That(733             Assert.That(734             Assert.That(735             Assert.That(2.5736             Assert.That(737             Assert.That(738             Assert.That(739 
740             741             Expect(742             Expect(743             Expect(744             Expect(745             Expect(746             Expect(747             Expect(748 749         750 
751         #region Operator Tests
752 753          NotOperator()
754 755              The ! operator is only available in the new syntax
756             Assert.That(42,!Is.Null);
757             758             Expect(Null);
759 760 
761 762          AndOperator()
763 764              The & operator is only available in the new syntax
765             Assert.That(5) & Is.LessThan(766             767             Expect(5) & LessThan(768 769 
770 771          OrOperator()
772 773              The | operator is only available in the new syntax
774             Assert.That(5) | Is.GreaterThan(775             Expect(5) | GreaterThan(776 777 
778 779          ComplexTests()
780 781             Assert.That(5) & Is.Not.GreaterThan(782             Expect(5) & Not.GreaterThan(783 
784             Assert.That(5) & !Is.GreaterThan(785             Expect(5) & !GreaterThan(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 = 793                 Assert.That(794                 Expect(795 #else
796                 Assert.That(null & !Is.LessThan(797                 Expect(null & !LessThan(798 #endif
799 800 801         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         810         811         812         813 
814             object[] c = new object[0];
815             Assert.That(c,Is.Null.All);
816         817         818         }
819         820 821 
822 #endregion
Nunit 单元测试

?

单元测试参考资料

  • MSDN - Microsoft.VisualStudio.TestTools.UnitTesting
  • 单元测试之道
  • VS2012 Unit Test 个人学习汇总(含目录)
  • 单元测试的优点
  • 对比MS Test与NUnit Test框架

(编辑:李大同)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章
      热点阅读