Junit學習筆記

時間 2019-11-13

標籤 junit 學習筆記欄目 Java 简体版

原文原文鏈接

什麼是單元測試？css

　　所謂單元測試是測試應用程序的功能是否可以按須要正常運行，而且確保是在開發人員的水平上，單元測試生成圖片。單元測試是一個對單一實體（類或方法）的測試。單元測試是每一個軟件公司提升產品質量、知足客戶需求的重要環節。html

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　單元測試能夠由兩種方式完成：前端

人工測試java	自動測試nginx
手動執行測試用例並不藉助任何工具的測試被稱爲人工測試。git - 消耗時間並單調：因爲測試用例是由人力資源執行，因此很是緩慢並乏味。程序員 - 人力資源上投資巨大：因爲測試用例須要人工執行，因此在人工測試上須要更多的試驗員。github - 可信度較低：人工測試可信度較低是可能因爲人工錯誤致使測試運行時不夠精確。web - 非程式化：編寫複雜並能夠獲取隱藏的信息的測試的話，這樣的程序沒法編寫。apache	藉助工具支持而且利用自動工具執行用例被稱爲自動測試。 - 快速自動化運行測試用例時明顯比人力資源快。 - 人力資源投資較少：測試用例由自動工具執行，因此在自動測試中須要較少的試驗員。 - 可信度更高：自動化測試每次運行時精確地執行相同的操做。 - 程式化：試驗員能夠編寫複雜的測試來顯示隱藏信息。

人工測試java

自動測試nginx

手動執行測試用例並不藉助任何工具的測試被稱爲人工測試。git

- 消耗時間並單調：因爲測試用例是由人力資源執行，因此很是緩慢並乏味。程序員

- 人力資源上投資巨大：因爲測試用例須要人工執行，因此在人工測試上須要更多的試驗員。github

- 可信度較低：人工測試可信度較低是可能因爲人工錯誤致使測試運行時不夠精確。web

- 非程式化：編寫複雜並能夠獲取隱藏的信息的測試的話，這樣的程序沒法編寫。apache

藉助工具支持而且利用自動工具執行用例被稱爲自動測試。

- 快速自動化運行測試用例時明顯比人力資源快。

- 人力資源投資較少：測試用例由自動工具執行，因此在自動測試中須要較少的試驗員。

- 可信度更高：自動化測試每次運行時精確地執行相同的操做。

- 程式化：試驗員能夠編寫複雜的測試來顯示隱藏信息。

什麼是 JUnit？

　　JUnit 是一個 Java 編程語言的單元測試框架。JUnit 在測試驅動的開發方面有很重要的發展，是起源於 JUnit 的一個統稱爲 xUnit 的單元測試框架之一。

　　JUnit 促進了「先測試後編碼」的理念，強調創建測試數據的一段代碼，能夠先測試，而後再應用。這個方法就比如「測試一點，編碼一點，測試一點，編碼一點……」，增長了程序員的產量和程序的穩定性，能夠減小程序員的壓力和花費在排錯上的時間。

特色：

JUnit 是一個開放的資源框架，用於編寫和運行測試。
提供註釋來識別測試方法。
提供斷言來測試預期結果。
提供測試運行來運行測試。
JUnit 測試容許你編寫代碼更快，並能提升質量。
JUnit 優雅簡潔。沒那麼複雜，花費時間較少。
JUnit 測試能夠自動運行而且檢查自身結果並提供即時反饋。因此也沒有必要人工梳理測試結果的報告。
JUnit 測試能夠被組織爲測試套件，包含測試用例，甚至其餘的測試套件。
JUnit 在一個條中顯示進度。若是運行良好則是綠色；若是運行失敗，則變成紅色。

什麼是一個單元測試用例?

　　單元測試用例是一部分代碼，能夠確保另外一端代碼（方法）按預期工做。爲了迅速達到預期的結果，就須要測試框架。JUnit 是 java 編程語言理想的單元測試框架。

　　一個正式的編寫好的單元測試用例的特色是：已知輸入和預期輸出，即在測試執行前就已知。已知輸入須要測試的先決條件，預期輸出須要測試後置條件。

　　每一項需求至少須要兩個單元測試用例：一個正檢驗，一個負檢驗。若是一個需求有子需求，每個子需求必須至少有正檢驗和負檢驗兩個測試用例。

Junit - 環境設置

本地環境設置

　　JUnit 是 Java 的一個框架，因此最根本的須要是在你的機器裏裝有 JDK。

系統要求

JDK	1.5或1.5以上
內存	沒有最小要求
磁盤空間	沒有最小要求
操做系統	沒有最小要求

步驟1：在你的機器裏驗證 Java 裝置

　　　　　　　　　　　　　　　　　如今打開控制檯，執行如下 java 要求：

操做系統	任務	命令
Windows	打開命令操做臺	c:>java -version
Linux	打開命令終端	$ java -version
Mac	打開終端	machine:~ joseph$ java -version

　　　　　　　　　　　　　　　　　咱們來驗證一下全部操做系統的輸出：

操做系統	輸出
Windows	java 版本「1.6.0_21」 Java（TM）SE 運行環境（build 1.6.0_21-b07） Java 熱點（TM）客戶端虛擬機（build 17.0-b17，混合模式，共享）
Linux	java 版本「1.6.0_21」 Java（TM）SE 運行環境（build 1.6.0_21-b07） Java 熱點（TM）客戶端虛擬機（build 17.0-b17，混合模式，共享）
Mac	java 版本「1.6.0_21」 Java（TM）SE 運行環境（build 1.6.0_21-b07） Java 熱點（TM）64-字節服務器虛擬機（build 17.0-b17，混合模式，共享）

操做系統

輸出

Windows

java 版本「1.6.0_21」

Java（TM）SE 運行環境（build 1.6.0_21-b07）

Java 熱點（TM）客戶端虛擬機（build 17.0-b17，混合模式，共享）

Linux

java 版本「1.6.0_21」

Java（TM）SE 運行環境（build 1.6.0_21-b07）

Java 熱點（TM）客戶端虛擬機（build 17.0-b17，混合模式，共享）

Mac

java 版本「1.6.0_21」

Java（TM）SE 運行環境（build 1.6.0_21-b07）

Java 熱點（TM）64-字節服務器虛擬機（build 17.0-b17，混合模式，共享）

　　若是你尚未安裝 Java，從如下網址安裝 http://www.oracle.com/technetwork/java/javase/downloads/index.html Java SDK。咱們採用 Java 1.6.0_21 做爲本教程的安裝版本。

步驟2：設置 JAVA 環境

　　　　　　　　設置 JAVA_HOME 環境變量，使之指向基本目錄位置，即在你機器上安裝 Java 的位置。

OS	輸出
Windows	設置環境變量 JAVA_HOME to C:\Program Files\Java\jdk1.6.0_21
Linux	輸出 JAVA_HOME=/usr/local/java-current
Mac	輸出 JAVA_HOME=/Library/Java/Home

輸出

Windows

設置環境變量 JAVA_HOME to C:\Program

Files\Java\jdk1.6.0_21

Linux

輸出 JAVA_HOME=/usr/local/java-current

Mac

輸出 JAVA_HOME=/Library/Java/Home

　　　　　　　　　　　　　　　　系統路徑添加 Java 編譯器位置。

OS	輸出
Windows	在系統變量路徑末端添加字符串 ;C:\Program Files\Java\jdk1.6.0_21\bin
Linux	輸出 PATH=$PATH:$JAVA_HOME/bin/
Mac	不須要

輸出

Windows

在系統變量路徑末端添加字符串

;C:\Program Files\Java\jdk1.6.0_21\bin

Linux

輸出 PATH=$PATH:$JAVA_HOME/bin/

Mac

不須要

　　　　　　　　　　　　　　　　使用以上解釋的 Java-version 命令驗證 Java 安裝。

步驟3：下載 Junit 檔案

　　　　從 http://www.junit.org 下載 JUnit 最新版本的壓縮文件。在編寫這個教程的同時，我已經下載了 Junit-4.10.jar 而且將它複製到 C:>JUnit 文件夾裏了。

OS	檔案名稱
Windows	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

步驟4：設置 JUnit 環境

　　　　設置 JAVA_HOME 環境變量，使之指向基本目錄位置，即在你機器上安裝 JUNIT 壓縮文件的位置。假設，咱們已經在如下不一樣的操做系統的 JUNIT 文件夾裏存儲了 junit4.10.jar。

OS	輸出
Windows	設置環境變量 JUNIT_HOME 到 C:\JUNIT
Linux	輸出 JUNIT_HOME=/usr/local/JUNIT
Mac	輸出 JUNIT_HOME=/Library/JUNIT

