用于单元测试的JUnit教程–最终指南（PDF下载）

编者注： 我们在Java Code Geeks上提供了许多JUnit教程，例如JUnit入门示例，使用断言和注释的 JUnit 示例， JUnit注释示例等。

但是，为了方便读者，我们希望将所有JUnit功能收集在一份详细的指南中。我们希望您能喜欢！

1.单元测试简介

什么是单元测试？

单元可以是函数，类，包或子系统。因此，术语“单元测试”指的是测试代码中如此小的单元，以确保它们按预期工作的实践。例如，我们可以测试输出是给定某些输入的预期结果，还是条件为真或假。

这种做法可帮助开发人员发现代码背后的逻辑故障，并提高代码质量。此外，可以使用单元测试，以确保代码在将来发生更改时能够按预期工作。

测试范围

通常，开发社区对于应该测试的代码百分比（测试覆盖率）有不同的看法。一些开发人员认为代码应具有100％的测试覆盖率，而其他开发人员则包含50％或更少的测试覆盖率。无论如何，您应该为代码的复杂或关键部分编写测试。

Java单元测试

Java中最受欢迎的测试框架是JUnit 。由于本指南主要针对JUnit，因此该测试框架的更多详细信息将在下一部分中介绍。 Java中另一个流行的测试框架是TestNG 。

2. JUnit简介

JUnit是一个开放源代码测试框架，用于编写和运行可重复的自动化测试，因此可以确保我们的代码能够按预期工作。 JUnit在行业中广泛使用，可以用作独立的Java程序（从命令行）或在IDE（例如Eclipse）中使用。

JUnit提供：

用于测试预期结果的断言。
用于共享通用测试数据的测试功能。
测试套件，可轻松组织和运行测试。
图形和文字测试赛跑者。

JUnit用于测试：

整个对象
对象的一部分–一种方法或某些交互方法
几个物体之间的相互作用

使用Eclipse的JUnit简单示例

在本节中，我们将看到一个简单的JUnit示例。首先，我们将介绍我们要测试的课程：

Calculate.java

package com.javacodegeeks.junit;public class Calculate {public int sum(int var1, int var2) {System.out.println("Adding values: " + var1 + " + " + var2);return var1 + var2;}}

在上面的源代码中，我们可以注意到该类有一个名为sum()公共方法，该方法将输入两个整数，将它们相加并返回结果。因此，我们将测试此方法。为此，我们将创建另一个类，该类包括将测试上一类的每个方法的方法（在这种情况下，我们只有一个要测试的方法）。这是最常见的用法。当然，如果一种方法非常复杂且可扩展，那么对于这种复杂方法，我们可以有多个测试方法。下一部分将介绍创建测试用例的详细信息。下面是名为CalculateTest.java的类的代码，它具有测试类的作用：

CalculateTest.java

package com.javacodegeeks.junit;import static org.junit.Assert.*;import org.junit.Test;public class CalculateTest {Calculate calculation = new Calculate();int sum = calculation.sum(2, 5);int testSum = 7;@Testpublic void testSum() {System.out.println("@Test sum(): " + sum + " = " + testSum);assertEquals(sum, testSum);}}

让我们解释一下上面的代码。首先，我们可以看到在testSum()方法上方有一个@Test批注。此注释指示可以将其附加到的public void方法作为测试用例运行。因此， testSum()方法是将测试sum()公共方法的方法。我们还可以观察到一种称为assertEquals(sum, testsum) 。方法assertEquals ([String message], object expected, object actual)将两个对象作为输入，并断言这两个对象相等。

如果我们运行测试类，请右键单击测试类，然后选择Run As-> Junit Test ，程序输出将如下所示：

Adding values: 2 + 5
@Test sum(): 7 = 7

为了查看JUnit测试的实际结果，Eclipse IDE提供了一个JUnit窗口，其中显示了测试结果。在测试成功的情况下，“ JUnit”窗口不会显示任何错误或失败，如下图所示：

图1：成功测试后的JUnit窗口。

现在，如果我们更改以下代码行：

int testSum = 10;

因此要测试的整数不相等，输出将是：

Adding values: 2 + 5
@Test sum(): 7 = 10

并且在JUnit窗口中，将出现一个错误，并且将显示此消息：

