Nunit说明及简单DEMO

using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;

//安装好NUnit后，环境是XP的，发现无法启动，修改一下配置后才能运行

   //修改NUnit.exe.config，在
   //1. 在  下 加 
   //  
   //   
   // 
   // 2. 在  加

   // 

   //  …… 
   //  
   //  …… 
   // 
namespace Nunit
{ 
    [TestFixtureAttribute]
    //用来修饰测试类。这个属性标记一个类包含了测试方法。
    //被TestFixtureAttribute修饰的类需满足以下限制
    //    a.必须是一个public类型，否则NUnit不会识别它。 
    //    b.它必须有一个缺省的构造子，否则Nunit不能构建他。 
    //    c.构造子不应该有任何方面的负面影响，因为在一个对话的过程中，NUnit可能构造类多次。 
   public class Program
   {
        int a = 0;
        int b = 0;
       [Test]
       // 用来修饰测试方法。Test属性标记某个类的某个方法为一个测试方法，而且此类必需已经标记为一个TestFixture
       static void Main(string[] args)
       {
       }
        //用来修饰方法。所属的类必需已经标记为一个TestFixture。一个TestFixture可以仅有一个SetUp方法。如果有多个定义，        TestFixture也会编译成功，但是测试不会运行。SetUpAttribute标记的方法是在每个测试方法被调用之前来完成的。
        [TestFixtureSetUp]
      //用来修饰方法。所属的类必需已经标记为一个TestFixture。这些个属性标记的方式在fixture任何测试执行之前完成。         TestFixture可以仅有一个TestFixtureSetUp方法。如果定义了多个，TestFixture可以成功编译，但是测试不会被执行。
       public void TextInital()
       {//初始化a,可以初始化数据连接等
           a = 10;
           Console.WriteLine("测试开前执行一次");
           Console.WriteLine("a=10");
       }
        // 用来修饰方法。所属的类必需已经标记为一个TestFixture。这些个属性标记的方式在fixture任何测试执行之后完成。TestFixture 可以仅有一个TestFixtureTearDownAttribute方法。如果定义了多个，TestFixture可以成功编译，但是测试不会被执行。

       [TestFixtureTearDown]

        public void TextDispose()
        {//初始化a,可以初始化数据连接等
       
            Console.WriteLine("测试完成后执行一次");
        }




       [SetUp]
       public void BeforeEvery() {
             b=1;
             Console.WriteLine("b=1");
           Console.WriteLine("每个方法测试开始前都执行我");
       }

          // 用来修饰方法。所属的类必需已经标记为一个TestFixture。一个TestFixture可以仅有一个TearDown方法。如果有多个定义，     TestFixture也会编译成功，但是测试不会运行。被TearDownAttribute修饰的方法是每个测试方法被调用之后来执行的。


       [TearDown]
       public void afterEvery() {
           b = 0;
           Console.WriteLine("b = 0");
           Console.WriteLine("每个方法测试完成后都执行我");
       }



       [Test]
       public void Add()
       {
           bool t = a == 10;
           Assert.AreEqual(true, t);
       }


       [Test, ExpectedException(typeof(ArgumentException))]
       public void Sub()
       {
           int a = 0;
           int b = 10 / a;
           Assert.AreEqual(true, true);
       }

        //修饰方法或修饰类。用来把测试分组，可以使用NUnit的Categories选项卡选择要测试的组，或排除一些组。
       [Test]
       [Category("group1")]
       public void g1a()
       {
          
           Assert.AreEqual(true, true);
       }
       [Test]
       [Category("group1")]
       public void g1b()
       {
           Assert.AreEqual(true, true);
       }


       [Test]
       [Category("group2")]
       public void g2a()
       {
         
           Assert.AreEqual(false, true);
       }
       [Test]
       [Category("group2")]
       public void g2b()
       {
           Assert.AreEqual(false, true);
       }


       [Test]
       public void withfixture()
       {
           Assert.AreEqual(true, (b == 1));
       }

       [Test]
       [Explicit]
       //用来修饰类或方法。Explicit属性会忽略一个测试或测试Fixture，直到它被显式的选择运行。。如果test和test fixture在执行的过程中被发现，就忽略他们。所以，这样一来进度条显示为黄色，因为有test或test fixture忽略了。
       public void withoutfixture()
       {
           Assert.AreEqual(true, (b == 1));
       }

        [Test]
        [Ignore]
    //    用来修饰类或方法。由于种种原因,有一些测试我们不想运行.当然,这些原因可能包括你认为这个测试还没有完成,这个测试正在重构之中,这个测试的需求不是太明确.但你有不想破坏测试,不然进度条可是红色的哟.怎么办?使用Ignore属性.你可以保持测试,但又不运行它们。
    //这个特性用来暂时不运行一个测试或fixture。比起注释掉测试或重命名方法，这是一个比较好的机制，因为测试会和余下的代码一起编译，而且在运行时有一个不会运行测试的标记，这样保证不会忘记测试。

       public void Ignore()
       {
           Assert.AreEqual(true, true);
       }


    }
}

执行结果如下

测试开前执行一次
a=10
***** Nunit.Program.Add
b=1
每个方法测试开始前都执行我
b = 0
每个方法测试完成后都执行我
***** Nunit.Program.g1a
b=1
每个方法测试开始前都执行我
b = 0
每个方法测试完成后都执行我
***** Nunit.Program.g1b
b=1
每个方法测试开始前都执行我
b = 0
每个方法测试完成后都执行我
***** Nunit.Program.Sub
b=1
每个方法测试开始前都执行我
b = 0
每个方法测试完成后都执行我
***** Nunit.Program.withfixture
b=1
每个方法测试开始前都执行我
b = 0
每个方法测试完成后都执行我
测试完成后执行一次

转载于:https://www.cnblogs.com/zihunqingxin/p/3280527.html