步驟5：設置 CLASSPATH 變量

　　　　設置 CLASSPATH 環境變量，使之指向 JUNIT 壓縮文件位置。假設，咱們已經在如下不一樣的操做系統的 JUNIT 文件夾裏存儲了 junit4.10.jar 。

OS	輸出
Windows	設置環境變量 CLASSPATH 到 %CLASSPATH%;%JUNIT_HOME%\junit4.10.jar;.;
Linux	輸出 CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.10.jar:.
Mac	輸出 CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.10.jar:.

步驟6：測試 JUnit 創建

　　　　在 C:\ > JUNIT_WORKSPACE 中建立一個 java 類文件，名稱爲 TestJunit。

import org.junit.Test; 

import static org.junit.Assert.assertEquals; 

public class TestJunit { 
    @Test public void testAdd() { 
        String str= "Junit is working fine"; 
        assertEquals("Junit is working fine",str); 
    } 
}

　　　　在 C:\ > JUNIT_WORKSPACE 中建立一個 java 類文件，名稱爲TestRunner，來執行測試用例。

import org.junit.runner.JUnitCore; 

import org.junit.runner.Result; 

import org.junit.runner.notification.Failure; 

public class TestRunner { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit.class);
         for (Failure failure : result.getFailures()) { 

            System.out.println(failure.toString()); 
        } 
    System.out.println(result.wasSuccessful());
     } 
}

步驟7：驗證結果

　　　　利用 javac 編譯器按照如下方式編寫類。

C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

　　　　如今運行 Test Runner 來看結果。

C:\JUNIT_WORKSPACE>java TestRunner

　　　　驗證輸出。

ture

JUnit - 基本用法

如今咱們將應用簡單的例子來一步一步教你如何使用 Junit。

建立一個類

在C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 MessageUtil.java 的類用來測試。

/* * This class prints the given message on console. */ 

public class MessageUtil { 
    private String message; 
    
    //Constructor //
    @param message to be printed 
       
    public MessageUtil(String message){ 
            this.message = message; 
        }
     // prints the message 

    public String printMessage(){ 
        System.out.println(message);
         return message; 
    }
 }

建立 Test Case 類

建立一個名爲 TestJunit.java 的測試類。
向測試類中添加名爲 testPrintMessage() 的方法。
向方法中添加 Annotaion @Test。
執行測試條件而且應用 Junit 的 assertEquals API 來檢查。

在C:\ > JUNIT_WORKSPACE路徑下建立一個文件名爲 TestJunit.java 的類

import org.junit.Test;

import static org.junit.Assert.assertEquals; 

    public class TestJunit { 
        String message = "Hello World"; 
        MessageUtil messageUtil = new MessageUtil(message); 
        @Test 
        public void testPrintMessage() {     

        assertEquals(message,messageUtil.printMessage()); 
    }
 }

建立 Test Runner 類

建立一個 TestRunner 類
運用 JUnit 的 JUnitCore 類的 runClasses 方法來運行上述測試類的測試案例
獲取在 Result Object 中運行的測試案例的結果
獲取 Result Object 的 getFailures() 方法中的失敗結果
獲取 Result object 的 wasSuccessful() 方法中的成功結果

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個文件名爲 TestRunner.java 的類來執行測試案例

import org.junit.runner.JUnitCore; 

import org.junit.runner.Result; 

import org.junit.runner.notification.Failure; 

public class TestRunner { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit.class); 
    for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString());
     } 
    System.out.println(result.wasSuccessful()); 
    } 
}

用 javac 編譯 MessageUtil、Test case 和 Test Runner 類。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

如今運行 Test Runner,它能夠運行在所提供的 Test Case 類中定義的測試案例。

C:\JUNIT_WORKSPACE>java TestRunner

檢查運行結果

Hello World true

如今更新 C:\ > JUNIT_WORKSPACE 路徑下的 TestJunit，而且檢測失敗。改變消息字符串。

import org.junit.Test;

import static org.junit.Assert.assertEquals; 

    public class TestJunit { 
        String message = "Hello World"; 
        MessageUtil messageUtil = new MessageUtil(message); 

@Test 
    public void testPrintMessage() {
 
    message = "New Word"; 
    assertEquals(message,messageUtil.printMessage()); 
    } 
}

讓咱們保持其餘類不變，再次嘗試運行相同的 Test Runner

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit.class);
    for (Failure failure : result.getFailures()) {
        System.out.println(failure.toString()); 
        } 
    System.out.println(result.wasSuccessful());
     }
}

如今運行在 Test Case 類中提供的即將運行測試案例的 Test Runner

C:\JUNIT_WORKSPACE>java TestRunner

檢查運行結果

Hello World testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d> false

JUnit 中的重要的 API

JUnit 中的最重要的程序包是 junit.framework 它包含了全部的核心類。一些重要的類列示以下：

序號	類的名稱	類的功能
1	Assert	assert 方法的集合
2	TestCase	一個定義了運行多重測試的固定裝置
3	TestResult	TestResult 集合了執行測試樣例的全部結果
4	TestSuite	TestSuite 是測試的集合

Assert 類

下面介紹的是 org.junit.Assert 類：

public class Assert extends java.lang.Object

這個類提供了一系列的編寫測試的有用的聲明方法。只有失敗的聲明方法纔會被記錄。Assert 類的重要方法列式以下：

序號	方法和描述
1	void assertEquals(boolean expected, boolean actual) 檢查兩個變量或者等式是否平衡
2	void assertFalse(boolean condition) 檢查條件是假的
3	void assertNotNull(Object object) 檢查對象不是空的
4	void assertNull(Object object) 檢查對象是空的
5	void assertTrue(boolean condition) 檢查條件爲真
6	void fail() 在沒有報告的狀況下使測試不經過

下面讓咱們在例子中來測試一下上面提到的一些方法。在 C:\ > JUNIT_WORKSPACE 目錄下建立一個名爲 TestJunit1.java 的類。

import org.junit.Test; 
import static org.junit.Assert.*; 

public class TestJunit1 { 

@Test 
    public void testAdd() { 

    //test data 
    int num= 5; 
    String temp= null; 
    String str= "Junit is working fine"; 
    
    //check for equality assertEquals("Junit is working fine", str); 
    //check for false condition assertFalse(num > 6); 
    //check for not null value assertNotNull(str); 
    } 
}

接下來，咱們在 C:\ > JUNIT_WORKSPACE 目錄下建立一個文件名爲 TestRunner1.java 的類來執行測試案例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result;
import org.junit.runner.notification.Failure; 

public class TestRunner1 { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit1.class); 
    for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString()); 
        } 
    System.out.println(result.wasSuccessful()); 
    } 
}

用 javac 編譯 Test case 和 Test Runner 類

C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

如今運行 Test Runner 它將運行在 Test Case 類中定義並提供的測試樣例。

C:\JUNIT_WORKSPACE>java TestRunner1

檢查輸出結果。

true

TestCase 類

下面介紹的是 org.junit.TestCaset 類：

public abstract class TestCase extends Assert implements Test

測試樣例定義了運行多重測試的固定格式。TestCase 類的一些重要方法列式以下：

序號	方法和描述
1	int countTestCases() 爲被run(TestResult result) 執行的測試案例計數
2	TestResult createResult() 建立一個默認的 TestResult 對象
3	String getName() 獲取 TestCase 的名稱
4	TestResult run() 一個運行這個測試的方便的方法，收集由TestResult 對象產生的結果
5	void run(TestResult result) 在 TestResult 中運行測試案例並收集結果
6	void setName(String name) 設置 TestCase 的名稱
7	void setUp() 建立固定裝置，例如，打開一個網絡鏈接
8	void tearDown() 拆除固定裝置，例如，關閉一個網絡鏈接
9	String toString() 返回測試案例的一個字符串表示

咱們在例子中嘗試一下上文提到的方法。在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲TestJunit2.java 的類。

import junit.framework.TestCase; 
import org.junit.Before;
import org.junit.Test; 

public class TestJunit2 extends TestCase { 
    protected double fValue1; 
    protected double fValue2; 
@Before 
    public void setUp() { 
        fValue1= 2.0; 
        fValue2= 3.0; 
    } 
@Test 
    public void testAdd() { 
        //count the number of test cases 

        System.out.println("No of Test Case = "+ this.countTestCases()); 
        //test getName 

        String name= this.getName(); 
        System.out.println("Test Case Name = "+ name); 
        //test setName
 
        this.setName("testNewAdd"); 
        String newName= this.getName(); 
        System.out.println("Updated Test Case Name = "+ newName); 
    } 
    //tearDown used to close the connection or clean up activities 
        public void tearDown( ) { } 
}

