Java Junit測試框架

                                                Java    Junit測試框架

一、相關概念

Ø JUnit：是一個開發源代碼的Java測試框架，用於編寫和運行可重複的測試。它是用於單元測試框架體系xUnit的一個實例（用於java語言）。主要用於白盒測試，迴歸測試。
Ø 白盒測試：把測試對象看做一個打開的盒子，程序內部的邏輯結構和其餘信息對測試人
員是公開的。
Ø 迴歸測試：軟件或環境的修復或更正後的再測試，自動測試工具對這類測試尤爲有用。
Ø 單元測試：最小粒度的測試，以測試某個功能或代碼塊。通常由程序員來作，由於它須要知道內部程序設計和編碼的細節。

二、 單元測試

2.一、單元測試的好處
Ø 提升開發速度，測試是以自動化方式執行的，提高了測試代碼的執行效率。
Ø 提升軟件代碼質量，它使用小版本發佈至集成，便於實現人員除錯。同時引入重構概念，讓代碼更乾淨和富有彈性。
Ø 提高系統的可信賴度，它是迴歸測試的一種。支持修復或更正後的「再測試」，可確保代碼的正確性。

2.二、單元測試的針對對象
Ø 面向過程的軟件開發針對過程。
Ø 面向對象的軟件開發針對對象。
Ø 能夠作類測試，功能測試，接口測試（最經常使用於測試類中的方法）。

2.三、單元測試工具和框架
目前的最流行的單元測試工具是xUnit系列框架，經常使用的根據語言不一樣分爲JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（PHP ）等等。
單元測試框架的第一個和最傑出的應用就是由Erich Gamma （《設計模式》的做者）和Kent Beck（XP（Extreme Programming）的創始人 ）提供的開放源代碼的JUnit。

三、Junit入門簡介

3.一、JUnit的好處和JUnit測試編寫原則
使用JUnit的好處：
Ø 可使測試代碼與產品代碼分開。
Ø 針對某一個類的測試代碼經過較少的改動即可以應用於另外一個類的測試。
Ø 易於集成到測試人員的構建過程當中，JUnit和Ant的結合能夠實施增量開發。
Ø JUnit是公開源代碼的，能夠進行二次開發。
Ø 能夠方便地對JUnit進行擴展。

JUnit測試編寫原則：
Ø 簡化測試的編寫，這種簡化包括測試框架的學習和實際測試單元的編寫。
Ø 使測試單元保持持久性。
Ø 能夠利用既有的測試來編寫相關的測試。

3.二、JUnit的特徵
Ø 使用斷言方法判斷指望值和實際值差別，返回Boolean值。
Ø 測試驅動設備使用共同的初始化變量或者實例。
Ø 測試包結構便於組織和集成運行。
Ø 支持圖型交互模式和文本交互模式。

3.3 JUnit框架組成
Ø 對測試目標進行測試的方法與過程集合，可稱爲測試用例(TestCase)。
Ø 測試用例的集合，可容納多個測試用例(TestCase)，將其稱做測試包(TestSuite)。
Ø 測試結果的描述與記錄。(TestResult) 。
Ø 測試過程當中的事件監聽者(TestListener)。
Ø 每個測試方法所發生的與預期不一致情況的描述，稱其測試失敗元素(TestFailure)
Ø JUnit Framework中的出錯異常（AssertionFailedError）。

    JUnit框架是一個典型的Composite模式：TestSuite能夠容納任何派生自Test的對象；當調用TestSuite對象的run()方法是，會遍歷本身容納的對象，逐個調用它們的run()方法。3.5 JUnit中經常使用的接口和類

Ø Test接口：運行測試和收集測試結果

    Test接口使用了Composite設計模式，是單獨測試用例（TestCase），聚合測試模式（TestSuite）及測試擴展（TestDecorator）的共同接口。 它的public int countTestCases（）方法，用來統計測試時有多少個TestCase。另一個方法就是public void　run（ TestResult ），TestResult是實例接受測試結果， run方法執行本次測試。

Ø TestCase抽象類：定義測試中固定方法

    TestCase是Test接口的抽象實現，（不能被實例化，只能被繼承）其構造函數TestCase(string name)根據輸入的測試名稱name建立一個測試實例。因爲每個TestCase在建立時都要有一個名稱，若測試失敗了，即可識別出是哪一個測試失敗。
TestCase類中包含的setUp()、tearDown()方法。

    setUp()方法集中初始化測試所需的全部變量和實例，而且在依次調用測試類中的每一個測試方法以前再次執行setUp()方法。
tearDown()方法則是在每一個測試方法以後，釋放測試程序方法中引用的變量和實例。

    開發人員編寫測試用例時，只需繼承TestCase，來完成run方法便可，而後JUnit得到測試用例，執行它的run方法，把測試結果記錄在TestResult之中。

