Junit使用简明手册

《Junit使用简明手册》由会员分享，可在线阅读，更多相关《Junit使用简明手册（27页珍藏版）》请在装配图网上搜索。

1、JUnit是什么？JUnit是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。它包括以下特性：1、用于测试期望结果的断言（Assertion）2、用于共享共同测试数据的测试工具3、用于方便的组织和运行测试的测试套件4、图形和文本的测试运行器JUnit最初是由Erich Gamma（GoF之一）和Kent Beck（xp和refactor的先驱之一）编写的. 需要说明的是junit一般是用来进行单元测试的，因此需要了解被测试代码的内部结构（即所谓的白盒测试），另外junit是在xp编程和重构 （refact

2、or）中被极力推荐使用的工具，因为在实现自动单元测试的情况下可以大大的提高开发的效率，但是实际上编写测试代码也是需要耗费很多的时间 和精力的，那么使用这个东东好处到底在哪里呢？笔者认为是这样的：1、对于xp编程而言，要求在编写代码之前先写测试，这样可以强制你在写代码之前好好的思考代码（方法）的功能和逻辑，否则编写的代码很不稳定，那么你需 要同时维护测试代码和实际代码，这个工作量就会大大增加。因此在xp编程中，基本过程是这样的：构思编写测试代码编写代码测试，而且编写测试 和编写代码都是增量式的，写一点测一点，在编写以后的代码中如果发现问题可以较块的追踪到问题的原因，减小回归错误的纠错难度2、对于

3、重构而言，其好处和xp编程中是类似的，因为重构也是要求改一点测一点，减少回归错误造成的时间消耗。3、对于非以上两种情况，我们在开发的时候使用junit写一些适当的测试也是有必要的，因为一般我们也是需要编写测试的代码的，可能原来不是使用的 junit，如果使用junit，而且针对接口（方法）编写测试代码会减少以后的维护工作，例如以后对方法内部的修改（这个就是相当于重构的工作了）。另 外就是因为junit有断言功能，如果测试结果不通过会告诉我们那个测试不通过，为什么，而如果是想以前的一般做法是写一些测试代码看其输出结果，然后再 由自己来判断结果使用正确，使用junit的好处就是这个结果是否正确的判

4、断是它来完成的，我们只需要看看它告诉我们结果是否正确就可以了，在一般情况下 会大大提高效率。JUnit入门 cherami 整理 安装JUnit安装很简单，先到以下地址下载一个最新的zip包：下载完以后解压缩到你喜欢的目录下，假设是JUNIT_HOME，然后将JUNIT_HOME下的junit.jar包加到你的系统的CLASSPATH 环境变量中，对于IDE环境，对于需要用到的junit的项目增加到lib中，其设置不同的IDE有不同的设置，这里不多讲。如何使用JUnit写测试？最简单的范例如下：1、创建一个TestCase的子类: package junitfaq