接下來，在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 TestRunner2.java 的類來執行測試案例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner2 { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit2.class); 
    for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString()); 
        } 
    System.out.println(result.wasSuccessful()); 
    } 
}

用 javac 編譯 Test case 和 Test Runner 類

C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

如今運行 Test Runner 它將運行在 Test Case 類中定義並提供的測試樣例。

C:\JUNIT_WORKSPACE>java TestRunner2

檢查輸出結果。

No of Test Case = 1 Test Case Name = testAdd Updated Test Case Name = testNewAdd true

TestResult 類

下面定義的是 org.junit.TestResult 類：

public class TestResult extends Object

TestResult 類收集全部執行測試案例的結果。它是收集參數層面的一個實例。這個實驗框架區分失敗和錯誤。失敗是能夠預料的而且能夠經過假設來檢查。錯誤是不可預料的問題就像 ArrayIndexOutOfBoundsException。TestResult 類的一些重要方法列式以下：

序號	方法和描述
1	void addError(Test test, Throwable t) 在錯誤列表中加入一個錯誤
2	void addFailure(Test test, AssertionFailedError t) 在失敗列表中加入一個失敗
3	void endTest(Test test) 顯示測試被編譯的這個結果
4	int errorCount() 獲取被檢測出錯誤的數量
5	Enumeration errors() 返回錯誤的詳細信息
6	int failureCount() 獲取被檢測出的失敗的數量
7	void run(TestCase test) 運行 TestCase
8	int int runCount() 得到運行測試的數量
9	void startTest(Test test) 聲明一個測試即將開始
10	void stop() 標明測試必須中止

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 TestJunit3.java 的類。

import org.junit.Test; 
import junit.framework.AssertionFailedError; 
import junit.framework.TestResult; 

public class TestJunit3 extends TestResult { 

// add the error 
public synchronized void addError(Test test, Throwable t) {         
    super.addError((junit.framework.Test) test, t); 
        } 
// add the failure public synchronized void addFailure(Test test, AssertionFailedError t) { 
    super.addFailure((junit.framework.Test) test, t); 
        } 
@Test 
    public void testAdd() { 
    // add any test 
    } 
// Marks that the test run should stop. 
    public synchronized void stop() { 
//stop the test here 
    } 
}

接下來，在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 TestRunner3.java 的類來執行測試案例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner3 { public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit3.class); 
    for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString()); 
        } 
        System.out.println(result.wasSuccessful()); 
    } 
}

用 javac 編譯 Test case 和 Test Runner 類

C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

如今運行 Test Runner 它將運行在 Test Case 類中定義並提供的測試樣例。

C:\JUNIT_WORKSPACE>java TestRunner3

檢查輸出結果。

true

TestSuite 類

下面定義的是 org.junit.TestSuite 類：

public class TestSuite extends Object implements Test

TestSuite 類是測試的組成部分。它運行了不少的測試案例。TestSuite 類的一些重要方法列式以下：

序號	方法和描述
1	void addTest(Test test) 在套中加入測試。
2	void addTestSuite(Class<? extends TestCase> testClass) 將已經給定的類中的測試加到套中。
3	int countTestCases() 對這個測試即將運行的測試案例進行計數。
4	String getName() 返回套的名稱。
5	void run(TestResult result) 在 TestResult 中運行測試並收集結果。
6	void setName(String name) 設置套的名稱。
7	Test testAt(int index) 在給定的目錄中返回測試。
8	int testCount() 返回套中測試的數量。
9	static Test warning(String message) 返回會失敗的測試而且記錄警告信息。

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 JunitTestSuite.java 的類。

import junit.framework.*; 

public class JunitTestSuite { 
    public static void main(String[] a) { 
   
     // add the test's in the suite 
    TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class ); 
    TestResult result = new TestResult(); 
　　　　suite.run(result);         
    System.out.println("Number of test cases = " + result.runCount()); 
    } 
}

用 javac 編譯 Test suit

C:\JUNIT_WORKSPACE>javac JunitTestSuite.java

如今運行 Test Suit

C:\JUNIT_WORKSPACE>java JunitTestSuite

檢查輸出結果。

No of Test Case = 1 Test Case Name = testAdd Updated Test Case Name = testNewAdd Number of test cases = 3

JUnit - 測試框架

什麼是 Junit 測試框架？

JUnit 是一個迴歸測試框架，被開發者用於實施對應用程序的單元測試，加快程序編制速度，同時提升編碼的質量。JUnit 測試框架可以輕鬆完成如下任意兩種結合：

Eclipse 集成開發環境
Ant 打包工具
Maven 項目構建管理

特性

JUnit 測試框架具備如下重要特性：

測試工具
測試套件
測試運行器
測試分類

測試工具

測試工具是一整套固定的工具用於基線測試。測試工具的目的是爲了確保測試可以在共享且固定的環境中運行，所以保證測試結果的可重複性。它包括：

在全部測試調用指令發起前的 setUp() 方法。
在測試方法運行後的 tearDown() 方法。

讓咱們來看一個例子：

import junit.framework.*; 
public class JavaTest extends TestCase { 
    protected int value1, value2; 
// assigning the values 
    protected void setUp(){ 
        value1=3; 
        value2=3; 
} 
// test method to add two values 
    public void testAdd(){ 
        double result= value1 + value2; 
        assertTrue(result == 6); 
    } 
}

測試套件

測試套件意味捆綁幾個測試案例而且同時運行。在 JUnit 中，@RunWith 和 @Suite 都被用做運行測試套件。如下爲使用 TestJunit1 和 TestJunit2 的測試分類：

import org.junit.runner.RunWith; 
import org.junit.runners.Suite; 

//JUnit Suite Test 
　　@RunWith(Suite.class) 
　　@Suite.SuiteClasses({ 
　　　　TestJunit1.class ,TestJunit2.class 
　　}) 

public class JunitTestSuite { } 

import org.junit.Test; 
import org.junit.Ignore;
import static org.junit.Assert.assertEquals; 

public class TestJunit1 { 
　　String message = "Robert"; 
　　MessageUtil messageUtil = new MessageUtil(message); 

@Test 
public void testPrintMessage() { 
　　System.out.println("Inside testPrintMessage()"); 
　　assertEquals(message, messageUtil.printMessage()); 
　　} 
}

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

public class TestJunit2 { 
　　String message = "Robert"; 
　　MessageUtil messageUtil = new MessageUtil(message);     
@Test 
public void testSalutationMessage() { 
　　System.out.println("Inside testSalutationMessage()"); 
　　message = "Hi!" + "Robert"; 
　　assertEquals(message,messageUtil.salutationMessage()); 
　　} 
}

測試運行器

測試運行器 用於執行測試案例。如下爲假定測試分類成立的狀況下的例子：

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
　　public static void main(String[] args) { 
　　　　Result result = JUnitCore.runClasses(TestJunit.class); 
　　for (Failure failure : result.getFailures()) { 
　　　　System.out.println(failure.toString()); 
　　　　} 
　　System.out.println(result.wasSuccessful()); 
　　} 
}

JUnit 測試分類

測試分類是在編寫和測試 JUnit 的重要分類。幾種重要的分類以下：

包含一套斷言方法的測試斷言
包含規定運行多重測試工具的測試用例
包含收集執行測試用例結果的方法的測試結果

JUnit - 編寫測試

在這裏你將會看到一個應用 POJO 類，Business logic 類和在 test runner 中運行的 test 類的 JUnit 測試的例子。

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 EmployeeDetails.java 的 POJO 類。

public class EmployeeDetails { 
    private String name; 
    private double monthlySalary;
　　private int age; 

/** * @return the name */ 
public String getName() {
 　　return name; 
　　}

/** * @param name the name to set */ 
public void setName(String name) { 
　　this.name = name; 
　　}

/** * @return the monthlySalary */
 public double getMonthlySalary() { 
　　return monthlySalary;
　　}

/** * @param monthlySalary the monthlySalary to set */ 
public void setMonthlySalary(double monthlySalary) { 
　　this.monthlySalary = monthlySalary; 
　　} 

/** * @return the age */
public int getAge() { 
　　return age; 
　　}

/** * @param age the age to set */ 
public void setAge(int age) {
 this.age = age; 
　　} 
}

EmployeeDetails 類被用於

取得或者設置僱員的姓名的值
取得或者設置僱員的每個月薪水的值
取得或者設置僱員的年齡的值

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 EmpBusinessLogic.java 的 business logic 類

