JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）。Junit测试是程序员测试，即白盒测试。该项目主页:[url]http://www.junit.org/[/url]
 
JUnit测试骨架
使用JUnit时，主要都是通过继承TestCase类别来撰写测试用例，使用testXXX()名称来撰写单元测试。
用JUnit写测试真正所需要的就三件事：
1．  一个import语句引入所有junit.framework.*下的类。
2．  一个extends语句让你的类从TestCase继承。
3．  一个调用super(string)的构造函数。
功能类MathTool
package com.zj.c01;
 
public class MathTool {
    public static int gcd(int num1, int num2) {
       int r = 0;
       while (num2 != 0) {
           r = num1 % num2;
           num1 = num2;
           num2 = r;
       }
       return num1;
    }
}
测试类MathToolTest
package com.zj.c01;
import junit.framework.TestCase;
 
public class MathToolTest extends TestCase {
    public MathToolTest(String name) {
       super(name);
    }
 
    public void testGcd() {
       assertEquals(5, MathTool.gcd(10, 5));
    }
}
使用Eclipse-Run As JUnit Test
在运行TestRunner执行测试时，你会发现到有Failure与Error两种测试尚未通过的信息。
Failure指的是预期的结果与实际运行单元的结果不同所导致，例如当使用assertEquals()或其它assertXXX()方法断言失败时，就会回报Failure，这时候要检查你的单元方法中的逻辑设计是否有误。
Error指的是你的程序没有考虑到的情况，在断言之前程序就因为某种错误引发例外而终止，例如在单元中存取某个数组，因为存取超出索引而引发 ArrayIndexOutOfBoundsException，这会使得单元方法无法正确完成，在测试运行到asertXXXX()前就提前结束，这时候要检查你的单元方法中是否有未考虑到的情况而引发流程突然中断。
 
JUnit的各种断言
JUnit提供了一些辅助函数，用于帮助你确定某个被测试函数是否工作正常。通常而言，我们把所有这些函数统称为断言。断言是单元测试最基本的组成部分。
1. assertEquals([String message], expected,actual)
比较两个基本类型或对象是否相等（expected和actual是原始类型数值(primitive value)或者必须为实现比较而具有equal方法）；
2.assertFalse([String message],boolean condition)
对布尔值求值，看它是否为“真“；
3.assertTrue([String message],boolean condition)
对布尔值求值，看它是否为“假“；
4.assertNull([String message],java.lang.Object object)
检查对象是否为“空“；
5.assertNotNull([String message],java.lang.Object object)
检查对象是否不为“空”；
6.assertSame([String message],expected,actual)
检查两个对象是否为同一实例；
7.assertNotSame([String message],expected,actual)
检查两个对象是否不为同一实例；
8. fail( String message )
使测试立即失败，其中 message 参数使可选的。这种断言通常被用于标记某个不应该到达的分支（例如，在一个预期发生的异常之后）
 
一个TestCase测试实例
下面是一个数字功能类，它提供了求最大值函数和求最小值函数：
package com.zj.c01;
 
public class NumberTool {
    public static int getMax(int[] arr) {
       int max = Integer.MIN_VALUE;
        if (arr.length == 0)
           throw new RuntimeException("Empty list");
       for (int index = 0; index < arr.length; index++) {
           if (arr[index] > max)
              max = arr[index];
       }
       return max;
    }
 
    public static int getMin(int[] arr) {
       int min = Integer.MAX_VALUE;
       if (arr.length == 0)
           throw new RuntimeException("Empty list");
       for (int i = 0; i < arr.length; i++) {
           if (arr[i] < min)
              min = arr[i];
       }
       return min;
    }
}
下面针对求最大值函数编写测试用例：
1.简单测试：[7,8,9]->9；
2.位序测试：[9,8,7] ->9；[7,9,8] ->9；[8,7,9] ->9；
3.重复值测试：[9,7,9,8] ->9；
4.单值测试：[1]->1；
5.负值测试：[-7,-8,-9]->-7；
6.空值测试：[]->抛出异常；
测试类NumberToolTest：
package com.zj.c01;
import junit.framework.TestCase;
 
public class NumberToolTest extends TestCase {
    public NumberToolTest(String name) {
       super(name);
    }
 
    public void testSimple() {
       assertEquals(9, NumberTool.getMax(new int[] { 7, 8, 9 }));
    }
 
    public void testOrder() {
       assertEquals(9, NumberTool.getMax(new int[] { 9, 8, 7 }));
       assertEquals(9, NumberTool.getMax(new int[] { 7, 9, 8 }));
       assertEquals(9, NumberTool.getMax(new int[] { 8, 7, 9 }));
    }
 
    public void testDups() {
       assertEquals(9, NumberTool.getMax(new int[] { 9, 7, 9, 8 }));
    }
 
    public void testOne() {
       assertEquals(1, NumberTool.getMax(new int[] { 1 }));
    }
 
    public void testNegitave() {
       assertEquals(-7, NumberTool.getMax(new int[] { -7, -8, -9 }));
    }
 