Ø Assert靜態類：一系列斷言方法的集合

    Assert包含了一組靜態的測試方法，用於指望值和實際值比對是否正確，即測試失敗，Assert類就會拋出一AssertionFailedError異常，JUnit測試框架將這種錯誤納入Failes並加以記錄，同時標誌爲未經過測試。若是該類方法中指定一個String類型的傳參則該參數將被作爲AssertionFailedError異常的標識信息，告訴測試人員改異常的詳細信息。

    JUnit 提供了6大類31組斷言方法，包括基礎斷言、數字斷言、字符斷言、布爾斷言、對象斷言。其中assertEquals（Object expcted,Object actual)內部邏輯判斷使用equals()方法，這代表斷言兩個實例的內部哈希值是否相等時，最好使用該方法對相應類實例的值進行比較。

    而assertSame（Object expected,Object actual）內部邏輯判斷使用了Java運算符「==」，這代表該斷言判斷兩個實例是否來自於同一個引用（Reference），最好使用該方法對不一樣類的實例的值進行比對。
asserEquals(String message,String expected,String actual)該方法對兩個字符串進行邏輯比對，若是不匹配則顯示着兩個字符串有差別的地方。

    ComparisonFailure類提供兩個字符串的比對，不匹配則給出詳細的差別字符。

Ø TestSuite測試包類??多個測試的組合

    TestSuite類負責組裝多個Test Cases。待測得類中可能包括了對被測類的多個測試，而TestSuit負責收集這些測試，使咱們能夠在一個測試中，完成所有的對被測類的多個測試。TestSuite類實現了Test接口，且能夠包含其它的TestSuites。它能夠處理加入Test時的全部拋出的異常。

TestSuite處理測試用例有6個規約（不然會被拒絕執行測試）
² 測試用例必須是公有類（Public）
² 用例必須繼承與TestCase類
² 測試用例的測試方法必須是公有的（ Public ）
² 測試用例的測試方法必須被聲明爲Void
² 測試用例中測試方法的前置名詞必須是test
² 測試用例中測試方法誤任何傳遞參數

Ø TestResult結果類和其它類與接口
    TestResult結果類集合了任意測試累加結果，經過TestResult實例傳遞個每一個測試的Run（）方法。TestResult在執行TestCase是若是失敗會異常拋出。 

    TestListener接口是個事件監聽規約，可供TestRunner類使用。它通知listener的對象相關事件，方法包括測試開始startTest(Test test)，測試結束endTest(Test test),錯誤，增長異常addError(Test test,Throwable t)和增長失敗addFailure(Test test,AssertionFailedError t)。

    TestFailure失敗類是個「失敗」情況的收集類，解釋每次測試執行過程當中出現的異常狀況。其toString()方法返回「失敗」情況的簡要描述

四、Eclipse中JUnit的使用

    測試對於保證軟件開發質量有着很是重要的做用，單元測試更是必不可少，JUnit是一個很是強大的單元測試包，能夠對一個/多個類的單個/多個方法測試，還能夠將不一樣的TestCase組合成TestSuit，使測試任務自動化。
Eclipse一樣集成了JUnit，能夠很是方便地編寫TestCase。Eclipse自帶了一個JUnit的插件，不用安裝就能夠在你的項目中開始測試相關的類，而且能夠調試你的測試用例和被測試類。

4.一、Eclipse中JUint使用步驟

如下步驟環境爲Eclipse SDK 3.2.2及JUnit3.8.1
Ø 新建一個測試用例或選擇已有的所想測試的JAVA文件，點擊「File->New->…」菜單項或右擊文件，在彈出的「New」對話框中選擇「JUnit Test Case」，就進入「New JUnit Test Case」對話框

Ø 在「New JUnit TestCase」對話框填寫相應的欄目，主要有Name（測試用例名），SuperClass（若JUnit的版本是3.8.1，則測試的超類通常默認爲junit.framework.TestCase； 若JUnit版本是JUnit 4.4，則默認超類爲java.lang.Object。），Class Under Test（被測試的類），Source Folder（測試用例保存的目錄），Package（測試用例包名），及是否自動生成main，setUp，tearDown方法。在此通常填寫NAME及選上覆選上setUpt和teardown便可。

Ø 點擊「Next>」按鈕，則進入Test Methods，在此你能夠直接勾選你想測試的被測試類的方法，Eclipse將自動生成與被選方法相應的測試方法，點擊「Fishish」按鈕後一個測試用例就建立好了。

Ø 編寫完成測試用例後，點擊「Run」按鈕就能夠看到運行結果了。

    補充：要使用JUnit，您必須首先將JUnit JAR保存在項目的Build路徑上並建立一個測試類。將JUnit保存在項目的Build路徑上的步驟爲：

    右擊項目—>選擇菜單底部的Properties選擇Java Build Path—>選擇Libraries—>點擊Add Variable按鈕—>查看已有的列表中有無JUnit文件，若沒有，則點擊Configure Variable—>New按鈕，輸入JUNIT_LIB做爲變量名稱，編輯該變量並指向解壓後的JUnit目錄中的一個名爲JUnit.jar的文件—>而後在選擇剛纔添加的jar文件依次點擊OK便可。