public class EmpBusinessLogic {
 // Calculate the yearly salary of employee 
    public double calculateYearlySalary(EmployeeDetails employeeDetails){ 
        double yearlySalary=0; 
        yearlySalary = employeeDetails.getMonthlySalary() * 12; 

        return yearlySalary;
 } 
// Calculate the appraisal amount of employee 
    public double calculateAppraisal(EmployeeDetails employeeDetails){ 
            double appraisal=0; 
        if(employeeDetails.getMonthlySalary() < 10000){ 
            appraisal = 500; 
        }else{ 
            appraisal = 1000; 
        } 
        return appraisal; 
    } 
}

EmpBusinessLogic 類被用來計算

僱員每一年的薪水
僱員的評估金額

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 TestEmployeeDetails.java 的準備被測試的測試案例類

import org.junit.Test; 
import static org.junit.Assert.assertEquals; 

public class TestEmployeeDetails { 
　　EmpBusinessLogic empBusinessLogic =new EmpBusinessLogic(); 
　　EmployeeDetails employee = new EmployeeDetails(); 

//test to check appraisal 
　　@Test 
　　public void testCalculateAppriasal() { 
　　　　employee.setName("Rajeev"); 
　　　　employee.setAge(25); 
　　　　employee.setMonthlySalary(8000); 
　　　　double appraisal= empBusinessLogic.calculateAppraisal(employee); 
　　　　assertEquals(500, appraisal, 0.0); 
　　} 

// test to check yearly salary 
　　@Test 
　　public void testCalculateYearlySalary() { 
　　　　employee.setName("Rajeev"); 
　　　　employee.setAge(25); 
　　　　employee.setMonthlySalary(8000); 
　　　　double salary= empBusinessLogic.calculateYearlySalary(employee); 
　　　　assertEquals(96000, salary, 0.0); 
　　} 
}

TestEmployeeDetails 是用來測試 EmpBusinessLogic 類的方法的，它

測試僱員的每一年的薪水
測試僱員的評估金額

如今讓咱們在 C:\ > JUNIT_WORKSPACE 路徑下建立一個名爲 TestRunner.java 的類來執行測試案例類

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
　　public static void main(String[] args) { 
　　　　　Result result = JUnitCore.runClasses(TestEmployeeDetails.class); 
　　for (Failure failure : result.getFailures()) { 
　　　　System.out.println(failure.toString()); 
　　} 
　　　　System.out.println(result.wasSuccessful());    
　　} 
}

用javac編譯 Test case 和 Test Runner 類

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

如今運行將會運行 Test Case 類中定義和提供的測試案例的 Test Runner

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

檢查運行結果

true

JUnit - 使用斷言

斷言

全部的斷言都包含在 Assert 類中

public class Assert extends java.lang.Object

這個類提供了不少有用的斷言方法來編寫測試用例。只有失敗的斷言纔會被記錄。Assert 類中的一些有用的方法列式以下：

序號	方法和描述
1	void assertEquals(boolean expected, boolean actual) 檢查兩個變量或者等式是否平衡
2	void assertTrue(boolean expected, boolean actual) 檢查條件爲真
3	void assertFalse(boolean condition) 檢查條件爲假
4	void assertNotNull(Object object) 檢查對象不爲空
5	void assertNull(Object object) 檢查對象爲空
6	void assertSame(boolean condition) assertSame() 方法檢查兩個相關對象是否指向同一個對象
7	void assertNotSame(boolean condition) assertNotSame() 方法檢查兩個相關對象是否不指向同一個對象
8	void assertArrayEquals(expectedArray, resultArray) assertArrayEquals() 方法檢查兩個數組是否相等

下面咱們在例子中試驗一下上面提到的各類方法。在 C:\ > JUNIT_WORKSPACE 路徑下建立一個文件名爲 TestAssertions.java 的類

import org.junit.Test; 
import static org.junit.Assert.*; 

public class TestAssertions { 
　　@Test 
　　public void testAssertions() { 
　　　　//test data 
　　　　String str1 = new String ("abc"); 
　　　　String str2 = new String ("abc"); 
　　　　String str3 = null; String str4 = "abc"; 
　　　　String str5 = "abc"; 
　　　　　　int val1 = 5; 
　　　　　　int val2 = 6; 
　　　　String[] expectedArray = {"one", "two", "three"}; 
　　　　String[] resultArray = {"one", "two", "three"}; 
//Check that two objects are equal assertEquals(str1, str2); 
//Check that a condition is true assertTrue (val1 < val2); 
//Check that a condition is false assertFalse(val1 > val2); 
//Check that an object isn't null assertNotNull(str1);
//Check that an object is null assertNull(str3); 
//Check if two object references point to the same object assertSame(str4,str5); 
//Check if two object references not point to the same object assertNotSame(str1,str3); 
//Check whether two arrays are equal to each other. assertArrayEquals(expectedArray, resultArray); } }

接下來，咱們在 C:\ > JUNIT_WORKSPACE 路徑下建立一個文件名爲 TestRunner.java 的類來執行測試用例

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner2 { 
　　public static void main(String[] args) { 
　　　　Result result = JUnitCore.runClasses(TestAssertions.class); 
　　for (Failure failure : result.getFailures()) { 
　　　　System.out.println(failure.toString()); 
　　　} 
　　System.out.println(result.wasSuccessful()); 
　　}
}

用 javac 編譯 Test case 和 Test Runner 類

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

如今運行將會運行 Test Case 類中定義和提供的測試案例的 Test Runner

C:\JUNIT_WORKSPACE>java TestRunner

檢查運行結果

true

註釋

註釋就好像你能夠在你的代碼中添加而且在方法或者類中應用的元標籤。JUnit 中的這些註釋爲咱們提供了測試方法的相關信息，哪些方法將會在測試方法先後應用，哪些方法將會在全部方法先後應用，哪些方法將會在執行中被忽略。
JUnit 中的註釋的列表以及他們的含義：

序號	註釋和描述
1	@Test 這個註釋說明依附在 JUnit 的 public void 方法能夠做爲一個測試案例。
2	@Before 有些測試在運行前須要創造幾個類似的對象。在 public void 方法加該註釋是由於該方法須要在 test 方法前運行。
3	@After 若是你將外部資源在 Before 方法中分配，那麼你須要在測試運行後釋放他們。在 public void 方法加該註釋是由於該方法須要在 test 方法後運行。
4	@BeforeClass 在 public void 方法加該註釋是由於該方法須要在類中全部方法前運行。
5	@AfterClass 它將會使方法在全部測試結束後執行。這個能夠用來進行清理活動。
6	@Ignore 這個註釋是用來忽略有關不須要執行的測試的。

在 C:\ > JUNIT_WORKSPACE 路徑下建立一個文件名爲 JunitAnnotation.java 的類來測試註釋

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

public class JunitAnnotation { 
//execute before class 
@BeforeClass 
　　public static void beforeClass() { 
　　　　System.out.println("in before class"); 
　　} 
//execute after class 
@AfterClass 
　　public static void afterClass() { 
　　　　System.out.println("in after class"); 
　　} 
//execute before test 
@Before 
　　public void before() { 
　　　　System.out.println("in before"); 
　　} 
//execute after test 
@After 
　　public void after() { 
　　　　System.out.println("in after"); 
　　} 
//test case 
@Test 
　　public void test() { 
　　　　System.out.println("in test"); 
　　} 
//test case ignore and will not execute 
@Ignore 
　　public void ignoreTest() { 
　　　　System.out.println("in ignore test"); 
　　} 
}

接下來，咱們在 C:\ > JUNIT_WORKSPACE 路徑下建立一個文件名爲 TestRunner.java 的類來執行註釋

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
　　public static void main(String[] args) { 
　　　　Result result = JUnitCore.runClasses(JunitAnnotation.class); 
　　for (Failure failure : result.getFailures()) { 
　　　　System.out.println(failure.toString()); 
　　　　} 
　　System.out.println(result.wasSuccessful()); 
　　}
}

用 javac 編譯 Test case 和 Test Runner 類

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

如今運行將會運行 Test Case 類中定義和提供的測試案例的 Test Runner

C:\JUNIT_WORKSPACE>java TestRunner

檢查運行結果

in before class in before in test in after in after class true

JUnit - 執行過程

本教程闡明瞭 JUnit 中的方法執行過程，即哪個方法首先被調用，哪個方法在一個方法以後調用。如下爲 JUnit 測試方法的 API，而且會用例子來講明。

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 類文件命名爲 JunitAnnotation.java 來測試註釋程序。

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

public class ExecutionProcedureJunit { 
//execute only once, in the starting 
@BeforeClass 
public static void beforeClass() {
　　System.out.println("in before class"); 
} 
//execute only once, in the end 
@AfterClass 
public static void afterClass() { 
　　System.out.println("in after class"); 
} 
//execute for each test, before executing test 
@Before 
public void before() { 
　　System.out.println("in before");
 } 
//execute for each test, after executing test 
@After 
public void after() { 
　　System.out.println("in after"); 
} 
//test case 1 

@Test 
public void testCase1() { 
　　System.out.println("in test case 1");
 } 
//test case 2 
@Test 
public void testCase2() { 
　　System.out.println("in test case 2"); 
　　} 
}

接下來，讓咱們在目錄 C:\ > JUNIT_WORKSPACE 中建立一個 java 類文件 TestRunner.java 來執行註釋程序。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
public static void main(String[] args) { 
    Result result = JUnitCore.runClasses(ExecutionProcedureJunit.class); 
　　for (Failure failure : result.getFailures()) { 
    　　System.out.println(failure.toString()); 
　　} 
    　　System.out.println(result.wasSuccessful()); 
    } 
}

