Tutorialspoint JUnit 教程

来源：易百教程

JUnit教程™

测试是检查应用程序是否是工作按照要求，并确保在开发者水平，单元测试进入功能性的处理。单元测试是单一实体（类或方法）的测试。 单元测试在每一个软件公司开发高品质的产品给他们的客户是十分必要的。

单元测试可以通过两种方式来完成：

手动测试 | 自动测试

手动执行测试用例，没有任何工具支持称为手动测试。

费时和乏味：由于测试案例是由人力的，所以它是非常缓慢而乏味的执行。

巨大的人力资源的投入：作为测试用例需要手动执行，所以更多的测试都需要手动测试。

较不可靠：手动测试是为测试可能不会被精确地每次执行，因为人为错误导致不可靠。

非可编程：无需编程就可以做，获取信息隐藏复杂的测试。

以工具支持，并通过使用自动化工具则称为自动化测试执行测试用例。

快速自动化运行测试用例比人力显著更快。

人力资源的投入较少：测试用例是通过使用自动化工具，所以较少测试者都需要在自动化测试执行。

更可靠：自动化测试在每次运行的时间进行精确的相同操作。

可编程：测试人员可以编写复杂的测试，以带出隐藏的信息。

JUnit是什么 ?

JUnit是一个Java编程语言编写的单元测试框架。 重要的是在测试驱动开发中，并且是一个家族的统称为xUnit单元测试框架中的一个。

JUnit促进“先测试再编码”，它强调建立测试数据的一段代码可以被测试，先测试再编码实现的想法。这种做法就像是“试了一下，码了一点，测试了一下，代码一点点......”这增加了程序员的工作效率和程序代码的稳定性，减少程序员的压力和花在调试的时间。

JUnit的特点

JUnit是用于编写和运行测试的开源框架。

提供了注释，以确定测试方法。

提供断言测试预期结果。

提供了测试运行的运行测试。

JUnit测试让您可以更快地编写代码，提高质量

JUnit是优雅简洁。它是不那么复杂以及不需要花费太多的时间。

JUnit测试可以自动运行，检查自己的结果，并提供即时反馈。没有必要通过测试结果报告来手动梳理。

JUnit测试可以组织成测试套件包含测试案例，甚至其他测试套件。

Junit显示测试进度的，如果测试是没有问题条形是绿色的，测试失败则会变成红色。

JUnit是Java中最有名的单元测试框架。然而，它仅适合于纯粹的单元测试，对于集成测试应该使用TestNG来代替。

欢迎学习JUnit 

一个单元可以是函数，类，包，或一个子系统。因此，术语：单元测试是指测试小单元做法代码，以便确保它们正常工作。例如，我们可以给予一定的输入测试输出是否是所希望看到那样，或者 if 的条件是真还是假。

这种做法可以帮助开发人员发现逻辑故障在代码中，以提高其代码的质量。另外，单元测试可以使用，以便确保代码将作为在未来变化预期的情况。

JUnit教程列表-基础部分

1. 单元测试介绍

2.JUnit测试是什么?

3.Eclipse JUnit简单示例

4.JUnit注解5.JUnit断言

6.使用Eclipse的JUnit实例

7.使用@Ignore注解

8.创建套件测试

9.创建参数测试

10.Junit规则

11.在命令行中运行JUnit测试

JUnit 4.x 教程实例

1.JUnit基本使用
介绍JUnit 4，支持基本的注解。

2.预期异常测试
测试异常抛出的方法。

3.忽略（Ignore）测试实例
忽略某些方法的单元测试。

4.测试（超时返回）时间
以确保一定时间后，测试方法将返回。

5.套件测试实例
捆绑几个单元测试用例并运行起来。

6.参数化测试实例
如何通过参数值传递到单元测试。

什么是单元测试用例？

单元测试用例是代码的一部分从而确保代码（方法）的另一部分工作正常。要快速实现这些理想的效果，测试框架是必需的。JUnit对于Java编程语言是完美的单元测试框架。

正式书面单元测试用例的特征是众所周知输入和期望的输出，这是在执行测试之前制定的。已知的输入应该作为测试的前提条件以及预期输出应该为测试后置条件。

必须有至少两个单元测试用例针对每个要求： 一个正测试和负测试。如果要求有不合要求，每个子需求必须至少有两个测试用例作为正负。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit教程

JUnit介绍,JUnit是什么？ - JUnit教程™

JUnit是什么？

