C#---NUnit詳細使用方法

1. TDD的簡介

首先什麼是TDD呢?Kent Beck在他的<<測試驅動開發 >>(Addison-Wesley Professional,2003)一書中,使用下面2個原則來定義TDD:

·除非你有一個失敗的自動測試,永遠不要寫一單行代碼.

·阻止重複

我想第一個原則是顯而易見的.在沒有失敗的自動測試下就不要寫代碼.因爲測試是嵌入在代碼必須滿足的需求中.如果沒有需求,就沒有必要實現任何東西.所以這個原則阻止我們去實現那些沒有測試和在解決方案中不需要的功能.

第二個原則說明了在一個程序中,不應該包含重複的代碼.如果代碼重複,我想這就是不好的軟件設計的象徵.隨着時間的流逝,它會對程序造成不一致的問題,並且使代碼變非常混亂 ,因爲我們時常不會記得重複代碼的位置.如果發現代碼重複,我想我們應該立即刪除代碼重複.其實這就涉及到重構了.在這裏我就不多講了.

一般來說,測試分爲2種類型,一是程序員自己的測試,另外一種是客戶的測試.關於客戶測試，我推薦一個FIT的框架，非常不錯。在這裏，我們講的TDD就是程序員測試.那麼什麼是程序員測試呢?我認爲就是我們常說的單元測試.既然是單元測試,在.NET裏勢必會用到某些工具,目前最著名恐怕就是我即將介紹的NUnit了,

2.NUnit的介紹

NUnit是一個單元測試框架,專門針對於.NET來寫的.其實在前面有JUnit(Java),CPPUnit(C++),他們都是xUnit的一員.最初,它是從JUnit而來.現在的版本是2.2.接下來我所用的都是基於這個版本.

NUnit最初是由James W. Newkirk, Alexei A. Vorontsov 和Philip A. Craig, 後來開發團隊逐漸龐大起來.在開發過程中, Kent Beck 和Erich Gamma2位牛人也提供了許多幫助.看來對於NUnit還真是下了一番力氣了.J

NUnit是xUnit家族種的第4個主打產品,完全由C#語言來編寫,並且編寫時充分利用了許多.NET的特性,比如反射,客戶屬性等等.

最重要的一點是它適合於所有.NET語言.

如果你還沒有下載,可以到http://www.nunit.org/去下載.

2.1 NUnit的介紹

   Ok,下面正式講解NUnit.在講解之前,看看幾張圖片:

     

圖1  NUnit運行的效果

                     圖2   NUnit運行的另外一個效果

 從中我們可以非常容易發現,右邊是個狀態條,圖1是紅色的,圖2是綠色的.爲什麼會這樣呢?因爲如果所有測試案例運行成功,就爲綠色,反之如果有一個不成功,則爲紅色,但也有黃色的.左面的工作域內則是我們寫的每一個單元測試.

通過上面的圖片,我想你對NUnit有個總的瞭解了.

接下來還是分爲2個部分,一是NUnit的佈局,另外一部分就是它的核心概念.

首先熟悉一下NUnit GUI的佈局.

讓我們更進一步看一下測試運行器窗口的佈局。在右邊面板的中間，可以看到測試進度條。進度條的顏色反映了測試執行的狀態：

• 綠色 描述目前所執行的測試都通過
• 黃色 意味某些測試忽略，但是這裏沒有失敗
• 紅色 表示有失敗

底部的狀態條表示下面的狀態：

• 狀態.說明了現在運行測試的狀態。當所有測試完成時，狀態變爲Completed.運行測試中，狀態是Running: <test-name> (<test-name>是正在運行的測試名稱)。
• Test Cases說明加載的程序集中測試案例的總個數。這也是測試樹裏葉子節點的個數。
• Tests Run 已經完成的測試個數。
• Failures  到目前爲止，所有測試中失敗的個數.
• Time  顯示運行測試時間（以秒計）

File主菜單有以下內容：