使用 javac 命令來編譯 Test case 和 Test Runner 類。

C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

如今運行 Test Runner 它會自動運行定義在 Test Case 類中的測試樣例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出

in before class in before in test case 1 in after in before in test case 2 in after in after class

觀察以上的輸出，這是 JUnite 執行過程：

beforeClass() 方法首先執行，而且只執行一次。
afterClass() 方法最後執行，而且只執行一次。
before() 方法針對每個測試用例執行，可是是在執行測試用例以前。
after() 方法針對每個測試用例執行，可是是在執行測試用例以後。
在 before() 方法和 after() 方法之間，執行每個測試用例。

JUnit - 執行測試

測試用例是使用 JUnitCore 類來執行的。JUnitCore 是運行測試的外觀類。它支持運行 JUnit 4 測試, JUnit 3.8.x 測試,或者他們的混合。要從命令行運行測試，能夠運行 java org.junit.runner.JUnitCore 。對於只有一次的測試運行，可使用靜態方法 runClasses(Class[])。

下面是 org.junit.runner.JUnitCore 類的聲明：

public class JUnitCore extends java.lang.Object

建立一個類

在目錄 C:\ > JUNIT_WORKSPACE 中建立一個被測試的 Java 類命名爲 MessageUtil.java。

/* * This class prints the given message on console. */ public class MessageUtil { private String message; //Constructor //@param message to be printed public MessageUtil(String message){ this.message = message; } // prints the message public String printMessage(){ System.out.println(message); return message; } }

建立測試用例類

建立一個 java 測試類叫作 TestJunit.java。
在類中加入一個測試方法 testPrintMessage()。
在方法 testPrintMessage() 中加入註釋 @Test。
實現測試條件而且用 Junit 的 assertEquals API 檢查測試條件。

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 類文件命名爲 TestJunit.java

import org.junit.Test; import static org.junit.Assert.assertEquals; public class TestJunit { String message = "Hello World"; MessageUtil messageUtil = new MessageUtil(message); @Test public void testPrintMessage() { assertEquals(message,messageUtil.printMessage()); } }

建立 TestRunner 類

接下來，讓咱們在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 類文件命名爲 TestRunner.java 來執行測試用例，導出 JUnitCore 類而且使用 runClasses() 方法，將測試類名稱做爲參數。

import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure; public class TestRunner { public static void main(String[] args) { Result result = JUnitCore.runClasses(TestJunit.class); for (Failure failure : result.getFailures()) { System.out.println(failure.toString()); } System.out.println(result.wasSuccessful()); } }

使用 javac 命令來編譯 Test case 和 Test Runner 類。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

如今運行 Test Runner 它會自動運行定義在 Test Case 類中的測試樣例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出

Hello World true

JUnit - 套件測試

測試套件

測試套件意味着捆綁幾個單元測試用例而且一塊兒執行他們。在 JUnit 中，@RunWith 和 @Suite 註釋用來運行套件測試。這個教程將向您展現一個例子，其中含有兩個測試樣例 TestJunit1 & TestJunit2 類，咱們將使用測試套件一塊兒運行他們。

建立一個類

在目錄 C:\ > JUNIT_WORKSPACE 中建立一個被測試的 java 類命名爲 MessageUtil.java

/* * 
    This class prints the given message on console. 
*/ 
public class MessageUtil { 
　　private String message; 
//Constructor 
//@param message to be printed 
　　public MessageUtil(String message){ 
　　　　this.message = message; 
　　} 
// prints the message 
　　public String printMessage(){ 
　　　　System.out.println(message); 
　　　　return message; 
　　} 
// add "Hi!" to the message 
　　public String salutationMessage(){ 
　　　　message = "Hi!" + message; 
　　　　System.out.println(message); 
　　　　return message; 
　　} 
}

建立 Test Case 類

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 測試類叫作 TestJunit1.java。

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

public class TestJunit1 { 
    String message = "Robert"; 
    MessageUtil messageUtil = new MessageUtil(message); 
@Test 
    public void testPrintMessage() { 
        System.out.println("Inside testPrintMessage()"); 
        assertEquals(message, messageUtil.printMessage()); 
    } 
}

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 測試類叫作 TestJunit2.java。

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

public class TestJunit2 { 
    String message = "Robert"; 
    MessageUtil messageUtil = new MessageUtil(message); 
@Test 
public void testSalutationMessage() { 
    System.out.println("Inside testSalutationMessage()"); 
    message = "Hi!" + "Robert";        
    assertEquals(message,messageUtil.salutationMessage()); 
    } 
}

使用 Test Suite 類

建立一個 java 類。
在類中附上 @RunWith(Suite.class) 註釋。
使用 @Suite.SuiteClasses 註釋給 JUnit 測試類加上引用。

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 類文件叫作 TestSuite.java 來執行測試用例。

import org.junit.runner.RunWith; 
import org.junit.runners.Suite; 
@RunWith(Suite.class) 
@Suite.SuiteClasses({ 
    TestJunit1.class, TestJunit2.class 
    }) 
public class JunitTestSuite { }

建立 Test Runner 類

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 類文件叫作 TestRunner.java 來執行測試用例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(JunitTestSuite.class); 
    for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString()); 
    } 
    System.out.println(result.wasSuccessful()); 
    } 
}

使用 javac 命令編譯全部的 java 類

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java TestJunit2.java JunitTestSuite.java TestRunner.java

如今運行 Test Runner，即運行全部的在以前 Test Case 類中定義的測試用例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出

Inside testPrintMessage() Robert Inside testSalutationMessage() Hi Robert true

JUnit - 忽略測試

有時可能會發生咱們的代碼尚未準備好的狀況，這時測試用例去測試這個方法或代碼的時候會形成失敗。@Ignore 註釋會在這種狀況時幫助咱們。

一個含有 @Ignore 註釋的測試方法將不會被執行。
若是一個測試類有 @Ignore 註釋，則它的測試方法將不會執行。

如今咱們用例子來學習 @Ignore。

建立一個類

在目錄 C:\ > JUNIT_WORKSPACE 中建立一個將被測試的 java 類命名爲 MessageUtil.java。

/* * 
    This class prints the given message on console. 
*/ 

public class MessageUtil { 
    private String message; 
//Constructor 
//@param message to be printed 
    public MessageUtil(String message){ 
        this.message = message; 
    }
 // prints the message 
    public String printMessage(){ 
        System.out.println(message); 
        return message; 
    } 
// add "Hi!" to the message 
public String salutationMessage(){ 
    message = "Hi!" + message; 
    System.out.println(message); 
    return message; 
    } 
}

建立 Test Case 類

建立 java 測試類命名爲 TestJunit.java。
在類中加入測試方法 testPrintMessage() 和 testSalutationMessage()。
在方法 testPrintMessage() 中加入 @Ignore 註釋。

在目錄 C:\ > JUNIT_WORKSPACE 中建立一個 java 類文件命名爲 TestJunit.java

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

public class TestJunit { 
    String message = "Robert"; 
    MessageUtil messageUtil = new MessageUtil(message); 
@Ignore 
@Test 
public void testPrintMessage() { 
    System.out.println("Inside testPrintMessage()"); 
    message = "Robert"; 
    assertEquals(message,messageUtil.printMessage()); 
} 
@Test 
public void testSalutationMessage() { 
    System.out.println("Inside testSalutationMessage()"); 
    message = "Hi!" + "Robert";             
　　assertEquals(message,messageUtil.salutationMessage()); 
    } 
}

建立 Test Runner 類