JJUnit是用于编写和运行可重复的自动化测试的开源测试框架， 这样可以保证我们的代码按预期工作。JUnit可广泛用于工业和作为支架(从命令行)或IDE(如Eclipse)内单独的Java程序。

JUnit提供：

断言测试预期结果。

测试功能共享通用的测试数据。

测试套件轻松地组织和运行测试。

图形和文本测试运行。

JUnit用于测试：

整个对象

对象的一部分 - 交互的方法或一些方法

几个对象之间的互动(交互)

JUnit的特点

JUnit是用于编写和运行测试的开源框架。

提供了注释，以确定测试方法。

提供断言测试预期结果。

提供了测试运行的运行测试。

JUnit测试让您可以更快地编写代码，提高质量

JUnit是优雅简洁。它是不那么复杂以及不需要花费太多的时间。

JUnit测试可以自动运行，检查自己的结果，并提供即时反馈。没有必要通过测试结果报告来手动梳理。

JUnit测试可以组织成测试套件包含测试案例，甚至其他测试套件。

Junit显示测试进度的，如果测试是没有问题条形是绿色的，测试失败则会变成红色。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit介绍,JUnit是什么？

Eclipse JUnit简单示例 - JUnit教程™

在本节中，我们将看到一个简单的JUnit例子。

先创建一个工程，名称为：CalculateTest，并在这个工程上点击右键，选择：Build Path -> Add Library -> JUnit ...，如下图所示：

选择 JUnit 的库版本为：JUnit 4，如下图所示：

整个工程的结构如下：

首先，我们将介绍一个测试类：

Calculate.java

package com.yiibai.junit;

public class Calculate {

	public int sum(int var1, int var2) {
		System.out.println("相加的值是: " + var1 + " + " + var2);
		return var1 + var2;
	}

}

在上面的代码中，我们可以看到，类有一个公共的方法sum(), 它得到输入两个整数，将它们相加并返回结果。在这里，我们将测试这个方法。为了这个目的，我们将创建另一个类包括方法，将测试之前的类(在此情况下，我们只有一个方法进行测试)中每一个的方法。这是使用的最常见的方式。当然，如果一个方法非常复杂且要扩展，我们可以在一个以上的试验方法来测试这一复杂方法。创建测试用例的详细信息将显示在下面的部分。下面，有一个类是：CalculateTest.java，它具有我们的测试类的角色的代码：

CalculateTest.java

package com.yiibai.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;

	@Test
	public void testSum() {
		System.out.println("@Test sum(): " + sum + " = " + testSum);
		assertEquals(sum, testSum);
	}

}

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

如果要运行测试类，右键点击测试类，并选择 Run As -> Junit Test, 该程序的输出将类似于如下：

相加的值是: 2 + 5
@Test sum(): 7 = 7

若要查看JUnit测试的实际结果，Eclipse IDE提供了JUnit的窗口，它显示了测试的结果。 在这种情况下测试成功，JUnit 窗口不显示任何错误或失败，因为我们可以在下面的图片中看到(Errors 0)：

现在，如果我们改变这一行的代码：

int testSum = 10;

使整数待测试不相等，则输出将是：

相加的值是: 2 + 5
@Test sum(): 7 = 10

在JUnit窗口，有一个错误将出现，并且会显示这样的信息：

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

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Eclipse JUnit简单示例

JUnit注解 - JUnit教程™

在本节中，我们将提到支持在JUnit4基本注释，下表列出了这些注释的概括：

注解 | 描述
@Test public void method() | 测试注释指示该公共无效方法它所附着可以作为一个测试用例。
@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的方法将不被执行。

让我们看看一个测试类，在上面提到的一些注解的一个例子。

AnnotationsTest.java

package com.yiibai.junit;

import static org.junit.Assert.*;
import java.util.*;
import org.junit.*;

public class AnnotationsTest {

	private ArrayList testList;

	@BeforeClass
	public static void onceExecutedBeforeAll() {
		System.out.println("@BeforeClass: onceExecutedBeforeAll");
	}

	@Before
	public void executedBeforeEach() {
		testList = new ArrayList();
		System.out.println("@Before: executedBeforeEach");
	}

	@AfterClass
	public static void onceExecutedAfterAll() {
		System.out.println("@AfterClass: onceExecutedAfterAll");
	}

	@After
	public void executedAfterEach() {
		testList.clear();
		System.out.println("@After: executedAfterEach");
	}

