N​Unit的Attribute​使​用​详​解

NUNIT使用详解(一)

2008/08/26 11:40

NUnit是一个单元测试框架,专门针对于.NET来写的，它是是xUnit的一员。NUnit完全由C#语言来编写,并且编写时充分利用了许多.NET的特性,比如反射,客户属性等等.
最重要的一点是它适合于所有.NET语言.

单元测试：
作为程序员在开发过程中，不可避免地要对软件的类及其方法进行测试。
在Web页面的测试过程中，好多朋友喜欢把测试结果使用Response.Write()显示在页面上。而在类库组件的开发时，由于没有可视化界面，有时不得不为该类库添模一个测试的项目（Console,WinForm,ASP.NET等），在该项目中调用类库组件的功能，以查看测试结果。
上面这种测试不是我们推荐的方法，因为我们在测试的时候应遵循以下原则：
    尽量不要破坏原有的代码结构，即不要在原代码中添加一些冗余的测试代码。
    测试模块应尽可能完整地展现测试结果。
    测试模块不应用完即扔掉，要保存以备后续的维护测试。
   
一、NUnit运行界面

《图1》
在右边有一个进度条，如果所有测试案例运行成功,就为绿色,反之如果有一个不成功,则为红色,但也有黄色的.
    绿色 描述目前所执行的测试都通过
    黄色 意味某些测试忽略，但是这里没有失败
    红色 表示有失败

左边的树状目录是我们们编写的每一个测试单元。

底部的状态条
   
状态：当所有测试完成时，状态变为Completed.运行测试中，状态是Running:
<test-name>
    Test Cases：说明加载的程序集中测试案例的总个数。这也是测试树里叶子节点的个数。
    Tests Run： 已经完成的测试个数。
    Failures： 到目前为止，所有测试中失败的个数.
    Time： 显示运行测试时间（以秒计）

二、在VS2008中配置NUnit进行测试
    1.新建一个类库项目。
    2.在解决方案中的项目图标上右击，选择“属性”。
    3.点击左边的“调试”标签
    4.在“启动操作”中选择“启动外部程序”，并指明NUnit程序的运行路径。
    5.在启动选项中的“工作目录”下，指明当前类库项目的DLL文件的所在路径。

    《图2》
    6.运行当前类库项目，我们会发现NUnit被启动起来了。

三、安装Unit与使用
   请到http://www.nunit.org/download.html下载NUnit，然后双击安装即可。
   
1.我们要使用NUnit对类库组件进行测试时，一般我们会新建一个测试类文件或新建一个测试项目。
    2.为测试项目添加引用“nunit.framework”
    3.在测试类文件中添加using NUnit.Framework;语句
    4.在该类文件或测试项目中编写测试代码，然后使用NUnit运行我们的测试代码以观察测试结果。

四、NUnit中的常用Attribute
所有NUnit属性都包含在Nunit.Framework命名空间里。测试项目必须引用框架的程序集，即nunit.framework.dll.

1.TestFixtureAttribute
    用来修饰测试类。这个属性标记一个类包含了测试方法。
    被TestFixtureAttribute修饰的类需满足以下限制
        a.必须是一个public类型，否则NUnit不会识别它。
        b.它必须有一个缺省的构造子，否则Nunit不能构建他。
        c.构造子不应该有任何方面的负面影响，因为在一个对话的过程中，NUnit可能构造类多次。
        如：
        using
System;
        using NUnit.Framework;
       [TestFixture]
        public class SuccessTests
        {
        // ...
        }

2.TestAttribute
   
用来修饰测试方法。Test属性标记某个类的某个方法为一个测试方法，而且此类必需已经标记为一个TestFixture。
    一个测试方法的签名定义如下：
       
public void MethodName()
    注意：测试方法必须没有参数。如果程序员将测试方法标记为不正确的签名，它不会运行。
        如：
        using
System;
        using NUnit.Framework;
       [TestFixture]
        public class SuccessTests
        {
            [Test]
            public
void Add()
            {
               
//...
            }
        }

3.SetUpAttribute
   