在目錄 C:\ > JUNIT_WORKSPACE 建立一個 java 類文件叫作 TestRunner.java 來執行測試用例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result;
import org.junit.runner.notification.Failure; 

public class TestRunner { 
    public static void main(String[] args) { 
    Result result = JUnitCore.runClasses(TestJunit.class); 
    for (Failure failure : result.getFailures()) { 
    System.out.println(failure.toString()); 
    }     
    System.out.println(result.wasSuccessful()); 
    } 
}

使用 javac 命令編譯 MessageUtil, Test case 和 Test Runner 類。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

如今運行 Test Runner 類，即不會運行在 Test Case 類中定義的 testPrintMessage() 測試用例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出。testPrintMessage() 測試用例並無被測試。

Inside testSalutationMessage() Hi!Robert true

如今更新在目錄 C:\ > JUNIT_WORKSPACE 中的 TestJunit 在類級別上使用 @Ignore 來忽略全部的測試用例

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

@Ignore 
public class TestJunit { 
　　String message = "Robert"; 
　　MessageUtil messageUtil = new MessageUtil(message); 
@Test 
public void testPrintMessage() { 
　　System.out.println("Inside testPrintMessage()"); 
　　message = "Robert"; 
　　assertEquals(message,messageUtil.printMessage()); 
　　} 
@Test 
public void testSalutationMessage() { 
　　System.out.println("Inside testSalutationMessage()"); 
　　message = "Hi!" + "Robert"; 
　　assertEquals(message,messageUtil.salutationMessage()); 
　　} 
}

使用 javac 命令編譯 Test case

C:\JUNIT_WORKSPACE>javac TestJunit.java

保持你的 Test Runner 不被改變，以下：

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
　　public static void main(String[] args) { 
　　　　Result result = JUnitCore.runClasses(TestJunit.class); 
　　for (Failure failure : result.getFailures()) { 
　　　　System.out.println(failure.toString()); 
　　} 
　　System.out.println(result.wasSuccessful()); 
　　} 
}

如今運行 Test Runner 即不會運行在 Test Case 類中定義的任何一個測試樣例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出。沒有測試用例被測試。

true

JUnit - 時間測試

由珍珍阿姨建立，最後一次修改 2016-08-12

JUnit - 時間測試

Junit 提供了一個暫停的方便選項。若是一個測試用例比起指定的毫秒數花費了更多的時間，那麼 Junit 將自動將它標記爲失敗。timeout 參數和 @Test 註釋一塊兒使用。如今讓咱們看看活動中的 @test(timeout)。

建立一個類

建立一個在 C:\JUNIT_WORKSPACE 中叫作 MessageUtil.java 的 java 類來測試。
在 printMessage() 方法內添加一個無限 while 循環。

/* * 
    This class prints the given message on console. 
*/ 
public class MessageUtil { 
    private String message; 
//Constructor 
//@param message to be printed 
    public MessageUtil(String message){
         this.message = message; 
    }
// prints the message 
    public void printMessage(){ 
        System.out.println(message); while(true); 
    } 
// add "Hi!" to the message 
public String salutationMessage(){ 
    message = "Hi!" + message; 
    System.out.println(message); 
    return message; 
    } 
}

建立 Test Case 類

建立一個叫作 TestJunit.java 的 java 測試類。
給 testPrintMessage() 測試用例添加 1000 的暫停時間。

在 C:\JUNIT_WORKSPACE 中建立一個文件名爲 TestJunit.java 的 java 類。

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

public class TestJunit { 
　　String message = "Robert"; 
　　MessageUtil messageUtil = new MessageUtil(message); 

@Test(timeout=1000) 
public void testPrintMessage() { 
　　System.out.println("Inside testPrintMessage()"); 
　　messageUtil.printMessage(); 
} 

@Test 
public void testSalutationMessage() { 
　　System.out.println("Inside testSalutationMessage()"); 
　　message = "Hi!" + "Robert"; 
　　assertEquals(message,messageUtil.salutationMessage()); 
    } 
}

建立 Test Runner 類

在 C:\JUNIT_WORKSPACE 中建立一個文件名爲 TestRunner.java 的 java 類來執行測試樣例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result;
import org.junit.runner.notification.Failure; 

public class TestRunner { 
    public static void main(String[] args) { 
        Result result = JUnitCore.runClasses(TestJunit.class); 
    for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString()); 
        } 
    System.out.println(result.wasSuccessful()); 
    } 
}

用 javac 編譯 MessageUtil，Test case 和 Test Runner 類。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

如今運行 Test Runner，它將運行由提供的 Test Case 類中所定義的測試用例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出。testPrintMessage() 測試用例將標記單元測試失敗。

Inside testPrintMessage() Robert Inside testSalutationMessage() Hi!Robert testPrintMessage(TestJunit): test timed out after 1000 milliseconds false

JUnit - 異常測試

Junit 用代碼處理提供了一個追蹤異常的選項。你能夠測試代碼是否它拋出了想要獲得的異常。expected 參數和 @Test 註釋一塊兒使用。如今讓咱們看看活動中的 @Test(expected)。

建立一個類

在 C:\ > JUNIT_WORKSPACE 中建立一個叫作 MessageUtil.java 的 java 類來測試。
在 printMessage()方法中添加一個錯誤條件。

/* * 
This class prints the given message on console. 
*/ 

public class MessageUtil { 
　　private String message; 
//Constructor 
//@param message to be printed 
　　public MessageUtil(String message){
 　　this.message = message; 
　　} 
// prints the message 
public void printMessage(){ 
　　System.out.println(message); 
　　int a =0; 
　　int b = 1/a; 
　　} 
// add "Hi!" to the message 
public String salutationMessage(){ 
　　message = "Hi!" + message; 
　　System.out.println(message); 
　　return message; 
　　} 
}

建立 Test Case 類

建立一個叫作 TestJunit.java 的 java 測試類。
給 testPrintMessage() 測試用例添加須要的異常 ArithmeticException。

在 C:> JUNIT_WORKSPACE 中建立一個文件名爲 TestJunit.java 的 java 類

import org.junit.Test; 
import org.junit.Ignore; 
import static org.junit.Assert.assertEquals; 

public class TestJunit { 
　　String message = "Robert"; 
　　MessageUtil messageUtil = new MessageUtil(message); 
@Test(expected = ArithmeticException.class) 
public void testPrintMessage() { 
　　　　System.out.println("Inside testPrintMessage()"); 
　　　　messageUtil.printMessage(); 
　　} 
@Test 
public void testSalutationMessage() { 
　　　　System.out.println("Inside testSalutationMessage()"); 
　　　　message = "Hi!" + "Robert"; 
　　　　assertEquals(message,messageUtil.salutationMessage()); 
　　} 
}

建立 TestRunner 類

在 C:> JUNIT_WORKSPACE 中建立一個文件名爲 TestJunit.java 的 java 類來執行測試用例。

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
public static void main(String[] args) { 
    Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) { 
        System.out.println(failure.toString()); 
    } 
    System.out.println(result.wasSuccessful()); 
    } 
}

用 javac 編譯 MessageUtil，Test case 和 Test Runner 類。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

如今運行 Test Runner，它將運行由提供的 Test Case 類中所定義的測試用例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出。testPrintMessage() 測試用例將經過。

Inside testPrintMessage() Robert Inside testSalutationMessage() Hi!Robert true

JUnit - 參數化測試

Junit 4 引入了一個新的功能參數化測試。參數化測試容許開發人員使用不一樣的值反覆運行同一個測試。你將遵循 5 個步驟來建立參數化測試。

用 @RunWith(Parameterized.class) 來註釋 test 類。
建立一個由 @Parameters 註釋的公共的靜態方法，它返回一個對象的集合(數組)來做爲測試數據集合。
建立一個公共的構造函數，它接受和一行測試數據相等同的東西。
爲每一列測試數據建立一個實例變量。
用實例變量做爲測試數據的來源來建立你的測試用例。

一旦每一行數據出現測試用例將被調用。讓咱們看看活動中的參數化測試。

建立一個類

在 C:\ > JUNIT_WORKSPACE 建立一個叫作 PrimeNumberChecker.java 的 java 類來測試。

public class PrimeNumberChecker { 
public Boolean validate(final Integer primeNumber) { 
    for (int i = 2; i < (primeNumber / 2); i++) { 
        if (primeNumber % i == 0) { 
　　　　　　　　return false; 
　　　　　　} 
　　　　}
　　return true; 
　　} 
}

建立 Parameterized Test Case 類

建立一個叫作 PrimeNumberCheckerTest.java 的 java 類。