	@Test
	public void EmptyCollection() {
		assertTrue(testList.isEmpty());
		System.out.println("@Test: EmptyArrayList");

	}

	@Test
	public void OneItemCollection() {
		testList.add("oneItem");
		assertEquals(1, testList.size());
		System.out.println("@Test: OneItemArrayList");
	}

	@Ignore
	public 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

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit注解

JUnit断言 - JUnit教程™

在本节中，我们将介绍一些断言方法。所有这些方法都受到 Assert 类扩展了java.lang.Object类并为它们提供编写测试，以便检测故障。下表中有一种最常用的断言方法的更详细的解释。

断言 | 描述
void assertEquals([String message], expected value, actual value) | 断言两个值相等。值可能是类型有 int, short, long, byte, char or java.lang.Object. 第一个参数是一个可选的字符串消息
void assertTrue([String message], boolean condition) | 断言一个条件为真
void assertFalse([String message],boolean condition) | 断言一个条件为假
void assertNotNull([String message], java.lang.Object object) | 断言一个对象不为空(null)
void assertNull([String message], java.lang.Object object) | 断言一个对象为空(null)
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) | 断言预期数组和结果数组相等。数组的类型可能是 int, long, short, char, byte or java.lang.Object.

 让我们看的一些前述断言的一个例子。

AssertionsTest.java

package com.yiibai.junit;

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

public class AssertionsTest {

	@Test
	public 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);
	}

}

在以上类中我们可以看到，这些断言方法是可以工作的。

 assertEquals() 如果比较的两个对象是相等的，此方法将正常返回；否则失败显示在JUnit的窗口测试将中止。

 assertSame() 和 assertNotSame() 方法测试两个对象引用指向完全相同的对象。

 assertNull() 和 assertNotNull() 方法测试一个变量是否为空或不为空(null)。

 assertTrue() 和 assertFalse() 方法测试if条件或变量是true还是false。

 assertArrayEquals() 将比较两个数组，如果它们相等，则该方法将继续进行不会发出错误。否则失败将显示在JUnit窗口和中止测试。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit断言

使用Eclipse的JUnit实例 - JUnit教程™

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

1. 初始步骤

让我们创建一个名为 JUnitGuide 的Java项目. 在 src 文件夹, 我们用鼠标右键单击并选择 New -> Package, 创造一个新的包名为： com.yiibai.junit 这里我们将定位类用于测试。 对于测试类，一个很好的做法就是创建专用于测试的一个新的源文件夹，这样的类用于测试以及测试类将在不同的源的文件夹。 为此，右键单击您的项目，选择 New -> Source Folder, 命名新的源文件夹test 并点击 Finish.

提示：
或者，可以通过右键点击项目创建一个新的源文件夹，选择Properties -> Java Build Path, 选择标签 Source, 选择 Add Folder -> Create New Folder, 写上名称为test，然后按 Finish。

可以很容易地看到，在项目中有两个源文件夹：

还可以创建一个新的包在新创建的测试文件夹，名称为 com.javacodegeeks.junit, 测试类不会在默认包中，我们已经准备好了，现在就开始吧！

2. 创建Java类用于测试

右键单击src文件夹并创建一个新的Java类称为 FirstDayAtSchool.java. 这个类的公共方法将被测试。

FirstDayAtSchool.java

package com.yiibai.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;
	}
}

3. 创建和运行JUnit测试案例

要为现有类 FirstDayAtSchool.java 创建一个JUnit测试案例, 在Package Explorer视图上右键单击并选择 New → JUnit Test Case. 更改源文件夹，这样的类将位于 test 源文件夹并确保该标志 New JUnit4 测试选择。

然后点击 Finish. 如果您的项目不包含JUnit库在classpath中，下面的消息会显示成为将JUnit库添加到类路径：

下面，有一个名为：FirstDayAtSchoolTest.java 类，这个测试类的代码如下所示：

FirstDayAtSchool.java

package com.yiibai.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" };

	@Test
	public void testPrepareMyBag() {
		System.out.println("Inside testPrepareMyBag()");
		assertArrayEquals(bag1, school.prepareMyBag());
	}

	@Test
	public 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视图将再一次失败：

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 使用Eclipse的JUnit实例

使用@Ignore注解 - JUnit教程™

断续上一节的例子，了解如何使用@Ignore注解。在测试类FirstDayAtSchoolTest中，我们将添加@Ignore注解到testAddPencils()方法。以这种方式，我们期望这个测试方法将被忽略，不被执行。

