JUNIT使用教程

使用目的 

       junit是java中书写unit test的framework,目前一些流行的unit test工具大都都是在junit上扩展而来的。目前它的版本是junit3.8.1,可以从www.junit.org上下载。 

Eclipse中配置junit 

在要使用JUNIT的project名上,点击properties--java build path-libraries, 点击Add External JARs,把JUNIT包点上就行了. 并在需要测试的项目上新建junit test case 


用法 

1.       基本使用步骤,Junit的使用非常简单,它的基本使用步骤: 

-          创建,从junit.framework.TestCase派生unit test需要的test case 

-          书写测试方法,提供类似于如下函数签名的测试方法: 

public void testXXXXX(); 

-          编译,书写完test case后,编译所写的test case类 

-          运行,启动junit test runner,来运行这个test case。 

Junit提供了2个基本的test runner:字符界面和图形界面。启动命令分别如下: 

a 图形界面: 

java junit.swingui.TestRunner XXXXX 

b 字符界面: 

java junit.textui.TestRunner XXXXX 

2.       使用例子: 

import junit.frmework.TestCase; 

public class TestSample extends TestCaset{ 

              public void testMethod1(){ 

                     assertTrue( true); 

} } 

3.       setUp与tearDown,这两个函数是junit framework中提供初始化和反初始化每个测试方法的。setUp在每个测试方法调用前被调用,负责初始化测试方法所需要的测试环境;tearDown在每个测试方法被调用之后被调用,负责撤销测试环境。它们与测试方法的关系可以描述如下: 

     测试开始 -> setUp -> testXXXX -> tearDown ->测试结束 


4.       使用例子: 

import junit.frmework.TestCase; 

public class TestSample extends TestCaset{ 