在 C:> JUNIT_WORKSPACE 中建立一個文件名爲 PrimeNumberCheckerTest.java 的 java 類。

import java.util.Arrays; 
import java.util.Collection; 
import org.junit.Test; 
import org.junit.Before; 
import org.junit.runners.Parameterized; 
import org.junit.runners.Parameterized.Parameters; 
import org.junit.runner.RunWith; 
import static org.junit.Assert.assertEquals; 

@RunWith(Parameterized.class) 
public class PrimeNumberCheckerTest { 
　　private Integer inputNumber; 
　　private Boolean expectedResult; 
　　private PrimeNumberChecker primeNumberChecker; 

@Before 
public void initialize() { 
　　primeNumberChecker = new PrimeNumberChecker(); 
} 
// Each parameter should be placed as an argument here 
// Every time runner triggers, it will pass the arguments 
// from parameters we defined in primeNumbers() method 
public PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) { 
　　this.inputNumber = inputNumber; 
　　this.expectedResult = expectedResult; 
} 
@Parameterized.Parameters 
public static Collection primeNumbers() { 
　　return Arrays.asList(new Object[][] { { 2, true }, { 6, false }, { 19, true }, { 22, false }, { 23, true } }); 
} 
// This test will run 4 times since we have 5 parameters defined 
@Test 
public void testPrimeNumberChecker() { 
　　System.out.println("Parameterized Number is : " + inputNumber); 
　　assertEquals(expectedResult, primeNumberChecker.validate(inputNumber)); 
　　} 
}

建立 TestRunner 類

在 C:> JUNIT_WORKSPACE 中建立一個文件名爲 TestRunner.java 的 java 類來執行測試用例

import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 

public class TestRunner { 
public static void main(String[] args) { 
　　Result result = JUnitCore.runClasses(PrimeNumberCheckerTest.class); 
　　for (Failure failure : result.getFailures()) { 
　　　　System.out.println(failure.toString()); 
　　　　} 
　　System.out.println(result.wasSuccessful()); 
　　} 
}

用 javac 編譯 PrimeNumberChecker，PrimeNumberCheckerTest 和 TestRunner 類。

C:\JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java TestRunner.java

如今運行 TestRunner，它將運行由提供的 Test Case 類中所定義的測試用例。

C:\JUNIT_WORKSPACE>java TestRunner

驗證輸出。

Parameterized Number is : 2 Parameterized Number is : 6 Parameterized Number is : 19 Parameterized Number is : 22 Parameterized Number is : 23 true

JUnit - ANT 插件

在這個例子中，咱們將展現如何使用 ANT 運行 JUnit。讓咱們跟隨如下步驟：

步驟 1:下載 Apache Ant

下載 Apache ANT

操做系統	文件名
Windows	apache-ant-1.8.4-bin.zip
Linux	apache-ant-1.8.4-bin.tar.gz
Mac	apache-ant-1.8.4-bin.tar.gz

步驟 2:設置 Ant 環境

設置 ANT_HOME 環境變量來指向 ANT 函數庫在機器中存儲的基本文件地址。例如，咱們已經在不一樣的操做系統的 apache-ant-1.8.4 文件夾中存儲了 ANT 函數庫。

操做系統	輸出
Windows	在 C:\Program Files\Apache Software Foundation \apache-ant-1.8.4 中設置環境變量 ANT_HOME
Linux	導出 ANT_HOME=/usr/local/\apache-ant-1.8.4
Mac	export ANT_HOME=/Library/\apache-ant-1.8.4

操做系統

輸出

Windows

在 C:\Program Files\Apache Software Foundation

\apache-ant-1.8.4 中設置環境變量 ANT_HOME

Linux

導出 ANT_HOME=/usr/local/\apache-ant-1.8.4

Mac

export ANT_HOME=/Library/\apache-ant-1.8.4

附加 ANT 編譯器地址到系統路徑，對於不一樣的操做系統來講以下所示：

操做系統	輸出
Windows	附加字符串 ;%ANT_HOME\bin to the end of the system variable, Path.
Linux	導出 PATH=$PATH:$ANT_HOME/bin/
Mac	不須要

操做系統

輸出

Windows

附加字符串 ;%ANT_HOME\bin to the end of the

system variable, Path.

Linux

導出 PATH=$PATH:$ANT_HOME/bin/

Mac

不須要

步驟 3:下載 Junit Archive

下載 JUnit Archive

操做系統	輸出
Windows	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

步驟 4:建立項目結構

在 C:\ > JUNIT_WORKSPACE 中建立文件夾 TestJunitWithAnt
在 C:\ > JUNIT_WORKSPACE > TestJunitWithAnt 中建立文件夾 src
在 C:\ > JUNIT_WORKSPACE > TestJunitWithAnt 中建立文件夾 test
在 C:\ > JUNIT_WORKSPACE > TestJunitWithAnt 中建立文件夾 lib
在 C:\ > JUNIT_WORKSPACE > TestJunitWithAnt >src 文件夾中建立 MessageUtil 類

/* * 
This class prints the given message on console. 
*/ 

public class MessageUtil { 
　　private String message; 
//Constructor
//@param message to be printed 
public MessageUtil(String message){ 
　　this.message = message; 
　　} 
// prints the message 
public String printMessage(){ 
　　System.out.println(message); 
　　return message; 
　　} 
// add "Hi!" to the message 
public String salutationMessage(){ 
　　message = "Hi!" + message; 
　　System.out.println(message); 
　　return message; 
　　} 
}

在 C:\ > JUNIT_WORKSPACE > TestJunitWithAnt > src 文件夾中建立 TestMessageUtil 類。

/* * 
This class prints the given message on console. 
*/ 

public class MessageUtil { 
　　private String message; 
//Constructor 
//@param message to be printed 
public MessageUtil(String message){ 
　　this.message = message; 
} 
// prints the message 
public String printMessage(){ 
　　System.out.println(message); 
　　return message; 
} 
// add "Hi!" to the message 
public String salutationMessage(){ 
　　message = "Hi!" + message; 
　　System.out.println(message); 
　　return message; 
　　} 
}

在 C:\ > JUNIT_WORKSPACE > TestJunitWithAnt > lib 文件夾中複製 junit-4.10.jar。

建立 ANT Build.xml

咱們將使用 ANT 中的任務來執行咱們的 junit 測試樣例。

<project name="JunitTest" default="test" basedir="."> 
    <property name="testdir" location="test" /> 
    <property name="srcdir" location="src" /> 
    <property name="full-compile" value="true" /> 
    　　<path id="classpath.base"/> 
　　　　<path id="classpath.test"> 
　　　　<pathelement location="/lib/junit-4.10.jar" /> 
　　　　<pathelement location="${testdir}" /> 
　　　　<pathelement location="${srcdir}" /> 
　　　　<path refid="classpath.base" /> 
　　　　</path> 

　　　　<target name="clean" > 
　　　　<delete verbose="${full-compile}"> <fileset dir="${testdir}" includes="**/*.class" /> </delete> 
　　　　</target> 

　　　　<target name="compile" depends="clean"> 
　　　　<javac srcdir="${srcdir}" destdir="${testdir}" verbose="${full-compile}"><classpath refid="classpath.test"/></javac> 
　　　　</target> 

　　　　<target name="test" depends="compile"> 
　　　　<junit> <classpath refid="classpath.test" /> <formatter type="brief" usefile="false" /> <test name="TestMessageUtil" /> </junit> 
　　　　</target> 

</project>

運行下列的 ant 命令

C:\JUNIT_WORKSPACE\TestJunitWithAnt>ant

驗證輸出。

Buildfile: C:\JUNIT_WORKSPACE\TestJunitWithAnt\build.xml 

clean: compile: [javac] Compiling 2 source files toC:\JUNIT_WORKSPACE\TestJunitWithAnt\test 
[javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\ MessageUtil.java] 
[javac] [parsing completed 18ms] 
[javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\ TestMessageUtil.java] 
[javac] [parsing completed 2ms] 