package com.yiibai.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" };

	@Test
	public void testPrepareMyBag() {
		System.out.println("Inside testPrepareMyBag()");
		assertArrayEquals(bag1, school.prepareMyBag());
	}

	@Ignore
	@Test
	public void testAddPencils() {
		System.out.println("Inside testAddPencils()");
		assertArrayEquals(bag2, school.addPencils());
	}

}

事实上，这输出会发生什么：

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

现在，我们将从testAddPencils()方法去除@Ignore注解，修改为注释整个类来代替。

package com.yiibai.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" };

	@Test
	public void testPrepareMyBag() {
		System.out.println("Inside testPrepareMyBag()");
		assertArrayEquals(bag1, school.prepareMyBag());
	}

	@Test
	public void testAddPencils() {
		System.out.println("Inside testAddPencils()");
		assertArrayEquals(bag2, school.addPencils());
	}

}

在这个测试类将不会执行，因此不显示在控制台和JUnit视图输出结果：

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 使用@Ignore注解

创建套件测试 - JUnit教程™

在本节中，我们将学习如何创建套件测试。测试套件是一些测试不同类用例，可以使用@RunWith和@Suite注解运行所有东西在一起。如果有很多测试类，想让它们都运行在同一时间，而不是单一地运行每个测试，这是非常有用的。

当一个类被注解为@RunWith， JUnit 将调用被在其中注解，以便运行测试类，而不使用内置的 JUnit 运行方法。

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

PrepareMyBagTest.java

package com.yiibai.junit;

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

public class PrepareMyBagTest {

	FirstDayAtSchool school = new FirstDayAtSchool();

	String[] bag = { "Books", "Notebooks", "Pens" };

	@Test
	public void testPrepareMyBag() {

		System.out.println("Inside testPrepareMyBag()");
		assertArrayEquals(bag, school.prepareMyBag());

	}

}

AddPencilsTest.java

package com.yiibai.junit;

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

public class AddPencilsTest {

	FirstDayAtSchool school = new FirstDayAtSchool();

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

	@Test
	public void testAddPencils() {

		System.out.println("Inside testAddPencils()");
		assertArrayEquals(bag, school.addPencils());

	}

}

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

SuiteTest.java

package com.yiibai.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 As -> JUnit Test, 两个测试类与已经在@ Suite.SuiteClasses注解定义的顺序执行。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 创建套件测试

创建参数化测试 - JUnit教程™

在本节中，我们将学习如何创建参数测试。为此，我们将使用前面章节中提供的一个公共方法添加整数。因此，这是要进行的测试类。

但是，一个测试类也可以被看作是一个参数化测试类？当然，但它要满足下列所有要求：

该类被注解为 @RunWith(Parameterized.class).
如前一节中所说明的, @RunWith 注解让JUnit来调用其中的注释来运行测试类，代替使用内置的JUnit运行器，Parameterized 是一个在JUnit内的运行器将运行相同的测试用例组在不同的输入。

这个类有一个构造函数，存储测试数据。

这个类有一个静态方法生成并返回测试数据，并注明@Parameters注解。

这个类有一个测试，它需要注解@Test到方法。

现在，我们将创建一个名为 CalculateTest.java 的一个新的测试类, 遵循上述指导原则。这个类的源代码如下。

CalculateTest.java

package com.yiibai.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;
	}

	@Parameters
	public static Collection addedNumbers() {
		return Arrays.asList(new Integer[][] { { 3, 1, 2 }, { 5, 2, 3 },
				{ 7, 3, 4 }, { 9, 4, 5 }, });
	}

	@Test
	public 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

正如我们在输出中看到，测试用例被执行4次，这是在方法的输入注解为@Parameters的数量。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 创建参数化测试

JUnit规则 - JUnit教程™

在本节中，我们学习和了解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 {
	@Rule
	public TestName name = new TestName();

	@Test
	public void testA() {
		System.out.println(name.getMethodName());
		assertEquals("testA", name.getMethodName());

	}

	@Test
	public void testB() {
		System.out.println(name.getMethodName());
		assertEquals("testB", name.getMethodName());
	}
}

我们可以看到，@Rule注解标记的类型是MethodRule的公共字段名，具体而言是TestName类型。 然后，可以在我们的测试中，这名称字段使用和查找，例如测试方法的名称，这种特定情况。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit规则