• New Project允許你創建一個新工程。工程是一個測試程序集的集合。這種機制讓你組織多個測試程序集，並把他們作爲一個組對待。
• Open 加載一個新的測試程序集，或一個以前保存的NUnit工程文件。
• Close關閉現在加載的測試程序集或現在加載的NUnit工程。
• Save 保存現在的Nunit工程到一個文件。如果正工作單個程序集，本菜單項允許你創建一個新的NUnit工程，並把它保存在文件裏。
• Save As允許你將現有NUnit工程作爲一個文件保存。
• Reload 強制重載現有測試程序集或NUnit工程。NUnit-Gui自動監測現加載的測試程序集的變化。

當程序集變化時，測試運行器重新加載測試程序集。（當測試正運行時，現在加載的測試程序集不會重新加載。在測試運行之間測試程序集僅可以重新加載。一個忠告：如果測試程序集依賴另外一個程序集，測試運行器不會觀察任何依賴的程序集。對測試運行器來說，強制一個重載使全部依賴的程序集變化可見。

• Recent Files  說明5個最近在NUnit中加載的測試程序集或NUnit工程（這個列表在Windows註冊表，由每個用戶維護，因此如果你共享你的PC，你僅看到你的測試）。最近程序集的數量可以使用Options菜單項修改，可以訪問Tool主菜單。
• Exit退出。
•  View菜單有以下內容：
• Expand一層層擴展現在樹中所選節點
• Collapse 摺疊現在樹中選擇的節點
• Expand All遞歸擴展樹中所選節點後的所有節點
• Collapse All遞歸摺疊樹中所選節點後的所有節點
• Expand Fixtures擴展樹中所有代表測試fixture的節點。
• Collapse Fixtures 摺疊樹中所有代表測試fixture的節點。
• Properties 顯示樹中現所選節點的屬性。
• Tools 菜單由這些項:
• Save Results as XML作爲一XML文件保存運行測試的結果。
• Options讓你定製NUnit的行爲。

現在看看右邊，你已經熟悉Run按鈕和進度條。這裏還有一個緊跟Run按鈕的Stop按鈕：點擊這個按鈕會終止執行正運行的測試。進度條下面是一個文本窗口，在它上方，由以下4個標籤：

• Errors and Failures 窗口顯示失敗的測試。在我們的例子裏，這個窗口是空。
• Tests Not Run 窗口顯示沒有得到執行的測試。
• Console.Error 窗口顯示運行測試產生的錯誤消息。這些此消息是應用程序代碼使用Console.Error輸出流可以輸出的。
• Console.Out窗口顯示運行測試打印到Console.Error輸出流的文本消息。

2.2 一些常用屬性

 接下來,我將講述這個框架如何使用.同時也涉及到一些非常重要的概念,我想其客戶屬性是非常重要的.在NUnit裏,有以下幾種屬性:

• Test Fixture
• Test

下面我將對每種屬性一一講解.

TestFixtureAttribute

    本屬性標記一個類包含測試,當然setup和teardown方法可有可無.(關於setup 和teardown方法在後面介紹)

    做爲一個測試的類,這個類還有一些限制

• 必須是Public,否則NUnit看不到它的存在.
• 它必須有一個缺省的構造函數,否則是NUnit不會構造它.
• 構造函數應該沒有任何副作用,因爲NUnit在運行時經常會構造這個類多次,如果要是構造函數要什麼副作用的話,那不是亂了.

舉個例子

 1  using System;

 2  using NUnit.Framework;

 3  namespace MyTest.Tests

 4{

 5

 6  [TestFixture]

 7  public class PriceFixture

 8  {

 9    // 

10  }

11}

12

