四、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()
{ /* ... */ }
}