在命令行中运行JUnit测试 - JUnit教程™

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

下面的步骤显示了如何在Eclipse之外(命令行下)运行测试。

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

JunitRunner.java

package com.yiibai.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测试类。

打开命令提示符，然后往下移目录，找到两个类所在的目录。

编译测试类和运行类。

1 | C:\Users\yiibai\eclipse_workspace\JUnitGuide\test\com\yiibai\junit>javac -classpath "C:\Users\yiibai\Downloads\junit-4.11.jar";"C:\Users\yiibai\Downloads\hamcrest-core-1.3.jar"; AssertionsTest.java JunitRunner.java

注：这里指定包含相关 junit 的相关 jar 包。

现在运行 JunitRunner.

1 | C:\Users\yiibai\eclipse_workspace\JUnitGuide\test\com\yiibai\junit>java -classpath "C:\Users\yiibai\Downloads\junit-4.11.jar";"C:\Users\yiibai\Downloads\hamcrest-core-1.3.jar"; JunitRunner

这里是结果输出：

All tests finished successfully...

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 在命令行中运行JUnit测试

JUnit4 基本用法实例 - JUnit教程™

本教程介绍了在JUnit4中支持的基本注解。

import org.junit.*;
import static org.junit.Assert.*;
import java.util.*;

/**
 * @author yiibai
 *
 */
public class JunitTest1 {

    private Collection collection;

    @BeforeClass
    public static void oneTimeSetUp() {
        // one-time initialization code
    	System.out.println("@BeforeClass - oneTimeSetUp");
    }

    @AfterClass
    public static void oneTimeTearDown() {
        // one-time cleanup code
    	System.out.println("@AfterClass - oneTimeTearDown");
    }

    @Before
    public void setUp() {
        collection = new ArrayList();
        System.out.println("@Before - setUp");
    }

    @After
    public void tearDown() {
        collection.clear();
        System.out.println("@After - tearDown");
    }

    @Test
    public void testEmptyCollection() {
        assertTrue(collection.isEmpty());
        System.out.println("@Test - testEmptyCollection");
    }

    @Test
    public void testOneItemCollection() {
        collection.add("itemA");
        assertEquals(1, collection.size());
        System.out.println("@Test - testOneItemCollection");
    }
}

运行结果：

@BeforeClass - oneTimeSetUp
@Before - setUp
@Test - testEmptyCollection
@After - tearDown
@Before - setUp
@Test - testOneItemCollection
@After - tearDown
@AfterClass - oneTimeTearDown

在JUnit 4中，必须声明“@BeforeClass”和“@AfterClass”的方法是静态方法。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit4 基本用法实例

JUnit4测试方法异常抛出实例 - JUnit教程™

它用于测试由方法抛出的异常。

import org.junit.*;

/**
 * JUnit Expected Exception Test
 * @author yiibai
 *
 */
public class JunitTest2 {

	@Test(expected = ArithmeticException.class)
	public void divisionWithException() {
	  int i = 1/0;
	}

}

在上述例子中，divisionWithException()方法将抛出ArithmeticException异常，因为这是一个预期的异常，因此单元测试会通过。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit4测试方法异常抛出实例

JUnit4忽略（Ignore）测试实例 - JUnit教程™

这种“忽略”是指方法还没有准备好进行测试，JUnit引擎会绕过(忽略)这个方法。

import org.junit.*;

/**
 * JUnit Ignore Test
 * @author yiibai
 *
 */
public class JunitTest3 {

	@Ignore("Not Ready to Run")
	@Test
	public void divisionWithException() {
	  System.out.println("Method is not ready yet");
	}

}

在上面的例子中，JUnit不会执行 divisionWithException()方法。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit4忽略（Ignore）测试实例

JUnit4时间（超时）测试实例 - JUnit教程™

“时间测试”是指，一个单元测试运行时间是否超过指定的毫秒数，测试将终止并标记为失败。

import org.junit.*;

/**
 * JUnit TimeOut Test
 * @author yiibai
 *
 */
public class JunitTest4 {

	@Test(timeout = 1000)
	public void infinity() {
		while (true);
	}

}

在上面的例子中，infinity() 方法将不会返回，因此JUnit引擎将其标记为失败，并抛出一个异常。

java.lang.Exception:test timed out after 1000 milliseconds

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit4时间（超时）测试实例

JUnit套件测试实例 - JUnit教程™

