编者注： 我们在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”窗口不会显示任何错误或失败，如下图所示：

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

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 。

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

您还可以在新创建的测试文件夹中创建一个新包，该包将称为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 。

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

下面是名为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视图将包含一个失败：

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

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

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

使用

让我们在上面的示例中看到如何使用@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视图中显示任何结果：

创建套件测试

在本节中，我们将看到如何创建套件测试。 测试套件是来自不同类的一些测试用例的集合，可以使用@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

这是输出：

All tests finished successfully...

5。结论

这是有关JUnit测试框架（Java中最流行的测试框架）的详细指南。

如果您喜欢此功能，请订阅我们的时事通讯，以享受每周更新和免费白皮书！ 另外，请访问JCG学院进行更高级的培训！

翻译自: https://www.javacodegeeks.com/2014/11/junit-tutorial-unit-testing.html