java.lang.AssertionError: expected: but was:
at com.javacodegeeks.junit.CalculateTest.testSum(CalculateTest.java:16)

JUnit批注

在本节中，我们将提到Junit 4支持的基本注释。下表总结了这些注释：

注解	描述
`@Test public void method()`	`Test`批注指示可以将其附加到的public void方法作为测试用例运行。
`@Before public void method()`	`Before`注释指示必须在类中的每个测试之前执行此方法，以便执行测试所需的一些前提条件。
`@BeforeClass public static void method()`	`BeforeClass`批注指示附加的静态方法必须在该类中的所有测试之前执行一次。当测试方法共享计算量大的设置（例如，连接到数据库）时，就会发生这种情况。
`@After public void method()`	`After`注释指示此方法在执行每个测试后执行（例如，在执行每个测试后重置一些变量，删除临时变量等）
`@AfterClass public static void method()`	在执行完JUnit测试用例类中的所有测试后需要执行一种方法以清理昂贵的设置（例如，与数据库断开连接）时，可以使用`AfterClass`注释。注意：附加此注释的方法（类似于`BeforeClass` ）必须定义为静态。
`@Ignore public static void method()`	当您要暂时禁用特定测试的执行时，可以使用“ `Ignore`注释。用`@Ignore`注释的每个方法都不会执行。

让我们看一个带有上面提到的一些注释的测试类的例子。

AnnotationsTest.java

package com.javacodegeeks.junit;import static org.junit.Assert.*;
import java.util.*;
import org.junit.*;public class AnnotationsTest {private ArrayList testList;@BeforeClasspublic static void onceExecutedBeforeAll() {System.out.println("@BeforeClass: onceExecutedBeforeAll");}@Beforepublic void executedBeforeEach() {testList = new ArrayList();System.out.println("@Before: executedBeforeEach");}@AfterClasspublic static void onceExecutedAfterAll() {System.out.println("@AfterClass: onceExecutedAfterAll");}@Afterpublic void executedAfterEach() {testList.clear();System.out.println("@After: executedAfterEach");}@Testpublic void EmptyCollection() {assertTrue(testList.isEmpty());System.out.println("@Test: EmptyArrayList");}@Testpublic void OneItemCollection() {testList.add("oneItem");assertEquals(1, testList.size());System.out.println("@Test: OneItemArrayList");}@Ignorepublic void executionIgnored() {System.out.println("@Ignore: This execution is ignored");}
}

如果我们运行上述测试，则控制台输出如下：

@BeforeClass: onceExecutedBeforeAll
@Before: executedBeforeEach
@Test: EmptyArrayList
@After: executedAfterEach
@Before: executedBeforeEach
@Test: OneItemArrayList
@After: executedAfterEach
@AfterClass: onceExecutedAfterAll

JUnit断言

在本节中，我们将介绍许多断言方法。所有这些方法都是由Assert类提供的，该类扩展了class java.lang.Object ，它们对于编写测试以检测故障很有用。下表提供了最常用的断言方法的更详细说明。

断言	描述
`void assertEquals([String message], expected value, actual value)`	断言两个值相等。值的类型可以是int，short，long，byte，char或java.lang.Object。第一个参数是可选的String消息。
`void assertTrue([String message], boolean condition)`	断言条件为真。
`void assertFalse([String message],boolean condition)`	断言条件为假。
`void assertNotNull([String message], java.lang.Object object)`	断言一个对象不为空。
`void assertNull([String message], java.lang.Object object)`	断言一个对象为空。
`void assertSame([String message], java.lang.Object expected, java.lang.Object actual)`	断言两个对象引用相同的对象。
`void assertNotSame([String message], java.lang.Object unexpected, java.lang.Object actual)`	断言两个对象没有引用相同的对象。
`void assertArrayEquals([String message], expectedArray, resultArray)`	断言期望的数组与结果数组相等。 Array的类型可以是int，long，short，char，byte或java.lang.Object。

让我们来看一些上述断言的示例。

AssertionsTest.java

package com.javacodegeeks.junit;import static org.junit.Assert.*;
import org.junit.Test;public class AssertionsTest {@Testpublic void test() {String obj1 = "junit";String obj2 = "junit";String obj3 = "test";String obj4 = "test";String obj5 = null;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);assertArrayEquals(arithmetic1, arithmetic2);}}