              protected void setUp(){ 

                     //初始化…… 



              public void testMethod1(){ 

                     assertTrue( true); 




potected void tearDown(){ 

       //撤销初始化…… 

} } 

5.       区分fail、exception。 

-          fail,期望出现的错误。产生原因:assert函数出错(如assertFalse(true));fail函数产生(如fail(……))。 

-          exception,不期望出现的错误,属于unit test程序运行时抛出的异常。它和普通代码运行过程中抛出的runtime异常属于一种类型。 

对于assert、fail等函数请参见junit的javadoc。 

6.       使用例子: 

import junit.frmework.TestCase; 

public class TestSample extends TestCaset{ 

              protected void setUp(){ 

                     //初始化…… 



              public void testMethod1(){ 

                     …… 

                     try{ 

                            boolean b= …… 

                            assertTrue( b); 

                            throw new Exception( “This is a test.”); 

                            fail( “Unable point.”);     //不可能到达 

                     }catch(Exception e){ 

                            fail( “Yes, I catch u”); //应该到达点 



…… 



potected void tearDown(){ 

       //撤销初始化…… 

} } 

7.       组装TestSuite,运行更多的test。在junit中,Test、TestCase和TestSuite三者组成了composiste pattern。通过组装自己的TestSuite,可以完成对添加到这个TestSuite中的所有的TestCase的调用。而且这些定义的 TestSuite还可以组装成更大的TestSuite,这样同时也方便了对于不断增加的TestCase的管理和维护。 

       它的另一个好处就是,可以从这个TestCase树的任意一个节点(TestSuite或TestCase)开始调用,来完成这个节点以下的所有TestCase的调用。提高了unit test的灵活性。 

8.       使用例子: 

import junit.framework.Test; 

import junit.framework.TestSuite; 

public class TestAll{ 

public class TestAll{ 

              //定义一个suite,对于junit的作用可以视为类似于java应用程序的main。 

    public static Test suite(){ 

        TestSuite suite = new TestSuite("Running all tests."); 

        suite.addTestSuite( TestCase1.class); 

        suite.addTestSuite( TestCase2.class); 

        return suite; 

    } 



运行同运行单独的一个TestCase是一样的,参见step 1 “运行”。 

9.       使用Ant junit task。我们除了使用java来直接运行junit之外,我们还可以使用junit提供的junit task与ant结合来运行。涉及的几个主要的ant task如下: 

-          <junit>,定义一个junit task 

-          <batchtest>,位于<junit>中,运行多个TestCase 

-          <test>,位于<junit>中,运行单个TestCase 

-          <formatter>,位于<junit>中,定义一个测试结果输出格式 

-          <junitreport>,定义一个junitreport task 

-          <report>,位于<junitreport>中,输出一个junit report 

具体的语法请参见相关文档。 

10.   使用例子: 

<junit printsummary="yes" haltonfailure="no"> 

    <classpath> 

        <path refid="classpath"/> 

        <pathelement location="${dist.junit}"/> 

    </classpath> 

    <formatter type="brief" usefile="false"/> 

    <formatter type="xml"/> 

    <batchtest todir="${doc.junitReport}"> 

        <fileset dir="${dist.junit}" includes="**/*Test.class" /> 

    </batchtest> 

</junit> 

<junitreport todir="${doc.junitReport}"> 

    <fileset dir="${doc.junitReport}"> 

        <include name="TEST*-*.xml"/> 

    </fileset> 

    <report format="frames" styledir="${junit.styleDir}" todir="${doc.junitReport}"/> 

</junitreport> 

检查表 

       junit的使用并不很难,然而要书写一个好的TestCase却并非易事。一个不好的TestCase往往是既浪费了时间,也起不了实际的作用。相反,一个好的TestCase,不仅可以很好的指出代码中存在的问题,而且也可以作为代码更准确的文档,同时还在持续集成的过程中起非常重要的作用。在此给出书写TestCase时需要注意的几点: 

-          测试的独立性:一次只测试一个对象,方便定位出错的位置。这有2层意思:一个TestCase,只测试一个对象;一个TestMethod,只测试这个对象中的一个方法。 

-          给测试方法一个合适的名字。 

-          在assert函数中给出失败的原因,如:assertTrue( “… should be true”, ……),方便查错。在这个例子中,如果无法通过assertTrue,那么给出的消息将被显示。在junit中每个assert函数都有第一个参数是出错时显示消息的函数原型。 

-          测试所有可能引起失败的地方,如:一个类中频繁改动的函数。对于那些仅仅只含有getter/setter的类,如果是由IDE(如Eclipse)产生的,则可不测;如果是人工写,那么最好测试一下。 

-          在setUp和tearDown中的代码不应该是与测试方法相关的,而应该是全局相关的。如针对与测试方法A和B,在setUp和tearDown中的代码应该是A和B都需要的代码。 

-          测试代码的组织:相同的包,不同的目录。这样,测试代码可以访问被测试类的protected变量/方法,方便测试代码的编写。放在不同的目录,则方便了测试代码的管理以及代码的打包和发布。一个例子如下: 

src   <=源代码根目录 

|---com 

     |---mod1 

         |---class1 

junit   <=测试代码根目录 

|---com 

     |---mod1 

         |---class1 









一个简单的测试用例。 

您是怎样编写测试代码的呢? 

在调试器中使用表达式也许是最简单的办法。您可以不用重新编译,就能改变调试器中的表达式,您甚至可以在您看到运行的对象实例后再决定如何改变;您也可以写一些作为测试的表达式将结果打印到标准输出。以上风格的测试都有一些局限,因为它们都需要人为的判断来分析程序运行的结果;而且,呈现给您的也是一些不友好的输出。您每次只能运行一个调试表达式,如果一个程序有太多的输出语句将导致您很难找到您需要的结果。 

JUnit Test不需要人的判断去解释,而且一次可以运行很多的测试。如果您需要测试某个东东的时候,您只要这么做即可: 

从TestCase继承出一个子类。 
重写runTest()方法。 
当您想检查一个值时,调用assertTrue()方法,并传入一个布尔量真值来代表测试通过。 
例如:为了测试同一货币单位的两个钱数的和,我们包含了一个真实的值表示了这两个钱数的和。如下: 

Java代码  收藏代码
  1. public void testSimpleAdd()  
  2.   
  3. {  
  4.   
  5. Money m12CHF = new Money(12,"CHF");  
  6.   
  7. Money m14CHF = new Money(14,"CHF");  
  8.   
  9. Money expected= new Money(26,"CHF");  
  10.   
  11. Money result = m12CHF.add(m14CHF)  
  12.   
  13. assertTrue(expected.equals(result));  
  14.   
  15. }  


如果,您要写的测试与以前写过的有些类似,那就写一个模板。如果,您想运行多个测试,那就建立一个组。 


模板: 

当您有两个或多个测试需要操作对象的同一或相近部分,该怎么办? 

测试需要运行在部分内容已经确定的对象上,这些已知的部分被称作测试模板。当您在写测试的时候,您通常会发现您构建测试环境(已知部分)的时间要比您真正比较测试结果的时间要长。 

从某种程度上说,您如果仔细使用构造函数,您写模板的时候也许更容易些。不管怎么样,许多的保存内容来自共享的模板。通常,您能够将这个模板应用到一些不同的测试上。每个测试用例将传递相近的信息或参数给模板,然后检查不同的结果。 

当您写一个通用的模板时,下面是您所要做的: 

从TestCase生成子类。 
给模板添加需要使用的实例变量。 
覆写setUp()方法来实例化变量。 
覆写tearDown()方法来释放您在setUp()方法中建立的永久资源。 
例如:为了写一些使用到 12瑞士法郎,14瑞士法郎,28美元不同组合的测试用例,那就首先写一个模板: 

Java代码  收藏代码
  1. public class MoneyTest extends TestCase  
  2.   
  3. {  
  4.   
  5. private Money f12CHF;  
  6.   
  7. private Money f14CHF;  
  8.   
  9. private Money f28USD;  
  10.   
  11. protected void setUp()  
  12.   
  13. {  
  14.   
  15. f12CHF = new Money(12,"CHF");  
  16.   
  17. f14CHF = new Money(14,"CHF");  
  18.   
  19. f28USD = new Money(28,"USD");  
  20.   
  21. }  
  22.   
  23. }  


一旦您写完了模板,那么,您就可以再写随意多的测试用例了。 

测试用例 

当您拥有了模板后,您是怎样来写和调用单独的测试用例呢? 

当没有模板的时候,写测试用例是简单的--只需覆写TestCase的匿名子类中的runTest方法。有模板后,生成TestCase的子类来写设置的代码。然后,为单独的测试用例写匿名子类。然而,当写过一些测试以后,您将注意到,很多的代码行都浪费在语法上了。 

JUnit提供了一个简练的方法来利用模板写测试,如下: 

1,在包含模板的类中提供一个public void 方法,通常约定:方法名以test开头。 

例如:为了测试Moeny 和MoneyBag的和,如下: 

Java代码  收藏代码
  1. public void testMoneyMoneyBag()  
  2.   
  3. {  
  4.   
  5. //[12 CHF] +[14 CHF] +[28 USD] == {[26 CHF] [28 USD] }  
  6.   
  7. Money bag[] = {f26CHF,f28USD};  
  8.   
  9. MoneyBag expected = new MoneyBag(bag);  
  10.   
  11. assertEquals(expected,f12CHF.add(f28USD.add(f14CHF)));  
  12.   
  13. }  


创建一个MoneyTest实例来运行这个用例的方法,如下: 

new MoneyTest("testMoneyMoneyBag") 

当这个测试运行时,这个参数名字被用来查找需要运行的方法。 

当您有多个测试用例时,可以将他们组织成(套件)suite. 

套件(suite) 

您怎样才能一次运行多个测试? 

只要您有了两个测试,您可能就希望一起运行他们。您当然可以每次只运行一个,但是很快您就会感到厌倦。JUnit提供了一个对象,TestSuite,以方便您一次完成任意多的测试一起运行。 

例如:只运行一个测试用例,您可能会执行: 

Java代码  收藏代码
  1. TestResult result = (new MoneyTest("testMoneyMoneyBag")).run();  

运行两个测试用例,可以先产生一个套件(Suite),然后将这两个测试用例包含其中,如下: 

Java代码  收藏代码
  1. TestSuite suite = new TestSuite();  
  2.   
  3. suite.addTest(new MoneyTest("testMoneyMoneyBag"));  
  4.   
  5. suite.addTest(new MoneyTest("testSimpleAdd"));  
  6.   
  7. TestResult result = suite.run();  


您可以采取另外的一种方式来一次运行多个测试用例,那就是让JUnit自己从用例类(TestCase)中提取套件(Suite)。您可以通过将用例类(TestCase)的类名传递给套件(Suite)的构造函数来做到这点。 

Java代码  收藏代码
  1. TestSuite suite = new TestSuite(MoneyTest.class);  
  2.   
  3. TestResult result = suite.run();  

使用手工方法的多数情况是,我们希望套件中只包含测试用例的一个子集。其他情况,推荐使用自动提取测试套件方法,它能够避免当您在新添加了一个测试用例后,还需要更改TestSuite(套件)产生代码。 

TestSuites(套件)不仅可以包含测试用例,它还可以包含实现Test接口的任意对象。例如,您可以在您的代码中产生一个套件,同时,我也产生一个,然后我们可以产生一个包含上述两个套件的套件来一起运行。 

Java代码  收藏代码
  1. TestSuite suite = new TestSuite();  
  2.   
  3. suite.addTest(Kent.suite());  
  4.   
  5. suite.addTest(Erich.suite());  
  6.   
  7. TestResult result = suite.run();  
  8.   
  9. TestRunner(测试执行器)  


您怎样运行测试,并收集执行后的结果? 

当您有了一个测试套件的时候,您就想运行它。Juint提供了工具来定义这个套件运行并显示测试结果,您需使您的套件能被TestRunner(测试运行器)访问;您可以使用静态方法suite(),并且返回一个suite(套件)来完成这项工作。 

Java代码  收藏代码
  1. public static Test suite()  
  2.   
  3. {  
  4.   
  5. TestSuite suite = new TestSuite();  
  6.   
  7. suite.addTest(new MoneyTest("testMoneyEquals"));  
  8. suite.addTest(new MoneyTest("testSimpleAdd"));  
  9. return suite;  
  10.   
  11.   
  12. }  

或则,采用自动提取的方式: 

Java代码  收藏代码
  1. public static Test suite() {  
  2. return new TestSuite(MoneyTest.class);  
  3. }  

如果,TestCase没有定义suite方法,测试执行器将自动尝试提取一个suite,并把以test开头的方法装入套件。 

Juint提供了图形和文本两种方式的测试执行器,启动方式分别是:java junit.awtui.TestRunner 或则 java junit.swingui.TestRunner. 

图形界面的执行方式提供了一个窗口,内容包括: 

一个输入文本框,用来键入包含suite方法的类的名字。 
一个启动测试的按钮。 
一个进度条,如果测试失败,他将从绿色变为红色。 
一个包含失败的测试的列表。 
当测试不通过时,juint在底部提供一个失败测试的报表。juint区分失败和错误。失败是预期的,并且使用断言assertions来做检查的.错误是没有预计到的,象数组索引越界。下图包含了一个失败的测试。 

当您改变代码后,您必须重新启动图形界面窗口,这是繁琐和耗时的。为了避免这种情况,JUnit 的AWT 和Swing UIs 可以利用junit.runner.LoadingTestCollector ,这个工具在测试的每次运行时都重新读入您的类。如果您想关闭这个功能,去掉"reload classes"属性选项即可。在帮助中您可以找到更详细的信息。 

有一个批处理来启动Junit.您可以在命令行中键入java junit.textui.TestRunner ,后跟包含suite方法的类名。这个方式得到一些终端文本输出。另外一种启动的方式是在您的TestCase类中,包含如下定义的main方法。 

例如:启动MoneyTest的测试执行器, 

Java代码  收藏代码
  1. public static void main(String args[]) {  
  2. junit.textui.TestRunner.run(suite());  
  3. }  


当您定义了这个main方法后,您就可以在命令行中键入:java MoneyTest 来运行您的测试了。 

无论是图形方式还是文本方式,都要确认在您的classpath上是否包含了junit.jar. 
展开阅读全文

没有更多推荐了,返回首页