4.二、Eclipse中JUnit應用示例

    下面咱們做一個在Eclipse中利用JUnit對HelloWorld的測試 測試方法：
Ø HelloWorld.sayHello()是否執行正常，而且結果也符合要求
Ø HelloWorld.add()方法是否與咱們預期同樣執行

    下一步，咱們準備對這兩個方法進行測試，確保功能正常。選中HelloWorld.java，右鍵點擊，選擇New->JUnit Test Case：

    進入下面這個頁面，在此諸多欄目已經填好，便是這個須要測試的文件的相關信息，如果想在測試完以後即刪除測試文件，也可更改路徑。（本機在Eclipse已有的JUnit3.8.1的基礎上又添加了一個新版本JUnit4.4）

    點擊Next進入Test Methods，在此選擇所要測試的方法sayHello及add。

    點擊Finish，最後編寫完成測試用例代碼以下：

    直接運行Run->Run As->JUnit Test，就能夠看到JUnit測試結果：

    綠色表示測試經過，只要有1個測試未經過，就會顯示紅色並列出未經過測試的方法。

五、後記

    從上面的來看，JUnit的使用並不很難，但關鍵就是最後一步完成測試碼，即編寫TestCase。要編寫一個好的TestCase卻並不是易事。一個很差的TestCase每每是既浪費了時間，也起不了實際的做用。相反，一個好的TestCase，不只能夠很好的指出代碼中存在的問題，並且也能夠做爲代碼更準確的文檔，同時還在持續集成的過程當中起很是重要的做用。咱們在做測試寫TestCase時須要注意的幾點：

Ø 測試的獨立性：一次只測試一個對象，方便定位出錯的位置。這有兩層意思：一個TestCase，只測試一個對象；一個TestMethod，只測試這個對象中的一個方法。

Ø 給測試方法一個合適的名字。 通常取名爲原來的方法名後加一個Test。

Ø 在assert函數中給出失敗的緣由，如：assertTrue( 「… should be true」, ……)，方便查錯。在這個例子中，若是沒法經過assertTrue，那麼給出的消息將被顯示。在junit中每一個assert函數都有第一個參數是出錯時顯示消息的函數原型。

Ø 測試全部可能引發失敗的地方，如：一個類中頻繁改動的函數。對於那些僅僅只含有getter/setter的類，若是是由IDE（如Eclipse）產生的，則可不測；若是是人工寫，那麼最好測試一下。

Ø 在setUp和tearDown中的代碼不該該是與測試方法相關的，而應該是全局相關的。如針對與測試方法A和B，在setUp和tearDown中的代碼應該是A和B都須要的代碼。

Ø 測試代碼的組織：相同的包，不一樣的目錄。這樣，測試代碼能夠訪問被測試類的protected變量/方法，方便測試代碼的編寫。放在不一樣的目錄，則方便了測試代碼的管理以及代碼的打包和發佈。

闡述JUnit的測試流程架構。咱們將從不一樣的角度來詳細分析這個圖。

圖 測試序列圖

 

 

TestNG和JUnit是針對Java語言的兩個比較經常使用的測試框架。JUnit出現的比較早，可是早期的JUnit 3對測試代碼有很是多的限制，使用起來很不方便，後來的JUnit 4獲得很大的改進。TestNG的出現介於JUnit 3和JUnit 4，可是TestNG在不少方面還要優於JUnit 4。下面從總體上對TestNG和JUnit 4進行比較全面的比較。


　　TestNG與JUnit的相同點：
1. 使用annotation，且大部分annotation相同。
2. 均可以進行單元測試（Unit test）。
3. 都是針對Java測試的工具。


　　TestNG與JUnit的不一樣點：
1. JUnit只能進行單元測試，TestNG能夠進行單元測試(unit test)，功能測試(function test)，端到端測試(e2e test)，集成測試(Integration test)等。
2. TestNG須要一個額外的xml配置文件，配置測試的class、method甚至package。
3. TestNG的運行方式更加靈活：命令行、ant和IDE，JUnit只能使用IDE。
4. TestNG的annotation更加豐富，好比@ExpectedExceptions、@DataProvider等。
5. 測試套件運行失敗，JUnit 4會從新運行整個測試套件。TestNG運行失敗時，會建立一個XML文件說明失敗的測試，利用這個文件執行程序，就不會重複運行已經成功的測試。