在上面的类中，我们可以看到这些assert方法是如何工作的。

如果两个比较的对象相等，则assertEquals()方法将正常返回，否则将在JUnit窗口中显示失败，并且测试将中止。
assertSame()和assertNotSame()方法测试两个对象引用是否指向完全相同的对象。
assertNull()和assertNotNull()方法测试变量是否为null。
assertTrue()和assertFalse()方法测试条件或变量是true还是false。
assertArrayEquals()将比较两个数组，如果它们相等，则该方法将继续进行而不会出现错误。否则，将在JUnit窗口中显示失败，并且测试将中止。

3.使用Eclipse的JUnit完整示例

在本节中，我们将显示一个使用JUnit的完整示例。我们将详细介绍如何创建和运行测试，并展示如何使用JUnit的特定注释和断言。

初始步骤

让我们创建一个名为JUnitGuide的Java项目。在src文件夹中，右键单击并选择com.javacodegeeks.junit > Package ，以创建一个名为com.javacodegeeks.junit的新程序包，在该程序包中将找到要测试的类。对于测试类，最好创建一个新的专用于测试的源文件夹，以使要测试的类和测试类位于不同的源文件夹中。为此，右键单击您的项目，选择New-> Source Folder ，将新的源文件夹命名为test，然后单击Finish 。

图2：创建一个名为test的新源文件夹。

小费
或者，您可以通过右键单击您的项目并选择Properties-> Java Build Path ，选择选项卡Source ，选择Add Folder-> Create New Folder ，编写名称test并按Finish来创建一个新的源文件夹。

您可以轻松地看到项目中有两个源文件夹：

图3

您还可以在新创建的测试文件夹中创建一个新包，该包将称为com.javacodegeeks.junit ，这样您的测试类就不会位于默认包中，我们可以开始了！

创建要测试的Java类

右键单击src文件夹，然后创建一个名为FirstDayAtSchool.java的新Java类。这是将测试其公共方法的类。

FirstDayAtSchool.java

package com.javacodegeeks.junit;import java.util.Arrays;public class FirstDayAtSchool {public String[] prepareMyBag() {String[] schoolbag = { "Books", "Notebooks", "Pens" };System.out.println("My school bag contains: "+ Arrays.toString(schoolbag));return schoolbag;}public String[] addPencils() {String[] schoolbag = { "Books", "Notebooks", "Pens", "Pencils" };System.out.println("Now my school bag contains: "+ Arrays.toString(schoolbag));return schoolbag;}
}

创建并运行一个JUnit测试用例

要为现有类FirstDayAtSchool.java创建一个JUnit测试用例，请在Package Explorer视图中右键单击它，然后选择New→JUnit Test Case 。更改源文件夹，以便将类定位到测试源文件夹，并确保已选择标志New JUnit4 test 。

图4：创建一个新的测试类。

然后，单击完成。如果您的项目的类路径中不包含JUnit库，则将显示以下消息，以便将JUnit库添加到类路径中：

图5：将JUnit4库添加到项目的构建路径。

下面是名为FirstDayAtSchoolTest.java的类的代码，这是我们的测试类：

FirstDayAtSchool.java

package com.javacodegeeks.junit;import static org.junit.Assert.*;import org.junit.Test;public class FirstDayAtSchoolTest {FirstDayAtSchool school = new FirstDayAtSchool();String[] bag1 = { "Books", "Notebooks", "Pens" };String[] bag2 = { "Books", "Notebooks", "Pens", "Pencils" };@Testpublic void testPrepareMyBag() {System.out.println("Inside testPrepareMyBag()");assertArrayEquals(bag1, school.prepareMyBag());}@Testpublic void testAddPencils() {System.out.println("Inside testAddPencils()");assertArrayEquals(bag2, school.addPencils());}}

现在，我们可以通过右键单击测试类并选择Run As-> JUnit Test来运行测试用例 。

程序输出将如下所示：

Inside testPrepareMyBag()
My school bag contains: [Books, Notebooks, Pens]
Inside testAddPencils()
Now my school bag contains: [Books, Notebooks, Pens, Pencils]