用来修饰方法。所属的类必需已经标记为一个TestFixture。一个TestFixture可以仅有一个SetUp方法。如果有多个定义，TestFixture也会编译成功，但是测试不会运行。SetUpAttribute标记的方法是在每个测试方法被调用之前来完成的。
        如：
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class SuccessTests
        {
            [SetUp]

            public
void Init()
            { /* ...
*/ }

[TearDown]
            public
void Dispose()
            { /* ...
*/ }

   
[Test]
            public
void Add()
            { /* ...
*/ }
        }
   
SetUp属性是从任何基类继承而来。因此，如果基类已经定义了一个SetUp方法，那么这个方法会在每个派生的类的测试方法之前调用。如果你打算在派生类里加入更多的SetUp功能，你需要将方法标记为适当的属性，然后调用基类方法。(车延禄)

SetUpAttribute使用案例：
       
如：我们以测试加减法为例
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class NumersFixture
        {
                   
[Test]
                   
public void AddTwoNumbers()
                   
{
                               
int a=1;
                               
int b=2;
                               
int sum=a+b;
                               
Assert.AreEqual(sum,3);
                   
}
                  
[Test]
                   
public void MultiplyTwoNumbers()
                   
{
                               
int a = 1;
                               
int b = 2;
                               
int product = a * b;
                               
Assert.AreEqual(2, product);
                   
}
        }
        不难看出两个测试方法中有重复的代码，如何去除重复的代码呢?我们可以提取这些代码到一个独立的方法,然后标志这个方法为SetUp 属性,这样2个测试方法可以共享对操作数的初始化了,这里是改动后的代码:
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class NumersFixture
        {
                   
private int a;
                   
private int b;
                  
[SetUp]
                   
public void InitializeOperands()
                   
{
                               
a = 1;
                               
b = 2;
                   
}

  
[Test]
                   
public void AddTwoNumbers()
                   
{
                               
int sum=a+b;
                               
Assert.AreEqual(sum,3);
                   
}
                   
[Test]
                   
public void MultiplyTwoNumbers()
                   
{
                               
int product = a * b;
                               
Assert.AreEqual(2, product);
                   
}
        }
       
这样NUnit将在执行每个测试前执行标记SetUp属性的方法.在本例中就是执行InitializeOperands()方法.记住，这里这个方法必须为public，不然就会有以下错误：Invalid Setup or TearDown
method signature

4.TearDownAttribute
   用来修饰方法。所属的类必需已经标记为一个TestFixture。一个TestFixture可以仅有一个TearDown方法。如果有多个定义，TestFixture也会编译成功，但是测试不会运行。被TearDownAttribute修饰的方法是每个测试方法被调用之后来执行的。
        如：
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class SuccessTests
        {
            [SetUp]
            public
void Init()
            { /* ...
*/ }

[TearDown]
            public
void Dispose()
            { /* ...
*/ }

  
[Test]
            public
void Add()
            { /* ...
*/ }
        }
   
TearDown属性是从任何的基类继承而来。因此，如果基类已经定义了一个TearDown方法，那么这个方法会在每个派生的类的测试方法之后调用。如果你打算在派生类里加入更多的TearDown功能，你需要将方法标记为适当的属性，然后调用基类方法。

5.TestFixtureSetUpAttribute
   用来修饰方法。所属的类必需已经标记为一个TestFixture。这些个属性标记的方式在fixture任何测试执行之前完成。TestFixture可以仅有一个TestFixtureSetUp方法。如果定义了多个，TestFixture可以成功编译，但是测试不会被执行。

6.TestFixtureTearDownAttribute
   用来修饰方法。所属的类必需已经标记为一个TestFixture。这些个属性标记的方式在fixture任何测试执行之后完成。TestFixture可以仅有一个TestFixtureTearDownAttribute方法。如果定义了多个，TestFixture可以成功编译，但是测试不会被执行。
        如：
        namespace
NUnit.Tests
        {
          using System;
          using NUnit.Framework;

[TestFixture]
          public class
SuccessTests
          {
          
[TestFixtureSetUp]
            public
void Init()
            { /* ...
*/ }

[TestFixtureTearDown]
            public
void Dispose()
            { /* ...
*/ }

[Test]
            public
void Add()
            { /* ...
*/ }
          }
        }