　　TestNG比JUnit 4靈活性的體現：
1. JUnit 4中必須把@BeforeClass修飾的方法聲明爲public static，這就限制了該方法中使用的變量必須是static。而TestNG中@BeforeClass修飾的方法能夠跟普通函數徹底同樣。
2. JUnit 4測試的依賴性很是強，測試用例間有嚴格的前後順序。前一個測試不成功，後續全部的依賴測試都會失敗。TestNG 利用@Test 的dependsOnMethods屬性來應對測試依賴性問題。某方法依賴的方法失敗，它將被跳過，而不是標記爲失敗。
3. 對於n個不一樣參數組合的測試，JUnit 4要寫n個測試用例。每一個測試用例完成的任務基本是相同的，只是受測方法的參數有所改變。TestNG的參數化測試只須要一個測試用例，而後把所須要的參數加到TestNG的xml配置文件中。這樣的好處是參數與測試代碼分離，非程序員也能夠修改參數，同時修改無需從新編譯測試代碼。
4. 爲了測試沒法用String或原語值表示的複雜參數化類型，TestNG提供的@DataProvider使它們映射到某個測試方法。
5. JUnit 4的測試結果經過Green/Red bar體現，TestNG的結果除了Green/Red bar，還有Console窗口和test-output文件夾，對測試結果的描述更加詳細，方便定位錯誤。


　　簡單說就是TestNG比Junit強大, 可是那些更強大的功能你所有都用不到的話, 那你仍是就用junit, 比較簡單, 國人用的多, 出了問題中文也比較好查.  英文還不錯而且有想要了解除了單元測試之外的測試的話, 就用TestNG吧。

詳解Java單元測試Junit框架實例

主要介紹了Java的異常測試框架JUnit使用上手指南,JUnit是Java代碼進行單元測試中的經常使用工具,

 

問題：

一、目前測試存在的問題

二、Junit注意的細節

三、Junit使用規範

四、斷言

五、案例

junit(單元測試框架)

一、目前存在的問題

一、目前的測試方法若是須要測試，都須要在main方法上調用

二、目前的結果都須要咱們人工比對

二、Junit 注意的細節

一、若是使用junit測試一個方法的時候，在junit窗口上顯示綠色那麼表示測試正確，若是顯示了紅色，則表明該方法測試出現了異常不經過

二、若是點擊方法名、類名、包名、工程名運行junit分別測試的是對於的方法，類、包中的全部類的test方法，工程中全部test的方法

三、@Test測試的方法不能是static修飾與不能帶有形參

四、若是測試一個方法的時候須要準備測試的環境或者是清理測試的環境，那麼能夠@Before、@After、@BeforeClass、@AfterClass 這四個註釋，@Before、@After 是在每一個測試方法測試的時候都會調用一次，@AfterClass、@BeforeClass是在全部的測試方法測試以前與以後都會調用一次，這個方法必須是靜態的

三、junit使用規範

一、一個類若是須要測試，那麼該類就應該對應着一個測試類，測試類的命名規範：被測試類的類名+Test

二、一個被測試的方法通常對應一個測試的方法，測試的方法的命名規範是：test+被測試的方法的方法名

四、斷言

斷言就是不顯示結果，按照程序運行的預期值和實際值進行比對，顯示運行的狀態。

?

1 2 3 4 5

Assert.assertSame( 5 , max); // 底層是用了  == Assert.assertSame( new String( "abc" ), "abc" ); Assert.assertEquals( new String( "abc" ), "abc" ); //底層是使用Equals方法比較的 Assert.assertNull( "aa" ); Assert.assertTrue( true );

五、案例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

