【JUnit技术专题】「入门到精通系列」手把手+零基础带你玩转单元测试，让你的代码更加“强壮”（核心API篇）

回顾一下JUnit

JUnit是一个回归测试框架，开发者使用它来实施应用程序的单元测试，以提高编码质量和加快程序编写速度。JUnit测试框架可以轻松地完成以下任意两种结合：

• IDEA 集成开发环境
• Gradle 项目构建管理
• Maven 项目构建管理

JUnit的特性

JUnit测试框架的四个重要特性：测试工具、测试套件、测试运行器和测试分类。

]其中，测试工具是JUnit提供的一组API，用于编写和运行单元测试；测试套件是将多个测试类组合在一起的一种方式，可以一次性运行多个测试类；测试运行器是用于运行测试的程序，可以选择要运行的测试类或测试套件；测试分类是JUnit 5中的新特性，可以根据不同的标签对测试进行分类和过滤。这些特性使得JUnit成为一款强大的测试框架，可以帮助开发者快速、准确地进行单元测试。

测试工具

测试工具是一整套固定的工具，用于进行基线测试。其目的在于确保测试能够在共享且固定的环境中运行，从而保证测试结果的可重复性。测试工具集包含以下两个方法：

1. setUp() 方法：在所有测试调用指令发起前执行，用于初始化测试环境和准备测试数据。

2. 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 注解被用于运行测试套件。

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 {
}

下面是使用 TestJunit1 和 TestJunit2 进行测试分类的示例：

建立一个TestJUnit1单元测试执行类

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit1 {
	String message = "Robert";
	MessageModel messageUtil = new MessageModel (message);
	@Test
	public void testPrintMessage() {
		System.out.println("Inside testPrintMessage()");
		assertEquals(message, messageUtil.printMessage());
	}
}

建立一个TestJUnit2单元测试执行类

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit2 {
   String message = "Robert";
   MessageModel messageUtil = new MessageModel (message);
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

测试运行器

测试运行器用于执行测试案例。以下是一个假定测试分类成立的示例：

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 的重要分类。几种重要的分类如下：

• 包含一套测试断言方法的测试断言。
• 包含规范运行多个测试工具的测试用例。
• 包含用于收集执行测试用例结果的方法的测试结果。

案例分析

下面的案例代码：

import org.junit.Test;
import org.junit.experimental.categories.Category;

public class JunitTest {

    @Category(SlowTests.class)
    @Test
    public void slowTest() {
        // 这里是慢速测试的测试代码
    }

    @Category(FastTests.class)
    @Test
    public void fastTest() {
        // 这里是快速测试的测试代码
    }

    public interface SlowTests {
        // 慢速测试接口
    }

    public interface FastTests {
        // 快速测试接口
    }
}

在上面的代码中，我们定义了两个测试接口 SlowTests 和 FastTests，用于标记测试方法属于哪个分类。在 slowTest() 方法上，我们使用了 @Category 注解，将该方法标记为慢速测试，并将其放入 SlowTests 接口中。同样的，fastTest() 方法被标记为快速测试，并放入 FastTests 接口中。

通过这种方式，我们可以轻松地对测试进行分类，并在运行测试时只运行特定的分类。例如，我们可以只运行慢速测试，而跳过快速测试，或者反过来。这样可以大大提高测试的效率和准确性。

---

JUnit 中的重要的 API

JUnit 中的最重要的程序包是 junit.framework 它包含了所有的核心类。一些重要的类列示如下：

序号	类名	功能
1	Assert	asssert方法的集合
2	TestCase	一个定义了运行多重测试的固定装置
3	TestResult	TestResult集合了执行测试样例的所有结果
4	TestSuite	TestSuite是测试的集合

Assert 类

下面介绍的是 org.junit.Assert 类：

public class Assert extends java.lang.Object

这个类提供了一系列的编写测试的有用的声明方法。只有失败的声明方法才会被记录。Assert 类的重要方法列式，如下：

序号	方法和描述
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() 在没有报告的情况下使测试不通过

下面让我们在例子中来测试一下上面提到的一些方法。

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(str);
  }
}

运行测试套件键值处理模式

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());
	}
}

TestCase 类

下面介绍的是 org.junit.TestCaset 类：

public abstract class TestCase extends Assert implements Test

测试样例定义了运行多重测试的固定格式。TestCase 类的一些重要方法列式如下：

序号	方法和描述
1	int countTestCases() 为被run(TestResult result) 执行的测试案例计数
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() 返回测试案例的一个字符串表示

我们在例子中尝试一下上文提到的方法。

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( ) {
  }
}

接下来创建一个名为 TestRunner2.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());
  }
}

检查输出结果。

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 类的一些重要方法列式如下：

序号	方法和描述
1	void addError(Test test, Throwable t) 在错误列表中加入一个错误
2	void addFailure(Test test, AssertionFailedError t) 在失败列表中加入一个失败
3	void endTest(Test test) 显示测试被编译的这个结果
4	int errorCount() 获取被检测出错误的数量
5	Enumeration errors() 返回错误的详细信息
6	int failureCount() 获取被检测出的失败的数量
7	void run(TestCase test) 运行 TestCase
8	void startTest(Test test) 声明一个测试即将开始
9	void stop() 标明测试必须停止
10	int runCount() 获得运行测试的数量

创建一个名为 TestJunit3.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
	}
}

接下来，创建一个名为 TestRunner3.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());
  }
}

现在运行 Test Runner 它将运行在 Test Case 类中定义并提供的测试样例，true。

TestSuite 类

下面定义的是 org.junit.TestSuite 类：

public class TestSuite extends Object implements Test

TestSuite 类是测试的组成部分。它运行了很多的测试案例。TestSuite 类的一些重要方法列式如下：

序号	方法和描述
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) 返回会失败的测试并且记录警告信息。

创建一个名为 JunitTestSuite.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());
 }
}

现在运行 Test Suite，检查输出结果。

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3