電子發(fā)燒友App
如果你才剛開始接觸Java世界，那么要做的第一件事情是，安裝JDK——Java Development Kit（Java開發(fā)工具包），它自帶有Java Runtime Environment（JRE）和JVM（Java運(yùn)行時環(huán)境）。它能讓你在自己的電腦上編譯、運(yùn)行、測試你的Java程序。
此外，你還需要IDE（集成開發(fā)環(huán)境）。選擇有很多，如IntelliJ、Eclipse和NetBeans。
Java Junit測試框架
1、相關(guān)概念
? JUnit：是一個開發(fā)源代碼的Java測試框架，用于編寫和運(yùn)行可重復(fù)的測試。它是用于單元測試框架體系xUnit的一個實(shí)例（用于java語言）。主要用于白盒測試，回歸測試。
? 白盒測試：把測試對象看作一個打開的盒子，程序內(nèi)部的邏輯結(jié)構(gòu)和其他信息對測試人
員是公開的。
? 回歸測試：軟件或環(huán)境的修復(fù)或更正后的再測試，自動測試工具對這類測試尤其有用。
? 單元測試：最小粒度的測試，以測試某個功能或代碼塊。一般由程序員來做，因?yàn)樗枰纼?nèi)部程序設(shè)計(jì)和編碼的細(xì)節(jié)。
2、 單元測試
2.1、單元測試的好處
? 提高開發(fā)速度，測試是以自動化方式執(zhí)行的，提升了測試代碼的執(zhí)行效率。
? 提高軟件代碼質(zhì)量，它使用小版本發(fā)布至集成，便于實(shí)現(xiàn)人員除錯。同時引入重構(gòu)概念，讓代碼更干凈和富有彈性。
? 提升系統(tǒng)的可信賴度，它是回歸測試的一種。支持修復(fù)或更正后的“再測試”，可確保代碼的正確性。
2.2、單元測試的針對對象
? 面向過程的軟件開發(fā)針對過程。
? 面向?qū)ο蟮能浖_發(fā)針對對象。
? 可以做類測試，功能測試，接口測試（最常用于測試類中的方法）。
2.3、單元測試工具和框架
目前的最流行的單元測試工具是xUnit系列框架，常用的根據(jù)語言不同分為JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（PHP ）等等。
單元測試框架的第一個和最杰出的應(yīng)用就是由Erich Gamma （《設(shè)計(jì)模式》的作者）和Kent Beck（XP（Extreme Programming）的創(chuàng)始人 ）提供的開放源代碼的JUnit。
3、Junit入門簡介
3.1、JUnit的好處和JUnit測試編寫原則
使用JUnit的好處：
? 可以使測試代碼與產(chǎn)品代碼分開。
? 針對某一個類的測試代碼通過較少的改動便可以應(yīng)用于另一個類的測試。
? 易于集成到測試人員的構(gòu)建過程中，JUnit和Ant的結(jié)合可以實(shí)施增量開發(fā)。
? JUnit是公開源代碼的，可以進(jìn)行二次開發(fā)。
? 可以方便地對JUnit進(jìn)行擴(kuò)展。
JUnit測試編寫原則：
? 簡化測試的編寫，這種簡化包括測試框架的學(xué)習(xí)和實(shí)際測試單元的編寫。
? 使測試單元保持持久性。
? 可以利用既有的測試來編寫相關(guān)的測試。
3.2、JUnit的特征
? 使用斷言方法判斷期望值和實(shí)際值差異，返回Boolean值。
? 測試驅(qū)動設(shè)備使用共同的初始化變量或者實(shí)例。
? 測試包結(jié)構(gòu)便于組織和集成運(yùn)行。
? 支持圖型交互模式和文本交互模式。
3.3 JUnit框架組成
? 對測試目標(biāo)進(jìn)行測試的方法與過程集合，可稱為測試用例（TestCase）。
? 測試用例的集合，可容納多個測試用例（TestCase），將其稱作測試包（TestSuite）。
? 測試結(jié)果的描述與記錄。（TestResult） 。
? 測試過程中的事件監(jiān)聽者（TestListener）。
? 每一個測試方法所發(fā)生的與預(yù)期不一致狀況的描述，稱其測試失敗元素（TestFailure）
? JUnit Framework中的出錯異常（AssertionFailedError）。
JUnit框架是一個典型的Composite模式：TestSuite可以容納任何派生自Test的對象；當(dāng)調(diào)用TestSuite對象的run（）方法是，會遍歷自己容納的對象，逐個調(diào)用它們的run（）方法。3.5 JUnit中常用的接口和類
? Test接口：運(yùn)行測試和收集測試結(jié)果
Test接口使用了Composite設(shè)計(jì)模式，是單獨(dú)測試用例（TestCase），聚合測試模式（TestSuite）及測試擴(kuò)展（TestDecorator）的共同接口。 它的public int countTestCases（）方法，用來統(tǒng)計(jì)測試時有多少個TestCase。另外一個方法就是public void run（ TestResult ），TestResult是實(shí)例接受測試結(jié)果， run方法執(zhí)行本次測試。
? TestCase抽象類：定義測試中固定方法
TestCase是Test接口的抽象實(shí)現(xiàn)，（不能被實(shí)例化，只能被繼承）其構(gòu)造函數(shù)TestCase（string name）根據(jù)輸入的測試名稱name創(chuàng)建一個測試實(shí)例。由于每一個TestCase在創(chuàng)建時都要有一個名稱，若測試失敗了，便可識別出是哪個測試失敗。
TestCase類中包含的setUp（）、tearDown（）方法。
setUp（）方法集中初始化測試所需的所有變量和實(shí)例，并且在依次調(diào)用測試類中的每個測試方法之前再次執(zhí)行setUp（）方法。
tearDown（）方法則是在每個測試方法之后，釋放測試程序方法中引用的變量和實(shí)例。
開發(fā)人員編寫測試用例時，只需繼承TestCase，來完成run方法即可，然后JUnit獲得測試用例，執(zhí)行它的run方法，把測試結(jié)果記錄在TestResult之中。
? Assert靜態(tài)類：一系列斷言方法的集合
Assert包含了一組靜態(tài)的測試方法，用于期望值和實(shí)際值比對是否正確，即測試失敗，Assert類就會拋出一AssertionFailedError異常，JUnit測試框架將這種錯誤歸入Failes并加以記錄，同時標(biāo)志為未通過測試。如果該類方法中指定一個String類型的傳參則該參數(shù)將被做為AssertionFailedError異常的標(biāo)識信息，告訴測試人員改異常的詳細(xì)信息。
JUnit 提供了6大類31組斷言方法，包括基礎(chǔ)斷言、數(shù)字?jǐn)嘌?、字符斷言、布爾斷言、對象斷言。其中assertEquals（Object expcted，Object actual）內(nèi)部邏輯判斷使用equals（）方法，這表明斷言兩個實(shí)例的內(nèi)部哈希值是否相等時，最好使用該方法對相應(yīng)類實(shí)例的值進(jìn)行比較。
而assertSame（Object expected，Object actual）內(nèi)部邏輯判斷使用了Java運(yùn)算符“==”，這表明該斷言判斷兩個實(shí)例是否來自于同一個引用（Reference），最好使用該方法對不同類的實(shí)例的值進(jìn)行比對。
asserEquals（String message，String expected，String actual）該方法對兩個字符串進(jìn)行邏輯比對，如果不匹配則顯示著兩個字符串有差異的地方。
ComparisonFailure類提供兩個字符串的比對，不匹配則給出詳細(xì)的差異字符。
? TestSuite測試包類？？多個測試的組合
TestSuite類負(fù)責(zé)組裝多個Test Cases。待測得類中可能包括了對被測類的多個測試，而TestSuit負(fù)責(zé)收集這些測試，使我們可以在一個測試中，完成全部的對被測類的多個測試。TestSuite類實(shí)現(xiàn)了Test接口，且可以包含其它的TestSuites。它可以處理加入Test時的所有拋出的異常。
TestSuite處理測試用例有6個規(guī)約（否則會被拒絕執(zhí)行測試）
2 測試用例必須是公有類（Public）
2 用例必須繼承與TestCase類
2 測試用例的測試方法必須是公有的（ Public ）
2 測試用例的測試方法必須被聲明為Void
2 測試用例中測試方法的前置名詞必須是test
2 測試用例中測試方法誤任何傳遞參數(shù)
? TestResult結(jié)果類和其它類與接口
TestResult結(jié)果類集合了任意測試?yán)奂咏Y(jié)果，通過TestResult實(shí)例傳遞個每個測試的Run（）方法。TestResult在執(zhí)行TestCase是如果失敗會異常拋出。
TestListener接口是個事件監(jiān)聽規(guī)約，可供TestRunner類使用。它通知listener的對象相關(guān)事件，方法包括測試開始startTest（Test test），測試結(jié)束endTest（Test test），錯誤，增加異常addError（Test test，Throwable t）和增加失敗addFailure（Test test，AssertionFailedError t）。
TestFailure失敗類是個“失敗”狀況的收集類，解釋每次測試執(zhí)行過程中出現(xiàn)的異常情況。其toString（）方法返回“失敗”狀況的簡要描述
4、Eclipse中JUnit的使用
測試對于保證軟件開發(fā)質(zhì)量有著非常重要的作用，單元測試更是必不可少，JUnit是一個非常強(qiáng)大的單元測試包，可以對一個/多個類的單個/多個方法測試，還可以將不同的TestCase組合成TestSuit，使測試任務(wù)自動化。
Eclipse同樣集成了JUnit，可以非常方便地編寫TestCase。Eclipse自帶了一個JUnit的插件，不用安裝就可以在你的項(xiàng)目中開始測試相關(guān)的類，并且可以調(diào)試你的測試用例和被測試類。
4.1、Eclipse中JUint使用步驟
以下步驟環(huán)境為Eclipse SDK 3.2.2及JUnit3.8.1
? 新建一個測試用例或選擇已有的所想測試的JAVA文件，點(diǎn)擊“File-》New-》…”菜單項(xiàng)或右擊文件，在彈出的“New”對話框中選擇“JUnit Test Case”，就進(jìn)入“New JUnit Test Case”對話框
? 在“New JUnit TestCase”對話框填寫相應(yīng)的欄目，主要有Name（測試用例名），SuperClass（若JUnit的版本是3.8.1，則測試的超類一般默認(rèn)為junit.framework.TestCase； 若JUnit版本是JUnit 4.4，則默認(rèn)超類為java.lang.Object。），Class Under Test（被測試的類），Source Folder（測試用例保存的目錄），Package（測試用例包名），及是否自動生成main，setUp，tearDown方法。在此一般填寫NAME及選上復(fù)選上setUpt和teardown即可。
? 點(diǎn)擊“Next》”按鈕，則進(jìn)入Test Methods，在此你可以直接勾選你想測試的被測試類的方法，Eclipse將自動生成與被選方法相應(yīng)的測試方法，點(diǎn)擊“Fishish”按鈕后一個測試用例就創(chuàng)建好了。
? 編寫完成測試用例后，點(diǎn)擊“Run”按鈕就可以看到運(yùn)行結(jié)果了。
補(bǔ)充：要使用JUnit，您必須首先將JUnit JAR保存在項(xiàng)目的Build路徑上并創(chuàng)建一個測試類。將JUnit保存在項(xiàng)目的Build路徑上的步驟為：
右擊項(xiàng)目—》選擇菜單底部的Properties選擇Java Build Path—》選擇Libraries—》點(diǎn)擊Add Variable按鈕—》查看已有的列表中有無JUnit文件，若沒有，則點(diǎn)擊Configure Variable—》New按鈕，輸入JUNIT_LIB作為變量名稱，編輯該變量并指向解壓后的JUnit目錄中的一個名為JUnit.jar的文件—》然后在選擇剛才添加的jar文件依次點(diǎn)擊OK即可。
4.2、Eclipse中JUnit應(yīng)用示例
下面我們作一個在Eclipse中利用JUnit對HelloWorld的測試 測試方法：
? HelloWorld.sayHello（）是否執(zhí)行正常，并且結(jié)果也符合要求
? HelloWorld.add（）方法是否與我們預(yù)期一樣執(zhí)行
下一步，我們準(zhǔn)備對這兩個方法進(jìn)行測試，確保功能正常。選中HelloWorld.java，右鍵點(diǎn)擊，選擇New-》JUnit Test Case：
進(jìn)入下面這個頁面，在此諸多欄目已經(jīng)填好，即是這個需要測試的文件的相關(guān)信息，若是想在測試完之后即刪除測試文件，也可更改路徑。（本機(jī)在Eclipse已有的JUnit3.8.1的基礎(chǔ)上又添加了一個新版本JUnit4.4）
點(diǎn)擊Next進(jìn)入Test Methods，在此選擇所要測試的方法sayHello及add。
點(diǎn)擊Finish，最后編寫完成測試用例代碼如下：
直接運(yùn)行Run-》Run As-》JUnit Test，就可以看到JUnit測試結(jié)果：
綠色表示測試通過，只要有1個測試未通過，就會顯示紅色并列出未通過測試的方法。
5、后記
從上面的來看，JUnit的使用并不很難，但關(guān)鍵就是最后一步完成測試碼，即編寫TestCase。要編寫一個好的TestCase卻并非易事。一個不好的TestCase往往是既浪費(fèi)了時間，也起不了實(shí)際的作用。相反，一個好的TestCase，不僅可以很好的指出代碼中存在的問題，而且也可以作為代碼更準(zhǔn)確的文檔，同時還在持續(xù)集成的過程中起非常重要的作用。我們在作測試寫TestCase時需要注意的幾點(diǎn)：
? 測試的獨(dú)立性：一次只測試一個對象，方便定位出錯的位置。這有兩層意思：一個TestCase，只測試一個對象；一個TestMethod，只測試這個對象中的一個方法。
? 給測試方法一個合適的名字。 一般取名為原來的方法名后加一個Test。
? 在assert函數(shù)中給出失敗的原因，如：assertTrue（ “… should be true”， ……），方便查錯。在這個例子中，如果無法通過assertTrue，那么給出的消息將被顯示。在junit中每個assert函數(shù)都有第一個參數(shù)是出錯時顯示消息的函數(shù)原型。
? 測試所有可能引起失敗的地方，如：一個類中頻繁改動的函數(shù)。對于那些僅僅只含有g(shù)etter/setter的類，如果是由IDE（如Eclipse）產(chǎn)生的，則可不測；如果是人工寫，那么最好測試一下。
? 在setUp和tearDown中的代碼不應(yīng)該是與測試方法相關(guān)的，而應(yīng)該是全局相關(guān)的。如針對與測試方法A和B，在setUp和tearDown中的代碼應(yīng)該是A和B都需要的代碼。
? 測試代碼的組織：相同的包，不同的目錄。這樣，測試代碼可以訪問被測試類的protected變量/方法，方便測試代碼的編寫。放在不同的目錄，則方便了測試代碼的管理以及代碼的打包和發(fā)布。
闡述JUnit的測試流程架構(gòu)。我們將從不同的角度來詳細(xì)分析這個圖。
圖 測試序列圖
TestNG和JUnit是針對Java語言的兩個比較常用的測試框架。JUnit出現(xiàn)的比較早，但是早期的JUnit 3對測試代碼有非常多的限制，使用起來很不方便，后來的JUnit 4得到很大的改進(jìn)。TestNG的出現(xiàn)介于JUnit 3和JUnit 4，但是TestNG在很多方面還要優(yōu)于JUnit 4。下面從整體上對TestNG和JUnit 4進(jìn)行比較全面的比較?！ estNG與JUnit的相同點(diǎn)：1. 使用annotation，且大部分annotation相同。2. 都可以進(jìn)行單元測試（Unit test）。3. 都是針對Java測試的工具。 TestNG與JUnit的不同點(diǎn)：1. JUnit只能進(jìn)行單元測試，TestNG可以進(jìn)行單元測試（unit test），功能測試（function test），端到端測試（e2e test），集成測試（Integration test）等。2. TestNG需要一個額外的xml配置文件，配置測試的class、method甚至package。3. TestNG的運(yùn)行方式更加靈活：命令行、ant和IDE，JUnit只能使用IDE。4. TestNG的annotation更加豐富，比如@ExpectedExceptions、@DataProvider等。5. 測試套件運(yùn)行失敗，JUnit 4會重新運(yùn)行整個測試套件。TestNG運(yùn)行失敗時，會創(chuàng)建一個XML文件說明失敗的測試，利用這個文件執(zhí)行程序，就不會重復(fù)運(yùn)行已經(jīng)成功的測試。 TestNG比JUnit 4靈活性的體現(xiàn)：1. JUnit 4中必須把@BeforeClass修飾的方法聲明為public static，這就限制了該方法中使用的變量必須是static。而TestNG中@BeforeClass修飾的方法可以跟普通函數(shù)完全一樣。2. JUnit 4測試的依賴性非常強(qiáng)，測試用例間有嚴(yán)格的先后順序。前一個測試不成功，后續(xù)所有的依賴測試都會失敗。TestNG 利用@Test 的dependsOnMethods屬性來應(yīng)對測試依賴性問題。某方法依賴的方法失敗，它將被跳過，而不是標(biāo)記為失敗。3. 對于n個不同參數(shù)組合的測試，JUnit 4要寫n個測試用例。每個測試用例完成的任務(wù)基本是相同的，只是受測方法的參數(shù)有所改變。TestNG的參數(shù)化測試只需要一個測試用例，然后把所需要的參數(shù)加到TestNG的xml配置文件中。這樣的好處是參數(shù)與測試代碼分離，非程序員也可以修改參數(shù)，同時修改無需重新編譯測試代碼。4. 為了測試無法用String或原語值表示的復(fù)雜參數(shù)化類型，TestNG提供的@DataProvider使它們映射到某個測試方法。5. JUnit 4的測試結(jié)果通過Green/Red bar體現(xiàn)，TestNG的結(jié)果除了Green/Red bar，還有Console窗口和test-output文件夾，對測試結(jié)果的描述更加詳細(xì)，方便定位錯誤?！ 『唵握f就是TestNG比Junit強(qiáng)大， 但是那些更強(qiáng)大的功能你全部都用不到的話， 那你還是就用junit， 比較簡單， 國人用的多， 出了問題中文也比較好查。 英文還不錯并且有想要了解除了單元測試以外的測試的話， 就用TestNG吧。
詳解Java單元測試Junit框架實(shí)例
主要介紹了Java的異常測試框架JUnit使用上手指南，JUnit是Java代碼進(jìn)行單元測試中的常用工具，
問題：
1、目前測試存在的問題
2、Junit注意的細(xì)節(jié)
3、Junit使用規(guī)范
4、斷言
5、案例
junit（單元測試框架）
1、目前存在的問題
1、目前的測試方法如果需要測試，都需要在main方法上調(diào)用
2、目前的結(jié)果都需要我們?nèi)斯け葘?/p>
2、Junit 注意的細(xì)節(jié)
1、如果使用junit測試一個方法的時候，在junit窗口上顯示綠色那么表示測試正確，如果顯示了紅色，則代表該方法測試出現(xiàn)了異常不通過
2、如果點(diǎn)擊方法名、類名、包名、工程名運(yùn)行junit分別測試的是對于的方法，類、包中的所有類的test方法，工程中所有test的方法
3、@Test測試的方法不能是static修飾與不能帶有形參
4、如果測試一個方法的時候需要準(zhǔn)備測試的環(huán)境或者是清理測試的環(huán)境，那么可以@Before、@After、@BeforeClass、@AfterClass 這四個注釋，@Before、@After 是在每個測試方法測試的時候都會調(diào)用一次，@AfterClass、@BeforeClass是在所有的測試方法測試之前與之后都會調(diào)用一次，這個方法必須是靜態(tài)的
3、junit使用規(guī)范
1、一個類如果需要測試，那么該類就應(yīng)該對應(yīng)著一個測試類，測試類的命名規(guī)范：被測試類的類名+Test
2、一個被測試的方法一般對應(yīng)一個測試的方法，測試的方法的命名規(guī)范是：test+被測試的方法的方法名
4、斷言
斷言就是不顯示結(jié)果，按照程序運(yùn)行的預(yù)期值和實(shí)際值進(jìn)行比對，顯示運(yùn)行的狀態(tài)。
5Assert.assertSame（5， max）; // 底層是用了 ==
Assert.assertSame（new String（“abc”）， “abc”）;
Assert.assertEquals（new String（“abc”）， “abc”）; //底層是使用Equals方法比較的
Assert.assertNull（“aa”）;
Assert.assertTrue（true）;
5、案例
??？
28package cn.xlucas.junit;
import java.io.*;
import org.junit.*;
public class JunitDemo1 {
//準(zhǔn)備測試的環(huán)境
//@Before
@BeforeClass
public static void beforeRead（）{
System.out.println（“準(zhǔn)備測試環(huán)境成功。。?！保?
}
//讀取文件數(shù)據(jù)，把把文件數(shù)據(jù)都
@Test
public void readFile（） throws IOException{
FileInputStream fileInputStream = newFileInputStream（“F：\\a.txt”）;
int content = fileInputStream.read（）;
System.out.println（“內(nèi)容：”+content）;
}
@Test
public void sort（）{
System.out.println（“讀取文件數(shù)據(jù)排序。?！保?
}
//清理測試環(huán)境的方法
// @After
@AfterClass
public static void afterRead（）{
System.out.println（“清理測試環(huán)境。?！保?
}
}
一、JUnit4是JUnit框架有史以來的最大改進(jìn)，其主要目標(biāo)便是利用Java5的Annotation特性簡化測試用例的編寫。
二、先簡單解釋一下什么是Annotation，這個單詞一般是翻譯成元數(shù)據(jù)。元數(shù)據(jù)是什么？元數(shù)據(jù)就是描述數(shù)據(jù)的數(shù)據(jù)。也就是說，這個東西在Java里面可以用來和public、static等關(guān)鍵字一樣來修飾類名、方法名、變量名。修飾的作用描述這個數(shù)據(jù)是做什么用的，差不多和public描述這個數(shù)據(jù)是公有的一樣
三、對Person類的方法進(jìn)行測試：
測試類Person：
?。踛ava］ view plain copy
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：
［java］ view plain copy
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類進(jìn)行測試
public class PersonTest {
private Person p;
@BeforeClass
public static void beforeClass（） {
System.out.println（“boforeClass”）;
}
@Before
public void before（） {
p = new Person（“l(fā)isi”，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”）;
}
}
輸出結(jié)果：
boforeClass
before
lisi
after
before
20
after
afterClass
以下是轉(zhuǎn)載：
我們先看一下在JUnit 3中我們是怎樣寫一個單元測試的。比如下面一個類：
?。踛ava］ view plain copy
public class AddOperation {
public int add（int x，int y）{
return x+y;
}
}
我們要測試add這個方法，我們寫單元測試得這么寫：
［java］ view plain copy
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中的靜態(tài)導(dǎo)入，這個相對來說就很簡單，只要在import關(guān)鍵字后面加上static關(guān)鍵字，就可以把后面的類的static的變量和方法導(dǎo)入到這個類中，調(diào)用的時候和調(diào)用自己的方法沒有任何區(qū)別。
我們可以看到上面那個單元測試有一些比較霸道的地方，表現(xiàn)在：
1.單元測試類必須繼承自TestCase。
2.要測試的方法必須以test開頭。
如果上面那個單元測試在JUnit 4中寫就不會這么復(fù)雜。代碼如下：
?。踛ava］ view plain copy
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已經(jīng)不會霸道的要求你必須繼承自TestCase了，而且測試方法也不必以test開頭了，只要以@Test元數(shù)據(jù)來描述即可。
從上面的例子可以看到在JUnit 4中還引入了一些其他的元數(shù)據(jù)，下面一一介紹：
@Before：
使用了該元數(shù)據(jù)的方法在每個測試方法執(zhí)行之前都要執(zhí)行一次。
@After：
使用了該元數(shù)據(jù)的方法在每個測試方法執(zhí)行之后要執(zhí)行一次。
注意：@Before和@After標(biāo)示的方法只能各有一個。這個相當(dāng)于取代了JUnit以前版本中的setUp和tearDown方法，當(dāng)然你還可以繼續(xù)叫這個名字，不過JUnit不會霸道的要求你這么做了。
@Test（expected=*.class）
在JUnit4.0之前，對錯誤的測試，我們只能通過fail來產(chǎn)生一個錯誤，并在try塊里面assertTrue（true）來測試?，F(xiàn)在，通過@Test元數(shù)據(jù)中的expected屬性。expected屬性的值是一個異常的類型
@Test（timeout=xxx）：
該元數(shù)據(jù)傳入了一個時間（毫秒）給測試方法，
如果測試方法在制定的時間之內(nèi)沒有運(yùn)行完，則測試也失敗。
@ignore：
該元數(shù)據(jù)標(biāo)記的測試方法在測試中會被忽略。當(dāng)測試的方法還沒有實(shí)現(xiàn)，或者測試的方法已經(jīng)過時，或者在某種條件下才能測試該方法（比如需要一個數(shù)據(jù)庫聯(lián)接，而在本地測試的時候，數(shù)據(jù)庫并沒有連接），那么使用該標(biāo)簽來標(biāo)示這個方法。同時，你可以為該標(biāo)簽傳遞一個String的參數(shù)，來表明為什么會忽略這個測試方法。比如：@lgnore（“該方法還沒有實(shí)現(xiàn)”），在執(zhí)行的時候，僅會報(bào)告該方法沒有實(shí)現(xiàn)，而不會運(yùn)行測試方法。
junit測試是現(xiàn)在編寫測試代碼的手段之一，
本文簡要介紹如何快速搭建一個junit測試環(huán)境。
工具/原料
eclipse工具
junit包
方法/步驟
1
首先創(chuàng)建一個java Project；將junit包和hamcrest-core包導(dǎo)入到項(xiàng)目中
2
創(chuàng)建一個source folder 資源文件夾 test，資源文件夾和普通的文件夾區(qū)別是，資源文件夾中的java文件可以被自動編譯。
3
在java文件中編寫java代碼UserMananger.java，在test文件中創(chuàng)建一個與需要進(jìn)行測試的java代碼同包名稱的TestUserManager.java文件。
4
junit4采用的是通過注解的方式（在方法的上面加上@）。
@Before表示在所有方法運(yùn)行前運(yùn)行的方法;
@After表示在所有的方法運(yùn)行之后執(zhí)行的方法;
@Test表示這是一個測試方法
@BeforeClass表示在這個測試類構(gòu)造之前執(zhí)行的方法
@AfterClass表示在這個測試類構(gòu)造之后執(zhí)行的方法
5
如果是對某一個方法進(jìn)行測試，在方法的名稱上點(diǎn)擊右鍵 --》 run as --》 JUnit Test
6
如果是對所有的方法都執(zhí)行一遍，在類體上右鍵--Run as--》 JunitTest 。
綠色的表示運(yùn)行通過的方法，紅x的表示運(yùn)行失敗的方法。
本文簡要介紹一下在Eclipse3.2中使用JUnit4進(jìn)行單元測試的方法。
首先，我們來一個傻瓜式速成教程，不要問為什么，F(xiàn)ollow Me，先來體驗(yàn)一下單元測試的快感！
首先新建一個項(xiàng)目叫JUnit_Test，我們編寫一個Calculator類，這是一個能夠簡單實(shí)現(xiàn)加減乘除、平方、開方的計(jì)算器類，然后對這些功能進(jìn)行單元測試。這個類并不是很完美，我們故意保留了一些Bug用于演示，這些Bug在注釋中都有說明。該類代碼如下：
package andycpp;
public class Calculator {
private static int result; // 靜態(tài)變量，用于存儲運(yùn)行結(jié)果
public void add（int n） {
result = result + n;
}
public void substract（int n） {
result = result - 1; //Bug： 正確的應(yīng)該是 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 ： 死循環(huán)
}
public void clear（） { // 將結(jié)果清零
result = 0;
}
public int getResult（） {
return result;
}
}
第二步，將JUnit4單元測試包引入這個項(xiàng)目：在該項(xiàng)目上點(diǎn)右鍵，點(diǎn)“屬性”，如圖：
在彈出的屬性窗口中，首先在左邊選擇“Java Build Path”，然后到右上選擇“Libraries”標(biāo)簽，之后在最右邊點(diǎn)擊“Add Library…”按鈕，如下圖所示：
然后在新彈出的對話框中選擇JUnit4并點(diǎn)擊確定，如上圖所示，JUnit4軟件包就被包含進(jìn)我們這個項(xiàng)目了。
第三步，生成JUnit測試框架：在Eclipse的Package Explorer中用右鍵點(diǎn)擊該類彈出菜單，選擇“New à JUnit Test Case”。如下圖所示：
在彈出的對話框中，進(jìn)行相應(yīng)的選擇，如下圖所示：
點(diǎn)擊“下一步”后，系統(tǒng)會自動列出你這個類中包含的方法，選擇你要進(jìn)行測試的方法。此例中，我們僅對“加、減、乘、除”四個方法進(jìn)行測試。如下圖所示：
之后系統(tǒng)會自動生成一個新類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（））;
}
}
第四步，運(yùn)行測試代碼：按照上述代碼修改完畢后，我們在CalculatorTest類上點(diǎn)右鍵，選擇“Run As à JUnit Test”來運(yùn)行我們的測試，如下圖所示：
運(yùn)行結(jié)果如下：
進(jìn)度條是紅顏色表示發(fā)現(xiàn)錯誤，具體的測試結(jié)果在進(jìn)度條上面有表示“共進(jìn)行了4個測試，其中1個測試被忽略，一個測試失敗”。
我們繼續(xù)對初級篇中的例子進(jìn)行分析。初級篇中我們使用Eclipse自動生成了一個測試框架，在這篇文章中，我們來仔細(xì)分析一下這個測試框架中的每一個細(xì)節(jié)，知其然更要知其所以然，才能更加熟練地應(yīng)用JUnit4。
一、 包含必要地Package
在測試類中用到了JUnit4框架，自然要把相應(yīng)地Package包含進(jìn)來。最主要地一個Package就是org.junit.*。把它包含進(jìn)來之后，絕大部分功能就有了。還有一句話也非常地重要“import static org.junit.Assert.*;”，我們在測試的時候使用的一系列assertEquals方法就來自這個包。大家注意一下，這是一個靜態(tài)包含（static），是JDK5中新增添的一個功能。也就是說，assertEquals是Assert類中的一系列的靜態(tài)方法，一般的使用方式是Assert. assertEquals（），但是使用了靜態(tài)包含后，前面的類名就可以省略了，使用起來更加的方便。
二、 測試類的聲明
大家注意到，我們的測試類是一個獨(dú)立的類，沒有任何父類。測試類的名字也可以任意命名，沒有任何局限性。所以我們不能通過類的聲明來判斷它是不是一個測試類，它與普通類的區(qū)別在于它內(nèi)部的方法的聲明，我們接著會講到。
三、 創(chuàng)建一個待測試的對象。
你要測試哪個類，那么你首先就要創(chuàng)建一個該類的對象。正如上一篇文章中的代碼：
private static Calculator calculator = new Calculator（）;
為了測試Calculator類，我們必須創(chuàng)建一個calculator對象。
四、 測試方法的聲明
在測試類中，并不是每一個方法都是用于測試的，你必須使用“標(biāo)注”來明確表明哪些是測試方法?！皹?biāo)注”也是JDK5的一個新特性，用在此處非常恰當(dāng)。我們可以看到，在某些方法的前有@Before、@Test、@Ignore等字樣，這些就是標(biāo)注，以一個“@”作為開頭。這些標(biāo)注都是JUnit4自定義的，熟練掌握這些標(biāo)注的含義非常重要。
五、 編寫一個簡單的測試方法。
首先，你要在方法的前面使用@Test標(biāo)注，以表明這是一個測試方法。對于方法的聲明也有如下要求：名字可以隨便取，沒有任何限制，但是返回值必須為void，而且不能有任何參數(shù)。如果違反這些規(guī)定，會在運(yùn)行時拋出一個異常。至于方法內(nèi)該寫些什么，那就要看你需要測試些什么了。比如：
@Test
public void testAdd（） {
calculator.add（2）;
calculator.add（3）;
assertEquals（5， calculator.getResult（））;
}
我們想測試一下“加法”功能時候正確，就在測試方法中調(diào)用幾次add函數(shù)，初始值為0，先加2，再加3，我們期待的結(jié)果應(yīng)該是5。如果最終實(shí)際結(jié)果也是5，則說明add方法是正確的，反之說明它是錯的。assertEquals（5， calculator.getResult（））;就是來判斷期待結(jié)果和實(shí)際結(jié)果是否相等，第一個參數(shù)填寫期待結(jié)果，第二個參數(shù)填寫實(shí)際結(jié)果，也就是通過計(jì)算得到的結(jié)果。這樣寫好之后，JUnit會自動進(jìn)行測試并把測試結(jié)果反饋給用戶。
六、 忽略測試某些尚未完成的方法。
如果你在寫程序前做了很好的規(guī)劃，那么哪些方法是什么功能都應(yīng)該實(shí)現(xiàn)定下來。因此，即使該方法尚未完成，他的具體功能也是確定的，這也就意味著你可以為他編寫測試用例。但是，如果你已經(jīng)把該方法的測試用例寫完，但該方法尚未完成，那么測試的時候一定是“失敗”。這種失敗和真正的失敗是有區(qū)別的，因此JUnit提供了一種方法來區(qū)別他們，那就是在這種測試函數(shù)的前面加上@Ignore標(biāo)注，這個標(biāo)注的含義就是“某些方法尚未完成，暫不參與此次測試”。這樣的話測試結(jié)果就會提示你有幾個測試被忽略，而不是失敗。一旦你完成了相應(yīng)函數(shù)，只需要把@Ignore標(biāo)注刪去，就可以進(jìn)行正常的測試。
七、 Fixture（暫且翻譯為“固定代碼段”）
Fixture的含義就是“在某些階段必然被調(diào)用的代碼”。比如我們上面的測試，由于只聲明了一個Calculator對象，他的初始值是0，但是測試完加法操作后，他的值就不是0了；接下來測試減法操作，就必然要考慮上次加法操作的結(jié)果。這絕對是一個很糟糕的設(shè)計(jì)！我們非常希望每一個測試都是獨(dú)立的，相互之間沒有任何耦合度。因此，我們就很有必要在執(zhí)行每一個測試之前，對Calculator對象進(jìn)行一個“復(fù)原”操作，以消除其他測試造成的影響。因此，“在任何一個測試執(zhí)行之前必須執(zhí)行的代碼”就是一個Fixture，我們用@Before來標(biāo)注它，如前面例子所示：
@Before
public void setUp（） throws Exception {
calculator.clear（）;
}
這里不在需要@Test標(biāo)注，因?yàn)檫@不是一個test，而是一個Fixture。同理，如果“在任何測試執(zhí)行之后需要進(jìn)行的收尾工作”也是一個Fixture，使用@After來標(biāo)注。由于本例比較簡單，沒有用到此功能。
JUnit4的一些基本知識就介紹到此，還有一些更靈活的用法放在本系列的高級篇中給大家介紹！
1.類的定義：類是同一事物的總稱，類是封裝對象的屬性和行為的載體，反過來說具有相同屬性和行為的一類實(shí)體被稱為類。
2.Junit工具的使用：
第一步
首先新建一個項(xiàng)目叫JUnit_Test，我們編寫一個Calculator類，這是一個能夠簡單實(shí)現(xiàn)加減乘除、平方、開方的計(jì)算器類，然后對這些功能進(jìn)行單體測試。
第二步，將JUnit4單元測試包引入這個項(xiàng)目：在該項(xiàng)目上點(diǎn)右鍵，點(diǎn)“屬性”，如圖：
在彈出的屬性窗口中，首先在左邊選擇“Java Build Path”，然后到右上選擇“Libraries”標(biāo)簽，之后在最右邊點(diǎn)擊“Add Library…”按鈕，如下圖所示：
然后在新彈出的對話框中選擇JUnit4并點(diǎn)擊確定，如上圖所示，JUnit4軟件包就被包含進(jìn)我們這個項(xiàng)目了。
第三步，生成JUnit測試框架：在Eclipse的Package Explorer中用右鍵點(diǎn)擊該類彈出菜單，選擇“New à JUnit Test Case”。如下圖所示：
點(diǎn)擊“下一步”后，系統(tǒng)會自動列出你這個類中包含的方法，選擇你要進(jìn)行測試的方法。此例中，我們僅對“加、減、乘、除”四個方法進(jìn)行測試。
之后系統(tǒng)會自動生成一個新類CalculatorTest，里面包含一些空的測試用例。你只需要將這些測試用例稍作修改即可使用。
第四步，運(yùn)行測試代碼：按照上述代碼修改完畢后，我們在CalculatorTest類上點(diǎn)右鍵，選擇“Run As à JUnit Test”來運(yùn)行我們的測試，如下圖所示：
運(yùn)行結(jié)果如下：
4.記錄各個階段的時間
1.類的定義：類是同一事物的總稱，類是封裝對象的屬性和行為的載體，反過來說具有相同屬性和行為的一類實(shí)體被稱為類。
2.Junit工具的使用：
第一步
首先新建一個項(xiàng)目叫JUnit_Test，我們編寫一個Calculator類，這是一個能夠簡單實(shí)現(xiàn)加減乘除、平方、開方的計(jì)算器類，然后對這些功能進(jìn)行單體測試。
第二步，將JUnit4單元測試包引入這個項(xiàng)目：在該項(xiàng)目上點(diǎn)右鍵，點(diǎn)“屬性”，如圖：
在彈出的屬性窗口中，首先在左邊選擇“Java Build Path”，然后到右上選擇“Libraries”標(biāo)簽，之后在最右邊點(diǎn)擊“Add Library…”按鈕，如下圖所示：
然后在新彈出的對話框中選擇JUnit4并點(diǎn)擊確定，如上圖所示，JUnit4軟件包就被包含進(jìn)我們這個項(xiàng)目了。
第三步，生成JUnit測試框架：在Eclipse的Package Explorer中用右鍵點(diǎn)擊該類彈出菜單，選擇“New à JUnit Test Case”。如下圖所示：
點(diǎn)擊“下一步”后，系統(tǒng)會自動列出你這個類中包含的方法，選擇你要進(jìn)行測試的方法。此例中，我們僅對“加、減、乘、除”四個方法進(jìn)行測試。
之后系統(tǒng)會自動生成一個新類CalculatorTest，里面包含一些空的測試用例。你只需要將這些測試用例稍作修改即可使用。
第四步，運(yùn)行測試代碼：按照上述代碼修改完畢后，我們在CalculatorTest類上點(diǎn)右鍵，選擇“Run As à JUnit Test”來運(yùn)行我們的測試，如下圖所示：
運(yùn)行結(jié)果如下：
1、Junit簡介：
Junit最初是由Erich Gamma 和 Kent Beck 編寫的一個回歸測試框架（regression testing framework），為單元測試（Unit Test）的支持框架。用來編寫和執(zhí)行重覆性的測試。即所謂白盒測試。
它包括了以下的特性：
1 對預(yù)期結(jié)果作斷言
2 提供測試裝備的生成與銷毀
3 易于組織執(zhí)行測試
4 圖形與文字界面的測試器
2、Junit的環(huán)境配置
環(huán)境：Eclipse 中配置junit，選擇項(xiàng)目Junit4（在Package Explorer中） -》 右擊鼠標(biāo) -》 選擇properties -》 選擇Java Build Path （在左邊的菜單中） -》 在右邊選擇標(biāo)簽 Libraries -》 單擊按鈕“Add Library” -》 選擇JUnit ， 單擊按鈕 “Next》” -》 選擇JUnit library version 為： JUnit4 -》 單擊按鈕“Finish” –》 單擊按鈕 “OK”
Junit4是Junit框架有史以來的最大改進(jìn)，其主要目標(biāo)是利用java5的Annotation特性來簡化測試用例的編寫。Junit4的官方網(wǎng)址是http://www.junit.org/。
3、總結(jié)一下3-4的不同，及4的改進(jìn)
下面我們以一個簡單的例子來介紹如何使用 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中必須導(dǎo)入的s
public Class XXXXTest{
@Test
public void helloTest（）{
asssertEqual（new XXXX（）.Hello（），”hello”）;
}
}
從上面例子我們對Junit3和Junit4有了一個初步的印象，下面我們重點(diǎn)介紹Junit4與Junit3的主要區(qū)別。
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 （） 不需要，
但是類開始的時候要標(biāo)記 @Test
通過assert*方法來判斷結(jié)果
assertTrue（baseClass.method （）.equals（“test.junit.BaseClass”））;
工商網(wǎng)監(jiān)
評論