“套件测试”是指捆绑了几个单元测试用例并运行起来。在JUnit中，@RunWith 和 @Suite 这两个注解是用来运行套件测试。

下面的例子演示这两个单元测试：JunitTest1 和 JunitTest2，在执行JunitTest5 后会一起运行。

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

/**
 * JUnit Suite Test
 * @author yiibai
 *
 */

@RunWith(Suite.class)
@Suite.SuiteClasses({
        JunitTest1.class,
        JunitTest2.class
})
public class JunitTest5 {
}

输出结果如下：

@BeforeClass - oneTimeSetUp
@Before - setUp
@Test - testEmptyCollection
@After - tearDown
@Before - setUp
@Test - testOneItemCollection
@After - tearDown
@AfterClass - oneTimeTearDown

P.S 结果是从JunitTest1和JunitTest2单元测试的结果汇总起来。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit套件测试实例

JUnit4参数化测试实例 - JUnit教程™

在JUnit中，可以同时使用@RunWith 和 @parameter 注解来为单元测试传递参数。

注意：

在Eclipse中因为版本问题，可能无法使用@parameters(name = "xxx")，详见解决办法(文章的最后部分： IDE Bug - Eclipse)：

 https://github.com/junit-team/junit/wiki/Parameterized-tests

1. MathUtils – 参数化测试

查看一个简单的 add 方法。

MathUtils.java

package com.yiibai.match.utils;

public class MathUtils {

	public static int add(int a, int b) {
		return a + b;
	}

}

这里有一个为上面的JUnit测试类，阅读不言自明的注释。

MathUtilsTest.java

package com.yiibai.match.utils;

import static org.junit.Assert.assertEquals;
import java.util.Arrays;
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 MathUtilsTest {

	private int numberA;
	private int numberB;
	private int expected;

	//parameters pass via this constructor
	public MathUtilsTest(int numberA, int numberB, int expected) {
		this.numberA = numberA;
		this.numberB = numberB;
		this.expected = expected;
	}

	//Declares parameters here
	@Parameters(name = "{index}: add({0}+{1})={2}")
	public static Iterable<Object[]> data1() {
		return Arrays.asList(new Object[][] {
			{ 1, 1, 2 },
			{ 2, 2, 4 },
			{ 8, 2, 10 },
			{ 4, 5, 9 }
		});
	}

	@Test
	public void test_add() {
		assertEquals(expected,MathUtils.add(numberA, numberB));
	}

}

什么是 {0}, {1} 和 {2}?
如果参数是 “{ 3, 4, 7 }”, 那么 {0} = 3, {1} = 4, {2} = 7. 请参考以下的输出：

2. DomainUtils – 参数化测试

查看域名验证程序。

DomainUtils.java

package com.yiibai.regex.utils;

import java.util.regex.Pattern;

public class DomainUtils {

	private static Pattern pDomainName;

	private static final String DOMAIN_NAME_PATTERN = "^((?!-)[A-Za-z0-9-]{1,63}(?<!-)\\.)+[A-Za-z]{2,6}$";

	static {
		pDomainName = Pattern.compile(DOMAIN_NAME_PATTERN);
	}

	//is this a valid domain name?
	public static boolean isValidDomainName(String domainName) {
		return pDomainName.matcher(domainName).find();
	}

}

这里有一个 JUnit 测试上面的类。

DomainUtilsTest.java

package com.yiibai.regex.utils;

import static org.junit.Assert.assertEquals;
import java.util.Arrays;
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 DomainUtilsTest {

	private String domain;
	private boolean expected;

	public DomainUtilsTest(String domain, boolean expected) {
		this.domain = domain;
		this.expected = expected;
	}

	@Parameters(name= "{index}: isValid({0})={1}")
 	public static Iterable<Object[]> data() {
 		return Arrays.asList(new Object[][] {
 		{ "google.com", true },
		{ "yiibai.com", true },
                { "-yiibai.com", false },
                { "yiibai-.com", false },
                { "3423kjk", false },
                { "mk#$kdo.com", false }
            }
 	);
     }

	@Test
	public void test_validDomains() {
		assertEquals(expected,DomainUtils.isValidDomainName(domain));
	}

}

输出结果：

完成

注
不需要必须去遵循“JUnit”声明参数提供者的方式，并把它传递到通过构造单元测试。如果和TestNG比较，TestNG更加灵活，传递参数为单元测试的方式。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » JUnit4参数化测试实例