5、;import java.util.*;import junit.framework.*;public class SimpleTest extends TestCase public SimpleTest(String name) super(name);2、写一个测试方法断言期望的结果：public void testEmptyCollection() Collection collection = new ArrayList();assertTrue(collection.isEmpty();注意：JUnit推荐的做法是以test作为待测试的方法的开头，这样这些方法可以被自动找到并被测试

6、。3、写一个suite()方法，它会使用反射动态的创建一个包含所有的testXxxx方法的测试套件：public static Test suite() return new TestSuite(SimpleTest.class);4、写一个main()方法以文本运行器的方式方便的运行测试：public static void main(String args) junit.textui.TestRunner.run(suite();5、运行测试：以文本方式运行：java junitfaq.SimpleTest 通过的测试结果是：.Time: 0OK (1 tests)Time上的小

7、点表示测试个数，如果测试通过则显示OK。否则在小点的后边标上F，表示该测试失败。每次的测试结果都应该是OK的，这样才能说明测试是成功的，如果不成功就要马上根据提示信息进行修正了。如果JUnit报告了测试没有成功，它会区分失败（failures）和错误（errors）。失败是你的代码中的assert方法失败引起的；而错误则 是代码异常引起的，例如ArrayIndexOutOfBoundsException。 以图形方式运行：java junit.swingui.TestRunner junitfaq.SimpleTest 通过的测试结果在图形界面的绿色条部分。以上是最简单的测

8、试样例，在实际的测试中我们测试某个类的功能是常常需要执行一些共同的操作，完成以后需要销毁所占用的资源（例如网络连接、数据库连接， 关闭打开的文件等），TestCase类给我们提供了setUp方法和tearDown方法，setUp方法的内容在测试你编写的TestCase子类的 每个testXxxx方法之前都会运行，而tearDown方法的内容在每个testXxxx方法结束以后都会执行。这个既共享了初始化代码，又消除了各 个测试代码之间可能产生的相互影响。 JUnit最佳实践 Martin Fowler说过：“当你试图打印输出一些信息或调试一个表达式时，写一些测试代码来替代那些

9、传统的方法。”一开始，你会发现你总是要创建一些新的 Fixture，而且测试似乎使你的编程速度慢了下来。然而不久之后，你会发现你重复使用相同的Fixture，而且新的测试通常只涉及添加一个新的测试 方法。 你可能会写许多测试代码，但你很快就会发现你设想出的测试只有一小部分是真正有用的。你所需要的测试是那些会失败的测试，即那些你认为不会失败的测试，或你认为应该失败却成功的测试。 我 们前面提到过测试是一个不会中断的过程。一旦你有了一个测试，你就要一直确保其正常工作，以检验你所加入的新的工作代码。不要每隔几天或最后才运行测试， 每天你都应该运行一下测试代码。这种投资很小，但可以

10、确保你得到可以信赖的工作代码。你的返工率降低了，你会有更多的时间编写工作代码。 不要认为压力大，就不写测试代码。相反编写测试代码会使你的压力逐渐减轻，应为通过编写测试代码，你对类的行为有了确切的认识。你会更快地编写出有效率地工作代码。下面是一些具体的编写测试代码的技巧或较好的实践方法： 1. 不要用TestCase的构造函数初始化Fixture，而要用setUp()和tearDown()方法。 2. 不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。 3. 避免编写有副作用

11、的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。简单的会滚就可以了。 4. 当继承一个测试类时，记得调用父类的setUp()和tearDown()方法。 5. 将测试代码和工作代码放在一起，一边同步编译和更新。（使用Ant中有支持junit的task.） 6. 测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。 7. 确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。 8. 如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要

12、仅用母语的Locale进行测试。 9. 尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁。 10.测试要尽可能地小，执行速度快。Junit使用简明手册在使用XP进行开发的过程，unit test是必不可少的环节。作为unit test，junit是首选的工具。本文从使用目的、如何使用、以及使用中需要考虑的问题，简略描述了junit的基本用法。使用目的junit是java中书写unit test的framework，目前一些流行的unit test工具大都都是在junit上扩展而来的。目前它的版本是junit3.8.1，可以从www

13、.junit.org上下载。用法1.       基本使用步骤，Junit的使用非常简单，它的基本使用步骤：-          创建，从junit.framework.TestCase派生unit test需要的test case-          书写测试方法，提供类似于如下函数签名的测试方法：public void testXXXXX();-

14、0;         编译，书写完test case后，编译所写的test case类-          运行，启动junit test runner，来运行这个test case。Junit提供了2个基本的test runner：字符界面和图形界面。启动命令分别如下：a 图形界面：java junit.swingui.TestRunner XXXXXb 字符界面：java junit.textui.TestRunner X

15、XXXX2.       使用例子：import junit.frmework.TestCase;public class TestSample extends TestCasetpublic void testMethod1()assertTrue( true);3.       setUp与tearDown，这两个函数是junit framework中提供初始化和反初始化每个测试方法的。setUp在每个测试方法调用前被调用，负责初始化测试方法所需要的测试环境；tearDo

16、wn在每个测试方法被调用之后被调用，负责撤销测试环境。它们与测试方法的关系可以描述如下：      测试开始 -> setUp -> testXXXX -> tearDown ->测试结束 4.       使用例子：import junit.frmework.TestCase;public class TestSample extends TestCasetprotected void setUp()/初始化public void testMetho

17、d1()assertTrue( true);potected void tearDown()/撤销初始化5.       区分fail、exception。-          fail，期望出现的错误。产生原因：assert函数出错（如assertFalse(true)）；fail函数产生（如fail()）。-          exception，不期望

18、出现的错误，属于unit test程序运行时抛出的异常。它和普通代码运行过程中抛出的runtime异常属于一种类型。对于assert、fail等函数请参见junit的javadoc。6.       使用例子：import junit.frmework.TestCase;public class TestSample extends TestCasetprotected void setUp()/初始化public void testMethod1()tryboolean b= assertTrue( b);throw new Exc

19、eption( “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

20、的调用。而且这些定义的TestSuite还可以组装成更大的TestSuite，这样同时也方便了对于不断增加的TestCase的管理和维护。它的另一个好处就是，可以从这个TestCase树的任意一个节点（TestSuite或TestCase）开始调用，来完成这个节点以下的所有TestCase的调用。提高了unit test的灵活性。8.       使用例子：import junit.framework.Test;import junit.framework.TestSuite;public class TestAllpublic cl

21、ass 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.    &

22、#160;  使用Ant junit task。我们除了使用java来直接运行junit之外，我们还可以使用junit提供的junit task与ant结合来运行。涉及的几个主要的ant task如下：-          <junit>，定义一个junit task-          <batchtest>，位于<junit>中，运行多个TestCase- 

23、         <test>，位于<junit>中，运行单个TestCase-          <formatter>，位于<junit>中，定义一个测试结果输出格式-          <junitreport>，定义一个junitreport task- 

24、60;        <report>，位于<junitreport>中，输出一个junit report具体的语法请参见相关文档。10.   使用例子：<junit printsummary="yes" haltonfailure="no"> <classpath> <path refid="classpath"/> <pathelement location="$di

25、st.junit"/> </classpath> <formatter type="brief" usefile="false"/> <formatter type="xml"/> <batchtest todir="$doc.junitReport"> <fileset dir="$dist.junit" includes="*/*Test.class" /> </batchtest>&

26、lt;/junit><junitreport todir="$doc.junitReport"> <fileset dir="$doc.junitReport"> <include name="TEST*-*.xml"/> </fileset> <report format="frames" styledir="$junit.styleDir" todir="$doc.junitReport"/></ju

27、nitreport>检查表junit的使用并不很难，然而要书写一个好的TestCase却并非易事。一个不好的TestCase往往是既浪费了时间，也起不了实际的作用。相反，一个好的TestCase，不仅可以很好的指出代码中存在的问题，而且也可以作为代码更准确的文档，同时还在持续集成的过程中起非常重要的作用。在此给出书写TestCase时需要注意的几点：-          测试的独立性：一次只测试一个对象，方便定位出错的位置。这有2层意思：一个TestCase，只测试一个对象；一个TestMethod

28、，只测试这个对象中的一个方法。-          给测试方法一个合适的名字。-          在assert函数中给出失败的原因，如：assertTrue( “ should be true”, )，方便查错。在这个例子中，如果无法通过assertTrue，那么给出的消息将被显示。在junit中每个assert函数都有第一个参数是出错时显示消息的函数原型。-    

29、60;     测试所有可能引起失败的地方，如：一个类中频繁改动的函数。对于那些仅仅只含有getter/setter的类，如果是由IDE（如Eclipse）产生的，则可不测；如果是人工写，那么最好测试一下。-          在setUp和tearDown中的代码不应该是与测试方法相关的，而应该是全局相关的。如针对与测试方法A和B，在setUp和tearDown中的代码应该是A和B都需要的代码。-     

30、0;    测试代码的组织：相同的包，不同的目录。这样，测试代码可以访问被测试类的protected变量/方法，方便测试代码的编写。放在不同的目录，则方便了测试代码的管理以及代码的打包和发布。一个例子如下：src <=源代码根目录 |-com |-mod1 |-class1junit <=测试代码根目录 |-com |-mod1 |-class1JUnit 4快速入门JUnit 4是JUnit框架有史以来的最大改进，其主要目标便是利用Java 5的Annotation特性简化测试用例的编写。让我们看看如何使用JUnit 4来进行Unit测试。

31、请注意：本文主要介绍JUnit 4的最新特性和用法，并不会讲解Unit测试的基础。如果你对JUnit框架还不熟悉，请先参考“在Eclipse中使用JUnit”一文，学习如何编写JUnit测试。我们使用的开发环境是Eclipse 3.2，它已经自带了JUnit 4.1，你需要将JUnit 4 Library添加到项目用到的Library中。另外，必须使用JDK 5.0或更高版本。要在Eclipse环境之外运行JUnit，需要下载JUnit 4.1，具体请访问JUnit.org。我们先看一个简单的Math类：package com.crackj2ee.junit4;public 

32、;class Math     public int abs(int value)         return value>=0 ? value : (-value);        public int div(int a, int

33、0;b)         return a / b;        /*     * BUG: if b less than 0!     */    public float e

34、xp(int a, int b)         float r = 1;        for(int i=0; i<b; i+)            r = r * a

35、;        return r;    注意exp()方法是有Bug的，如果传入参数2, -1，则期待的返回值应为0.5F，但实际返回值为1.0F。下面我们看看传统的JUnit的TestCase：public class MathTest extends TestCase     public void setUp()  super.

36、setUp();     public void tearDown()  super.tearDown();     public void testAbs()  assertTrue(true);     public void testDiv() .    public void

37、60;testExp() .JUnit依赖反射来执行每个以test开头的方法。然而，在最新的JUnit 4中，由于有了Annotation的支持，我们的测试方法不需要再以testXxx标识了，而是写上一个Test标注即可。例如：Test public void doAbs() .甚至MathTest类也不必继承自TestCase。你也许会想到，不继承自TestCase就无法调用assertXxx方法了，正因为如此，所有的assertXxx方法全部以静态方法被放入了Assert类，使用Assert.assertXxx()调用。如果使用import

38、 static org.junit.Assert.*;则原有的代码不必改动。setUp()和tearDown()方法也依赖Before和After标记，这样做的最大的好处是在继承体系内不必担心忘记了在setUp()方法中调用父类的super.setUp()方法，JUnit框架会自动处理父类的Before和After标记的方法。并且，JUnit框架对Before和After的调用顺序类似于类的构造方法和析构方法，即Before按照父类到子类的顺序调用，After则相反，这样保证了资源的正确获取和释放。当然，不再强迫必须使用setUp和tearDown作为方法名，可以使用更有意

39、义的方法名，例如：initDatabase()和closeDatabase()，只要它们被标注了Before和After即可。来看看使用Annotation的MathTest：package com.crackj2ee.junit4;import static org.junit.Assert.*;import org.junit.*;public class MathTest     public MathTest()    

40、0;    System.out.println("new MathTest instance.");        Before    public void setUp() throws Exception         System.out.println(&q

41、uot;call Before before a test method");        After    public void tearDown() throws Exception         System.out.println("call After&

42、#160;after a test method");        Test    public void doAbs()         Math math = new Math();        ass

43、ertEquals(200, math.abs(200);        assertEquals(100, math.abs(-100);        assertEquals(0, math.abs(0);        Test    public void d

44、oDiv()         Math math = new Math();        assertEquals(5, math.div(100, 20);        assertEquals(4, math.div(100, 21);  &

45、#160;     Test(expected=ArithmeticException.class)    public void doDiv0()         new Math().div(127, 0);        Test(timeout=1)   

46、60;public void doLongTimeTask()         double d = 0;        for(int i=1; i<10000000; i+)            d+=i; 

47、       Test    public void testExp()         Math math = new Math();        assertEquals(32f, math.exp(2, 5), 0.001

48、f);        assertEquals(1f, math.exp(2, 0), 0.001f);        assertEquals(0.5f, math.exp(2, (-1), 0.001f);    对测试异常，JUnit 4可以用expected=Exception.class来期待一个预期的异常，而不必编写try&#

49、160;  .  fail("No exception");catch(Exception e)   / OK!来看看doDiv0测试，我们期待一个除数为0的ArithmeticException，因此编写如下测试方法：Test(expected=ArithmeticException.class)public void doDiv0()     new Math().div(127, 

50、0);对于非常耗时的测试，Test还有一个timeout来标识该方法最长执行时间，超过此时间即表示该测试方法失败：Test(timeout=1)public void doLongTimeTask()     double d = 0;    for(int i=1; i<10000000; i+)        d+=i;以上方法若执行时间

51、超过1ms则测试失败，由于依赖CPU的执行速度，在不同的机器上测试结果也不同。JUnit 4另一个较大的变化是引入了BeforeClass和AfterClass，它们在一个Test类的所有测试方法执行前后各执行一次。这是为了能在BeforeClass中初始化一些昂贵的资源，例如数据库连接，然后执行所有的测试方法，最后在AfterClass中释放资源。正如你能想到的，由于BeforeClass和AfterClass仅执行一次，因此它们只能标记静态方法，在所有测试方法中共享的资源也必须是静态引用：private static Object dbConnection;B

52、eforeClasspublic static void setUpBeforeClass() throws Exception     System.out.println("call BeforeClass and init database connection");    dbConnection = new Object();AfterClassp

53、ublic static void tearDownAfterClass() throws Exception     System.out.println("call AfterClass to release database connection");    dbConnection = null;最后执行测试用例，可以看到结果：各个方法执行顺序如下：call

54、BeforeClass and init database connectionnew MathTest instance.call Before before a test methodcall After after a test methodnew MathTest instance.call Before before a test methodcall After after a test method.call AfterClass to release database connection可以看到，BeforeClass是在实例化MathTest之前调用的，因此不能在构造方法中

55、初始化共享资源。最后需要注意的是由于Java 5的自动Box/Unbox特性，在调用assertEquals()时要特别注意，如果你传入：assertEquals(100F, 100);则按照自动Box变为：assertEquals(new Float(100F), new Integer(100);测试失败，因为Float类和Integer类不是同一类型。因此要特别注意float和double的测试。事实上对float和double应使用assertEquals(float, float, float delta);assertEquals(double, double, double de

56、lta);delta指定了两个作比较的浮点数的相差范围，在此范围内的两个浮点数将认为相等。可以传入一个很小的数例如0.0001F。 JUnit 4非常适合使用Java 5的开发人员，但是无法在Java 1.4中获得这些好处，并且，也不与以前的版本兼容。因此，如果你正在使用Java 5，就可以考虑使用JUnit 4来编写测试。全面认识JUnit 4的新特征提要 本文将向你介绍如何实现从JUnit 3.8向JUnit 4的迁移。同时，还讨论JUnit 4中的一些新特征，特别包括对注解的使用；最后，简要介绍这个新版本的IDE集成现状。一、 引言在本文开始，我将假定，你已经了解由Kent B

57、eck和Erich Gamma发明的这个Java单元测试框架并因此而略过必要的简介。所以，我将集中分析从JUnit 3.8到最新版本-JUnit 4的迁移过程以及其在IDE和Ant中的集成。JUnit 4是一种与其之前的版本完全不同的API，它根据Java 5.0中的新特征(注解，静态导入等)构建而成。如你所见，JUnit 4更简单、更丰富和更易于使用，而且它引入了更为灵活的初始化和清理工作，还有限时的和参数化测试用例。 代码实例最能说明问题。因此，在本文中，我将使用一个例子来展示不同的测试用例：一个计算器。该示例计算器很简单，效率并不高，甚至还有一些错误；它仅仅操作整数，并且把结果存储在一个

58、静态变量中。Substract方法并不返回一个有效的结果，而且也没有实现乘法运算，而且看上去在squareRoot方法中还存在一个错误：无限循环。这些错误将帮助说明使用JUnit 4进行测试的有效性。你可以打开和关闭这个计算器，而且你可以清除这些结果。下面是其实现代码：package calc;public class Calculator private static int result; /存储结果的静态变量public void add(int n) result = result + n;public void substract(int n) result = result - 1

59、; /错误：应该是"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 (; ;) ; /错误：无限循环public void clear() /清除结果result = 0;public void switchOn() /打开屏幕，显示"hello"，并报警re

60、sult = 0; /实现其它的计算器功能public void switchOff() /显示"bye bye"，报警，并关闭屏幕public int getResult() return result;二、 迁移一个测试类现在，我将把一个已经使用JUnit 3.8编写成的简单的测试类迁移到JUnit 4。这个类有一些缺陷：它没有测试所有的业务方法，而且看上去在testDivide方法中还存在一个错误(8/2不等于5)。因为还没有实现乘法运算功能，所以对其测试将被忽略。下面，我们把两个版本的框架之间的差别以粗体显示出现于表格1中。表格1.分别以JUnit 3.8和JUni

61、t 4实现的CaculatorTest。JUnit 3.8 package junit3;import calc.Calculator;import junit.framework.TestCase;public class CalculatorTest extends TestCase private static Calculator calculator = new Calculator();Override protected void setUp() calculator.clear(); public void testAdd() calculator.add(1); calcul

62、ator.add(1); assertEquals(calculator.getResult()， 2);public void testSubtract() calculator.add(10); calculator.subtract(2);assertEquals(calculator.getResult()， 8);public void testDivide() calculator.add(8);calculator.divide(2);assert calculator.getResult() = 5;public void testDivideByZero() try calc

63、ulator.divide(0);fail();catch (ArithmeticException e) public void notReadyYetTestMultiply() calculator.add(10);calculator.multiply(10);assertEquals(calculator.getResult()， 100);JUnit 4package JUnit 4; import calc.Calculator;import org.junit.Before;import org.junit.Ignore;import org.junit.Test;import

64、 static org.junit.Assert.*;public class CalculatorTest private static Calculator calculator = new Calculator();Before public void clearCalculator() calculator.clear();Test public void add() calculator.add(1); calculator.add(1);assertEquals(calculator.getResult()， 2);Test public void subtract() calcu

65、lator.add(10);calculator.subtract(2);assertEquals(calculator.getResult()， 8);Test public void divide() calculator.add(8);calculator.divide(2);assert calculator.getResult() = 5;Test(expected = ArithmeticException.class)public void divideByZero() calculator.divide(0);Ignore("not ready yet")T

66、est public void multiply() calculator.add(10);calculator.multiply(10);assertEquals(calculator.getResult()， 100);三、 包首先，你可以看到，JUnit 4使用org.junit.*包而JUnit 3.8使用的是junit.framework.*。当然，为了向后兼容性起见，JUnit 4jar文件发行中加入了这两种包。四、 继承在中，测试类不必再扩展junit.framework.TestCase；事实上，它们不必须扩展任何内容。但是，JUnit 4中使用的是注解。为了以一个测试用例方式

67、执行，一个JUnit 4类中至少需要一个Test注解。例如，如果你仅使用Before和After注解而没有至少提供一个Test方法来编写一个类，那么，当你试图执行它时将得到一个错误：java.lang.Exception: No runnable methods. 五、 断言（Assert）方法因为在JUnit 4中一个测试类并不继承自TestCase(在JUnit 3.8中，这个类中定义了assertEquals()方法)，所以你必须使用前缀语法(举例来说，Assert.assertEquals()或者（由于JDK5.0）静态地导入Assert类。这样以来，你就可以完全象以前一样使用asse

68、rtEquals方法(举例来说，assertEquals()。另外，在JUnit 4中，还引入了两个新的断言方法，它们专门用于数组对象的比较。如果两个数组包含的元素都相等，那么这两个数组就是相等的。public static void assertEquals(String message， Object expecteds， Object actuals);public static void assertEquals(Object expecteds， Object actuals);由于JDK 5.0的自动装箱机制的出现，原先的个assertEquals方法全部去掉了。例如，原先JUni

69、t 3.8中的assertEquals(long，long)方法在JUnit 4中要使用assertEquals(Object，Object)。对于assertEquals(byte，byte)、assertEquals(int，int)等也是这样。这种改进将有助于避免反模式。在JUnit 4中，新集成了一个assert关键字(见我们的例子中的divide()方法)。你可以象使用assertEquals方法一样来使用它，因为它们都抛出相同的异常(java.lang.AssertionError)。JUnit 3.8的assertEquals将抛出一个junit.framework.Assert

70、ionFailedError。注意，当使用assert时，你必须指定Java的"-ea"参数；否则，断言将被忽略。六、 预设环境（Fixture）Fixture是在测试期间初始化和释放任何普通对象的方法。在JUnit 3.8中，你要使用setUp()来实现运行每一个测试前的初始化工作，然后使用tearDown()来进行每个测试后的清理。这两个方法在TestCase类中都得到重载，因此都被唯一定义。注意，我在这个Setup方法使用的是Java5.0内置的Override注解-这个注解指示该方法声明要重载在超类中的方法声明。在JUnit 4中，则代之使用的是Before和Aft

71、er注解；而且，可以以任何命名(在我们的例子中是clearCalculator()来调用这些方法。在本文后面，我将更多地解释这些注解。七、 测试JUnit 3.8通过分析它的签名来识别一个测试方法：方法名必须以"test"为前缀，它必须返回void，而且它必须没有任何参数(举例来说，publicvoidtestDivide()。一个不遵循这个命名约定的测试方法将被框架简单地忽略，而且不抛出任何异常（指示发生了一个错误）。JUnit 4不使用与JUnit 3.8相同的约定。一个测试方法不必以'test'为前缀，但是要使用Test注解。但是，正如在前一个框架中一

72、样，一个测试方法也必须返回void并且是无参数的。在JUnit 4中，可以在运行时刻控制这个要求，并且不符合要求的话会抛出一个异常：java.lang.Exception: Method xxx should have no parametersjava.lang.Exception: Method xxx should be voidTest注解支持可选参数。它声明一个测试方法应该抛出一个异常。如果它不抛出或者如果它抛出一个与事先声明的不同的异常，那么该测试失败。在我们的例子中，一个整数被零除应该引发一个ArithmeticException异常。八、 忽略一个测试记住，不能执行多个方法。然

73、而，如果你不想让测试失败的话，你可以仅仅忽略它。那么，在JUnit 3.8中，我们是如何实现临时禁止一个测试的呢?方法是：通过注释掉它或者改变命名约定，这样测试运行机就无法找到它。在我的例子中，我使用了方法名notReadyYetTestMultiply()。它没有以"test"开头，所以它不会被识别出来。现在的问题是，在成百上千的测试中间，你可能记不住重命名这个方法。在JUnit 4中，为了忽略一个测试，你可以注释掉一个方法或者删除Test注解(你不能再改变命名约定，否则将抛出一个异常)。然而，该问题将保留：该运行机将不报告这样一个测试。现在，你可以把Ignore注解添加

74、到Test的前面或者后面。测试运行机将报告被忽略的测试的个数，以及运行的测试的数目和运行失败的测试数目。注意，Ignore使用一个可选参数(一个String)，如果你想记录为什么一个测试被忽略的话。九、 运行测试在JUnit 3.8中，你可以选择使用若干运行机：文本型，AWT或者Swing。JUnit 4仅仅使用文本测试运行机。注意，JUnit 4不会显示任何绿色条来通知你测试成功了。如果你想看到任何类型的绿色的话，那么你可能需要使用JUnit扩展或一种集成了JUnit的IDE（例如IDEA或者Eclipse）。首先，我想使用老式但好用的junit.textui.TestRunner来运行该J

75、Unit 3.8测试类(考虑到使用assert关键字，我使用了-ea参数)。java -ea junit.textui.TestRunner junit3.CalculatorTest .F.E.There was 1 error:1) testDivide(junit3.CalculatorTest)java.lang.AssertionErrorat junit3.CalculatorTest.testDivide(CalculatorTest.java:33)There was 1 failure:1) testSubtract(junit3.CalculatorTest)junit.framework.AssertionFailedError: expected:9 but was:8at junit3.CalculatorTest.testSubtract(CalculatorTest.java:27)FAILURES!Tests run: 4， Failures: 1， Errors: 1TestDivide产生一个错误，因为断言确定了8/2不等于5。TestSubstract产生一个失败，因为10-2应该等于8，但是在这个实现中存在一个错误：它返回9。现在，我使用新的org.junit.runner