并且在JUnit视图中不会出现故障或错误。如果我们更改其中一个数组，则它包含的内容超出了预期的元素：

String[] bag2 = { "Books", "Notebooks", "Pens", "Pencils", "Rulers"};

然后再次运行测试类，JUnit视图将包含一个失败：

图6：测试失败

否则，如果我们再次更改数组之一，则它包含的元素与预期的元素不同：

String[] bag1 = { "Books", "Notebooks", "Rulers" };

然后再次运行测试类，JUnit视图将再次包含一个失败：

图7：测试失败

使用

让我们在上面的示例中看到如何使用@Ignore批注。在测试类FirstDayAtSchoolTest我们将@Ignore批注添加到testAddPencils()方法。这样，我们希望该测试方法将被忽略并且不会执行。

package com.javacodegeeks.junit;import static org.junit.Assert.*;import org.junit.Ignore;
import org.junit.Test;public class FirstDayAtSchoolTest {FirstDayAtSchool school = new FirstDayAtSchool();String[] bag1 = { "Books", "Notebooks", "Pens" };String[] bag2 = { "Books", "Notebooks", "Pens", "Pencils" };@Testpublic void testPrepareMyBag() {System.out.println("Inside testPrepareMyBag()");assertArrayEquals(bag1, school.prepareMyBag());}@Ignore@Testpublic void testAddPencils() {System.out.println("Inside testAddPencils()");assertArrayEquals(bag2, school.addPencils());}}

确实，这是根据输出发生的情况：

Inside testPrepareMyBag()
My school bag contains: [Books, Notebooks, Pens]

现在，我们将从testAddPencils()方法中删除@Ignore批注，而改为对整个类进行批注。

package com.javacodegeeks.junit;import static org.junit.Assert.*;import org.junit.Ignore;
import org.junit.Test;@Ignore
public class FirstDayAtSchoolTest {FirstDayAtSchool school = new FirstDayAtSchool();String[] bag1 = { "Books", "Notebooks", "Pens" };String[] bag2 = { "Books", "Notebooks", "Pens", "Pencils" };@Testpublic void testPrepareMyBag() {System.out.println("Inside testPrepareMyBag()");assertArrayEquals(bag1, school.prepareMyBag());}@Testpublic void testAddPencils() {System.out.println("Inside testAddPencils()");assertArrayEquals(bag2, school.addPencils());}}

其测试类将不会执行，因此不会在控制台输出和junit视图中显示任何结果：

图8

创建套件测试

在本节中，我们将看到如何创建套件测试。测试套件是来自不同类的一些测试用例的集合，可以使用@RunWith和@Suite批注一起运行它们。如果您有许多测试类，并且想要一起运行它们，而不是一次运行一个测试，这将非常有帮助。

当使用@RunWith注释类时，JUnit将调用对其进行注释的类以运行测试，而不是使用JUnit内置的运行程序。

基于前面几节的类，我们可以创建两个测试类。一个类将测试公共方法prepareMyBag() ，另一类将测试方法addPencils() 。因此，我们最终将具有以下类：

PrepareMyBagTest.java

package com.javacodegeeks.junit;import org.junit.Test;
import static org.junit.Assert.*;public class PrepareMyBagTest {FirstDayAtSchool school = new FirstDayAtSchool();String[] bag = { "Books", "Notebooks", "Pens" };@Testpublic void testPrepareMyBag() {System.out.println("Inside testPrepareMyBag()");assertArrayEquals(bag, school.prepareMyBag());}}

AddPencilsTest.java

package com.javacodegeeks.junit;import org.junit.Test;
import static org.junit.Assert.*;public class AddPencilsTest {FirstDayAtSchool school = new FirstDayAtSchool();String[] bag = { "Books", "Notebooks", "Pens", "Pencils" };@Testpublic void testAddPencils() {System.out.println("Inside testAddPencils()");assertArrayEquals(bag, school.addPencils());}}

现在，我们将创建一个测试套件，以便一起运行上述类。右键单击测试源文件夹，并使用以下代码创建一个名为SuiteTest.java的新Java类：

SuiteTest.java

package com.javacodegeeks.junit;import org.junit.runner.RunWith;
import org.junit.runners.Suite;@RunWith(Suite.class)
@Suite.SuiteClasses({ PrepareMyBagTest.class, AddPencilsTest.class })
public class SuitTest {}

