JUnit - 快速指南
JUnit - Overview
测试是检查应用程序功能以确保其按要求运行的过程。 单元测试在开发人员层面上出现; 它是单个实体（类或方法）的测试。 单元测试在帮助软件公司向其客户提供优质产品方面发挥着关键作用。
单元测试可以通过两种方式完成 - 手动测试和自动测试。
| 手动测试 | 自动化测试 |
|---|---|
| 在没有任何工具支持的情况下手动执行测试用例称为手动测试。 | 使用自动化工具获取工具支持和执行测试用例称为自动化测试。 |
| Time-consuming and tedious - 由于测试用例是由人力资源执行的，因此非常缓慢而乏味。 | Fast - 自动化运行测试用例的速度明显快于人力资源。 |
| Huge investment in human resources - 由于需要手动执行测试用例，因此手动测试需要更多测试人员。 | Less investment in human resources - 使用自动化工具执行测试用例，因此自动化测试中需要的测试人员数量较少。 |
| Less reliable - 手动测试不太可靠，因为它必须考虑到人为错误。 | More reliable - 自动化测试精确可靠。 |
| Non-programmable - 无法编写复杂的测试来获取隐藏信息。 | Programmable - 测试人员可以Programmable复杂的测试来显示隐藏的信息。 |
什么是JUnit？
JUnit是Java编程语言的单元测试框架。 它在测试驱动开发中起着至关重要的作用，并且是一系列单元测试框架，统称为xUnit。
JUnit提出了“首先测试然后编码”的想法，它强调为一段代码设置测试数据，这些代码可以先测试然后再实现。 这种方法就像“测试一点，代码一点，测试一点，代码一点点”。 它提高了程序员的工作效率和程序代码的稳定性，从而减轻了程序员的压力和调试时间。
JUnit的特点
JUnit是一个开源框架，用于编写和运行测试。
提供用于标识测试方法的注释。
提供用于测试预期结果的断言。
提供用于运行测试的测试运行器。
JUnit测试允许您更快地编写代码，从而提高质量。
JUnit非常简单。 它不那么复杂，花费的时间也少。
JUnit测试可以自动运行，并检查自己的结果并提供即时反馈。 无需手动梳理测试结果报告。
JUnit测试可以组织到包含测试用例甚至其他测试套件的测试套件中。
如果测试运行平稳，JUnit会在条形图中显示绿色的测试进度，当测试失败时，它会变为红色。
什么是单元测试案例？
单元测试用例是代码的一部分，它确保代码的另一部分（方法）按预期工作。 为了快速达到预期的结果，需要一个测试框架。 JUnit是Java编程语言的完美单元测试框架。
正式的书面单元测试用例的特征在于已知输入和预期输出，这是在执行测试之前得出的。 已知输入应测试前提条件，预期输出应测试后置条件。
每个要求必须至少有两个单元测试用例 - 一个是阳性测试，一个是阴性测试。 如果需求具有子需求，则每个子需求必须至少有两个测试用例为正面和负面。
JUnit - Environment Setup
尝试在线选项
我们已经在线设置了Java编程环境，因此您可以在线编译和执行所有可用的示例。 它让您对正在阅读的内容充满信心，并使您能够使用不同的选项验证程序。 随意修改任何示例并在线执行。
使用CodingGround提供的在线编译器尝试以下示例
public class MyFirstJavaProgram { public static void main(String []args) { System.out.println("Hello World"); } }对于本教程中给出的大多数示例，您可以在右上角的网站代码部分找到Try it选项，它将带您进入在线编译器。 所以，只要利用它，享受你的学习。
本地环境设置 (Local Environment Setup)
JUnit是Java的框架，因此第一个要求是在您的机器中安装JDK。
系统要求
| JDK | 1.5或以上。 |
|---|---|
| 记忆 | 没有最低要求。 |
| 磁盘空间 | 没有最低要求。 |
| 操作系统 | 没有最低要求。 |
步骤1:验证计算机中的Java安装
首先，打开控制台并根据您正在使用的操作系统执行java命令。
| OS | 任务 | 命令 |
|---|---|---|
| Windows | 打开命令控制台 | c:\> java -version |
| Linux | 打开命令终端 | $ java -version |
| Mac | 开放式终端 | 机器:~joseph $ java -version |
让我们验证所有操作系统的输出 -
| OS | output |
|---|---|
| Windows | java版“1.8.0_101” Java（TM）SE运行时环境（版本1.8.0_101） |
| Linux | java版“1.8.0_101” Java（TM）SE运行时环境（版本1.8.0_101） |
| Mac | java版“1.8.0_101” Java（TM）SE运行时环境（版本1.8.0_101） |
如果您的系统上没有安装Java，请从以下链接https://www.oracle.com下载Java软件开发工具包（SDK）。 我们假设Java 1.8.0_101是本教程的已安装版本。
第2步:设置JAVA环境
将JAVA_HOME环境变量设置为指向计算机上安装Java的基本目录位置。 例如。
| OS | output |
|---|---|
| Windows | 将环境变量JAVA_HOME设置为C:\Program Files\Java\jdk1.8.0_101 |
| Linux | export JAVA_HOME =/usr/local/java-current |
| Mac | export JAVA_HOME =/Library/Java/Home |
将Java编译器位置附加到系统路径。
| OS | output |
|---|---|
| Windows | 在系统变量Path的末尾附加字符串C:\Program Files\Java\jdk1.8.0_101\bin 。 |
| Linux | export PATH = $ PATH:$ JAVA_HOME/bin/ |
| Mac | 不需要 |
如上所述，使用命令java -version验证Java安装。
第3步:下载JUnit存档
从http://www.junit.org下载最新版本的JUnit jar文件。 在编写本教程时，我们已经下载了Junit-4.12.jar并将其复制到C:\“JUnit文件夹中。
| OS | 存档名称 |
|---|---|
| Windows | junit4.12.jar |
| Linux | junit4.12.jar |
| Mac | junit4.12.jar |
第4步:设置JUnit环境
将JUNIT_HOME环境变量设置为指向计算机上存储JUNIT jar的基本目录位置。 假设我们已经将junit4.12.jar存储在JUNIT文件夹中。
| Sr.No | 操作系统和描述 |
|---|---|
| 1 | Windows 将环境变量JUNIT_HOME设置为C:\JUNIT |
| 2 | Linux export JUNIT_HOME =/usr/local/JUNIT |
| 3 | Mac export JUNIT_HOME =/Library/JUNIT |
第5步:设置CLASSPATH变量
将CLASSPATH环境变量设置为指向JUNIT jar位置。
| Sr.No | 操作系统和描述 |
|---|---|
| 1 | Windows 将环境变量CLASSPATH设置为％CLASSPATH％;％JUNIT_HOME％\ junit4.12.jar;。; |
| 2 | Linux export CLASSPATH = $ CLASSPATH:$ JUNIT_HOME/junit4.12.jar:。 |
| 3 | Mac export CLASSPATH = $ CLASSPATH:$ JUNIT_HOME/junit4.12.jar:。 |
第6步:测试JUnit设置
在C:\》JUNIT_WORKSPACE创建一个java类文件名C:\》JUNIT_WORKSPACE
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestJunit {
@Test
public void testAdd() {
String str = "Junit is working fine";
assertEquals("Junit is working fine",str);
}
}
在C:\》JUNIT_WORKSPACE创建一个java类文件名TestRunner来执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
第7步:验证结果
使用javac编译器编译类如下 -
C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java
现在运行Test Runner以查看结果如下 -
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
true
JUnit - Test Framework
JUnit是一个Regression Testing Framework ，开发人员使用它来实现Java中的单元测试，并加快编程速度并提高代码质量。 JUnit Framework可以轻松地与以下任何一个集成 -
- Eclipse
- Ant
- Maven
JUnit测试框架的特性
JUnit测试框架提供以下重要功能 -
- Fixtures
- 测试套件
- 测试跑步者
- JUnit类
Fixtures
Fixtures是一组对象的固定状态，用作运行测试的基线。 测试夹具的目的是确保存在一个众所周知的固定环境，在该环境中运行测试以使结果可重复。 它包括 -
- setUp（）方法，在每次测试调用之前运行。
- tearDown（）方法，在每个测试方法之后运行。
我们来看一个例子 -
import junit.framework.*;
public class JavaTest extends TestCase {
protected int value1, value2;
// assigning the values
protected void setUp(){
value1 = 3;
value2 = 3;
}
// test method to add two values
public void testAdd(){
double result = value1 + value2;
assertTrue(result == 6);
}
}
测试套房
测试套件捆绑了一些单元测试用例并将它们一起运行。 在JUnit中，@ RunWith和@Suite注释都用于运行套件测试。 下面给出了一个使用TestJunit1和TestJunit2测试类的示例。
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
//JUnit Suite Test
@RunWith(Suite.class)
@Suite.SuiteClasses({
TestJunit1.class ,TestJunit2.class
})
public class JunitTestSuite {
}
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit1 {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
assertEquals(message, messageUtil.printMessage());
}
}
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit2 {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
测试跑步者
测试运行器用于执行测试用例。 这是一个假设测试类TestJunit已经存在的示例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
JUnit类
JUnit类是重要的类，用于编写和测试JUnits。 一些重要的课程是 -
Assert - 包含一组断言方法。
TestCase - 包含一个测试用例，用于定义运行多个测试的fixture。
TestResult - 包含收集执行测试用例结果的方法。
JUnit - Basic Usage
现在让我们有一个基本的例子来演示使用JUnit的逐步过程。
创建一个类 (Create a Class)
在C:\》JUNIT_WORKSPACE创建一个要测试的java类，比如MessageUtil.java
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
}
创建测试用例类 (Create Test Case Class)
- 创建一个java测试类，比如TestJunit.java。
- 将测试方法testPrintMessage（）添加到测试类。
- 将Annotaion @Test添加到方法testPrintMessage（）。
- 使用JUnit的assertEquals API实现测试条件并检查条件。
在C:\》JUNIT_WORKSPACE创建一个java类文件名C:\》JUNIT_WORKSPACE 。
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Hello World";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
assertEquals(message,messageUtil.printMessage());
}
}
创建测试运行器类 (Create Test Runner Class)
- 创建一个TestRunner java类。
- 使用JUnit的JUnitCore类的runClasses方法来运行上面创建的测试类的测试用例。
- 获取在Result Object中运行的测试用例的结果。
- 使用Result对象的getFailures（）方法获取失败。
- 使用Result对象的wasSuccessful（）方法获取Success结果。
在C:\》JUNIT_WORKSPACE创建名为TestRunner.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译MessageUtil，Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
Hello World
true
现在在C:\》JUNIT_WORKSPACE更新TestJunit，以便测试失败。 更改消息字符串。
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Hello World";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
message = "New Word";
assertEquals(message,messageUtil.printMessage());
}
}
让我们按原样保留其余的类，并尝试运行相同的Test Runner。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false
JUnit - API
JUnit中最重要的包是junit.framework ，它包含所有核心类。 一些重要的课程如下 -
| Sr.No. | class名称 | 功能 |
|---|---|---|
| 1 | Assert | 一组断言方法。 |
| 2 | TestCase | 测试用例定义了用于运行多个测试的夹具。 |
| 3 | TestResult | TestResult收集执行测试用例的结果。 |
| 4 | TestSuite | TestSuite是测试的组合。 |
断言类
以下是org.junit.Assert类的声明 -
public class Assert extends java.lang.Object
该类提供了一组用于编写测试的断言方法。 仅记录失败的断言。 Assert类的一些重要方法如下 -
| Sr.No. | 方法和描述 |
|---|---|
| 1 | void assertEquals(boolean expected, boolean actual) 检查两个基元/对象是否相等。 |
| 2 | void assertFalse(boolean condition) 检查条件是否为假。 |
| 3 | void assertNotNull(Object object) 检查对象是否为空。 |
| 4 | void assertNull(Object object) 检查对象是否为空。 |
| 5 | void assertTrue(boolean condition) 检查条件是否为真。 |
| 6 | void fail() 没有消息就失败了。 |
我们在一个例子中使用一些上述方法。 在C:\》JUNIT_WORKSPACE创建名为TestJunit1.java的java类文件。
import org.junit.Test;
import static org.junit.Assert.*;
public class TestJunit1 {
@Test
public void testAdd() {
//test data
int num = 5;
String temp = null;
String str = "Junit is working fine";
//check for equality
assertEquals("Junit is working fine", str);
//check for false condition
assertFalse(num > 6);
//check for not null value
assertNotNull(temp);
}
}
接下来，在C:\“JUNIT_WORKSPACE中创建名为TestRunner1.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner1 {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit1.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译测试用例和Test Runner类。
C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner1
验证输出。
true
TestCase类
以下是org.junit.TestCase类的声明 -
public abstract class TestCase extends Assert implements Test
测试用例定义了用于运行多个测试的夹具。 TestCase类的一些重要方法如下 -
| Sr.No. | 方法和描述 |
|---|---|
| 1 | int countTestCases() 计算run（TestResult结果）执行的测试用例数。 |
| 2 | TestResult createResult() 创建默认的TestResult对象。 |
| 3 | String getName() 获取TestCase的名称。 |
| 4 | TestResult run() 一种方便的方法来运行此测试，使用默认的TestResult对象收集结果。 |
| 5 | void run(TestResult result) 运行测试用例并在TestResult中收集结果。 |
| 6 | void setName(String name) 设置TestCase的名称。 |
| 7 | void setUp() 设置夹具，例如，打开网络连接。 |
| 8 | void tearDown() 例如，撕下夹具，关闭网络连接。 |
| 9 | String toString() 返回测试用例的字符串表示形式。 |
我们在一个例子中使用一些上述方法。 在C:\“JUNIT_WORKSPACE中创建名为TestJunit2.java的java类文件。
import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;
public class TestJunit2 extends TestCase {
protected double fValue1;
protected double fValue2;
@Before
public void setUp() {
fValue1 = 2.0;
fValue2 = 3.0;
}
@Test
public void testAdd() {
//count the number of test cases
System.out.println("No of Test Case = "+ this.countTestCases());
//test getName
String name = this.getName();
System.out.println("Test Case Name = "+ name);
//test setName
this.setName("testNewAdd");
String newName = this.getName();
System.out.println("Updated Test Case Name = "+ newName);
}
//tearDown used to close the connection or clean up activities
public void tearDown( ) {
}
}
接下来，在C:\“JUNIT_WORKSPACE中创建名为TestRunner2.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner2 {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit2.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译测试用例和Test Runner类。
C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner2
验证输出。
No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true
TestResult类
以下是org.junit.TestResult类的声明 -
public class TestResult extends Object
TestResult收集执行测试用例的结果。 它是收集参数模式的一个实例。 测试框架区分故障和错误。 预计会出现故障并通过断言进行检查。 错误是像ArrayIndexOutOfBoundsException这样的意外问题。 TestResult类的一些重要方法如下 -
| Sr.No. | 方法和描述 |
|---|---|
| 1 | void addError(Test test, Throwable t) 向错误列表添加错误。 |
| 2 | void addFailure(Test test, AssertionFailedError t) 在故障列表中添加故障。 |
| 3 | void endTest(Test test) 通知结果测试已完成。 |
| 4 | int errorCount() 获取检测到的错误数。 |
| 5 | Enumeration《TestFailure》 errors() 返回错误的枚举。 |
| 6 | int failureCount() 获取检测到的失败次数。 |
| 7 | void run(TestCase test) 运行TestCase。 |
| 8 | int runCount() 获取运行测试的数量。 |
| 9 | void startTest(Test test) 通知结果将开始测试。 |
| 10 | void stop() 标记测试应该停止。 |
在C:\“JUNIT_WORKSPACE中创建名为TestJunit3.java的java类文件。
import org.junit.Test;
import junit.framework.AssertionFailedError;
import junit.framework.TestResult;
public class TestJunit3 extends TestResult {
// add the error
public synchronized void addError(Test test, Throwable t) {
super.addError((junit.framework.Test) test, t);
}
// add the failure
public synchronized void addFailure(Test test, AssertionFailedError t) {
super.addFailure((junit.framework.Test) test, t);
}
@Test
public void testAdd() {
// add any test
}
// Marks that the test run should stop.
public synchronized void stop() {
//stop the test here
}
}
接下来，在C:\“JUNIT_WORKSPACE中创建名为TestRunner3.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner3 {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit3.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译测试用例和Test Runner类。
C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner3
验证输出。
true
TestSuite类
以下是org.junit.TestSuite类的声明:
public class TestSuite extends Object implements Test
TestSuite是一个综合测试。 它运行一组测试用例。 TestSuite类的一些重要方法如下 -
| Sr.No. | 方法和描述 |
|---|---|
| 1 | void addTest(Test test) 在套件中添加测试。 |
| 2 | void addTestSuite(Class《? extends TestCase》 testClass) 将给定类的测试添加到套件中。 |
| 3 | int countTestCases() 计算此测试将运行的测试用例数。 |
| 4 | String getName() 返回套件的名称。 |
| 5 | void run(TestResult result) 运行测试并在TestResult中收集结果。 |
| 6 | void setName(String name) 设置套件的名称。 |
| 7 | Test testAt(int index) 返回给定索引处的测试。 |
| 8 | int testCount() 返回此套件中的测试数。 |
| 9 | static Test warning(String message) 返回将失败的测试并记录警告消息。 |
在C:\“JUNIT_WORKSPACE中创建一个名为JunitTestSuite.java的java类文件，以创建测试套件。
import junit.framework.*;
public class JunitTestSuite {
public static void main(String[] a) {
// add the test's in the suite
TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
TestResult result = new TestResult();
suite.run(result);
System.out.println("Number of test cases = " + result.runCount());
}
}
使用javac编译Test套件类。
C:\JUNIT_WORKSPACE>javac JunitTestSuite.java
现在运行测试套件。
C:\JUNIT_WORKSPACE>java JunitTestSuite
验证输出。
No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3
JUnit - Writing a Test
在这里，我们将看到一个使用POJO类，业务逻辑类和测试类的JUnit测试的完整示例，它将由测试运行器运行。
在C:\“JUNIT_WORKSPACE中创建EmployeeDetails.java ，这是一个POJO类。
public class EmployeeDetails {
private String name;
private double monthlySalary;
private int age;
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the monthlySalary
*/
public double getMonthlySalary() {
return monthlySalary;
}
/**
* @param monthlySalary the monthlySalary to set
*/
public void setMonthlySalary(double monthlySalary) {
this.monthlySalary = monthlySalary;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
}
EmployeeDetails类用于 -
- 获取/设置员工姓名的值。
- 获取/设置员工月薪的值。
- 获取/设置员工年龄的值。
在C:\“JUNIT_WORKSPACE中创建一个名为EmpBusinessLogic.java的文件，其中包含业务逻辑。
public class EmpBusinessLogic {
// Calculate the yearly salary of employee
public double calculateYearlySalary(EmployeeDetails employeeDetails) {
double yearlySalary = 0;
yearlySalary = employeeDetails.getMonthlySalary() * 12;
return yearlySalary;
}
// Calculate the appraisal amount of employee
public double calculateAppraisal(EmployeeDetails employeeDetails) {
double appraisal = 0;
if(employeeDetails.getMonthlySalary() < 10000){
appraisal = 500;
}else{
appraisal = 1000;
}
return appraisal;
}
}
EmpBusinessLogic类用于计算 -
- 员工的年薪。
- 员工的评估金额。
在C:\“JUNIT_WORKSPACE中创建一个名为TestEmployeeDetails.java的文件，其中包含要测试的测试用例。
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestEmployeeDetails {
EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
EmployeeDetails employee = new EmployeeDetails();
//test to check appraisal
@Test
public void testCalculateAppriasal() {
employee.setName("Rajeev");
employee.setAge(25);
employee.setMonthlySalary(8000);
double appraisal = empBusinessLogic.calculateAppraisal(employee);
assertEquals(500, appraisal, 0.0);
}
// test to check yearly salary
@Test
public void testCalculateYearlySalary() {
employee.setName("Rajeev");
employee.setAge(25);
employee.setMonthlySalary(8000);
double salary = empBusinessLogic.calculateYearlySalary(employee);
assertEquals(96000, salary, 0.0);
}
}
TestEmployeeDetails类用于测试EmpBusinessLogic类的方法。 它
- 测试员工的年薪。
- 测试员工的评估金额。
接下来，在C:\“JUNIT_WORKSPACE中创建一个名为TestRunner.java的java类，以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestEmployeeDetails.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译测试用例和Test Runner类。
C:\JUNIT_WORKSPACE>javac EmployeeDetails.java
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
true
JUnit - Using Assertion
断言(Assertion)
所有断言都在Assert类中。
public class Assert extends java.lang.Object
该类提供了一组断言方法，对编写测试很有用。 仅记录失败的断言。 Assert类的一些重要方法如下 -
| Sr.No. | 方法和描述 |
|---|---|
| 1 | void assertEquals(boolean expected, boolean actual) 检查两个基元/对象是否相等。 |
| 2 | void assertTrue(boolean condition) 检查条件是否为真。 |
| 3 | void assertFalse(boolean condition) 检查条件是否为假。 |
| 4 | void assertNotNull(Object object) 检查对象是否为空。 |
| 5 | void assertNull(Object object) 检查对象是否为空。 |
| 6 | void assertSame(object1, object2) assertSame（）方法测试两个对象引用是否指向同一个对象。 |
| 7 | void assertNotSame(object1, object2) assertNotSame（）方法测试两个对象引用是否指向同一对象。 |
| 8 | void assertArrayEquals(expectedArray, resultArray); assertArrayEquals（）方法将测试两个数组是否彼此相等。 |
我们在一个例子中使用一些上述方法。 在C:\“JUNIT_WORKSPACE中创建名为TestAssertions.java的java类文件。
import org.junit.Test;
import static org.junit.Assert.*;
public class TestAssertions {
@Test
public void testAssertions() {
//test data
String str1 = new String ("abc");
String str2 = new String ("abc");
String str3 = null;
String str4 = "abc";
String str5 = "abc";
int val1 = 5;
int val2 = 6;
String[] expectedArray = {"one", "two", "three"};
String[] resultArray = {"one", "two", "three"};
//Check that two objects are equal
assertEquals(str1, str2);
//Check that a condition is true
assertTrue (val1 < val2);
//Check that a condition is false
assertFalse(val1 > val2);
//Check that an object isn't null
assertNotNull(str1);
//Check that an object is null
assertNull(str3);
//Check if two object references point to the same object
assertSame(str4,str5);
//Check if two object references not point to the same object
assertNotSame(str1,str3);
//Check whether two arrays are equal to each other.
assertArrayEquals(expectedArray, resultArray);
}
}
接下来，在C:\“JUNIT_WORKSPACE中创建一个名为TestRunner.java的java类文件，以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner2 {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestAssertions.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
true
注释(Annotation)
注释就像元标记，您可以将其添加到代码中，并将它们应用于方法或类中。 JUnit中的这些注释提供了有关测试方法的以下信息 -
- 哪些方法将在测试方法之前和之后运行。
- 哪些方法在所有方法之前和之后运行，以及。
- 在执行期间将忽略哪些方法或类。
下表提供了JUnit中的注释列表及其含义 -
| Sr.No. | 注释和说明 |
|---|---|
| 1 | @Test Test annotation告诉JUnit它所附加的public void方法可以作为测试用例运行。 |
| 2 | @Before 几个测试需要在它们运行之前创建类似的对象。 使用@Before注释public void方法会导致该方法在每个Test方法之前运行。 |
| 3 | @After 如果在Before方法中分配外部资源，则需要在测试运行后释放它们。 使用@After注释public void方法会导致该方法在Test方法之后运行。 |
| 4 | @BeforeClass 使用@BeforeClass注释公共静态void方法会导致它在类中的任何测试方法之前运行一次。 |
| 5 | @AfterClass 这将在所有测试完成后执行该方法。 这可用于执行清理活动。 |
| 6 | @Ignore Ignore注释用于忽略测试，并且不会执行该测试。 |
在C:\“JUNIT_WORKSPACE中创建名为JunitAnnotation.java的java类文件以测试注释。
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class JunitAnnotation {
//execute before class
@BeforeClass
public static void beforeClass() {
System.out.println("in before class");
}
//execute after class
@AfterClass
public static void afterClass() {
System.out.println("in after class");
}
//execute before test
@Before
public void before() {
System.out.println("in before");
}
//execute after test
@After
public void after() {
System.out.println("in after");
}
//test case
@Test
public void test() {
System.out.println("in test");
}
//test case ignore and will not execute
@Ignore
public void ignoreTest() {
System.out.println("in ignore test");
}
}
接下来，在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行注释。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(JunitAnnotation.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
in before class
in before
in test
in after
in after class
true
JUnit - Execution Procedure
本章解释了JUnit中方法的执行过程，它定义了被调用方法的顺序。 下面讨论的是JUnit测试API方法的执行过程和示例。
在C:\> JUNIT_WORKSPACE中创建一个名为ExecutionProcedureJunit.java的java类文件来测试注释。
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class ExecutionProcedureJunit {
//execute only once, in the starting
@BeforeClass
public static void beforeClass() {
System.out.println("in before class");
}
//execute only once, in the end
@AfterClass
public static void afterClass() {
System.out.println("in after class");
}
//execute for each test, before executing test
@Before
public void before() {
System.out.println("in before");
}
//execute for each test, after executing test
@After
public void after() {
System.out.println("in after");
}
//test case 1
@Test
public void testCase1() {
System.out.println("in test case 1");
}
//test case 2
@Test
public void testCase2() {
System.out.println("in test case 2");
}
}
接下来，在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行注释。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(ExecutionProcedureJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class
见上面的输出。 执行程序如下 -
- 首先，beforeClass（）方法只执行一次。
- afterClass（）方法只执行一次。
- before（）方法对每个测试用例执行，但在执行测试用例之前。
- after（）方法为每个测试用例执行，但是在执行测试用例之后。
- 在before（）和after（）之间，每个测试用例都会执行。
JUnit - Executing Tests
测试用例使用JUnitCore类执行。 JUnitCore是运行测试的外观。 它支持运行JUnit 4测试，JUnit 3.8.x测试和混合。 要从命令行运行测试，请运行java org.junit.runner.JUnitCore“TestClass”。 对于一次性测试运行，请使用静态方法runClasses（Class []）。
以下是org.junit.runner.JUnitCore类的声明:
public class JUnitCore extends java.lang.Object
在这里，我们将看到如何在JUnitCore的帮助下执行测试。
创建一个类 (Create a Class)
在C:\“JUNIT_WORKSPACE中创建一个要测试的java类，比如MessageUtil.java 。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
}
创建测试用例类 (Create Test Case Class)
创建一个java测试类，比如TestJunit.java。
将测试方法testPrintMessage（）添加到测试类。
将Annotaion @Test添加到方法testPrintMessage（）中。
使用JUnit的assertEquals API实现测试条件并检查条件。
在C:\“JUNIT_WORKSPACE中创建名为TestJunit.java的java类文件。
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Hello World";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
assertEquals(message,messageUtil.printMessage());
}
}
创建测试运行器类 (Create Test Runner Class)
现在在C:\“JUNIT_WORKSPACE中创建一个名为TestRunner.java的java类文件来执行测试用例。 它导入JUnitCore类并使用runClasses（）方法，该方法将测试类名称作为其参数。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
Hello World
true
JUnit - Suite Test
Test suite用于捆绑一些单元测试用例并将它们一起运行。 在JUnit中， @RunWith和@Suite注释都用于运行套件测试。 本章以两个测试类TestJunit1和TestJunit2 ，它们使用Test Suite一起运行。
创建一个类 (Create a Class)
在C:\“JUNIT_WORKSPACE中创建一个要测试的java类，比如MessageUtil.java 。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
// add "Hi!" to the message
public String salutationMessage(){
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
创建测试用例类
在C:\“JUNIT_WORKSPACE中创建名为TestJunit1.java的java类文件。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit1 {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
assertEquals(message, messageUtil.printMessage());
}
}
在C:\“JUNIT_WORKSPACE中创建名为TestJunit2.java的java类文件。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit2 {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
创建测试套件类
- 创建一个java类。
- 使用类附加@RunWith（Suite.class）注释。
- 使用@ Suite.SuiteClasses批注添加对JUnit测试类的引用。
在C:\“JUNIT_WORKSPACE中创建名为TestSuite.java的java类文件以执行测试用例。
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({
TestJunit1.class,
TestJunit2.class
})
public class JunitTestSuite {
}
创建测试运行器类 (Create Test Runner Class)
在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(JunitTestSuite.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译所有java类。
C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java
TestJunit2.java JunitTestSuite.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true
JUnit - Ignore Test
有时，在运行测试用例时，我们的代码并没有完全准备就绪。 结果，测试用例失败。 @Ignore注释在这种情况下@Ignore帮助。
使用@Ignore注释的测试方法将不会被执行。
如果测试类使用@Ignore注释，则不会执行任何测试方法。
现在让我们看看@Ignore在行动。
创建一个类 (Create a Class)
在C:\“JUNIT_WORKSPACE中创建一个要测试的java类，比如MessageUtil.java 。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
// add "Hi!" to the message
public String salutationMessage(){
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
创建测试用例类 (Create Test Case Class)
创建一个java测试类，比如TestJunit.java。
将测试方法testPrintMessage（）或testSalutationMessage（）添加到测试类。
将Annotaion @Ignore添加到方法testPrintMessage（）中。
在C:\JUNIT_WORKSPACE中创建名为TestJunit.java的java类文件。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Ignore
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
message = "Robert";
assertEquals(message,messageUtil.printMessage());
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
创建测试运行器类 (Create Test Runner Class)
在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译MessageUtil，Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java
现在运行Test Runner，它不会运行在提供的Test Case类中定义的testPrintMessage（）测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。 testPrintMessage（）测试用例未经过测试。
Inside testSalutationMessage()
Hi!Robert
true
现在，在C:\> JUNIT_WORKSPACE中更新TestJunit以忽略所有测试用例。 在class添加@Ignore。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
@Ignore
public class TestJunit {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
message = "Robert";
assertEquals(message,messageUtil.printMessage());
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
使用javac编译测试用例。
C:\JUNIT_WORKSPACE>javac TestJunit.java
让Test Runner保持不变，如下所示 -
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
现在运行Test Runner，它不会运行在提供的Test Case类中定义的任何测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。 没有测试测试用例。
true
JUnit - Time Test
JUnit提供了一个方便的Timeout选项。 如果测试用例花费的时间超过指定的毫秒数，则JUnit会自动将其标记为失败。 timeout参数与@Test注释一起使用。 让我们看看@Test（超时）的实际效果。
创建一个类 (Create a Class)
在C:\“JUNIT_WORKSPACE中创建一个要测试的java类，比如MessageUtil.java 。
在printMessage（）方法中添加无限while循环。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public void printMessage(){
System.out.println(message);
while(true);
}
// add "Hi!" to the message
public String salutationMessage(){
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
创建测试用例类 (Create Test Case Class)
创建一个java测试类，比如TestJunit.java 。 为testPrintMessage（）测试用例添加1000的超时。
在C:\“JUNIT_WORKSPACE中创建名为TestJunit.java的java类文件。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test(timeout = 1000)
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
messageUtil.printMessage();
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
创建测试运行器类 (Create Test Runner Class)
在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译MessageUtil，Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。 testPrintMessage（）测试用例将标记单元测试失败。
Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
testPrintMessage(TestJunit): test timed out after 1000 milliseconds
false
JUnit - Exceptions Test
JUnit提供了跟踪代码异常处理的选项。 您可以测试代码是否抛出所需的异常。 expected参数与@Test注释一起使用。 让我们看看@Test（预期）在行动。
创建一个类 (Create a Class)
在C:\“JUNIT_WORKSPACE中创建一个要测试的java类，比如MessageUtil.java 。
在printMessage（）方法中添加错误条件。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public void printMessage(){
System.out.println(message);
int a = 0;
int b = 1/a;
}
// add "Hi!" to the message
public String salutationMessage(){
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
创建测试用例类 (Create Test Case Class)
创建一个名为TestJunit.java的java测试类。 将预期的异常ArithmeticException添加到testPrintMessage（）测试用例。
在C:\“JUNIT_WORKSPACE中创建名为TestJunit.java的java类文件。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test(expected = ArithmeticException.class)
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
messageUtil.printMessage();
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
创建测试运行器类 (Create Test Runner Class)
在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译MessageUtil，Test case和Test Runner类。
C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。 testPrintMessage（）测试用例将被传递。
Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
true
JUnit - Parameterized Test
JUnit 4引入了一项名为parameterized tests的新功能。 参数化测试允许开发人员使用不同的值反复运行相同的测试。 创建参数化测试需要遵循五个步骤。
使用@RunWith（Parameterized.class）注释测试类。
创建一个使用@Parameters注释的公共静态方法，该方法返回一个对象集合（作为数组）作为测试数据集。
创建一个公共构造函数，它接受相当于一行“测试数据”的内容。
为测试数据的每个“列”创建一个实例变量。
使用实例变量作为测试数据的来源创建测试用例。
对于每行数据，将调用一次测试用例。 让我们看看参数化测试的实际效果。
创建一个类 (Create a Class)
在C:\“JUNIT_WORKSPACE中创建一个要测试的java类，比如PrimeNumberChecker.java。
public class PrimeNumberChecker {
public Boolean validate(final Integer primeNumber) {
for (int i = 2; i < (primeNumber/2); i++) {
if (primeNumber % i == 0) {
return false;
}
}
return true;
}
}
创建参数化测试用例类
创建一个java测试类，比如PrimeNumberCheckerTest.java 。 在C:\“JUNIT_WORKSPACE中创建名为PrimeNumberCheckerTest.java的java类文件。
import java.util.Arrays;
import java.util.Collection;
import org.junit.Test;
import org.junit.Before;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
private Integer inputNumber;
private Boolean expectedResult;
private PrimeNumberChecker primeNumberChecker;
@Before
public void initialize() {
primeNumberChecker = new PrimeNumberChecker();
}
// Each parameter should be placed as an argument here
// Every time runner triggers, it will pass the arguments
// from parameters we defined in primeNumbers() method
public PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) {
this.inputNumber = inputNumber;
this.expectedResult = expectedResult;
}
@Parameterized.Parameters
public static Collection primeNumbers() {
return Arrays.asList(new Object[][] {
{ 2, true },
{ 6, false },
{ 19, true },
{ 22, false },
{ 23, true }
});
}
// This test will run 4 times since we have 5 parameters defined
@Test
public void testPrimeNumberChecker() {
System.out.println("Parameterized Number is : " + inputNumber);
assertEquals(expectedResult,
primeNumberChecker.validate(inputNumber));
}
}
创建测试运行器类 (Create Test Runner Class)
在C:\“JUNIT_WORKSPACE中创建名为TestRunner.java的java类文件以执行测试用例。
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(PrimeNumberCheckerTest.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
使用javac编译PrimeNumberChecker，PrimeNumberCheckerTest和Test Runner类。
C:\JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java
TestRunner.java
现在运行Test Runner，它将运行在提供的Test Case类中定义的测试用例。
C:\JUNIT_WORKSPACE>java TestRunner
验证输出。
Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
true
JUnit - Plug with ANT
我们将有一个示例来演示如何使用ANT运行JUnit。 请按照以下步骤操作。
第1步:下载Apache Ant
根据您正在使用的操作系统下载Apache Ant。
| OS | 存档名称 |
|---|---|
| Windows | apache-ant-1.8.4-bin.zip |
| Linux | apache-ant-1.8.4-bin.tar.gz |
| Mac | apache-ant-1.8.4-bin.tar.gz |
第2步:设置Ant环境
将ANT_HOME环境变量设置为指向基本目录位置，ANT库存储在您的计算机上。 我们假设Ant库存储在apache-ant-1.8.4文件夹中。
| Sr.No. | 操作系统和描述 |
|---|---|
| 1 | Windows 将环境变量ANT_HOME设置为C:\Program Files\Apache Software Foundation\apache-ant-1.8.4 |
| 2 | Linux export ANT_HOME = /usr/local/apache-ant-1.8.4 |
| 3 | Mac export ANT_HOME = /Library/apache-ant-1.8.4 |
将Ant编译器位置附加到系统路径，如下所示 -
| OS | output |
|---|---|
| Windows | 在系统变量Path的末尾附加字符串%ANT_HOME\bin 。 |
| Linux | export PATH = $ PATH:$ ANT_HOME/bin/ |
| Mac | 不需要 |
第3步:下载JUnit存档
下载适合您操作系统的JUnit存档。
| OS | 存档名称 |
|---|---|
| Windows | junit4.10.jar |
| Linux | junit4.10.jar |
| Mac | junit4.10.jar |
第4步:创建项目结构
在C:\“JUNIT_WORKSPACE中创建一个文件夹TestJunitWithAnt。
在C:\“JUNIT_WORKSPACE”TestJunitWithAnt中创建一个文件夹src 。
在C:\“JUNIT_WORKSPACE”TestJunitWithAnt中创建文件夹test 。
在C:\“JUNIT_WORKSPACE”TestJunitWithAnt中创建一个文件夹lib 。
在C:\“JUNIT_WORKSPACE”TestJunitWithAnt“srcfolder中创建MessageUtil类。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
// add "Hi!" to the message
public String salutationMessage(){
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
在文件夹C:\“JUNIT_WORKSPACE”TestJunitWithAnt“src中创建TestMessageUtil类。
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestMessageUtil {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
assertEquals(message,messageUtil.printMessage());
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
将junit-4.10.jar复制到文件夹C:\> JUNIT_WORKSPACE> TestJunitWithAnt> lib。
创建ANT Build.xml
我们将在Ant中使用《junit》任务来执行我们的JUnit测试用例。
<project name = "JunitTest" default = "test" basedir = ".">
<property name = "testdir" location = "test" />
<property name = "srcdir" location = "src" />
<property name = "full-compile" value = "true" />
<path id = "classpath.base"/>
<path id = "classpath.test">
<pathelement location = "lib/junit-4.10.jar" />
<pathelement location = "${testdir}" />
<pathelement location = "${srcdir}" />
<path refid = "classpath.base" />
</path>
<target name = "clean" >
<delete verbose = "${full-compile}">
<fileset dir = "${testdir}" includes = "**/*.class" />
</delete>
</target>
<target name = "compile" depends = "clean">
<javac srcdir = "${srcdir}" destdir = "${testdir}"
verbose = "${full-compile}">
<classpath refid = "classpath.test"/>
</javac>
</target>
<target name = "test" depends = "compile">
<junit>
<classpath refid = "classpath.test" />
<formatter type = "brief" usefile = "false" />
<test name = "TestMessageUtil" />
</junit>
</target>
</project>
运行以下Ant命令。
C:\JUNIT_WORKSPACE\TestJunitWithAnt>ant
验证输出。
Buildfile: C:\JUNIT_WORKSPACE\TestJunitWithAnt\build.xml
clean:
compile:
[javac] Compiling 2 source files to C:\JUNIT_WORKSPACE\TestJunitWithAnt\test
[javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
MessageUtil.java]
[javac] [parsing completed 18ms]
[javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
TestMessageUtil.java]
[javac] [parsing completed 2ms]
[javac] [search path for source files: C:\JUNIT_WORKSPACE\
TestJunitWithAnt\src]
[javac] [loading java\lang\Object.class(java\lang:Object.class)]
[javac] [loading java\lang\String.class(java\lang:String.class)]
[javac] [loading org\junit\Test.class(org\junit:Test.class)]
[javac] [loading org\junit\Ignore.class(org\junit:Ignore.class)]
[javac] [loading org\junit\Assert.class(org\junit:Assert.class)]
[javac] [loading java\lang\annotation\Retention.class
(java\lang\annotation:Retention.class)]
[javac] [loading java\lang\annotation\RetentionPolicy.class
(java\lang\annotation:RetentionPolicy.class)]
[javac] [loading java\lang\annotation\Target.class
(java\lang\annotation:Target.class)]
[javac] [loading java\lang\annotation\ElementType.class
(java\lang\annotation:ElementType.class)]
[javac] [loading java\lang\annotation\Annotation.class
(java\lang\annotation:Annotation.class)]
[javac] [checking MessageUtil]
[javac] [loading java\lang\System.class(java\lang:System.class)]
[javac] [loading java\io\PrintStream.class(java\io:PrintStream.class)]
[javac] [loading java\io\FilterOutputStream.class
(java\io:FilterOutputStream.class)]
[javac] [loading java\io\OutputStream.class(java\io:OutputStream.class)]
[javac] [loading java\lang\StringBuilder.class
(java\lang:StringBuilder.class)]
[javac] [loading java\lang\AbstractStringBuilder.class
(java\lang:AbstractStringBuilder.class)]
[javac] [loading java\lang\CharSequence.class(java\lang:CharSequence.class)]
[javac] [loading java\io\Serializable.class(java\io:Serializable.class)]
[javac] [loading java\lang\Comparable.class(java\lang:Comparable.class)]
[javac] [loading java\lang\StringBuffer.class(java\lang:StringBuffer.class)]
[javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\MessageUtil.class]
[javac] [checking TestMessageUtil]
[javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\TestMessageUtil.class]
[javac] [total 281ms]
test:
[junit] Testsuite: TestMessageUtil
[junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec
[junit]
[junit] ------------- Standard Output ---------------
[junit] Inside testPrintMessage()
[junit] Robert
[junit] Inside testSalutationMessage()
[junit] Hi!Robert
[junit] ------------- ---------------- ---------------
BUILD SUCCESSFUL
Total time: 0 seconds
JUnit - Plug with Eclipse
要使用eclipse设置JUnit，请按照以下步骤操作。
第1步:下载JUnit Archive
根据系统上的操作系统下载JUnit jar。
| OS | 存档名称 |
|---|---|
| Windows | junit4.10.jar |
| Linux | junit4.10.jar |
| Mac | junit4.10.jar |
假设您已将上述JAR文件复制到文件夹C:\> JUnit。
第2步:设置Eclipse环境
打开eclipse→右键单击项目，然后单击属性>构建路径>配置构建路径，并使用Add External Jar按钮在库中添加junit-4.10.jar。
我们假设您的Eclipse内置了JUnit插件。 如果它在C:\> eclipse\plugins目录中不可用，那么您可以从JUnit Plugin下载它。 将下载的zip文件解压缩到Eclipse的plugin文件夹中。 最后重启Eclipse。
现在您的Eclipse已准备好开发JUnit测试用例。
第3步:验证Eclipse中的JUnit安装
在Eclipse中的任何位置创建一个项目TestJunit 。 然后创建一个MessageUtil类以在项目中进行测试。
/*
* This class prints the given message on console.
*/
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
}
在项目中创建一个测试类TestJunit 。
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Hello World";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
assertEquals(message,messageUtil.printMessage());
}
}
以下应该是项目结构 -
最后，右键单击该程序并以JUnit身份运行以验证程序的输出。
验证结果。
JUnit - Extensions
以下是JUnit扩展 -
- Cactus
- JWebUnit
- XMLUnit
- MockObject
Cactus
Cactus是一个简单的测试框架，用于测试服务器端Java代码（Servlet，EJB，Tag Libs，Filters）。 Cactus的目的是降低为服务器端代码编写测试的成本。 它使用JUnit并扩展它。 Cactus实现了一个容器内策略，用于在容器内执行测试。
仙人掌生态系统由几个组成部分组成 -
Cactus Framework是Cactus Framework的核心。 它是提供API来编写Cactus测试的引擎。
Cactus Integration Modules是前端和框架，提供了使用Cactus Framework（Ant脚本，Eclipse插件和Maven插件）的简便方法。
以下代码演示了如何使用Cactus。
import org.apache.cactus.*;
import junit.framework.*;
public class TestSampleServlet extends ServletTestCase {
@Test
public void testServlet() {
// Initialize class to test
SampleServlet servlet = new SampleServlet();
// Set a variable in session as the doSomething()
// method that we are testing
session.setAttribute("name", "value");
// Call the method to test, passing an
// HttpServletRequest object (for example)
String result = servlet.doSomething(request);
// Perform verification that test was successful
assertEquals("something", result);
assertEquals("otherValue", session.getAttribute("otherName"));
}
}
JWebUnit
JWebUnit是一个基于Java的Web应用程序测试框架。 它将现有的测试框架（如HtmlUnit和Selenium）与统一，简单的测试界面结合在一起，以测试Web应用程序的正确性。
JWebUnit提供了一个高级Java API，用于导航Web应用程序并结合一组断言来验证应用程序的正确性。 这包括通过链接导航，表单输入和提交，表格内容验证以及其他典型的商业Web应用程序功能。
与仅使用JUnit或HtmlUnit相比，简单的导航方法和即用型断言允许更快速地创建测试。 如果你想从HtmlUnit切换到其他插件，如Selenium（即将推出），则无需重写测试。
这是一个示例代码。
import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;
public class ExampleWebTestCase extends TestCase {
private WebTester tester;
public ExampleWebTestCase(String name) {
super(name);
tester = new WebTester();
}
//set base url
public void setUp() throws Exception {
getTestContext().setBaseUrl("http://myserver:8080/myapp");
}
// test base info
@Test
public void testInfoPage() {
beginAt("/info.html");
}
}
XMLUnit
XMLUnit提供了一个JUnit扩展类，XMLTestCase和一组支持类，允许进行断言 -
两段XML之间的差异（通过Diff和DetailedDiff类）。
一段XML的有效性（通过Validator类）。
使用XSLT（通过Transform类）转换XML片段的结果。
在一段XML上评估XPath表达式（通过实现XpathEngine接口的类）。
DOM Traversal（通过NodeTest类）公开的XML片段中的各个节点。
让我们假设我们有两个XML，我们希望比较并断言它们是相等的。 我们可以编写一个这样的简单测试类 -
import org.custommonkey.xmlunit.XMLTestCase;
public class MyXMLTestCase extends XMLTestCase {
// this test method compare two pieces of the XML
@Test
public void testForXMLEquality() throws Exception {
String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
String myTestXML = "<msg><localId>2376</localId></msg>";
assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
}
}
MockObject
在单元测试中，模拟对象可以模拟复杂的，真实的（非模拟）对象的行为，因此当真实对象不可行或不可能合并到单元测试中时非常有用。
使用模拟对象进行测试的常见编码风格是 -
- 创建模拟对象的实例。
- 在模拟对象中设置状态和期望。
- 使用模拟对象作为参数调用域代码。
- 验证模拟对象的一致性。
下面给出了使用Jmock的MockObject示例。
import org.jmock.Mockery;
import org.jmock.Expectations;
class PubTest extends TestCase {
Mockery context = new Mockery();
public void testSubReceivesMessage() {
// set up
final Sub sub = context.mock(Sub.class);
Pub pub = new Pub();
pub.add(sub);
final String message = "message";
// expectations
context.checking(new Expectations() {
oneOf (sub).receive(message);
});
// execute
pub.publish(message);
// verify
context.assertIsSatisfied();
}
}