    public void testEmpty() {
       try {
           NumberTool.getMax(new int[] {});
           fail("Should have thrown an exception");
       } catch (RuntimeException e) {
           assertTrue(true);
       }
    }
}
使用Eclipse-Run As JUnit Test
 
JUnit和异常
对于测试而言，下面两种异常是我们可能会感兴趣的：
1．  从测试代码抛出的可预测异常。
2．  由于某个模块（或代码）发生严重错误，而抛出的不可预测异常。
任何对assertTrue(true)的使用都应该被翻译为“我预期控制流程会达到这个地方”。通常而言，对于方法中每个被期望的异常，你都应该写一个专门的测试来确认该方法在应该抛出异常的时候确实会抛出异常。如上例中testEmpty()测试方法的设计。
对于处于出乎意料的异常，你最好简单的改变你的测试方法的声明让它能抛出可能的异常。JUnit框架可以捕获任何异常，并且把它报告为一个错误，这些都不需要你的参与。
 
Per-method的Setup和Tear-down
对于重复出现在各个单元测试中的运行环境，可以集中加以管理，可以在继承TestCase之后，重新定义setUp()与tearDown()方法，将数个单元测试所需要的运行环境在setUp()中创建，并在tearDown()中销毁。
JUnit的TestCase基类提供两个方法供你改写，分别用于环境的建立和清理：
protected void setup();
protected void teardown();
 
测试类MathToolTest2：
package com.zj.c01;
import junit.framework.TestCase;
 
public class NumberToolTest2 extends TestCase {
    private int[] arr;
 
    public NumberToolTest2(String name) {
       super(name);
    }
 
    protected void setUp() throws Exception {
       super.setUp();
       arr = new int[] { -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
    }
 
    protected void tearDown() throws Exception {
       super.tearDown();
       arr = null;
    }
 
    public void testMax() {
       assertEquals(5, NumberTool.getMax(arr));
    }
 
    public void testMin() {
       assertEquals(-5, NumberTool.getMin(arr));
    }
}
 
TestSuite
每一个定义好的TestCase，都使用TestRunner来运行测试，事实上TestRunner并不直接运行TestCase上的单元方法，而是通过TestSuite ，TestSuite可以将数个TestCase组合在一起。
在上面的例子中，并没有看到任何的TestSuite，这是因为TestRunner的run()方法中会建立TestSuite：
static public void run(Class testClass) {
    run(new TestSuite(testClass));
}
在这个TestSuite的建构式中，会使用反射自动找出testXXX()方法，并加入待执行的测试方法， TestRunner的run()方法中会去执行TestSuite上的run()方法，然后TestSuite会将之委托给TestCase上的 run()方法，而该run()方法中执行每一个testXXX()方法。
如果你只想执行某TestCase中的部分测试函数，则可自己构建TestSuite，下面的代码针对NumberToolTest中的两个测试函数testSimple()和testNegitave()进行测试。
package com.zj.c02;
import com.zj.c01.NumberToolTest;
import junit.framework.Test;
import junit.framework.TestSuite;
 
public class PartTest {
    public static Test suite() {
       TestSuite suite = new TestSuite();
       suite.addTest(new NumberToolTest("testSimple"));
       suite.addTest(new NumberToolTest("testNegitave"));
       return suite;
    }
}
使用Eclipse-Run As JUnit Test
你也可以组合多个testCase，下面的代码将MathToolTest和NumberToolTest集中到一个TestSuite中：
package com.zj.c02;
import com.zj.c01.MathToolTest;
import com.zj.c01.NumberToolTest;
import junit.framework.Test;
import junit.framework.TestSuite;
 
public class CompositeTest {
    public static Test suite() {
       TestSuite suite = new TestSuite("Running all tests.");
       suite.addTestSuite(MathToolTest.class);
       suite.addTestSuite(NumberToolTest.class);
       return suite;
    }
}
使用Eclipse-Run As JUnit Test
 
Per-suite Setup和Tear-down
一般而言，你只须针对每个方法设置运行环境；但是在某些情况下，你须为整个test suite设置一些环境，以及在test suite中的所有方法都执行完成后做一些清理工作。要达到这种效果，你需要per-suite setup和per-suite teardown。
Per-suite的setup要复杂一些。你需要提供所需测试的一个suite（无论通过什么样的方式）并且把它包装进一个TestSetup对象。注意你可以在同一个类中同时使用per-sutie和per-test的setup()和teardown。
package com.zj.c02;
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestSuite;
import com.zj.c01.MathToolTest;
import com.zj.c01.NumberToolTest;
 
public class WrapperCompositeTest {
    public static Test suite() {
       TestSuite suite = new TestSuite("Running all tests with env.");
       suite.addTestSuite(MathToolTest.class);
       suite.addTestSuite(NumberToolTest.class);
       TestSetup wrapper = new TestSetup(suite) {
           protected void setUp() {
              doSetUp();
           }
 
           protected void tearDown() {
              doTearDown();
           }
       };
       return wrapper;
    }
 
    public static void doSetUp() {
       // initialization codes
    }
 
    public static void doTearDown() {
       // release codes
    }
}
 
参考资料
[1]单元测试之道Java版——使用Junit, 电子工业出版社
[2]JUnit 学习笔记