使用@Suite.SuiteClasses批注，您可以定义执行中将包括哪些测试类。

因此，如果右键单击测试套件并选择Run @Suite.SuiteClasses > JUnit Test ，则将按照@Suite.SuiteClasses批注中定义的顺序执行两个测试类。

创建参数化测试

在本节中，我们将看到如何创建参数化测试。为此，我们将使用第2.1节中提到的类，该类提供了用于添加整数的公共方法。因此，这将是要测试的课程。

但是什么时候可以将测试类视为参数化测试类？当然，当满足以下所有要求时：

该类用@RunWith(Parameterized.class)注释。
如上一节所述， @RunWith注释使JUnit可以调用@RunWith注释的类来运行测试，而不是使用JUnit内置的运行程序。 Parameterized是JUnit内部的运行程序，它将使用不同的输入集运行相同的测试用例。
该类具有一个用于存储测试数据的构造函数。
该类具有生成和返回测试数据的静态方法，并带有@Parameters注释。
该类有一个测试，这显然意味着它需要一个带有@Test注释的方法。

现在，我们将创建一个名为CalculateTest.java的新测试类，它将遵循上述准则。此类的源代码如下。

CalculateTest.java

package com.javacodegeeks.junit;import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import java.util.Collection;import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;@RunWith(Parameterized.class)
public class CalculateTest {private int expected;private int first;private int second;public CalculateTest(int expectedResult, int firstNumber, int secondNumber) {this.expected = expectedResult;this.first = firstNumber;this.second = secondNumber;}@Parameterspublic static Collection addedNumbers() {return Arrays.asList(new Integer[][] { { 3, 1, 2 }, { 5, 2, 3 },{ 7, 3, 4 }, { 9, 4, 5 }, });}@Testpublic void sum() {Calculate add = new Calculate();System.out.println("Addition with parameters : " + first + " and "+ second);assertEquals(expected, add.sum(first, second));}
}

正如我们在以上课程中所观察到的，它满足了以上所有要求。该方法addedNumbers带注释@Parameters返回数组的集合。每个数组都包含每个测试执行的输入/输出编号。每个数组中的元素数必须与构造函数中的参数数相同。因此，在这种特定情况下，每个数组包含三个元素，两个元素代表要添加的数字，一个元素代表结果。

如果我们运行CalculateTest测试用例，则控制台输出如下：

Addition with parameters : 1 and 2
Adding values: 1 + 2
Addition with parameters : 2 and 3
Adding values: 2 + 3
Addition with parameters : 3 and 4
Adding values: 3 + 4
Addition with parameters : 4 and 5
Adding values: 4 + 5

正如我们在输出中看到的，测试用例执行了四次，这是方法中用@Parameters注释注释的输入数。

规则

在本节中，我们介绍JUnit的一项新功能，即“规则” ，它允许非常灵活地添加或重新定义测试类中每个测试方法的行为。为此，应使用@Rule批注，以标记测试类的公共字段。这些字段的类型应该为MethodRule ，这是对运行和报告测试方法的一种更改。可以将多个MethodRules应用于测试方法。 MethodRule接口具有许多实现，例如ErrorCollector允许在发现第一个问题后继续执行测试； ExpectedException允许在测试中指定期望的异常类型和消息； TestName可以在测试中提供当前测试名称方法和许多其他方法。除已定义的规则外，开发人员可以创建自己的自定义规则，并根据需要在测试用例中使用它们。

下面，我们介绍了在我们自己的测试中使用名为TestName的现有规则之一的方法。测试即将开始时调用TestName 。

NameRuleTest.java

package com.javacodegeeks.junit;import static org.junit.Assert.*;import org.junit.*;
import org.junit.rules.TestName;public class NameRuleTest {@Rulepublic TestName name = new TestName();@Testpublic void testA() {System.out.println(name.getMethodName());assertEquals("testA", name.getMethodName());}@Testpublic void testB() {System.out.println(name.getMethodName());assertEquals("testB", name.getMethodName());}
}

我们可以看到@Rule批注标记了公共字段name ，该name是MethodRule类型，尤其是TestName类型。然后，在这种特定情况下，我们可以在测试中使用此name字段并查找例如测试方法的名称。

