JUnit 4

zz from http://www.javabeat.net/tips/159-junit-40-example.html

 

 

1)The tests: Unlike in JUnit 3.x 不需要 extend TestCase 来实现 tests. 一个简单的 Java class 可以作为 TestCase. 测试方法可以用org.junit.Test申明  
@Test
public void emptyTest() {
stack = new Stack<String>();
assertTrue(stack.isEmpty());
}

2)Using Assert Methods: In JUnit 4.0 test classes do not inherit from TestCase, as a result, the Assert methods are not available to the test classes. In order to use the Assert methods, you have to use either the prefixed syntax (Assert.assertEquals()) or, use a static import for the Assert class.

import static org.junit.Assert.*;
Now the assert methods may be used directly as done with the previous versions of JUnit.

需要在文件开头的地方import static org.junit.Assert.*； 不然的话就要写成Assert.assertEquals()

 

3)Changes in Assert Methods: The new assertEquals methods use Autoboxing, and hence all the assertEquals(primitive, primitive) methods will be tested as assertEquals(Object, Object). This may lead to some interesting results. For example autoboxing will convert all numbers to the Integer class, so an Integer(10) may not be equal to Long(10). This has to be considered when writing tests for arithmetic methods. For example, the following Calc class and it's corresponding test CalcTest will give you an error.

public class Calc {
public long add(int a, int b) {
return a+b;
}
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalcTest {
@Test
public void testAdd() {
assertEquals(5, new Calc().add(2, 3));
}
}
You will end up with the following error.

java.lang.AssertionError: expected:<5> but was:<5>
This is due to autoboxing. By default all the integers are cast to Integer, but we were expecting long here. Hence the error. In order to overcome this problem, it is better if you type cast the first parameter in the assertEquals to the appropriate return type for the tested method as follows

assertEquals((long)5, new Calc().add(2, 3));

 

assertEquals不仅仅是比较数值，还会比较类型

There are also a couple of methods for comparing Arrays

public static void assertEquals(String message, Object[] expecteds, Object[] actuals);
public static void assertEquals(Object[] expecteds, Object[] actuals);

assertEquals还能比较数组

4)Setup and TearDown: You need not have to create setup and teardown methods for setup and teardown. The @Before, @After and @BeforeClass, @AfterClass annotations are used for implementing setup and teardown operations. The @Before and @BeforeClass methods are run before running the tests. The @After and @AfterClass methods are run after the tests are run. The only difference being that the @Before and @After can be used for multiple methods in a class, but the @BeforeClass and @AfterClass can be used only once per class.

@Before and @BeforeClass会在测试之前跑. The @After and @AfterClass会在测试之后跑。@BeforeClass 和 @AfterClass每个类只跑一次

5)Parameterized Tests: JUnit 4.0 comes with another special runner: Parameterized, which allows you to run the same test with different data. For example, in the the following peice of code will imply that the tests will run four times, with the parameter "number" changed each time to the value in the array.

@RunWith(value = Parameterized.class)
public class StackTest {
Stack<Integer> stack;
private int number;

public StackTest(int number) {
this.number = number;
}

@Parameters
public static Collection data() {
Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
return Arrays.asList(data);
}
...
}
The requirement for parameterized tests is to
Have the annotation @RunWith for the Test Class
Have a public static method that returns a Collection for data. Each element of the collection must be an Array of the various paramters used for the test.
You will also need a public constructor that uses the parameters
参数化测试

要求：

•  @Parameters 标注的public static方法，返回值为 Collection。 Collection的元素必须是Array
•  @RunWith 申明这个类是参数化测试的（貌似不是必须）
•  这个类有一个public 的构造函数（Constructor）

 

 

6)Test Suites: In JUnit 3.8 you had to add a suite() method to your classes, to run all tests as a suite. With JUnit 4.0 you use annotations instead. To run the CalculatorTest and SquareTest you write an empty class with @RunWith and @Suite annotations.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({StackTest.class})
public class AllTests {
}
The "Suite" class takes SuiteClasses as argument which is a list of all the classes that can be run in the suite.
The following is a listing of the example StackTest used in the post.

package tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import java.util.Collection;
import java.util.EmptyStackException;
import java.util.Stack;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(value = Parameterized.class)
public class StackTest {
Stack<Integer> stack;

private int number;

public StackTest(int number) {
this.number = number;
}

@Parameters
public static Collection data() {
Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
return Arrays.asList(data);
}

@Before
public void noSetup() {
stack = new Stack<Integer>();
}

@After
public void noTearDown() {
stack = null;
}

@Test
public void pushTest() {
stack.push(number);
assertEquals(stack.peek(), number);

}

@Test
public void popTest() {
}

@Test(expected = EmptyStackException.class)
public void peekTest() {
stack = new Stack<Integer>();
stack.peek();
}

@Test
public void emptyTest() {
stack = new Stack<Integer>();
assertTrue(stack.isEmpty());
}

@Test
public void searchTest() {
}
}