package cn.xlucas.junit; import java.io.*; import org.junit.*; public class JunitDemo1 {   //準備測試的環境   //@Before   @BeforeClass   public static void beforeRead(){     System.out.println("準備測試環境成功...");   }   //讀取文件數據，把把文件數據都   @Test   public void readFile() throws IOException{     FileInputStream fileInputStream = new FileInputStream("F:\\a.txt");     int content = fileInputStream.read();     System.out.println("內容："+content);   }   @Test   public void sort(){     System.out.println("讀取文件數據排序..");   }    //清理測試環境的方法 // @After    @AfterClass   public static void afterRead(){     System.out.println("清理測試環境..");   } }

1、JUnit4是JUnit框架有史以來的最大改進，其主要目標即是利用Java5的Annotation特性簡化測試用例的編寫。

 

2、先簡單解釋一下什麼是Annotation，這個單詞通常是翻譯成元數據。元數據是什麼？元數據就是描述數據的數據。也就是說，這個東西在Java裏面能夠用來和public、static等關鍵字同樣來修飾類名、方法名、變量名。修飾的做用描述這個數據是作什麼用的，差很少和public描述這個數據是公有的同樣

 

3、對Person類的方法進行測試：

 

測試類Person：

 

package com.ren.junit;

public class Person {

    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

測試該類的方法PersonTest:

package com.ren.junit;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

//對Person類進行測試
public class PersonTest {

    private Person p;

    @BeforeClass
    public static void beforeClass() {
        System.out.println("boforeClass");
    }

    @Before
    public void before() {
        p = new Person("lisi",20);
        System.out.println("before");
    }

    @Test
    public void testGetName() {

        System.out.println(p.getName());
    }

    @Test
    public void testGetAge() {

        System.out.println(p.getAge());
    }

    @After
    public void after() {
        System.out.println("after");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("afterClass");
    }
}

輸出結果：
boforeClass
before
lisi
after
before
20
after
afterClass

如下是轉載：

咱們先看一下在JUnit 3中咱們是怎樣寫一個單元測試的。好比下面一個類：

 

public class AddOperation {
      public int add(int x,int y){
          return x+y;
      }
}

咱們要測試add這個方法，咱們寫單元測試得這麼寫：

import junit.framework.TestCase;
import static org.junit.Assert.*;
public class AddOperationTest extends TestCase{

      public void setUp() throws Exception {
      }

      public void tearDown() throws Exception {
      }

      public void testAdd() {
          System.out.println(\"add\");
          int x = 0;
          int y = 0;
          AddOperation instance = new AddOperation();
          int expResult = 0;
          int result = instance.add(x, y);
          assertEquals(expResult, result);
      }
}

能夠看到上面的類使用了JDK5中的靜態導入，這個相對來講就很簡單，只要在import關鍵字後面加上static關鍵字，就能夠把後面的類的static的變量和方法導入到這個類中，調用的時候和調用本身的方法沒有任何區別。


咱們能夠看到上面那個單元測試有一些比較霸道的地方，表如今：
1.單元測試類必須繼承自TestCase。
2.要測試的方法必須以test開頭。

若是上面那個單元測試在JUnit 4中寫就不會這麼複雜。代碼以下：

import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

/**
*
* @author bean
*/
public class AddOperationTest extends TestCase{

      public AddOperationTest() {
      }

      @Before
      public void setUp() throws Exception {
      }

      @After
      public void tearDown() throws Exception {
      }

      @Test
      public void add() {
          System.out.println(\"add\");
          int x = 0;
          int y = 0;
          AddOperation instance = new AddOperation();
          int expResult = 0;
          int result = instance.add(x, y);
          assertEquals(expResult, result);
      }

}

咱們能夠看到，採用Annotation的JUnit已經不會霸道的要求你必須繼承自TestCase了，並且測試方法也沒必要以test開頭了，只要以@Test元數據來描述便可。
從上面的例子能夠看到在JUnit 4中還引入了一些其餘的元數據，下面一一介紹：
@Before：
使用了該元數據的方法在每一個測試方法執行以前都要執行一次。

@After：
使用了該元數據的方法在每一個測試方法執行以後要執行一次。

注意：@Before和@After標示的方法只能各有一個。這個至關於取代了JUnit之前版本中的setUp和tearDown方法，固然你還能夠繼續叫這個名字，不過JUnit不會霸道的要求你這麼作了。

@Test(expected=*.class)
在JUnit4.0以前，對錯誤的測試，咱們只能經過fail來產生一個錯誤，並在try塊裏面assertTrue（true）來測試。如今，經過@Test元數據中的expected屬性。expected屬性的值是一個異常的類型

@Test(timeout=xxx):
該元數據傳入了一個時間（毫秒）給測試方法，
若是測試方法在制定的時間以內沒有運行完，則測試也失敗。

@ignore：
該元數據標記的測試方法在測試中會被忽略。當測試的方法尚未實現，或者測試的方法已通過時，或者在某種條件下才能測試該方法（好比須要一個數據庫聯接，而在本地測試的時候，數據庫並無鏈接），那麼使用該標籤來標示這個方法。同時，你能夠爲該標籤傳遞一個String的參數，來代表爲何會忽略這個測試方法。好比：@lgnore(「該方法尚未實現」)，在執行的時候，僅會報告該方法沒有實現，而不會運行測試方法。

 

 

junit測試是如今編寫測試代碼的手段之一,本文簡要介紹如何快速搭建一個junit測試環境.

 

工具/原料

 

• eclipse工具
• junit包

 

方法/步驟

 

 

 

1. 1

   首先建立一個java Project；將junit包和hamcrest-core包導入到項目中
2. 2

   建立一個source folder 資源文件夾 test，資源文件夾和普通的文件夾區別是，資源文件夾中的java文件能夠被自動編譯。
3. 3

   在java文件中編寫java代碼UserMananger.java，在test文件中建立一個與須要進行測試的java代碼同包名稱的TestUserManager.java文件。
4. 4

   junit4採用的是經過註解的方式（在方法的上面加上@）.

   @Before表示在全部方法運行前運行的方法;

   @After表示在全部的方法運行以後執行的方法;

   @Test表示這是一個測試方法

   @BeforeClass表示在這個測試類構造以前執行的方法

   @AfterClass表示在這個測試類構造以後執行的方法
5. 5

   若是是對某一個方法進行測試，在方法的名稱上點擊右鍵 --> run as --> JUnit Test
6. 6

   若是是對全部的方法都執行一遍,在類體上右鍵--Run as--> JunitTest .

   綠色的表示運行經過的方法,紅x的表示運行失敗的方法.

    

    

   本文簡要介紹一下在 Eclipse3.2 中使用 JUnit4 進行單元測試的方法。

   首先，咱們來一個傻瓜式速成教程，不要問爲何，Follow Me，先來體驗一下單元測試的快感！

   首先新建一個項目叫JUnit_Test，咱們編寫一個Calculator類，這是一個可以簡單實現加減乘除、平方、開方的計算器類，而後對這些功能進行單元測試。這個類並非很完美，咱們故意保留了一些Bug用於演示，這些Bug在註釋中都有說明。該類代碼以下：

   
   

   package andycpp;
   
   public class Calculator {
       private static int result; // 靜態變量，用於存儲運行結果
       public void add(int n) {
           result = result + n;
       }
       public void substract(int n) {
           result = result - 1;  //Bug: 正確的應該是 result =result-n
       }
       public void multiply(int n) {
       }          // 此方法還沒有寫好
       public void divide(int n) {
           result = result / n;
       }
       public void square(int n) {
           result = n * n;
       }
       public void squareRoot(int n) {
           for (; ;) ;            //Bug : 死循環
       }
       public void clear() {     // 將結果清零
           result = 0;
       }
       public int getResult() {
           return result;
       }
   }

   第二步，將JUnit4單元測試包引入這個項目：在該項目上點右鍵，點「屬性」，如圖：

    

   
   在彈出的屬性窗口中，首先在左邊選擇「 Java Build Path 」，而後到右上選擇「 Libraries 」標籤，以後在最右邊點擊「 Add Library… 」按鈕，以下圖所示：
   
   
   而後在新彈出的對話框中選擇 JUnit4 並點擊肯定，如上圖所示， JUnit4 軟件包就被包含進咱們這個項目了。
   
       第三步，生成 JUnit 測試框架：在 Eclipse 的 Package Explorer 中用右鍵點擊該類彈出菜單，選擇「 New à JUnit Test Case 」。以下圖所示：
   
   
   在彈出的對話框中，進行相應的選擇，以下圖所示：
   
   
       點擊「下一步」後，系統會自動列出你這個類中包含的方法，選擇你要進行測試的方法。此例中，咱們僅對「加、減、乘、除」四個方法進行測試。以下圖所示：
   
   
   

   以後系統會自動生成一個新類CalculatorTest，裏面包含一些空的測試用例。你只須要將這些測試用例稍做修改便可使用。完整的CalculatorTest代碼以下：

   
   

   package andycpp;
   
   import static org.junit.Assert.*;
   import org.junit.Before;
   import org.junit.Ignore;
   import org.junit.Test;
   
   public class CalculatorTest {
   
       private static Calculator calculator = new Calculator();
       
       @Before
       public void setUp() throws Exception {
           calculator.clear();
       }
   
       @Test
       public void testAdd() {
           calculator.add(2);
           calculator.add(3);
           assertEquals(5, calculator.getResult());
       }
   
       @Test
       public void testSubstract() {
           calculator.add(10);
           calculator.substract(2);
           assertEquals(8, calculator.getResult());
       }
   
       @Ignore("Multiply() Not yet implemented")
       @Test
       public void testMultiply() {
       }
   
       @Test
       public void testDivide() {
           calculator.add(8);
           calculator.divide(2);
           assertEquals(4, calculator.getResult());
       }
   }

   第四步，運行測試代碼：按照上述代碼修改完畢後，咱們在CalculatorTest類上點右鍵，選擇「Run As à JUnit Test」來運行咱們的測試，以下圖所示：

    

   運行結果以下：

    

    

   進度條是紅顏色表示發現錯誤，具體的測試結果在進度條上面有表示「共進行了4個測試，其中1個測試被忽略，一個測試失敗」。

    

   咱們繼續對初級篇中的例子進行分析。初級篇中咱們使用Eclipse自動生成了一個測試框架，在這篇文章中，咱們來仔細分析一下這個測試框架中的每個細節，知其然更要知其因此然，才能更加熟練地應用JUnit4。

   1、     包含必要地Package

   在測試類中用到了JUnit4框架，天然要把相應地Package包含進來。最主要地一個Package就是org.junit.*。把它包含進來以後，絕大部分功能就有了。還有一句話也很是地重要「import static org.junit.Assert.*;」，咱們在測試的時候使用的一系列assertEquals方法就來自這個包。你們注意一下，這是一個靜態包含（static），是JDK5中新增添的一個功能。也就是說，assertEquals是Assert類中的一系列的靜態方法，通常的使用方式是Assert. assertEquals()，可是使用了靜態包含後，前面的類名就能夠省略了，使用起來更加的方便。

   2、     測試類的聲明

   你們注意到，咱們的測試類是一個獨立的類，沒有任何父類。測試類的名字也能夠任意命名，沒有任何侷限性。因此咱們不能經過類的聲明來判斷它是否是一個測試類，它與普通類的區別在於它內部的方法的聲明，咱們接着會講到。

   3、     建立一個待測試的對象。

   你要測試哪一個類，那麼你首先就要建立一個該類的對象。正如上一篇文章中的代碼：

    

   private static Calculator calculator = new Calculator();

    

   爲了測試Calculator類，咱們必須建立一個calculator對象。

   4、     測試方法的聲明

   在測試類中，並非每個方法都是用於測試的，你必須使用「標註」來明確代表哪些是測試方法。「標註」也是JDK5的一個新特性，用在此處很是恰當。咱們能夠看到，在某些方法的前有@Before、@Test、@Ignore等字樣，這些就是標註，以一個「@」做爲開頭。這些標註都是JUnit4自定義的，熟練掌握這些標註的含義很是重要。

   5、     編寫一個簡單的測試方法。

   首先，你要在方法的前面使用@Test標註，以代表這是一個測試方法。對於方法的聲明也有以下要求：名字能夠隨便取，沒有任何限制，可是返回值必須爲void，並且不能有任何參數。若是違反這些規定，會在運行時拋出一個異常。至於方法內該寫些什麼，那就要看你須要測試些什麼了。好比：

    

       @Test
   
       public void testAdd() {
   
             calculator.add(2);
   
             calculator.add(3);
   
             assertEquals(5, calculator.getResult());
   
       }

    

   咱們想測試一下「加法」功能時候正確，就在測試方法中調用幾回add函數，初始值爲0，先加2，再加3，咱們期待的結果應該是5。若是最終實際結果也是5，則說明add方法是正確的，反之說明它是錯的。assertEquals(5, calculator.getResult());就是來判斷期待結果和實際結果是否相等，第一個參數填寫期待結果，第二個參數填寫實際結果，也就是經過計算獲得的結果。這樣寫好以後，JUnit會自動進行測試並把測試結果反饋給用戶。

   6、     忽略測試某些還沒有完成的方法。

   若是你在寫程序前作了很好的規劃，那麼哪些方法是什麼功能都應該實現定下來。所以，即便該方法還沒有完成，他的具體功能也是肯定的，這也就意味着你能夠爲他編寫測試用例。可是，若是你已經把該方法的測試用例寫完，但該方法還沒有完成，那麼測試的時候必定是「失敗」。這種失敗和真正的失敗是有區別的，所以JUnit提供了一種方法來區別他們，那就是在這種測試函數的前面加上@Ignore標註，這個標註的含義就是「某些方法還沒有完成，暫不參與這次測試」。這樣的話測試結果就會提示你有幾個測試被忽略，而不是失敗。一旦你完成了相應函數，只須要把@Ignore標註刪去，就能夠進行正常的測試。

   7、     Fixture（暫且翻譯爲「固定代碼段」）

   Fixture的含義就是「在某些階段必然被調用的代碼」。好比咱們上面的測試，因爲只聲明瞭一個Calculator對象，他的初始值是0，可是測試完加法操做後，他的值就不是0了；接下來測試減法操做，就必然要考慮上次加法操做的結果。這絕對是一個很糟糕的設計！咱們很是但願每個測試都是獨立的，相互之間沒有任何耦合度。所以，咱們就頗有必要在執行每個測試以前，對Calculator對象進行一個「復原」操做，以消除其餘測試形成的影響。所以，「在任何一個測試執行以前必須執行的代碼」就是一個Fixture，咱們用@Before來標註它，如前面例子所示：

    

         @Before
   
         public void setUp() throws Exception {
   
              calculator.clear();
   
         }

    

   這裏不在須要@Test標註，由於這不是一個test，而是一個Fixture。同理，若是「在任何測試執行以後須要進行的收尾工做」也是一個Fixture，使用@After來標註。因爲本例比較簡單，沒有用到此功能。

           JUnit4的一些基本知識就介紹到此，還有一些更靈活的用法放在本系列的高級篇中給你們介紹！

    

    

   1.類的定義：類是同一事物的總稱，類是封裝對象的屬性和行爲的載體，反過來講具備相同屬性和行爲的一類實體被稱爲類。

    

   2.Junit工具的使用：

    

   第一步

    

   首先新建一個項目叫JUnit_Test，咱們編寫一個Calculator類，這是一個可以簡單實現加減乘除、平方、開方的計算器類，而後對這些功能進行單體測試。

    

   第二步，將JUnit4單元測試包引入這個項目：在該項目上點右鍵，點「屬性」，如圖：

    

   在彈出的屬性窗口中，首先在左邊選擇「Java Build Path」，而後到右上選擇「Libraries」標籤，以後在最右邊點擊「Add Library…」按鈕，以下圖所示：

    

    

   而後在新彈出的對話框中選擇JUnit4並點擊肯定，如上圖所示，JUnit4軟件包就被包含進咱們這個項目了。
   
       第三步，生成JUnit測試框架：在Eclipse的Package Explorer中用右鍵點擊該類彈出菜單，選擇「New à JUnit Test Case」。以下圖所示：

    

    

    

    

   點擊「下一步」後，系統會自動列出你這個類中包含的方法，選擇你要進行測試的方法。此例中，咱們僅對「加、減、乘、除」四個方法進行測試。

    

    

    

   以後系統會自動生成一個新類CalculatorTest，裏面包含一些空的測試用例。你只須要將這些測試用例稍做修改便可使用。

    

   第四步，運行測試代碼：按照上述代碼修改完畢後，咱們在CalculatorTest類上點右鍵，選擇「Run As à JUnit Test」來運行咱們的測試，以下圖所示：

    

    

    

    

   運行結果以下：

    

    

   4.記錄各個階段的時間

   1.類的定義：類是同一事物的總稱，類是封裝對象的屬性和行爲的載體，反過來講具備相同屬性和行爲的一類實體被稱爲類。

   2.Junit工具的使用：

   第一步

   首先新建一個項目叫JUnit_Test，咱們編寫一個Calculator類，這是一個可以簡單實現加減乘除、平方、開方的計算器類，而後對這些功能進行單體測試。

   第二步，將JUnit4單元測試包引入這個項目：在該項目上點右鍵，點「屬性」，如圖：

   在彈出的屬性窗口中，首先在左邊選擇「Java Build Path」，而後到右上選擇「Libraries」標籤，以後在最右邊點擊「Add Library…」按鈕，以下圖所示：

   而後在新彈出的對話框中選擇JUnit4並點擊肯定，如上圖所示，JUnit4軟件包就被包含進咱們這個項目了。
   
       第三步，生成JUnit測試框架：在Eclipse的Package Explorer中用右鍵點擊該類彈出菜單，選擇「New à JUnit Test Case」。以下圖所示：

    

   點擊「下一步」後，系統會自動列出你這個類中包含的方法，選擇你要進行測試的方法。此例中，咱們僅對「加、減、乘、除」四個方法進行測試。

    

   以後系統會自動生成一個新類CalculatorTest，裏面包含一些空的測試用例。你只須要將這些測試用例稍做修改便可使用。

   第四步，運行測試代碼：按照上述代碼修改完畢後，咱們在CalculatorTest類上點右鍵，選擇「Run As à JUnit Test」來運行咱們的測試，以下圖所示：

    

   運行結果以下：

   一、Junit簡介：

       Junit最初是由Erich Gamma 和 Kent Beck 編寫的一個迴歸測試框架(regression testing framework)，爲單元測試（Unit Test）的支持框架。用來編寫和執行重覆性的測試。即所謂白盒測試。

    

   它包括瞭如下的特性：

    

     1 對預期結果做斷言
     2 提供測試裝備的生成與銷燬
     3 易於組織執行測試
     4 圖形與文字界面的測試器
   二、Junit的環境配置
   環境：Eclipse 中配置junit，選擇項目Junit4(在Package Explorer中) -> 右擊鼠標 -> 選擇properties -> 選擇Java Build Path (在左邊的菜單中) -> 在右邊選擇標籤 Libraries  -> 單擊按鈕「Add Library」  -> 選擇JUnit , 單擊按鈕 「Next>」  -> 選擇JUnit library version 爲： JUnit4 -> 單擊按鈕「Finish」 –> 單擊按鈕 「OK」

    

    Junit4是Junit框架有史以來的最大改進，其主要目標是利用java5的Annotation特性來簡化測試用例的編寫。Junit4的官方網址是http://www.junit.org/。

    

    

    

   三、總結一下3-4的不一樣,及4的改進

    

   下面咱們以一個簡單的例子來介紹如何使用 Junit4同Junit3編寫測試用例：
   public Class XXXX{

    

        public String hello(){

    

        return 「hello」;

    

         }

    

   }

    

   對於這個類的用junit3編寫測試用例：

    

   import junit.framework.TestCase;

    

      public Class XXXXTest extends TestCase{

    

      public void testHello(){

    

      asssertEqual(new XXXX().Hello(),」hello」);

    

     }

    

   }

    

   用junit4編寫測試用例：

    

   import static org.junit.framework.assertEqual;

    

   import org.junit.Test;

    

   //這兩個是junit4中必須導入的s

    

   public Class XXXXTest{

    

   @Test

    

   public void helloTest(){

    

       asssertEqual(new XXXX().Hello(),」hello」);

    

   }

    

   }

    

   從上面例子咱們對Junit3和Junit4有了一個初步的印象，下面咱們重點介紹Junit4與Junit3的主要區別。

    

   JUnit3  JUnit4 必須引入類TestCase import junit.framework.TestCase; 必須引入 import org.junit.Test; import static org.junit.Assert.*; 必須繼承類TestCase class BaseClassTest extends TestCase 不須要 測試方法必須以test開頭 public void testMethod () 不須要， 可是類開始的時候要標記 @Test 經過assert*方法來判斷結果 assertTrue(baseClass.method ().equals(「test.junit.BaseClass」));