Junit入门和基本运行结构分析
The test code must be written to do a few things:
一、测试流程：
1） Setup all conditions needed for testing (create any re-quired objects, allocate any needed resources, etc.)
初始化资源
2） Call the method to be tested
调用方法开始测试
3） Verify that the method to be tested functioned as ex-Pected
验证被测试方法是否按期望方式运行
4） Clean up after itself
完成测试后自行清理资源
下面让以上述为依据看看testCase的源代码：
public abstract class TestCase extends Assert implements Test {
/**
* the name of the test case测试用例名称
*/
private String fName;
/**
* No-arg constructor to enable serialization. This method 构造函数
* is not intended to be used by mere mortals without calling setName().
*/
public TestCase() {
fName= null;
}
/**
* Constructs a test case with the given name.构造函数
*/
public TestCase(String name) {
fName= name;
}
/**
* Counts the number of test cases executed by run(TestResult result).记录测试用例数目
*/
public int countTestCases() {
return 1;
}
/**
* Creates a default TestResult object//创建默认TestResult对象，里面存储测试结果
*
* @see TestResult
*/
protected TestResult createResult() {
return new TestResult();
}
/**
* A convenience method to run this test, collecting the results with a
* default TestResult object.执行测试很简易的方法，使用默认的TestResult
*
* @see TestResult
*/
public TestResult run() {
TestResult result= createResult();
run(result);
return result;
}
/**
* Runs the test case and collects the results in TestResult.执行测试并把手机测试结果信息存入指定TestResult
*/
public void run(TestResult result) {
result.run(this);
}
/**
* Runs the bare test sequence. 执行测试方法，包括初始化和销毁方法
* @throws Throwable if any exception is thrown
*/
public void runBare() throws Throwable {
Throwable exception= null;
setUp();
try {
runTest();
} catch (Throwable running) {
exception= running;
}
finally {
try {
tearDown();
} catch (Throwable tearingDown) {
if (exception == null) exception= tearingDown;
}
}
if (exception != null) throw exception;
}
/**
* Override to run the test and assert its state. 执行测试方法
* @throws Throwable if any exception is thrown
*/
protected void runTest() throws Throwable {
assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
Method runMethod= null;
try {
// use getMethod to get all public inherited
// methods. getDeclaredMethods returns all
// methods of this class but excludes the
// inherited ones.
runMethod= getClass().getMethod(fName, (Class[])null);
} catch (NoSuchMethodException e) {
fail("Method \""+fName+"\" not found");
}
if (!Modifier.isPublic(runMethod.getModifiers())) {
fail("Method \""+fName+"\" should be public");
}
try {
runMethod.invoke(this);
}
catch (InvocationTargetException e) {
e.fillInStackTrace();
throw e.getTargetException();
}
catch (IllegalAccessException e) {
e.fillInStackTrace();
throw e;
}
}
/**
* Sets up the fixture, for example, open a network connection.
* This method is called before a test is executed. 测试前的初始化方法
*/
protected void setUp() throws Exception {
}
/**
* Tears down the fixture, for example, close a network connection.
* This method is called after a test is executed. 测试后的销毁方法
*/
protected void tearDown() throws Exception {
}
/**
* Returns a string representation of the test case
*/
@Override
public String toString() {
return getName() + "(" + getClass().getName() + ")";
}
/**
* Gets the name of a TestCase返回测试案例的名称
* @return the name of the TestCase
*/
public String getName() {
return fName;
}
/**
* Sets the name of a TestCase设定测试案例的名称
* @param name the name to set
*/
public void setName(String name) {
fName= name;
}
}
二、运行方式：
您定义自己的TestCase，并使用TestRunner来运行测试，事实上TestRunner并不直接运行 TestCase上的单元方法，而是透过TestSuite，TestSuite可以将数个TestCase在一起，而让每个TestCase保持简单。
public class SimpleTest extends TestCase {
protected int fValue1;
protected int fValue2;
SimpleTest(String name){
super(name);
}
@Override
protected void setUp() {
fValue1= 2;
fValue2= 3;
}
public void testAdd() {
double result= fValue1 + fValue2;
// forced failure result == 5
assertTrue(result == 6);
}
public void testDivideByZero() {
int zero= 0;
int result= 8/zero;
result++; // avoid warning for not using result
}
public void testEquals() {
assertEquals(12, 12);
assertEquals(12L, 12L);
assertEquals(new Long(12), new Long(12));
assertEquals("Size", 12, 13);
assertEquals("Capacity", 12.0, 11.99, 0.0);
}
public static void main (String[] args) {
junit.textui.TestRunner.run(suite());
}
}
在这个例子中，您并没有看到任何的TestSuite，事实上，如果您没有提供任何的TestSuite，TestRunner会自己建立一个，然后这个 TestSuite会使用反射（reflection）自动找出testXXX()方法。
如果您要自行生成TestSuite，则在继承TestCase之后，提供静态的（static）的suite()方法，例如：
public static Test suite() {
/*
* the type safe way
**/
TestSuite suite= new TestSuite();
suite.addTest(
new SimpleTest("add") {
@Override
protected void runTest() { testAdd(); }
}
);
suite.addTest(
new SimpleTest("testDivideByZero") {
@Override
protected void runTest() { testDivideByZero(); }
}
);
return suite;
/*
* the dynamic way
*/
//return new TestSuite(SimpleTest.class);
}
JUnit并没有规定您一定要使用testXXX()这样的方式来命名您的测试方法，如果您要提供自己的方法（当然JUnit 鼓励您使用testXXX()这样的方法名称），则可以如上撰写，为了要能够使用建构函式提供测试方法名称，您的TestCase必须提供如下的建构函式：
public SimpleTest (String testMethod) {
super(testMethod);
}
如果要加入更多的测试方法，使用addTest()就可以了，suite()方法传回一个TestSuite物件，它与 TestCase都实作了Test介面，TestRunner会调用TestSuite上的run()方法，然后TestSuite会将之委託给 TestCase上的run()方法，并执行每一个testXXX()方法。
除了组合TestCase之外，您还可以将数个TestSuite组合在一起，例如：
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTestSuite(TestCase1.class);
suite.addTestSuite(TestCase2.class);
return suite;
}
如此之来，您可以一次运行所有的测试，而不必个别的运行每一个测试案例，您可以写一个运行全部测试的主测试，而在使用TestRunner时呼叫 suite()方法，例如：
junit.textui.TestRunner.run(TestAll.suite());
TestCase与TestSuite都实作了Test介面，其运行方式为 Command 模式 的一个实例，而TestSuite可以组合数个TestSuite或TestCase，这是 Composite 模式的一个实例。
三、失败和错误的区别
通常情况下是不希望自己编写的Java代码抛出错误的，而只应该抛出异常。通常来说，应该让Java虚拟机本身来抛出错误。因为一个错误意味着低级别的、不可恢复的问题，例如：无法装载一个类，这种问题我们也不期望被恢复。出于这个原因，也许我们对JUnit通过抛出错误来表示一个断言的失败而感到有些奇怪。
JUnit抛出的是错误而不是异常，这是因为在Java中，错误是不需要检查的；因此，不是每个方法都必须声明它会抛出哪些错误。你可能会认为RuntimeException可以完成相同的功能，但是如果JUnit抛出这种在产品代码中可能抛出的异常的类型，JUnit测试就会和你的产品相互影响。这种影响会降低JUnit的价值。
当你的测试包含了一个失败的断言，JUnit会将它算做一个失败的测试；但是如果你的测试抛出了一个异常（并且没有捕获它），JUnit将它看成是一个错误。这个区别是很细微的，却是非常有用的：一个失败的断言通常表示产品代码中有问题，而一个错误却表示测试本身或周围的环境存在着问题。也许你的测试期望了一个不该期望的错误的异常对象，或者错误地在一个null的应用上调用了一个函数。也有可能磁盘已经满了，或者网络连接不可用，或者是一个文件找不到了。JUnit并不把这个算做产品代码的缺陷，因此它只是在表达，“有些不对劲了。我不能分辨这个测试是否通过。请解决这个问题并再重新测试一次。”这就是失败和错误的区别。
JUnit的测试运行器会报告一个测试运行的结果，格式如下：“78 run, 2 failures,1 error。”从这个结果可以判断有75个测试已经通过，有两个失败，还有一个没有结论。我们的建议是先去调查那个错误，解决了此问题以后再重新运行这个测试。也许在解决了这个错误以后，所有的测试都通过了！