NUnit学习笔记 2007版
一、简介
NUnit是一款堪与JUnit齐名的开源回归测试框架，供.net开发人员做单元测试之用，可以从www.nunit.org网站上免费获得，当前版本2.2.10。NUnit 2.2.10有5个下载文件，这里用的是NUnit-2.2.10-net-2.0.msi（如果使用的是.net1.1环境，请下载NUnit-2.2.10-net-1.1.msi文件，但这里主要介绍.net2.0环境下NUnit 2.2.10的使用）。下载后双击该文件，然后按提示进行安装，这样系统中就具备NUnit环境了。
二、创建项目
开发工具我选择了微软的Visual Studio.net 2005（适用于.net2.0环境，以下简称vs05）和Visual Studio.net 2003（适用于.net1.1环境，以下简称vs03），打开后点击菜单“文件”->“新建”->“项目”，打开“新建项目”对话框：
vs05的新建项目对话框
vs03的新建项目对话框
在该对话框中，“项目类型”我选择的是“Visual Basic”，如果想使用C#或者J#，请自行选择“Visual C#”或“Visual J#”，反正操作都一样，下边也会介绍到，不过VC就免谈了；“模板”我选的是“控制台应用程序”，您也可以选其它“模板”，我看的例子创建的就是“类库”；名称和位置请自行设定，VB、C#、J#项目我都建了，分别起名为NUnitVB、NUnitCS和NUnitJS，位置是本机F:\YPJCCK\NUnit\VS。设置好后，点击“确定”按钮，创建该项目。
下面点击菜单“项目”->“添加引用”，打开“添加引用”对话框：
vs05的添加引用对话框
vs03的添加引用对话框
如果是在vs05中，请直接在“.NET”选项卡中找到组件名称为nunit.framework的一项，选中，然后点击“确定”按钮；如果是在vs03中，在“.NET”选项卡中找到组件名称为nunit.framework的一项，双击添加到“选定的组件”中，别的组件不用管，然后点击“确定”按钮。此时就可以在项目中使用NUnit类库了。
三、编写用于测试的类
用于测试的类很简单，名为Book，只有id和name两个属性，这两个属性将分别用于两个用例当中。
下面开始编写。请点击菜单“项目”->“添加类”，打开“添加新项”对话框：
vs05的添加新项对话框
vs03的添加新项对话框
在该对话框中，“类”模板被默认选中，请将名称修改为Book.vb或Book.cs、Book.jsl，然后点击“添加”或“打开”按钮。
下面修改代码。VB代码如下：
Public Class Book
Private pid As String = Nothing
Private pname As String = Nothing
Public Property id() As String
Get
Return pid
End Get
Set(ByVal Value As String)
pid = Value
End Set
End Property
Public Property name() As String
Get
Return pname
End Get
Set(ByVal Value As String)
pname = Value
End Set
End Property
End Class
C#代码如下：
using System;
using System.Collections.Generic;
using System.Text;
namespace NUnitCS
{
class Book
{
private string pid = null;
private string pname = null;
public string id
{
get
{
return pid;
}
set
{
pid = value;
}
}
public string name
{
get
{
return pname;
}
set
{
pname = value;
}
}
}
}
J#代码如下：
package NUnitJS;
public class Book
{
private String pid = null;
private String pname = null;
/** @property */
public void set_id(String value)
{
pid = value;
}
/** @property */
public String get_id()
{
return pid;
}
/** @property */
public void set_name(String value)
{
pname = value;
}
/** @property */
public String get_name()
{
return pname;
}
}
至此，用于测试的类编写完成。
四、编写测试用例
这里只用了一个类进行测试，名为BookTest，以前这样的类可能需要继承NUnit.Framework.TestCase类，但现在只需要对该类使用TestFixture属性进行标识即可，而无须继承了。BookTest类包含两个用例，分别对应该类的testId和testName方法，即每个方法实现了一个测试用例。注意，在NUnit中，这些用来实现测试用例的方法有两种手段进行标识：一个是以testXXX的格式来命名，一个是使用Test属性进行标识。此外，BookTest还有Init和Dispose这两个方法，并分别使用SetUp和TearDown属性来进行标识，前者在每个测试方法开始之前执行，多用来做初始化；后者在每个测试方法完成之后执行，多用来清理资源。注意，这两个方法的名称并没有什么限制，但必须用SetUp和TearDown属性进行标识。另外，NUnit还提供了TestFixtureSetUp和TestFixtureTearDown属性，功能与SetUp和TearDown类似，但前者是在所有用例执行之前做初始化、之后做清理，而后者是在每个用例执行之前做初始化、之后做清理。下面开始编写BookTest。
点击菜单“项目”->“添加类”，打开“添加新项”对话框，将名称改为BookTest.vb或BookTest.cs、BookTest.jsl，然后点击“添加”按钮创建该类并修改代码。VB代码如下：
Imports NUnit.Framework
<TestFixture()> _
Public Class BookTest
Dim bo As Book = Nothing
<SetUp()> _
Public Sub Init()
Console.WriteLine("测试开始！")
bo = New Book
Console.WriteLine("book对象被初始化！")
End Sub
<Test()> _
Public Sub testId()
bo.id = "001" '设置id属性的值为
'使用Assert查看id属性的值是否为
Assert.AreEqual("001", bo.id)
Console.WriteLine("id属性被测试！")
End Sub
<Test()> _
Public Sub testName()
bo.name = "ASP" '设置name属性的值为ASP
'使用Assert查看name属性的值是否为JSP，这是个必然出现错误的测试
Assert.AreEqual("JSP", bo.name)
Console.WriteLine("name属性被测试！")
End Sub
<TearDown()> _
Public Sub Dispose()
Console.WriteLine("book对象将被清理！")
bo = Nothing
Console.WriteLine("测试结束！")
End Sub
End Class
C#代码如下：
using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
namespace NUnitCS
{
[TestFixture]
public class BookTest
{
private Book book = null;
[SetUp]
public void Init()
{
Console.WriteLine("测试开始！");
book = new Book();
Console.WriteLine("book对象被初始化！");
}
[Test]
public void testId()
{
book.id = "001"; //设置id属性的值为
//使用Assert查看id属性的值是否为
Assert.AreEqual("001", book.id);
Console.WriteLine("id属性被测试！");
}
[Test]
public void testName()
{
book.name = "ASP"; //设置name属性的值为ASP
//使用Assert查看name属性的值是否为JSP，这是个必然出现错误的测试
Assert.AreEqual("JSP", book.name);
Console.WriteLine("name属性被测试！");
}
[TearDown]
public void Dispose()
{
Console.WriteLine("book对象将被清理！");
book = null;
Console.WriteLine("测试结束！");
}
}
}
J#代码如下：
package NUnitJS;
import System.*;
import NUnit.Framework.*;
/** @attribute TestFixture() */
public class BookTest
{
private Book book = null;
/** @attribute SetUp() */
public void Init()
{
Console.WriteLine("测试开始！");
book = new Book();
Console.WriteLine("book对象被初始化！");
}
/** @attribute Test() */
public void testId()
{
book.set_id("001"); //设置id属性的值为001
//使用Assert查看id属性的值是否为001
Assert.AreEqual("001", book.get_id());
Console.WriteLine("id属性被测试！");
}
/** @attribute Test() */
public void testName()
{
book.set_id("ASP"); //设置name属性的值为ASP
//使用Assert查看name属性的值是否为JSP，这是个必然出现错误的测试
Assert.AreEqual("JSP", book.get_name());
Console.WriteLine("name属性被测试！");
}
/** @attribute TearDown() */
public void Dispose()
{
Console.WriteLine("book对象将被清理！");
book = null;
Console.WriteLine("测试结束！");
}
}
这里Init和Dispose方法没什么好说的，就是执行了对book对象的初始化和清理，不过testId和testName需要说明一下。前者是在对book的id属性进行测试，首先赋值为”001”，然后使用Assert的AreEqual方法查看id属性中存放的值是否是期待的值，由于我的期待值也是”001”，所以执行后这个用例应该是成功的；后者则是对book的name属性进行测试，也是首先赋值为”ASP”，然后使用Assert的AreEqual方法查看其值是否是期待的，由于我特意将期待值设定为根本不可能的”JSP”，因此这个用例执行后会出现一个错误。
下面简单介绍一下静态类NUnit.Framework.Assert。该类主要包含20个方法：
1．AreEqual()和AreNotEqual()，各18个重载，用来查看两个对象的值是否相等或不等，与对象比较中使用的Equals()方法类似。
2．AreSame()和AreNotSame()，各3个重载，用来比较两个对象的引用是否相等或不等，类似于通过“Is”或“==”比较两个对象。
3．Contains()，3个重载，用来查看对象是否在集合中，集合类型应与System.Collections.IList兼容。示例：
VB代码：
Dim o As New Object
Dim al As New ArrayList
al.Add(o)
Assert.Contains(o, al)
C#代码：
object o = new object();
ArrayList al = new ArrayList();
al.Add(o);
Assert.Contains(o, al);
J#代码：
Object o = new Object();
ArrayList al = new ArrayList();
al.Add(o);
Assert.Contains(o, al);
4．Greater()和Less()，各18个重载，用来比较两个数值的大小，前者相当于大于号(>)，后者相当于小于号(<)。
5．IsInstanceOfType()和IsNotInstanceOfType()，各3个重载，用来判断对象是否兼容于指定类型。示例：
VB代码：
Dim t As Type = New Object().GetType
Dim s As String = ""
Assert.IsInstanceOfType(t, s)
C#代码：
Type t = new object().GetType();
tring s = "";
Assert.IsInstanceOfType(t, s);
J#代码：
Type t = new Object().GetType();
String s = "";
Assert.IsInstanceOfType(t, s);
由于Object是.net中所有类型的基类，String类型兼容于Object，因此这个示例是能够运行通过的。而下边这个示例运行将是失败的：
VB代码：
Dim t As Type = New ArrayList().GetType
Dim s As String = ""
Assert.IsInstanceOfType(t, s)
C#代码：
Type t = new ArrayList().GetType();
string s = "";
Assert.IsInstanceOfType(t, s);
J#代码：
Type t = new ArrayList().GetType();
String s = "";
Assert.IsInstanceOfType(t, s);
6．IsAssignableFrom()和IsNotAssignableFrom()，各3个重载，用来判断对象是否是指定类型的实例。示例：
VB代码：
Dim t As Type = New Object().GetType
Dim s As String = ""
Assert.IsAssignableFrom(t, s)
C#代码：
Type t = new object().GetType();
string s = "";
Assert.IsAssignableFrom(t, s);
J#代码：
Type t = new Object().GetType();
String s = "";
Assert.IsAssignableFrom(t, s);
这个示例与之前的示例是一样的，但由于字符串s不是Object类型的，因此无法运行通过。而下边这个实例可以运行通过：
VB代码：
Dim t As Type = "".GetType
Dim s As String = ""
Assert.IsAssignableFrom(t, s)
C#代码：
Type t = "".GetType();
string s = "";
Assert.IsAssignableFrom(t, s);
J#代码：
Type t = "".GetType();
String s = "";
Assert.IsAssignableFrom(t, s);
7．IsFalse()和IsTrue()，各3个重载，用来查看变量是是否为false或true，如果IsFalse()查看的变量的值是false则测试成功，如果是true则失败，IsTrue()与之相反。
8．IsNull()和IsNotNull()，各3个重载，用来查看对象是否为空和不为空。
9．IsEmpty()和IsNotEmpty()，各6个重载，用来判断字符串或集合是否为空串或没有元素，其中集合类型应与ICollection兼容。
10．IsNaN()，3个重载，用来判断指定的值是否不是数字。
11．Fail()，3个重载，意为失败，用来抛出错误。我个人认为有两个用途：首先是在测试驱动开发中，由于测试用例都是在被测试的类之前编写，而写成时又不清楚其正确与否，此时就可以使用Fail方法抛出错误进行模拟；其次是抛出意外的错误，比如要测试的内容是从数据库中读取的数据是否正确，而导致错误的原因却是数据库连接失败。
12．Ignore()，3个重载，意为忽略，用来忽略后续代码的执行，用途可以参考Fail()方法。
此外，NUnit还提供了一个专用于字符串的静态类NUnit.Framework.StringAssert，该类主要包含4个方法：
1．Contains()，3个重载，用来查看指定的第二个字符串中是否包含了第一个字符串。
2．StartsWith ()和EndsWith ()，各3个重载，分别用来查看指定的第一个字符串是否位于第二个字符串的开头和结尾。
3．AreEqualIgnoringCase()，3个重载，用来比较两个字符串是否相等。
五、运行NUnit
下面请先点击菜单“调试”->“启动调试”或按F5键运行程序。等等，main函数里头好象一句代码也没写过呢吧？没错，一句也没写，不过你照做就可以了。在看到黑屏一闪之后，程序生成完毕。
程序生成后，就可以使用NUnit进行测试了。NUnit有两种界面，一种是命令行的，一种是可视化的，这里使用的就是后者。点击“开始”菜单->“所有程序”->“NUnit-Net-2.0 2.2.10”->“NUnit-Net-2.0 2.2.10”，打开NUnit的可视化界面：
点击菜单“File”->“Open”，打开刚才运行生成的可执行文件：
此时就可以使用BookTest类对Book类进行测试了。请首先选择testId，点击“Run”按钮，运行结果如下图：
testId前的灰点变绿，而且进度条显示为绿条，这表明运行成功。下面再选择BookTest，点击“Run”按钮，运行结果如下图：
testId前的点依然是绿色，但testName前的点是红色，而且进度条显示为红条，这表明testName中存在错误。不过这个错误是预计之内的，如果不想看到，可以在vs中将testName()方法中的”JSP”改成”ASP”，然后重新运行。此时无须重新启动NUnit，NUnit会自动加载重新编写好的文件。此时再运行BookTest，进度条已不是红色，而是绿色了。
六、命令行下
本小节将简单介绍一下NUnit的命令行界面。请先打开命令行工具，点击“开始”菜单->“运行”，打开运行对话框，输入cmd，回车，然后执行命令：
set path=%path%;E:\Program Files\NUnit-Net-2.0 2.2.10\bin
这里E:\Program Files\NUnit-Net-2.0 2.2.10是我本机的NUnit安装目录，bin为NUnit工具存放目录，为了调用方便，将该目录设置到环境变量Path当中。如果您想一劳永逸，也可以选中“我的电脑”点击鼠标右键，选择“属性”打开“系统属性”对话框，然后依次点击“高级”选项卡->“环境变量”按钮，在“环境变量”对话框中进行设置。
下面在命令行中调整路径到刚才运行生成的可执行文件所在目录，执行命令：
nunit-console NUnitVB.exe
执行结果如下：
执行结束后，目录下会生成一个TestResult.xml文件，该文件以XML格式保存了测试结果信息。
七、NUnit使用进阶
ExpectedException属性，异常测试，用于测试是否会抛出指定的异常，若抛出则NUnit-GUI的状态条为绿色，反之为红色。
示例：
VB代码：
Imports NUnit.Framework
<TestFixture()> _
Public Class Test
<Test(), ExpectedException(GetType(Exception))> _
Public Sub TestExpectedException()
Dim s As String = ""
If s = "" Then
Throw New Exception()
End If
End Sub
End Class
C#代码：
using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
namespace NUnitCS
{
[TestFixture]
class Test
{
[Test]
[ExpectedException(typeof(Exception))]
public void TestExpectedException()
{
string s = "";
if (s == "")
throw new Exception();
}
}
}
J#代码：
package NUnitJS;
import NUnit.Framework.*;
/** @attribute TestFixture() */
public class Test
{
/** @attribute Test() */
/** @attribute ExpectedException(Exception.class) */
public void TestExpectedException() throws Exception
{
String s = "";
if (s == "")
throw new Exception();
}
}
测试效果：NUnit-GUI状态条为绿色。
具体说明：由于字符串s在初始化时已赋值为""，因此在判断相等时条件成立，这样就抛出了异常，状态条当然也就为绿色了。如果想让状态条显示为红色，将判断条件改为不等就可以了。
Ignore属性，忽略测试，可以供类和方法使用，用于忽略暂时不想运行的测试用例。
示例1：
VB代码：
<TestFixture(), Ignore("class test ignore")> _
Public Class Test
<Test()> _
Public Sub TestIgnore()
End Sub
<Test()> _
Public Sub TestIgnore2()
End Sub
End Class
C#代码：
[TestFixture]
[Ignore("class test ignore")]
class Test
{
[Test]
public void TestIgnore()
{}
[Test]
public void TestIgnore2()
{}
}
J#代码：
/** @attribute TestFixture() */
/** @attribute Ignore("class test ignore") */
public class Test
{
/** @attribute Test() */
public void TestIgnore()
{}
/** @attribute Test() */
public void TestIgnore2()
{}
}
测试效果：NUnit-GUI状态条为黄色。
示例2：
VB代码：
<TestFixture()> _
Public Class Test
<Test(), Ignore("function test ignore")> _
Public Sub TestIgnore()
End Sub
<Test()> _
Public Sub TestIgnore2()
End Sub
End Class
C#代码：
[TestFixture]
class Test
{
[Test]
[Ignore("function test ignore")]
public void TestIgnore()
{}
[Test]
public void TestIgnore2()
{}
}
J#代码：
/** @attribute TestFixture() */
public class Test
{
/** @attribute Test() */
/** @attribute Ignore("function test ignore") */
public void TestIgnore()
{}
/** @attribute Test() */
public void TestIgnore2()
{}
}
测试效果：NUnit-GUI状态条为黄色，但与方法TestIgnore2对应的节点显示为绿色。由于本例仅忽略了方法TestIgnore，而这并不会影响TestIgnore2，因此TestIgnore2依然会正常运行。
Suite属性。根据NUnit文档的说明，Suite属性是用来标记返回类型为NUnit.Core.TestSuite的类属性成员的，该类属性成员所返回的对象会包含一组测试类，也就是说Suite属性其实是用来组织一组测试类的。那么组织这些测试类到TestSuite对象中有何用呢？其实在早期的NUint当中，提供有NUnit.TextUI.TestRunner类，该类有个Run方法，参数就是TestSuite对象，通过该方法可以在代码中调用NUnit环境，从而运行TestSuite对象中的测试类。不过现在NUnit似乎已经不再使用这种方式了，故此对于Suite属性这里不再介绍。
Category属性，分组测试，用于将测试类和测试方法分组，从而使测试类和测试方法可以按组进行测试。
示例:
VB代码：
<TestFixture(), Category("class1")> _
Public Class Class11
<Test()> _
Public Sub Test()
End Sub
End Class
<TestFixture(), Category("class1")> _
Public Class Class12
<Test()> _
Public Sub Test()
End Sub
End Class
<TestFixture(), Category("class2")> _
Public Class Class21
<Test()> _
Public Sub Test()
End Sub
End Class
<TestFixture(), Category("class2")> _
Public Class Class22
<Test()> _
Public Sub Test()
End Sub
End Class
<TestFixture()> _
Public Class Class3
<Test(), Category("function1")> _
Public Sub Test11()
End Sub
<Test(), Category("function1")> _
Public Sub Test12()
End Sub
<Test(), Category("function2")> _
Public Sub Test21()
End Sub
<Test(), Category("function2")> _
Public Sub Test22()
End Sub
End Class
C#代码：
[TestFixture]
[Category("class1")]
class Class11
{
[Test]
public void Test()
{}
}
[TestFixture]
[Category("class1")]
class Class12
{
[Test]
public void Test()
{}
}
[TestFixture]
[Category("class2")]
class Class21
{
[Test]
public void Test()
{}
}
[TestFixture]
[Category("class2")]
class Class22
{
[Test]
public void Test()
{}
}
[TestFixture]
class Class3
{
[Test]
[Category("function1")]
public void Test11()
{}
[Test]
[Category("function1")]
public void Test12()
{}
[Test]
[Category("function2")]
public void Test21()
{}
[Test]
[Category("function2")]
public void Test22()
{}
}
J#代码：
/** @attribute TestFixture() */
/** @attribute Category("class1") */
public class Class11
{
/** @attribute Test() */
public void Test()
{}
}
/** @attribute TestFixture() */
/** @attribute Category("class1") */
public class Class12
{
/** @attribute Test() */
public void Test()
{}
}
/** @attribute TestFixture() */
/** @attribute Category("class2") */
public class Class21
{
/** @attribute Test() */
public void Test()
{}
}
/** @attribute TestFixture() */
/** @attribute Category("class2") */
public class Class22
{
/** @attribute Test() */
public void Test()
{}
}
/** @attribute TestFixture() */
public class Class3
{
/** @attribute Test() */
/** @attribute Category("function1") */
public void Test11()
{}
/** @attribute Test() */
/** @attribute Category("function1") */
public void Test12()
{}
/** @attribute Test() */
/** @attribute Category("function2") */
public void Test21()
{}
/** @attribute Test() */
/** @attribute Category("function2") */
public void Test22()
{}
}
测试效果：示例中包含5个类，前4个类被分为class1和class2两个组，后1个类中包含的四个方法被分为funtion1和function2两个组。对于这种分组的测试，要想看出效果，在打开NUnit后，需要先在Categories选项卡中作出选择，如下图所示：
可以看到，所有的组默认都在上边的Available Categories列表框中，选中的组则通过Add按钮添加到下边的Selected Categories列表框中，NUnit允许选中多个。测试完成后对于不想要的组，还可以通过Remove按钮放回到上边。选好后，选择Tests选项卡，选中根节点，然后点击Run按钮，效果如下：
可以看到，只有与class1组对应的Class11和Class12这两个类被测试了。
此外您可能也注意到了，Categories选项卡中还提供了一个Exclude these categories选项，选中该选项，回到Tests选项卡，选中根节点，然后点击Run按钮，效果如下：
此时与class1组对应的Class11和Class12这两个类在测试中被忽略了。
Explicit属性，与Ignore属性有些类似，也是用于对暂时不想运行的测试类或测试方法做忽略的。但与Ignore属性相比还有两点差别：一个是Explicit属性不需要说明信息，一个是使用Explicit属性做忽略的类或方法在NUnit中被选中后，将不再被忽略，而是进行测试。
示例：
VB代码：
<TestFixture()> _
Public Class Test
<Test(), Explicit()> _
Public Sub TestMethod()
End Sub
End Class
<TestFixture(), Explicit()> _
Public Class Test2
<Test()> _
Public Sub TestMethod()
End Sub
End Class
C#代码：
[TestFixture]
public class Test
{
[Test, Explicit]
public void TestMethod()
{}
}
[TestFixture, Explicit]
public class Test2
{
[Test]
public void TestMethod()
{}
}
J#代码：
/** @attribute TestFixture() */
public class Test
{
/** @attribute Test(),Explicit() */
public void TestMethod()
{}
}
/** @attribute TestFixture(),Explicit() */
public class Test2
{
/** @attribute Test() */
public void TestMethod()
{}
}
测试效果：类Test所忽略的是方法，若不在NUnit中选中该方法，测试后该方法前的圆点为黄色，即在测试中被忽略，若选中了则在测试后显示为绿色或红色，这与测试的结果有关；类Test2所忽略的是类，效果与Test类似。
Platform属性，平台属性，用来指定运行平台，若测试类或测试方法所运行的平台与指定的一致则执行，否则忽略。此外，Platform属性还提供了两个参数，Exclude和Include，前者用于指定将要忽略的平台，后者指定将要运行的平台。后者与默认指定的情况一致。
示例：
VB代码：
<TestFixture()> _
Public Class Test
<Test(), Platform(Exclude:="Win98,Linux")> _
Public Sub PlatformTest1()
End Sub
<Test(), Platform(Include:="Win98,Linux")> _
Public Sub PlatformTest2()
End Sub
End Class
<TestFixture(), Platform("Net-2.0")> _
Public Class Test2
<Test()> _
Public Sub PlatformTest1()
End