[javac] [search path for source files: C:\JUNIT_WORKSPACE\ TestJunitWithAnt\src] 
[javac] [loading java\lang\Object.class(java\lang:Object.class)] 
[javac] [loading java\lang\String.class(java\lang:String.class)] 
[javac] [loading org\junit\Test.class(org\junit:Test.class)] 
[javac] [loading org\junit\Ignore.class(org\junit:Ignore.class)] 
[javac] [loading org\junit\Assert.class(org\junit:Assert.class)] 
[javac] [loading java\lang\annotation\Retention.class (java\lang\annotation:Retention.class)] 
[javac] [loading java\lang\annotation\RetentionPolicy.class (java\lang\annotation:RetentionPolicy.class)] 
[javac] [loading java\lang\annotation\Target.class (java\lang\annotation:Target.class)] 
[javac] [loading java\lang\annotation\ElementType.class (java\lang\annotation:ElementType.class)] 
[javac] [loading java\lang\annotation\Annotation.class (java\lang\annotation:Annotation.class)] 
[javac] [checking MessageUtil] 
[javac] [loading java\lang\System.class(java\lang:System.class)] 
[javac] [loading java\io\PrintStream.class(java\io:PrintStream.class)] 
[javac] [loading java\io\FilterOutputStream.class (java\io:FilterOutputStream.class)] 
[javac] [loading java\io\OutputStream.class(java\io:OutputStream.class)] 
[javac] [loading java\lang\StringBuilder.class (java\lang:StringBuilder.class)] 
[javac] [loading java\lang\AbstractStringBuilder.class (java\lang:AbstractStringBuilder.class)] 
[javac] [loading java\lang\CharSequence.class(java\lang:CharSequence.class)] 
[javac] [loading java\io\Serializable.class(java\io:Serializable.class)]
[javac] [loading java\lang\Comparable.class(java\lang:Comparable.class)] 
[javac] [loading java\lang\StringBuffer.class(java\lang:StringBuffer.class)] 
[javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\MessageUtil.class] 
[javac] [checking TestMessageUtil] 
[javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\TestMessageUtil.class] 
[javac] [total 281ms] 

test: [junit] Testsuite: TestMessageUtil 
[junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec [junit] 
[junit] ------------- Standard Output --------------- 
[junit] Inside testPrintMessage()
[junit] Robert 
[junit] Inside testSalutationMessage() 
[junit] Hi!Robert 
[junit] ------------- ---------------- --------------- BUILD SUCCESSFUL Total time: 0 seconds

JUnit - Eclipse 插件

爲了設置帶有 eclipse 的 JUnit，須要遵循如下步驟。

步驟 1：下載 Junit archive

下載 JUnit

操做系統	文件名
Windows	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

假設你在 C:>JUnit 文件夾中複製了以上 JAR 文件。

步驟 2：設置 Eclipse 環境

打開 eclipse -> 右擊 project 並點擊 property > Build Path > Configure Build Path，而後使用 Add External Jar 按鈕在函數庫中添加 junit-4.10.jar。

咱們假設你的 eclipse 已經內置了 junit 插件而且它在 C:>eclipse/plugins 目錄下，如不能得到，那麼你能夠從 JUnit Plugin 上下載。在 eclipse 的插件文件夾中解壓下載的 zip 文件。最後重啓 eclipse。

如今你的 eclipse 已經準備好 JUnit 測試用例的開發了。

步驟 3：覈實 Eclipse 中的 Junit 安裝

在 eclipse 的任何位置上建立一個 TestJunit 項目。
建立一個 MessageUtil 類來在項目中測試。

/* * 
This class prints the given message on console. 
*/ 
public class MessageUtil { 
    private String message; 
//Constructor 
//@param message to be printed 
public MessageUtil(String message){ 
    this.message = message; 
} 
// prints the message 
public String printMessage(){ 
    System.out.println(message); 
    return message; 
    } 
}

在項目中建立一個 test 類 TestJunit

import org.junit.Test; 
import static org.junit.Assert.assertEquals; 

public class TestJunit { 
　　String message = "Hello World"; 
　　MessageUtil messageUtil = new MessageUtil(message); 
@Test 
　　public void testPrintMessage() { 
　　　　assertEquals(message,messageUtil.printMessage()); 
　　} 
}

下面是項目結構

最後，經過右擊程序和 run as junit 驗證程序的輸出。

驗證結果

JUnit - 框架擴展

如下是 JUnit 擴展

Cactus
JWebUnit
XMLUnit
MockObject

Cactus

Cactus 是一個簡單框架用來測試服務器端的 Java 代碼（Servlets, EJBs, Tag Libs, Filters）。Cactus 的設計意圖是用來減少爲服務器端代碼寫測試樣例的成本。它使用 JUnit 而且在此基礎上進行擴展。Cactus 實現了 in-container 的策略，意味着能夠在容器內部執行測試。

Cactus 系統由如下幾個部分組成：

Cactus Framework（Cactus 框架） 是 Cactus 的核心。它是提供 API 寫 Cactus 測試代碼的引擎。
Cactus Integration Modules（Cactus 集成模塊） 它是提供使用 Cactus Framework（Ant scripts, Eclipse plugin, Maven plugin）的前端和框架。

這是使用 cactus 的樣例代碼。

import org.apache.cactus.*; 
import junit.framework.*; 

public class TestSampleServlet extends ServletTestCase { 
@Test 
public void testServlet() { 
// Initialize class to test 
SampleServlet servlet = new SampleServlet(); 
// Set a variable in session as the doSomething() 
// method that we are testing session.setAttribute("name", "value"); 
// Call the method to test, passing an
// HttpServletRequest object (for example) 
String result = servlet.doSomething(request); 
// Perform verification that test was successful 
assertEquals("something", result); a
ssertEquals("otherValue", session.getAttribute("otherName")); 
} 
}

JWebUnit

JWebUnit 是一個基於 Java 的用於 web 應用的測試框架。它以一種統1、簡單測試接口的方式包裝瞭如 HtmlUnit 和 Selenium 這些已經存在的框架來容許你快速地測試 web 應用程序的正確性。

JWebUnit 提供了一種高級別的 Java API 用來處理結合了一系列驗證程序正確性的斷言的 web 應用程序。這包括經過連接，表單的填寫和提交，表格內容的驗證和其餘 web 應用程序典型的業務特徵。

這個簡單的導航方法和隨時可用的斷言容許創建更多的快速測試而不是僅僅使用 JUnit 和 HtmlUnit。另外若是你想從 HtmlUnit 切換到其它的插件，例如 Selenium(很快可使用)，那麼不用重寫你的測試樣例代碼。

如下是樣例代碼。

import junit.framework.TestCase; 
import net.sourceforge.jwebunit.WebTester; 

public class ExampleWebTestCase extends TestCase { 
　　private WebTester tester; 
public ExampleWebTestCase(String name) { 
　　super(name); 
　　tester = new WebTester(); 
} 

//set base url public void setUp() throws Exception { 
　　getTestContext().setBaseUrl("http://myserver:8080/myapp"); 
} 
// test base info 
@Test 
public void testInfoPage() { 
　　beginAt("/info.html"); 
　　} 
}

XMLUnit

XMLUnit 提供了一個單一的 JUnit 擴展類，即 XMLTestCase，還有一些容許斷言的支持類：

比較兩個 XML 文件的不一樣（經過使用 Diff 和 DetailedDiff 類）
一個 XML 文件的驗證（經過使用 Validator 類）
使用 XSLT 轉換一個 XML 文件的結果（經過使用 Transform 類）
對一個 XML 文件 XPath 表達式的評估（經過實現 XpathEngine 接口）
一個 XML 文件進行 DOM Traversal 後的獨立結點（經過使用 NodeTest 類）

咱們假設有兩個咱們想要比較和斷言它們相同的 XML 文件，咱們能夠寫一個以下的簡單測試類：

import org.custommonkey.xmlunit.XMLTestCase; 

public class MyXMLTestCase extends XMLTestCase { 
// this test method compare two pieces of the XML 

@Test 
public void testForXMLEquality() throws Exception { 
    String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>"; 
    String myTestXML = "<msg><localId>2376</localId></msg>"; 
    assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML); 
    } 
}

MockObject

在一個單元測試中，虛擬對象能夠模擬複雜的，真實的（非虛擬）對象的行爲，所以當一個真實對象不現實或不可能包含進一個單元測試的時候很是有用。

用虛擬對象進行測試時通常的編程風格包括：

建立虛擬對象的實例
在虛擬對象中設置狀態和描述
結合虛擬對象調用域代碼做爲參數
在虛擬對象中驗證一致性

如下是使用 Jmock 的 MockObject 例子。

import org.jmock.Mockery; 
import org.jmock.Expectations; 

class PubTest extends TestCase { 
Mockery context = new Mockery(); 
public void testSubReceivesMessage() { 

// set up
 final Sub sub = context.mock(Sub.class); 
Pub pub = new Pub(); 
pub.add(sub); 
final String message = "message"; 

// expectations 
context.checking(new Expectations() { 
oneOf (sub).receive(message); 
}); 

// execute 
pub.publish(message); 

// verify 
context.assertIsSatisfied(); 
    } 
}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。