分类目录

JUnit的另一个新功能称为类别，它使您可以将某些类型的测试组合在一起，甚至可以包括或排除组（类别）。例如，您可以将慢速测试与快速测试分开。要将测试用例或方法分配给这些类别之一，需要提供@Category批注。下面是一个示例，该示例基于JUnit 4.8的发行说明如何使用JUnit的这一出色功能。

public interface FastTests { /* category marker */
}

public interface SlowTests { /* category marker */
}

首先，我们定义两个类别，即FastTests和SlowTests。类别可以是类或接口。

public class A {@Testpublic void a() {fail();}@Category(SlowTests.class)@Testpublic void b() {}
}

在上面的代码中，我们使用@Category批注标记了类A的测试方法b() ，以表明该特定方法属于SlowTests类别。因此，我们不仅可以标记整个类，还可以分别标记一些测试方法。

@Category({ SlowTests.class, FastTests.class })
public class B {@Testpublic void c() {}
}

在上面的代码示例中，我们可以看到整个类B都使用@Category注解进行了注释。使用@Category批注对测试类进行批注会自动将其所有测试方法包括在此类别中。我们还可以看到测试类或测试方法可以属于多个类别。

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@SuiteClasses({ A.class, B.class })
// Note that Categories is a kind of Suite
public class SlowTestSuite {// Will run A.b and B.c, but not A.a
}

在此代码示例中，我们注意到有一个名为SlowTestSuite的套件测试。基本上，类别是一种套件。在此套件中，我们观察到一个名为@IncludeCategory的新注释，该注释指示将在执行中包括哪些类别。在这种特定情况下，将执行属于SlowTests类别的方法。因此，仅在测试方法b()类的A将以及测试方法来执行c()类的B ，这两者都属于SlowTests类别。

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@ExcludeCategory(FastTests.class)
@SuiteClasses({ A.class, B.class })
// Note that Categories is a kind of Suite
public class SlowTestSuite {// Will run A.b, but not A.a or B.c
}

最后，我们对测试套件进行了一些更改，并添加了一个名为@ExcludeCategory新注释，该注释指示将从执行中排除哪些类别。在此特定情况下，将仅执行类A的测试方法b() ，因为这是唯一明确属于SlowTests类别的测试方法。

我们注意到在这两种情况下，类A的测试方法a()均不会执行，因为它不属于任何类别。

4.从命令行运行JUnit测试

您可以使用org.junit.runner.JUnitCore类在Eclipse外部运行JUnit测试。此类提供了runClasses()方法，该方法使您可以执行一个或多个测试类。 runClasses()方法的返回类型是org.junit.runner.Result类型的对象。该对象可用于收集有关测试的信息。另外，如果测试失败，则可以使用对象org.junit.runner.notification.Failure来保存失败测试的描述。

以下过程显示了如何在Eclipse外部运行测试。

使用以下代码创建一个名为JunitRunner.java的新Java类：

JunitRunner.java

package com.javacodegeeks.junit;import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;public class JunitRunner {public static void main(String[] args) {Result result = JUnitCore.runClasses(AssertionsTest.class);for (Failure fail : result.getFailures()) {System.out.println(fail.toString());}if (result.wasSuccessful()) {System.out.println("All tests finished successfully...");}}
}

例如，我们选择运行AssertionsTest测试类。

- 打开命令提示符并向下移动目录，以查找两个类所在的目录。

C:\Users\konstantina\eclipse_luna_workspace\JUnitGuide\test\com\javacodegeeks\junit>javac -classpath "C:\Users\konstantina\Downloads\junit-4.11.jar";"C:\Users\konstantina\Downloads\hamcrest-core-1.3.jar"; AssertionsTest.java JunitRunner.java

就像我们在Eclipse中所做的一样，我们还应该将JUnit的库jar包含到类路径中。

- 现在运行JunitRunner 。

C:\Users\konstantina\eclipse_luna_workspace\JUnitGuide\test\com\javacodegeeks\junit>java -classpath "C:\Users\konstantina\Downloads\junit-4.11.jar";"C:\Users\konstantina\Downloads\hamcrest-core-1.3.jar"; JunitRunner

这是输出：