TestAttribute

 Test屬性用來標記一個類(已經標記爲TestFixture)的某個方法是可以測試的.爲了和先前的版本向後兼容,頭4個字符(“test”)忽略大小寫.(參看http://nunit.org/test.html)

這個測試方法可以定義爲:       

public void MethodName()

從上面可以看出,這個方法沒有任何參數,其實測試方法必須沒有參數.如果我們定義方法不對的話,這個方法不會出現在測試方法列表中.也就是說在NUnit的界面左邊的工作域內,看不到這個方法.還有一點就是這個方法不返回任何參數,並且必須爲Public.

例如:

 1using System;

 2using NUnit.Framework;

 3

 4namespace MyTest.Tests

 5{

 6  [TestFixture]

 7  public class SuccessTests

 8  {

 9    [Test] public void Test1()

10    { /**//*  */ }

11  }

12}

13

14

一般來說,有了上面兩個屬性,你可以做基本的事情了.



另外，我們再對如何進行比較做一個描述。

在NUnit中，用Assert（斷言）進行比較，Assert是一個類，它包括以下方法：AreEqual，AreSame，Equals， Fail，Ignore，IsFalse，IsNotNull，具體請參看NUnit的文檔。

3.如何在.NET中應用NUnit

我將舉個例子,一步一步演示如何去使用NUnit.

第1步.爲測試代碼創建一個Visual Studio工程。

在Microsoft Visual Studio .NET中，讓我們開始創建一個新的工程。選擇Visual C#工程作爲工程類型，Class Library作爲模板。將工程命名爲NUnitQuickStart.圖4-1是一個描述本步驟的Visual Studio .NET。

 
                            圖 4-1: 創建第一個NUnit工程

第2步.增加一個NUnit框架引用

在Microsoft Visual Studio .NET裏創建這個例子時，你需要增加一個NUnit.framework.dll引用，如下：

在Solution Explorer右擊引用，然後選擇增加引用

   NUnit.framework組件，在Add Reference對話框中按Select和OK按鈕。

圖4-2 描述了這步:

 
圖 4-2: 增加一個 NUnit.framework.dll 引用到工程

第3步.爲工程加一個類.

爲工程加一個NumbersFixture類。這裏是這個例子的代碼。

 1using System; 
 2using NUnit.Framework; 
 3  
 4namespace NUnitQuickStart 
 5{ 
 6            [TestFixture] 
 7            public class NumersFixture 
 8            { 
 9                        [Test] 
10                        public void AddTwoNumbers() 
11                        { 
12                                    int a=1; 
13                                    int b=2; 
14                                    int sum=a+b; 
15                                    Assert.AreEqual(sum,3); 
16                        } 
17            } 
18}
19

第4步.建立你的Visual Studio 工程，使用NUnit-Gui測試

從程序->NUnit2.2打開NUnit-gui,加載本本工程編譯的程序集.

爲了在Visual Studio .NET中自動運行NUnit-Gui，你需要建立NUnit-Gui作爲你的啓動程序：

在 Solution Explorer裏右擊你的NunitQuickStart工程。

在彈出菜單中選擇屬性。

在顯示的對話框的左面，點擊Configuration Properties夾

選擇出現在Configuration Properties夾下的Debugging。

在屬性框右邊的Start Action部分，選擇下拉框的Program作爲Debug Mode值。

按Apply按鈕

設置NUnit-gui.exe 作爲Start Application。，你既可以鍵入nunit-gui.exe的全路徑，也可使用瀏覽按鈕來指向它。

圖4-3 幫助描述本步驟:
  

圖 4-3:將NUnit-Gui 作爲工程的測試運行器

第5步.編譯運行測試.

 現在編譯solution。成功編譯後，開始應用程序。NUnit-Gui測試運行器出現。當你第一次開始NUnit-Gui，它打開時沒有測試加載。從File菜單選擇Oprn，瀏覽NUnitQuickStart.dll的路徑。當你加載了測試的程序集，測試運行器爲加載的程序集的測試產生一個可見的表現。在例子中，測試程序集僅有一個測試，測試程序集的結構如圖4－4所示：

 
 圖 4-4: 測試程序集的測試在 NUnit-Gui中的視圖

按Run按鈕。樹的節點變爲綠色，而且測試運行器窗口上的進度條變綠，綠色代表成功通過。

 

4.其他的一些核心概念

 上面的例子介紹了基本的NUnit特性和功能. TestFixture, Test, 和 Assert是3個最基本的特徵,我們可以用這些特性進行程序員測試了.但是有的時候,你覺得這3個遠遠不夠,比如有的時候打開一個數據庫連接多次,有沒有隻讓它打開一次的方法呢?如果我想把測試分類,應該怎樣實現呢?如果我想忽略某些測試,又應該如何去完成呢?不用擔心,NUnit已經有這樣的功能了.

下面我們一一作出回答.

SetUp/TearDown 屬性

在早期給的test fixture定義裏,我們說test fixture的測試是一組常規運行時資源.在測試完成之後,或是在測試執行種,或是釋放或清除之前,這些常規運行時資源在一確定的方式上可能需要獲取和初始化.NUnit使用2個額外的屬性:SetUp 和TearDown,就支持這種常規的初始化/清除.我們上面的例子來描述這個功能.讓我們增加乘法.

 1using System; 
 2using NUnit.Framework; 
 3  
 4namespace NUnitQuickStart 
 5{ 
 6            [TestFixture] 
 7            public class NumersFixture 
 8            { 
 9                        [Test] 
10                        public void AddTwoNumbers() 
11                        { 
12                                    int a=1; 
13                                    int b=2; 
14                                    int sum=a+b; 
15                                    Assert.AreEqual(sum,3); 
16                        } 
17                        [Test] 
18                        public void MultiplyTwoNumbers() 
19                        { 
20                                    int a = 1; 
21                                    int b = 2; 
22                                    int product = a * b; 
23                                    Assert.AreEqual(2, product); 
24                        } 
25  
26            } 
27} 
28

   我們仔細一看,不對,有重複的代碼,如何去除重複的代碼呢?我們可以提取這些代碼到一個獨立的方法,然後標誌這個方法爲SetUp 屬性,這樣2個測試方法可以共享對操作數的初始化了,這裏是改動後的代碼: 

 1using System; 
 2using NUnit.Framework; 
 3  
 4namespace NUnitQuickStart 
 5{ 
 6            [TestFixture] 
 7            public class NumersFixture 
 8            { 
 9                        private int a; 
10                        private int b; 
11                        [SetUp] 
12                        public void InitializeOperands() 
13                        { 
14                                    a = 1; 
15                                    b = 2; 
16                        } 
17  
18                        [Test] 
19                        public void AddTwoNumbers() 
20                        { 
21                                    int sum=a+b; 
22                                    Assert.AreEqual(sum,3); 
23                        } 
24                        [Test] 
25                        public void MultiplyTwoNumbers() 
26                        { 
27                                    int product = a * b; 
28                                    Assert.AreEqual(2, product); 
29                        } 
30  
31            } 
32} 
33

   這樣NUnit將在執行每個測試前執行標記SetUp屬性的方法.在本例中就是執行InitializeOperands()方法.記住，這裏這個方法必須爲public，不然就會有以下錯誤：Invalid Setup or TearDown method signature

ExpectedException

這裏是一個驗證這個假設的測試.有的時候,我們知道某些操作會有異常出現,例如, 在實例中增加除法,某個操作被0除,拋出的異常和.NET文檔描述的一樣.參看以下源代碼.

1[Test]

2[ExpectedException(typeof(DivideByZeroException))]

3public void DivideByZero()

4{

5   int zero = 0;

6   int infinity = a/zero;

7   Assert.Fail("Should have gotten an exception");

8}

9

   除了[Test]屬性之外, DivideByZero方法有另外一個客戶屬性: ExpectedException.在這個屬性裏,你可以在執行過程中捕獲你期望的異常類型,例如在本例就是DivideByZeroException.如果這個方法在沒有拋出期望異常的情況下完成了,這個測試失敗.使用這個屬性幫助我們寫程序員測試驗證邊界條件(Boundary Conditions).

Ignore 屬性

   由於種種原因,有一些測試我們不想運行.當然,這些原因可能包括你認爲這個測試還沒有完成,這個測試正在重構之中,這個測試的需求不是太明確.但你有不想破壞測試,不然進度條可是紅色的喲.怎麼辦?使用Ignore屬性.你可以保持測試,但又不運行它們.讓我們標記MultiplyTwoNumbers測試方法爲Ignore屬性:

1[Test]

2[Ignore("Multiplication is ignored")]

3public void MultiplyTwoNumbers()

4{

5   int product = a * b;

6   Assert.AreEqual(2, product);

7}

   運行測試,現在產生了下面的輸出(在圖5-1顯示):

 
圖 5-1: 在一個程序員測試中使用 Ignore屬性

   Ignore屬性可以附加到一個獨立的測試方法,也可以附加到整個測試類(TestFixture).如果Ignore屬性附加到TestFixture,所有在fixture的測試都被忽略.

TestFixtureSetUp/TestFixtureTearDown

   有時,一組測試需要的資源太昂貴.例如,數據庫連接可能是一個關鍵資源,在一個test fixture的每個測試中,打開/關閉數據庫連接可能非常慢.這就是我在開始提到的問題.如何解決?NUnit有一對類似於前面討論的SetUp/TearDown的屬性: TestFixtureSetUp/TestFixtureTearDown.正如他們名字表明的一樣,這些屬性用來標記爲整個test fixture初始化/釋放資源方法一次的方法.

   例如,如果你想爲所有test fixture的測試共享相同的數據庫連接對象,我們可以寫一個打開數據庫連接的方法,標記爲TestFixtureSetUp屬性,編寫另外一個關閉數據庫連接的方法,標記爲TestFixtureTearDown屬性.這裏是描述這個的例子.

 1using NUnit.Framework;

 2

 3[TestFixture]

 4public class DatabaseFixture

 5{

 6   [TestFixtureSetUp]

 7   public void OpenConnection()

 8   {

 9      //open the connection to the database

10   }

11 

12   [TestFixtureTearDown]

13   public void CloseConnection()

14   {

15      //close the connection to the database

16   }

17   

18   [SetUp]

19   public void CreateDatabaseObjects()

20   {

21      //insert the records into the database table

22   }

23 

24   [TearDown]

25   public void DeleteDatabaseObjects()

26   {

27      //remove the inserted records from the database table

28   }

29 

30   [Test]

31   public void ReadOneObject()

32   {

33      //load one record using the open database connection

34   }

35 

36   [Test]

37   public void ReadManyObjects()

38   {

39      //load many records using the open database connection

40   }

41}

42

43

Test Suite

   Test Suite是test case或其他test suite的集合. 合成(Composite)^,模式描述了test case和test suite之間的關係.

 參考來自NUnit的關於Suite的代碼

Suite Attribute

 1namespace NUnit.Tests
 2{
 3using System;
 4  using NUnit.Framework;
 5 
 6
 7
 8  public class AllTests
 9  {
10    [Suite]
11    public static TestSuite Suite
12    {
13      get
14      {
15        TestSuite suite = new TestSuite("All Tests");
16        suite.Add(new OneTestCase());
17        suite.Add(new Assemblies.AssemblyTests());
18        suite.Add(new AssertionTest());
19        return suite;
20      }
21    }
22  }
23} 
24

Category屬性

 對於測試來說，你有的時候需要將之分類，此屬性正好就是用來解決這個問題的。

 你可以選擇你需要運行的測試類目錄，也可以選擇除了這些目錄之外的測試都可以運行。在命令行環境裏 /include 和/exclude來實現。在GUI環境下，就更簡單了，選擇左邊工作域裏的Catagories Tab，選擇Add和Remove既可以了。

在上面的例子上做了一些改善，代碼如下：

 1using System; 

 2using NUnit.Framework; 

 3  

 4namespace NUnitQuickStart 

 5{ 

 6            [TestFixture] 

 7            public class NumersFixture 

 8            { 

 9                        private int a; 

10                        private int b; 

11                        [SetUp] 

12                        public  void InitializeOperands() 

13                        { 

14                                    a = 1; 

15                                    b = 2; 

16                        } 

17  

18                        [Test] 

19                        [Category("Numbers")] 

20                        public void AddTwoNumbers() 

21                        { 

22                                    int sum=a+b; 

23                                    Assert.AreEqual(sum,3); 

24                        } 

25                        

26                        [Test] 

27                [Category("Exception")] 

28                        [ExpectedException(typeof(DivideByZeroException))] 

29                        public void DivideByZero() 

30                        { 

31                                    int zero = 0; 

32                                    int infinity = a/zero; 

33                                    Assert.Fail("Should have gotten an exception"); 

34                        } 

35                        [Test] 

36                        [Ignore("Multiplication is ignored")] 

37                        [Category("Numbers")] 

38                        public void MultiplyTwoNumbers() 

39                        { 

40                                    int product = a * b; 

41                                    Assert.AreEqual(2, product); 

42                        } 

43  

44               } 

45





        NUnit-GUI界面如圖5-2：

圖5-2:使用Catagories屬性的界面

Explicit屬性

本屬性忽略一個test和test fixture，直到它們顯式的選擇執行。如果test和test fixture在執行的過程中被發現，就忽略他們。所以，這樣一來進度條顯示爲黃色，因爲有test或test fixture忽略了。

 例如：

  

 1
 2                        [Test,Explicit] 
 3                        [Category("Exception")] 
 4                        [ExpectedException(typeof(DivideByZeroException))] 
 5                        public void DivideByZero() 
 6                        { 
 7                                    int zero = 0; 
 8                                    int infinity = a/zero; 
 9                                    Assert.Fail("Should have gotten an exception"); 
10                        }
11

    爲什麼會設計成這樣呢？原因是Ingore屬性忽略了某個test或test fixture，那麼他們你再想調用執行是不可能的。那麼萬一有一天我想調用被忽略的test或test fixture怎麼辦，就用Explicit屬性了。我想這就是其中的原因吧。

Expected Exception屬性

  期望在運行時拋出一個期望的異常，如果是，則測試通過，否則不通過。

參看下面的例子：

 1[Test] 
 2[ExpectedException(typeofInvalidOperationException))] 
 3public void ExpectAnException() 
 4 { 
 5   int zero = 0; 
 6   int infinity = a/zero; 
 7   Assert.Fail("Should have gotten an exception"); 
 8                       
 9 } 
10

    在本測試中，應該拋出DivideByZeroException，但是期望的是InvalidOperationException，所以不能通過。如果我們將[ExpectedException(typeof(InvalidOperationException))]改爲[ExpectedException(typeof(DivideByZeroException))]，本測試通過。

5 . 測試生命週期合約

   如果記得test case的定義,其中一個屬性是測試的獨立性或隔離性.SetUp/TearDown方法提供達到測試隔離性的目的.SetUp確保共享的資源在每個測試運行前正確初始化,TearDown確保沒有運行測試產生的遺留副作用. TestFixtureSetUp/TestFixtureTearDown同樣提供相同的目的,但是卻在test fixture範圍裏,我們剛纔描述的內容組成了測試框架的運行時容器(test runner)和你寫的測試之間的生命週期合約(life-cycle contract).

   爲了描述這個合約,我們寫一個簡單的測試來說明什麼方法調用了,怎麼合適調用的.這裏是代碼:

 1using System;

 2using NUnit.Framework;

 3[TestFixture]

 4public class LifeCycleContractFixture

 5{

 6   [TestFixtureSetUp]

 7   public void FixtureSetUp()

 8   {

 9      Console.Out.WriteLine("FixtureSetUp");

10   }

11 

12   [TestFixtureTearDown]

13   public void FixtureTearDown()

14   {

15      Console.Out.WriteLine("FixtureTearDown");

16   }

17   

18   [SetUp]

19   public void SetUp()

20   {

21      Console.Out.WriteLine("SetUp");

22   }

23

24   [TearDown]

25   public void TearDown()

26   {

27      Console.Out.WriteLine("TearDown");

28   }

29 

30   [Test]

31   public void Test1()

32   {

33      Console.Out.WriteLine("Test 1");

34   }

35

36   [Test]

37   public void Test2()

38   {

39      Console.Out.WriteLine("Test 2");

40   }

41

42}

43

44

當編譯和運行這個測試,可以在System.Console窗口看到下面的輸出:

FixtureSetUp

SetUp

Test 1

TearDown

SetUp

Test 2

TearDown

FixtureTearDown

   可以看到, SetUp/TearDown方法調用在每個測試方法的前後. 整個fixture調用一次TestFixtureSetUp/TestFixtureTearDown方法.

參考

1)      http://www.nunit.org

2)      James W. Newkirk and Alexei A. Vorontsov ,Test-Driven Development in Microsoft .NET，Microsoft Press，2003

3)      http://www.testdriven.com

4)      Kent Beck, Test-Driven Development: By Example ，Addison-Wesley Professional, 2003

5)      Andrew Hunt ,David Thomas ,Pragmatic Unit Testing  In   C#  With NUnit
6)      NUnit中文文檔:http://www.36sign.com/nunit