SetUp/TearDown方法提供达到测试隔离性的目的.SetUp确保共享的资源在每个测试运行前正确初始化,TearDown确保没有运行测试产生的遗留副作用. TestFixtureSetUp/TestFixtureTearDown同样提供相同的目的,但是却在test fixture范围里
   
我们写一个简单的测试来说明什么方法调用了,怎么合适调用
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class
LifeCycleContractFixture
        {
            [TestFixtureSetUp]

            public
void FixtureSetUp()
            {
               
Console.Out.WriteLine("FixtureSetUp");
            }
           
[TestFixtureTearDown]
            public
void FixtureTearDown()
            {
               
Console.Out.WriteLine("FixtureTearDown");
            }
            [SetUp]
            public
void SetUp()
            {
               
Console.Out.WriteLine("SetUp");
            }
            [TearDown]
            public
void TearDown()
            {
               
Console.Out.WriteLine("TearDown");
            }
           [Test]
            public
void Test1()
            {
               
Console.Out.WriteLine("Test 1");
            }
            [Test]
            public
void Test2()
            {
               
Console.Out.WriteLine("Test 2");
            }
        }
        运行结果：
        FixtureSetUp
        SetUp
        Test 1
        TearDown
        SetUp
        Test 2
        TearDown
        FixtureTearDown
   
7.ExpectedExceptionAttribute
   修饰方法，用来测试一个方法是否抛出了指定的异常。本属性有两种重载方式。第一种是一个Type，此Type为期望的异常的精确类型。 第二种是一个期望的异常全名的字符串。(车延禄)
    在执行测试时，如果它抛出了指定的异常，那么测试通过。如果抛出一个不同的异常，测试就失败。如果抛出了一个由期望异常继承而来的异常，这也是成功的。
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class SuccessTests
        {
           [Test]
           
[ExpectedException(typeof(InvalidOperationException))]
            public
void ExpectAnExceptionByType()
            { /* ...
*/ }

[Test]
           
[ExpectedException("System.InvalidOperationException")]
            public
void ExpectAnExceptionByName()
            { /* ...
*/ }
        }
       
8.CategoryAttribute
    修饰方法或修饰类。用来把测试分组，可以使用NUnit的Categories选项卡选择要测试的组，或排除一些组。
   
对类分组：
        using
System;
        using NUnit.Framework;
        [TestFixture]
       
[Category("LongRunning")]
        public class LongRunningTests
        {
        // ...
        }
    对方法分组：
        using
System;
        using NUnit.Framework;
        [TestFixture]
        public class SuccessTests
        {
            [Test]
           
[Category("Long")]
            public
void VeryLongTest()
            { /* ...
*/ }
        }

下面我们编写三个测试方法，并分为两组“Compare”和“TestNull”，在NUnit中测试“Compare”组的内容：
    第一步：点击左侧的“Categories”选项卡
    第二步：在“Available Categories”列表框中选择“Compare”，点击“Add”按钮
    第三步：点击左侧“Test”选项卡，点击树状目录中的“Class1”，点击“Run”按钮
   
我们发现只有TestTowInstanceName和TestTowInstanceEqual两个测试方法运行了，而TestNull没有运行，因此TestNull不是“Compare”组的。

《图3》

《图4》

9.ExplicitAttribute
    用来修饰类或方法。Explicit属性会忽略一个测试或测试Fixture，直到它被显式的选择运行。。如果test和test fixture在执行的过程中被发现，就忽略他们。所以，这样一来进度条显示为黄色，因为有test或test fixture忽略了。
    修饰类：
        using
System;
        using NUnit.Framework;
        [TestFixture, Explicit]
        public class ExplicitTests
        {
        // ...
        }
    修饰方法：
        using
System;
        using NUnit.Framework;

   
[TestFixture]
        public class SuccessTests
        {
            [Test,
Explicit]
            public
void ExplicitTest()
            { /* ...
*/ }
        }
   

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

修饰方法
        using
System;
        using NUnit.Framework;

[TestFixture]
        public class SuccessTests
        {
            [Test]
           
[Ignore("Ignore a test")]
            public
void IgnoredTest()
            { /* ...
*/ }
        }

出处：http://wenku.baidu.com/view/c40f6f53c281e53a5802ffa8.html