&&&&JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）,供Java开发人员编写单元测试之用。
　　Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。
　　Junit本质上是一套框架，即开发者制定了一套条条框框，遵循这此条条框框要求编写测试代码，如继承某个类，实现某个接口，就可以用Junit进行自动测试了。
　　由于Junit相对独立于所编写的代码，可以测试代码的编写可以先于实现代码的编写，XP 中推崇的 test first design的实现有了现成的手段：用Junit写测试代码，写实现代码，运行测试，测试失败，修改实现代码，再运行测试，直到测试成功。以后对代码的修改和优化，运行测试成功，则修改成功。
　　Java 下的 team 开发，采用 cvs(版本控制) + ant(项目管理) + junit(集成测试) 的模式时，通过对ant的配置，可以很简单地实现测试自动化。
　　对不同性质的被测对象，如Class，Jsp，Servlet，Ejb等，Junit有不同的使用技巧，以后慢慢地分别讲叙。以下以Class测试为例讲解，除非特殊说明。
2、下载安装
去Junit主页下载最新版本3.8.1程序包junit-3.8.1.zip
用winzip或unzip将junit-3.8.1.zip解压缩到某一目录名为$JUNITHOME
将junit.jar和$JUNITHOME/junit加入到CLASSPATH中，加入后者只因为测试例程在那个目录下。
注意不要将junit.jar放在jdk的extension目录下
运行命令,结果如右图。
java junit.swingui.TestRunner junit.samples.AllTests
3、Junit架构
　　下面以Money这个类为例进行说明。
public class Money {
private int fA//余额
private String fC//货币类型
public Money(int amount, String currency) {
fCurrency=
public int amount() {
public String currency() {
public Money add(Money m) {//加钱
return new Money(amount()+m.amount(), currency());
public boolean equals(Object anObject) {//判断钱数是否相等
if (anObject instanceof Money) {
Money aMoney= (Money)anO
return aMoney.currency().equals(currency())
&& amount() == aMoney.amount();
　　Junit本身是围绕着两个设计模式来设计的：命令模式和集成模式.
　　利用TestCase定义一个子类，在这个子类中生成一个被测试的对象，编写代码检测某个方法被调用后对象的状态与预期的状态是否一致，进而断言程序代码有没有bug。
　　当这个子类要测试不只一个方法的实现代码时，可以先建立测试基础，让这些测试在同一个基础上运行，一方面可以减少每个测试的初始化，而且可以测试这些不同方法之间的联系。
　　例如，我们要测试Money的Add方法，可以如下:
public class MoneyTest extends TestCase { //TestCase的子类
public void testAdd() { //把测试代码放在testAdd中
Money m12CHF= new Money(12, "CHF"); //本行和下一行进行一些初始化
Money m14CHF= new Money(14, "CHF");
Money expected= new Money(26, "CHF");//预期的结果
Money result= m12CHF.add(m14CHF); //运行被测试的方法
Assert.assertTrue(expected.equals(result)); //判断运行结果是否与预期的相同
　　如果测试一下equals方法，用类似的代码，如下：
public class MoneyTest extends TestCase { //TestCase的子类
public void testEquals() { //把测试代码放在testEquals中
Money m12CHF= new Money(12, "CHF"); //本行和下一行进行一些初始化
Money m14CHF= new Money(14, "CHF");
Assert.assertTrue(!m12CHF.equals(null));//进行不同情况的测试
Assert.assertEquals(m12CHF, m12CHF);
Assert.assertEquals(m12CHF, new Money(12, "CHF")); // (1)
Assert.assertTrue(!m12CHF.equals(m14CHF));
　　当要同时进行测试Add和equals方法时，可以将它们的各自的初始化工作，合并到一起进行，形成测试基础,用setUp初始化，用tearDown清除。如下：
public class MoneyTest extends TestCase {//TestCase的子类
private Money f12CHF;//提取公用的对象
private Money f14CHF;
protected void setUp() {//初始化公用对象
f12CHF= new Money(12, "CHF");
f14CHF= new Money(14, "CHF");
public void testEquals() {//测试equals方法的正确性
Assert.assertTrue(!f12CHF.equals(null));
Assert.assertEquals(f12CHF, f12CHF);
Assert.assertEquals(f12CHF, new Money(12, "CHF"));
Assert.assertTrue(!f12CHF.equals(f14CHF));
public void testSimpleAdd() {//测试add方法的正确性
Money expected= new Money(26, "CHF");
Money result= f12CHF.add(f14CHF);
Assert.assertTrue(expected.equals(result));
　　将以上三个中的任一个TestCase子类代码保存到名为MoneyTest.java的文件里，并在文件首行增加
import junit.framework.*;
，都是可以运行的。关于Junit运行的问题很有意思，下面单独说明。
　　上面为解释概念“测试基础(fixture)”，引入了两个对两个方法的测试。命令模式与集成模式的本质区别是，前者一次只运行一个测试。
　　利用TestSuite可以将一个TestCase子类中所有test***()方法包含进来一起运行，还可将TestSuite子类也包含进来，从而行成了一种等级关系。可以把TestSuite视为一个容器，可以盛放TestCase中的test***()方法，它自己也可以嵌套。这种体系架构，非常类似于现实中程序一步步开发一步步集成的现况。
　　对上面的例子，有代码如下：
public class MoneyTest extends TestCase {//TestCase的子类
public static Test suite() {//静态Test
TestSuite suite= new TestSuite();//生成一个TestSuite
suite.addTest(new MoneyTest("testEquals")); //加入测试方法
suite.addTest(new MoneyTest("testSimpleAdd"));
　　从Junit2.0开始，有列简捷的方法:
public class MoneyTest extends TestCase {//TestCase的子类
public static Test suite() {静态Test
return new TestSuite(MoneyTest.class); //以类为参数
　　TestSuite见嵌套的例子，在后面应用案例中有。
4、测试代码的运行
　　先说最常用的集成模式。
　　测试代码写好以后，可以相应的类中写main方法，用java命令直接运行；也可以不写main方法，用Junit提供的运行器运行。Junit提供了textui,awtui和swingui三种运行器。
　　以前面第2步中的AllTests运行为例，可有四种：
java junit.textui.TestRunner junit.samples.AllTests
java junit.awtui.TestRunner junit.samples.AllTests
java junit.swingui.TestRunner junit.samples.AllTests
java junit.samples.AllTests
　　main方法中一般也都是简单地用Runner调用suite()，当没有main时，TestRunner自己以运行的类为参数生成了一个TestSuite.
　　对于命令模式的运行，有两种方法。
TestCase test= new MoneyTest("simple add") {
public void runTest() {
testSimpleAdd();
TestCase test= new MoneyTest("testSimpleAdd");
　　我试了一下，好象有问题，哪位朋友成功了，请指点我一下。确实可以。
import junit.framework.*;
public class MoneyTest extends TestCase {//TestCase的子类
private Money f12CHF;//提取公用的对象
private Money f14CHF;
public MoneyTest(String name){
super(name);
protected void setUp() {//初始化公用对象
f12CHF= new Money(12, "CHF");
f14CHF= new Money(14, "CHF");
public void testEquals() {//测试equals方法的正确性
Assert.assertTrue(!f12CHF.equals(null));
Assert.assertEquals(f12CHF, f12CHF);
Assert.assertEquals(f12CHF, new Money(12, "CHF"));
Assert.assertTrue(!f12CHF.equals(f14CHF));
public void testAdd() {//测试add方法的正确性
Money expected= new Money(26, "CHF");
Money result= f12CHF.add(f14CHF);
Assert.assertTrue(expected.equals(result));
// public static void main(String[] args) {
// TestCase test=new MoneyTest("simple add") {
// public void runTest() {
// testAdd();
// junit.textui.TestRunner.run(test);
public static void main(String[] args) {
TestCase test=new MoneyTest("testAdd");
junit.textui.TestRunner.run(test);
再给一个静态方法用集成测试的例子：
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(
new testCar("getWheels") {
protected void runTest() { testGetWheels(); }
suite.addTest(
new testCar("getSeats") {
protected void runTest() { testGetSeats(); }
5、应用案例
Junit Primer例程，运行如下：
java com.hedong.JunitLearning.Primer.ShoppingCartTest
Ant+Junit+Mailto实现自动编译、调试并发送结果的build.xml
JUnit实施,写得很棒，理解也深刻。例程运行如下：
java com.hedong.JunitLearning.car.testCarNoJunit
java junit.swingui.TestRunner com.hedong.JunitLearning.car.testCar
Junit与log4j结合，阿菜的例程运行：
6、一些问题
　　有人在实践基础上总结出一些非常有价值的使用技巧，我没有经过一一“测试”，暂列在此。
不要用TestCase的构造函数初始化Fixture，而要用setUp()和tearDown()方法。
不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。不知3.8中是不是还是如此，不过它提供的例子有一个是指定用VectorSuite的，如果不指定呢？
避免编写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。简单的回滚就可以了。
当继承一个测试类时，记得调用父类的setUp()和tearDown()方法。
将测试代码和工作代码放在一起，一边同步编译和更新。（使用Ant中有支持junit的task.）
测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。
确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。
如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要仅用母语的Locale进行测试。
尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁。
测试要尽可能地小，执行速度快。
把测试程序建立在与被测对象相同的包中
在你的原始代码目录中避免测试码出现，可在一个源码镜像目录中放测试码
在自己的应用程序包中包含一个TestSuite测试类
7、相关资源下载
以下jar包，我只是做了打包、编译和调试的工作，供下载学习之用，相关的权利属于原作者。
可运行例程.jar
阿菜的例程
Junit API 汉译(pdf)
8、未完成的任务
将Junit用链接池测试
阅读(...) 评论()Java编程（17）
下载Junit4,在junit.org 里面右上角有个 github项目的链接。
打开eclispe 新建java Project,右键项目 properties&Java Build Path&Libraries&Add Extenal Jars &加入刚才的 Junit4的jar包。
新建一个 类
junit1.java
package junit1;
import org.junit.A
import org.junit.B
import org.junit.T
import junit.framework.TestC
public class junit1 extends TestCase{
textBefore(){
System.out.println(&前置测试中!!&);
public void testPrintln(){
System.out.println(&测试中!!&);
public void testAfter(){
System.out.println(&后置测试中!!&);
右键 run as & Junit Test
运行结果;'
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：233641次
积分：5174
积分：5174
排名：第5778名
原创：291篇
转载：32篇
评论：31条
文章：45篇
阅读：61309
文章：36篇
阅读：9855
文章：25篇
阅读：13035
(9)(7)(1)(13)(8)(14)(5)(7)(8)(26)(33)(10)(11)(10)(26)(30)(20)(9)(13)(3)(7)(4)(3)(7)(1)(7)(5)(26)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'JUnit单元测试教程（翻译自Java Code Geeks）
本教程翻译自 Code Geeks，原文网址：。翻译的过程中，有少部分内容是译者添加的解释说明和对原文章中错误地方的修正。水平有限，如果有错误的地方，希望能在我的博客里告诉我，谢谢。
相关的例子不想自己写的同学们可以去这里下载：
1. 单元测试简介
1.1 什么是单元测试？
一个单元可以是一个方法、一个类、一个包、 或者一个子。所以术语单元测试表示对代码中的很小的单元的测试行为，以确保它们能够按预期工作。例如，我们给定一些输入，测试是否是预期的输出，或者测试一个条件是真还是假。
这种测试行为能帮助开发者发现隐藏在代码后面的错误，并提高代码质量。单元测试也被用来确保代码能够按照预期工作，以防止未来可能的变化。
1.2 测试覆盖
总的来说，开发者社区对代码测试要达到多少比例存在不同的观点。许多开发者认为代码的测试覆盖率要达到100%。另一些则认为50%或者更低就可以了。但无论如何，你都应该为你的代码中复杂的以及重要的部分编写测试。
1.3 Java中的单元测试
Java中最著名的测试框架是JUnit，本指南是专门介绍JUnit的，接下来的部分将详细介绍该测试框架的更多细节。Java中另一个著名的测试框架是TestNG。
2. JUnit简介
JUnit是一个开源的测试框架，它被用来编写和运行可重复的自动化测试，保证我们的代码按照预期的执行。JUnit被广泛使用：它可以在Java程序中单独使用（使用命令行）或者结合IDE使用，如Eclipse。
JUnit提供以下功能：
断言测试的预期结果。 共享测试数据的特性。 使用Test suites简化测试用例的组织和运行。 图形化和文本化测试用例？（Graphical and textual test runners.）
JUnit可以用来测试以下内容：
一个对象 部分对象&&一个方法或几个相互影响的方法 多个对象之间的交互
2.1 使用Eclipse实现简单JUnit测试例子
在这一节我们将展示一个简单的JUnit例子。首先来看一下我们要测试的类：
Calculate.java:
package com.javacodegeeks.
public class Calculate {
public int sum(int var1, int var2) {
System.out.println(&Adding values: & + var1 + & + & + var2);
return var1 + var2;
在上面的中，我们看到该类有一个public的方法sum()，方法接受两个int参数，相加之后返回结果。我们将测试这个方法。因此我们需要创建另一个类，并在这个类中为测试Calculate类中的所有需要测试的方法一一编写测试方法（在这个例子中，我们只有一个方法需要测试）。这是最普通的使用方法。当然如果一个方法非常复杂，我们可以为这个方法编写多个测试方法。编写测试用例的更多细节，我们将在下一节介绍。下面的CalculateTest.java类就是我们的测试类：
package com.javacodegeeks.
import static org.junit.Assert.*;
import org.junit.T
public class CalculateTest {
Calculate calculation = new Calculate();
int sum = calculation.sum(2, 5);
int testSum = 7;
public void testSum() {
System.out.println(&@Test sum(): & + sum + & = & + testSum);
assertEquals(sum, testSum);
让我们来解释一下上面的代码。首先我们看到在testSum()方法上有一个@Test注解。这个注解表示这个方法可以作为一个测试用例运行。所以testSum()方法被用来测试sum()方法。我们还看到了assertEquals(sum, testSum)方法，assertEquals ([String message], object expected, object actual)方法用来接手两个对象，并断言这两个对象是否相等。
运行该测试类，Run As&&JUnit Test，程序输出将如下所示：
vcHLyOfPwsv5yr61xL3nw+ajujwvcD4NCjxwPjxpbWcgYWx0PQ=="这里写图片描述" src="/uploadfile/Collfiles/60.png" title="\" />
如果我们改变一下代码：
int testSum = 10;
修改代码后两个整数的测试不再相等，程序输出将如下所示：
同时，在JUnit窗口中会显示测试出错，并给出错误信息：
2.2 JUnit注解
本节我们将介绍JUnit4支持的基本注解，下表是对这些索引的总结：
让我们来看一个包含了以上注解的测试类的例子：
AnnotationsTest.java:
package com.javacodegeeks.
import static org.junit.Assert.assertE
import static org.junit.Assert.assertT
import java.util.ArrayL
import org.junit.A
import org.junit.AfterC
import org.junit.B
import org.junit.BeforeC
import org.junit.I
import org.junit.T
public class AnnotationsTest {
private ArrayList testL
* if the method isn't static, throw following exception:
* java.lang.Exception: Method onceExecutedBeforeAll() should be static
@BeforeClass
public static void onceExecutedBeforeAll() {
System.out.println(&@BeforeClass: onceExecutedBeforeAll&);
public void executedBeforeEach() {
testList = new ArrayList();
System.out.println(&@Before: executedBeforeEach&);
* If the method isn't static, throw following exception:
* java.lang.Exception: Method onceExecutedAfterAll() should be static
@AfterClass
public static void onceExecutedAfterAll() {
System.out.println(&@AfterClass: onceExecutedAfterAll&);
public void executedAfterEach() {
testList.clear();
System.out.println(&@After: executedAfterEach&);
public void EmptyCollection() {
assertTrue(testList.isEmpty());
System.out.println(&@Test: EmptyArrayList&);
public void OneItemCollection() {
testList.add(&oneItem&);
assertEquals(1, testList.size());
System.out.println(&@Test: OneItemArrayList&);
public void executionIgnored() {
System.out.println(&@Ignore: This execution is ignored&);
执行以上测试，控制台输出如下所示：
JUnit窗口显示如下信息：
2.3 Junit断言
本节我们将展示一些断言方法。所有这些方法由Assert类提供，Assert类继承自java.lang.Object。这些断言能帮助你编写测试用例，监测到失败的测试。下表是对一些最常用的断言方法的详细介绍：
让我们看一个上述断言的例子：
AssertionsTest.java
package com.javacodegeeks.
import static org.junit.Assert.*;
import org.junit.T
public class AssertionsTest {
public void test() {
String obj1 = &junit&;
String obj2 = &junit&;
String obj3 = &test&;
String obj4 = &test&;
String obj5 =
int var1 = 1;
int var2 = 2;
int[] arithmetic1 = {1,2,3};
int[] arithmetic2 = {1,2,3};
assertEquals(obj1, obj2);
assertSame(obj3, obj4);
assertNotSame(obj2, obj4);
assertNotNull(obj1);
assertNull(obj5);
assertTrue(var1 != var2);
assertFalse(var1 == var2);
assertArrayEquals(arithmetic1, arithmetic2);
从以上类中我们可以看到断言方法是怎样工作的。
assertEquals()：如果两个对象相等，方法正常返回；否则在JUnit窗口中将显示错误，该测试将被中断。 assertSame()与assertNotSame()：测试两个对象的引用是否指向了同一个对象。 assertNull()与assertNotNull()：测试一个变量是否是null或非null。 assertTrue()与assertFalse()：测试一个条件或变量时true或false.。 assertArrayEquals()：比较两个数组是否相等。如果相等，方法正常返回；否则在JUnit窗口中将显示错误，该测试将被中断。
3. 使用Eclipse实现完整的JUnit例子
本节我们将展示一个使用JUnit的完整例子。我们将讲解怎样创建和运行测试用例，以及怎样使用JUnit的注解和断言。
3.1 创建工程
创建一个名为JUnitGuide的java工程。创建一个包com.javacodegeeks.junit用来放被测试的类。对于测试类，一个好的实践是创建一个专用于测试的源码包。这样被测试类和测试类就被分在了不同的源码包中。创建test包：右键单击你的工程， New&&Source Folder,命名源码包为test。
提示：创建源码包的另一种方式：右键单击你的工程?Properties?Java Build Path,选择Source 项，然后Add Folder?Create New Folder。输入源码包名，点击finish。
你能看到在工程里有两个源码包：
你可以在test源码包中也创建一个名称为com.javacodegeeks.junit的包，这样你的测试类就不会被放在默认的包中。
3.2 创建要被测试的Java类
右击src源码包，创建一个名为FirstDayAtScholl.java的类。该类的public方法将被测试。
FirstDayAtSchool.java
3.3 创建并运行JUnit测试用例
为已经存在的类FirstDayAtSchool.java创建测试用例：选中FirstDayAtSchool.java类，右击选择New?JUnit Test Case。改变源码包，将测试用例类放在test源码包中。确保选择&JUnit 4 test&选项。
点击&Finish&。如果你的项目classpath下还没有包含JUnit4，将会弹出如下所示的信息让你将JUnit4 Library添加进你的工程中。
(译者注：也可以直接在test源码包中像创建普通类一样创建一个测试用例类。只要该类中的方法用@Test注解标注上，就能引入JUnit框架，并成为测试用例。)
以下就是我们创建的名为FirstDayAtSchoolTest.java的测试用例。
FirstDayAtSchoolTest.java
右键Run As?JUnit Test，运行测试用例。
程序输出如下所示：
JUnit窗口显示如下：
此时JUnit窗口没有任何错误或失败。如果我们改变其中一个数组，让它包含比预期更多的元素：
再次运行测试类，JUnit窗口将显示有一个失败的测试用例：
或者，我们再次改变数组，让它包含与预期不同的元素：
再次运行测试类，JUnit窗口将再次显示一个测试用例fail：
3.4 使用@Ignore注解
在上面的例子中，让我们看看怎样使用@Ignore注解。在测试类FirstDayAtSchoolTest.java的testAddPencils()方法上标注@Ignore注解。通过这种方式，我们将该测试方法忽略掉，测试时不会执行。
执行测试，输出如下所示：@Ignore注解的测试方法没有执行。
JUnit窗口显示如下：
现在，我们去掉testAddPencils()方法上的@Ignore注解，将@Ignore注解标注在FirstDayAtSchoolTest.java类上。
运行该测试类发现：整个测试用例将不会执行，所以控制台上没有任何输出。JUnit窗口显示如下信息：
3.5 创建测试套件（suite tests）
本节，我们将展示如何创建测试套件。测试套件是来自于不同类的多个测试用例的集合。使用@Runwith和@Suite注解可以让这些测试类一起运行。当你有许多测试类并且你希望这些测试类一起执行时，这是非常有用的。
在上一节类的基础上，我们可以创建两个测试类。一个测试prepareMyBag()方法，另一个测试addPencils()方法。两个测试类如下所示：
PrepareMyBagTest.java.
AddPencilsTest.java.
我们来创建一个测试套件类来运行以上两个测试类。测试套件类SuiteTest.java如下所示：
SuiteTest.java.
使用@Suite.SuiteClasses注解来定义哪些测试类将被包含进测试套件一起执行。
运行该测试套件，这两个测试类将按照在@Suite.SuiteClasses注解中声明的顺序执行。
执行完毕后JUnit窗口显示信息如下：
3.6 创建参数化测试（parameterized tests）
本节我们将展示如何创建参数化的测试。我们将使用前面的2.1节中的类作为被测试类。
什么时候一个测试类才能被认为是一个参数化的测试类呢？当测试类满足下列条件的时候：
? 该类使用@RunWith(Parameterized.class)标注；
@RunWith注解告诉JUnit使用该注解标明的执行器执行测试用例，而不是使用JUnit内置的默认执行器。Parameterized是JUnit中的一个执行器，该执行器将使用一组不同的输入来多次执行一个相同的测试用例。
? 该类有唯一的构造函数来创建测试数据；
? 该类有一个static方法用来产生并返回测试数据，该方法使用@Parameters注解标注；
? 该类有一个使用@Test标注的测试用例（译者注：废话吗这不是）。
我们创建了一个新的测试类CalculateTest.java。该类遵循以上的规则。该类源码如下：
上如代码满足以上的所有规则。addedNumbers方法使用@Parameters标注，返回数组的集合。每一个数组包含一次测试执行的I/O数据。数组中元素的个数必须和构造函数中参数的个数一致。在该例子中，一个数组包含三个元素，两个代表要被相加的数，一个代表结果。
运行该测试用例，控制台输出如下所示：
JUnit窗口输出信息如下：
从上述信息可以看出，该测试用例执行了4次，这正是使用@Parameters注解标注的方法中输入的测试数据的个数。
3.7 规则（Rules）
本节我们将介绍JUnit4的一个新特性，叫做规则（Rules）。Rules允许我们灵活的增加或重新定义每一个测试方法的行为。为达到这个目的，使用@Rule注解标注测试类中public的域（fields）。这些域必须是MethodRule类型的，他们标明了一个测试方法的运行或结果报告作出了哪些改变。一个测试方法可以应用多个MethodRule。MethodRule接口有许多实现，如ErrorCollector，该规则允许测试用例在发现第一次错误是可以继续运行；ExpectedException，该规则允许我们明确预期异常的类型及异常信息；TestName，该规则允许我们在测试方法中获取到当前测试方法的名称；等等其他规则。除了JUnit已经定义的规则，开发者也可以自定义规则并在测试用例中使用。
下面，我们展示一个使用已经存在的TestName规则的例子。当一个测试类开始执行时TestName被调用。
NameRuleTest.java
如上所示：@Rule注解标注了一个public的域name，该域是MethodRule类型的。确切的说，该类是MethodRule接口的实现类MethodRule类型。然后我们就可以使用name在我们的测试方法中获取当前正在运行的测试方法的名字了。
（译者注：关于Rules的详细说明，请查看JUnit4官方文档：。运行里面的例子，有疑问就修改例子测试，一目了然。Rules还是有不少用处的。）
3.8 策略（Categories）
JUnit的另一个新特性是策略，这允许你将特定的测试放在一起形成一个分组（group），并可以包含或排除某些分组。例如你可以将运行慢的测试用例与运行快的测试用例分开。JUnit提供了@Category注解为一个测试用例标明策略。以下是使用该新特性的例子。该特性从JUnit4.8开始支持。
首先，定义两个策略，FastTests和SlowTests。一个策略可以是一个类或者一个借口。
以上的代码中，我们在A类的b()方法上使用了@Category注解，标注该方法在SlowTests策略中。所以，@Category注解不仅可以标注整个类，也可以标注某一个测试方法。
以上的代码中，我们看到整个B类使用了@Category标注。在类上标注后，该类的所有测试方法都会自动包含进@Category中声明的策略中。我们也可以看到，一个类或者一个测试方法可以属于多个策略。
以上代码中，我们看到有一个名为SlowTestSuite_1的测试套件。一般情况下，我们认为策略就是一种测试套件。在该套件中，我们使用@IncludeCategory注解标明哪些策略将会被执行。在该例中，属于SlowTests策略的所有方法将会被执行。因此，A类中的b()方法和B类中的c方法将被执行，他们都属于SlowTests策略。
以上代码中，我们对测试套件做了一些修改，我们添加了一个新的注解@ExcludeCategory，该注解表明那些策略将被排除。在本例中，只有A类的b()方法会执行，因为他是唯一只属于SlowTests策略，并不属于FastTests策略的测试方法。
通过以上两个例子我们看到，A类的a()方法从未执行，因为它不属于任何策略。
5. 命令行运行JUnit测试
通过使用org.junit.runner.JUnitCore 类，可以在Eclipse之外运行测试用例。该类提供了runClasses()方法允许执行一个或多个测试类。runClasses()方法的返回类型是一个org.junit.runner.Result对象。该对象可以搜集所有测试的信息。如果有失败的测试用例，你可以使用org.junit.runner.notification.Failure对象来获取失败的测试用例的描述。
下面的流程展示了如何在Eclipse之外运行你的测试。
创建一个新类JunitRunner.java如下所示：
JunitRunner.java
我们选择运行名为AssertionsTest的测试类。
? 打开DOS窗口，并定位到JunitRunner.java所在的目录（译者注：本人的目录是**\JUnitGuide\test\com\javacodegeeks\junit）。
? 编译测试类和Runner类。
javac -classpath &D:\learnTech\test\junit-4.11.jar&;&D:\learnTech\test\hamcrest-core-1.3.0.jar&; AssertionsTest.java JunitRunner.java
和在Eclipse中一样，我们需要将JUnit的jar包包含进classpath中。运行完上述命令。在Junitrunner.java所在的目录下就生成了AssertionsTest.class 和JunitRunner.class两个class文件。如下所示：
? 在DOS窗口中，退回到test源码目录（译者注：本人的目录是**\JUnitGuide\test）。
? 运行JunitRunner类。
java -classpath &D:\learnTech\test\junit-4.11.jar&;&D:\learnTech\test\hamcrest-core-1.3.0.jar&; JunitRunner
输出结果为：