转载 2007年09月17日 16:46:00

Gunjan Doshi
Instrumental Services Inc.

Download the PDF Version of this article.

Abstract: JUnit needs no introduction. Originally written by Kent Beck and Erich Gamma, the software is the preferred tool of choice for developer testing. Now, the team of Kent Beck and Erich Gamma is back again with a new version of JUnit – 4.0. This quick reference guide is for programmers and testers looking to migrate to JUnit 4.0. If you have a flight to catch or do not want to spend 10 minutes going through the guide, just jump to the summary section and you will learn enough.

For the purpose of this article, I will call JUnit 3.8.1 and its predecessors as the old JUnit and JUnit 4.0 as the new JUnit.

Table of contents:

This guide contains the following sections:

·         Old JUnit revisited

·         Cut the chase to JUnit 4.0

·         Run the tests

·         Set up and tear down

·         One-time set up and tear down

·         Expecting exceptions

·         Other Annotations

o        Ignoring a test

o        Timing out a test

·         Summary

Old JUnit revisited

Using the old JUnit, let us write a test, which verifies the availability of a book in the library.

To summarize the steps:

·         We extend from junit.framework.TestCase.

·         We name the test methods with a prefix of ‘test’.

·         We validate conditions using one of the several assert methods.

Cut the chase to JUnit 4.0

Let us write the same test using JUnit 4.0.

When I upgrade to a new version I look for tasks, I do not have to do anymore. Here is the same code with notes telling us what not to do anymore.

To summarize:

·         We do not extend from junit.framework.TestCase.

·         We do not prefix the test method with ‘test’.

Next, I look for new tasks I must always do. The diagram below summarizes what we must do according to the new JUnit standards:

To summarize:

·         Use a normal class and not extend from junit.framework.TestCase.

·         Use the Test annotation to mark a method as a test method. To use the Test annotation, we need to import org.junit.Test

·         Use one of the assert methods. There is no difference between the old assert methods and the new assert methods. An easy way to use the assert method is to do a static import as shown by point 2 in the code above.

·         Run the test using JUnit4TestAdapter. If you want to learn more about JUnit4TestAdapter, keep reading ahead.

Run the tests

Unfortunately, our favorite development environments are still unaware of JUnit 4. JUnit4Adapter enables compatibility with the old runners so that the new JUnit 4 tests can be run with the old runners. The suite method in the diagram above illustrates the use of JUnit4Adapter.

Alternatively, you can use the JUnitCore class in the org.junit.runner package. JUnit 4 runner can also run tests written using the old JUnit. To run the tests using the JUnitCore class via the command line, type:

java org.junit.runner.JUnitCore LibraryTest

Set up and tear down

The new JUnit provides two new annotations for set up and tear down:

·         @Before: Method annotated with @Before executes before every test.

·         @After: Method annotated with @After executes after every test.

Here is the code that demonstrates the use of @Before and @After:

Two features of @Before and @After annotations that are helpful to learn:

·         You can have any number of @Before and @After as you need.

·         It is possible to inherit the @Before and @After methods. New JUnit executes @Before methods in superclass before the inherited @Before methods. @After methods in subclasses are executed before the inherited @After methods.

One-time set up and tear down

The new JUnit4 provides @BeforeClass and @AfterClass annotations for one-time set up and tear down. This is similar to the TestSetup class in the old junit.extensions package, which ran setup code once before all the tests and cleanup code once after all the tests.

Here is the code that demonstrates @BeforeClass and @AfterClass:

Unlike @Before and @After annotations, only one set of @BeforeClass and @AfterClass annotations are allowed.

Expecting exceptions

The new JUnit makes checking for exceptions very easy. The @Test annotation takes a parameter, which declares the type of Exception that should be thrown. The code below demonstrates this:

In the code above, bookNotAvailableInLibrary is a test, which passes only if BookNotAvailableException is thrown. The test fails if no exception is thrown. Test also fails if a different exception is thrown.

Other Annotations

Ignoring a test

The @Ignore annotation tells the runner to ignore the test and report that it was not run. You can pass in a string as a parameter to @Ignore annotation that explains why the test was ignored. E.g. The new JUnit will not run a test method annotated with @Ignore(“Database is down”) but will only report it. The version of JUnit4Adapter, I used, did not work with @Ignore annotation. Kent Beck has informed me that the next version of JUnitAdapter will fix this problem.

Timing out a test

You can pass in a timeout parameter to the test annotation to specify the timeout period in milliseconds. If the test takes more, it fails. E.g. A method annotated with @Test (timeout=10) fails if it takes more than 10 milliseconds.

Finally, I would like to thank Kent Beck for taking the time to demonstrate and teach the new JUnit to me.


To summarize the new JUnit style:

  1. It Requires JDK 5 to run.
  2. Test classes do not have to extend from junit.framework.TestCase.
  3. Test methods do not have to be prefixed with ‘test’.
  4. There is no difference between the old assert methods and the new assert methods.
  5. Use @Test annotations to mark a method as a test case.
  6. @Before and @After annotations take care of set up and tear down.
  7. @BeforeClass and @AfterClass annotations take care of one time set up and one time tear down.
  8. @Test annotations can take a parameter for timeout. Test fails if the test takes more time to execute.
  9. @Test annotations can take a parameter that declares the type of exception to be thrown.
  10. JUnit4Adapter enables running the new JUnit4 tests using the old JUnit runners.
  11. Old JUnit tests can be run in the new JUnit4 runner.


1.  概念   首先,枚举并不是一种新技术,而是一种基础数据类型.它隶属于两种基础类型中的值类型,如下:     2.  为什么要有枚举   枚举在真正的开发中是非常常用的,它的作用很简单...
  • wang379275614
  • wang379275614
  • 2014年09月29日 01:11
  • 1596


Java5: 1、泛型 Generics:         引用泛型之后,允许指定集合里元素的类型,免去了强制类型转换,并且能在编译时刻进行类型检查的好处。         Parame...
  • samjustin1
  • samjustin1
  • 2016年08月21日 16:36
  • 12391


Jdk5.0新特性: Collection在jdk1.5以后,有了一个父接口Iterable,这个接口的出现的将iterator方法进行抽取,提高了扩展性。 -------------------...
  • Happy_wu
  • Happy_wu
  • 2016年06月02日 20:36
  • 1218


Java5: 1、泛型 Generics:         引用泛型之后,允许指定集合里元素的类型,免去了强制类型转换,并且能在编译时刻进行类型检查的好处。         Parameterized...
  • qq_30641447
  • qq_30641447
  • 2015年11月15日 21:58
  • 8382

JAVA5 线程新特性

1.阻塞队列: BlockingQueue,zhog
  • oZaCao1
  • oZaCao1
  • 2014年10月05日 21:08
  • 270


jdk1.5之后的新特性:       泛型       枚举       静态导入       自动拆箱装箱       增强for循环        可变参数...
  • u010918487
  • u010918487
  • 2015年09月20日 00:58
  • 486


常见的名词: IDE:(集成开发环境)Integrated DevelopmentEnvironmentMyEclipse 快捷键的模块设置 window->java->editor->templa...
  • u012173245
  • u012173245
  • 2015年02月28日 22:20
  • 504


  • u013575441
  • u013575441
  • 2015年05月31日 22:55
  • 412

java5 多线程新特性

package com.main.thread; import java.util.concurrent.Callable; import java.util.concurrent.Completi...
  • wwwyuanliang10000
  • wwwyuanliang10000
  • 2014年07月23日 09:48
  • 590


  • u013575441
  • u013575441
  • 2015年05月31日 22:42
  • 627