JUnit - 快速指南

---

JUnit - 概述

测试是检查应用程序功能以确保其按要求运行的过程。单元测试出现在开发人员的层面上；它是单个实体（类或方法）的测试。单元测试在帮助软件公司向客户交付优质产品方面发挥着至关重要的作用。

单元测试可以通过两种方式完成——手动测试和自动化测试。

什么是 JUnit？

JUnit 是 Java 编程语言的单元测试框架。它在测试驱动开发中发挥着至关重要的作用，是一个统称为 xUnit 的单元测试框架系列。

JUnit提倡“先测试，后编码”的思想，强调为一段代码建立测试数据，让其可以先测试，再实现。这种方法就像“测试一点，编码一点，测试一点，编码一点”。它提高了程序员的生产力和程序代码的稳定性，进而减少了程序员的压力和调试所花费的时间。

JUnit 的特点

• JUnit 是一个开源框架，用于编写和运行测试。

• 提供注释来标识测试方法。

• 提供用于测试预期结果的断言。

• 提供用于运行测试的测试运行程序。

• JUnit 测试使您可以更快地编写代码，从而提高质量。

• JUnit 非常简单。它不太复杂并且花费的时间也更少。

• JUnit 测试可以自动运行，它们检查自己的结果并提供即时反馈。无需手动梳理测试结果报告。

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

• JUnit 在条形图中显示测试进度，如果测试运行顺利，则为绿色；如果测试失败，则变为红色。

什么是单元测试用例？

单元测试用例是代码的一部分，它确保代码的另一部分（方法）按预期工作。为了快速达到预期的结果，需要一个测试框架。JUnit 是一个完美的 Java 编程语言单元测试框架。

正式的书面单元测试用例的特征是已知的输入和预期的输出，这是在测试执行之前计算出来的。已知输入应测试前置条件，预期输出应测试后置条件。

每个需求必须至少有两个单元测试用例 - 一个正测试和一个负测试。如果一个需求有子需求，则每个子需求必须至少有两个测试用例，分别为正面和负面。

JUnit - 环境设置

本地环境设置

JUnit 是 Java 的框架，因此第一个要求是在您的计算机上安装 JDK。

系统要求

第 1 步：验证计算机中的 Java 安装

首先，打开控制台并根据您正在使用的操作系统执行java命令。

让我们验证所有操作系统的输出 -

如果您的系统上没有安装 Java，请从以下链接下载 Java 软件开发工具包 (SDK)：https://www.oracle.com。我们假设 Java 1.8.0_101 作为本教程的安装版本。

第二步：设置JAVA环境

设置JAVA_HOME环境变量以指向计算机上安装 Java 的基本目录位置。例如。

将 Java 编译器位置附加到系统路径。

如上所述，使用命令java -version验证 Java 安装。

第 3 步：下载 JUnit 存档

从http://www.junit.org下载最新版本的 JUnit jar 文件。在编写本教程时，我们已经下载了 Junit-4.12.jar 并将其复制到 C:\>JUnit 文件夹中。

第4步：设置JUnit环境

将JUNIT_HOME环境变量设置为指向计算机上存储 JUNIT jar 的基本目录位置。假设我们已将 junit4.12.jar 存储在 JUNIT 文件夹中。

第 5 步：设置 CLASSPATH 变量

将CLASSPATH环境变量设置为指向 JUNIT jar 位置。

第 6 步：测试 JUnit 设置

在C:\>JUNIT_WORKSPACE中创建一个java类文件名称TestJunit

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中创建一个名为 TestRunner 的 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());
   }
}  	

第 7 步：验证结果

使用javac编译器编译类，如下所示 -

C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

现在运行测试运行程序以查看结果，如下所示 -

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

true

JUnit - 测试框架

JUnit 是一个回归测试框架，开发人员使用它来实现 Java 中的单元测试，加快编程速度并提高代码质量。JUnit 框架可以轻松地与以下任一集成：

• 蚀
• 蚂蚁
• 梅文

JUnit 测试框架的特点

JUnit 测试框架提供以下重要功能 -

• 固定装置
• 测试套件
• 测试跑者
• JUnit 类

固定装置

Fixtures是一组对象的固定状态，用作运行测试的基线。测试夹具的目的是确保有一个众所周知的固定环境来运行测试，以便结果可重复。它包括 -

• setUp() 方法，在每次测试调用之前运行。
• TeaDown() 方法，在每个测试方法之后运行。

让我们看一个例子 -

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 类是重要的类，用于编写和测试 JUnit。一些重要的课程是 -

• Assert - 包含一组断言方法。

• TestCase - 包含定义运行多个测试的夹具的测试用例。

• TestResult - 包含收集执行测试用例结果的方法。

JUnit - 基本用法

现在让我们通过一个基本示例来演示使用 JUnit 的逐步过程。

创建一个类

创建一个要测试的java类，例如C:\>JUNIT_WORKSPACE中的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;
   }   
}  

创建测试用例类

• 创建一个 java 测试类，例如 TestJunit.java。
• 将测试方法 testPrintMessage() 添加到您的测试类中。
• 将注释@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());
   }
}

创建测试运行器类

• 创建一个 TestRunner java 类。
• 使用 JUnit 的 JUnitCore 类的 runClasses 方法来运行上面创建的测试类的测试用例。
• 获取结果对象中运行的测试用例的结果。
• 使用 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、测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

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

让我们保持其余类不变，并尝试运行相同的测试运行程序。

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

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false

JUnit-API

JUnit 中最重要的包是junit.framework，它包含所有核心类。一些重要的类如下 -

断言类

以下是org.junit.Assert类的声明-

public class Assert extends java.lang.Object

此类提供了一组对于编写测试有用的断言方法。仅记录失败的断言。Assert 类的一些重要方法如下 -

让我们在示例中使用上述一些方法。在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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner1

验证输出。

true

测试用例类

以下是org.junit.TestCase类的声明-

public abstract class TestCase extends Assert implements Test

测试用例定义了运行多个测试的夹具。TestCase类的一些重要方法如下 -

让我们在示例中使用上述一些方法。在 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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner2

验证输出。

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true

测试结果类

以下是org.junit.TestResult类的声明-

public class TestResult extends Object

TestResult 收集执行测试用例的结果。它是收集参数模式的一个实例。测试框架区分失败和错误。可以预见失败并通过断言进行检查。错误是不可预见的问题，例如 ArrayIndexOutOfBoundsException。TestResult类的一些重要方法如下 -

在 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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner3

验证输出。

true

测试套件类

以下是org.junit.TestSuite类的声明：

public class TestSuite extends Object implements Test

TestSuite 是测试的组合。它运行一组测试用例。TestSuite类的一些重要方法如下 -

在 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 编译测试套件类。

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 - 编写测试

在这里，我们将看到一个使用 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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java 
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

true

JUnit - 使用断言

断言

所有断言都在 Assert 类中。

public class Assert extends java.lang.Object

此类提供了一组断言方法，对于编写测试很有用。仅记录失败的断言。Assert 类的一些重要方法如下 -

让我们在示例中使用上述一些方法。在 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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

true

注解

注释就像元标记一样，您可以将其添加到代码中，并将它们应用于方法或类中。JUnit 中的这些注释提供了有关测试方法的以下信息 -

• 哪些方法将在测试方法之前和之后运行。
• 哪些方法在所有方法之前和之后运行，以及。
• 执行期间哪些方法或类将被忽略。

下表提供了 JUnit 中的注释列表及其含义 -

在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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

in before class
in before
in test
in after
in after class
true

JUnit - 执行过程

本章解释了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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

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 - 执行测试

测试用例使用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 的帮助下执行测试。

创建一个类

创建一个要测试的 java 类，例如MessageUtil.java，位于 C:\>JUNIT_WORKSPACE 中。

/*
* 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;
   }   
	
}  

创建测试用例类

• 创建一个 java 测试类，例如 TestJunit.java。

• 将测试方法 testPrintMessage() 添加到您的测试类中。

• 将注释@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());
   }
}

创建测试运行器类

现在在 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 编译测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

Hello World
true

JUnit - 套件测试

测试套件用于捆绑一些单元测试用例并将它们一起运行。在 JUnit 中，@RunWith和@Suite注释都用于运行套件测试。本章以具有两个测试类TestJunit1和TestJunit2的示例为例，它们使用测试套件一起运行。

创建一个类

创建一个要测试的java类，例如C:\>JUNIT_WORKSPACE中的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 {   
}  	

创建测试运行器类

在 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

现在运行测试运行程序，它将运行提供的测试用例类中定义的测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true

JUnit - 忽略测试

有时，我们的代码在运行测试用例时还没有完全准备好。结果，测试用例失败。@Ignore注释在这种情况下很有帮助。

• 用@Ignore注释的测试方法将不会被执行。

• 如果一个测试类被@Ignore注解，那么它的任何测试方法都不会被执行。

现在让我们看看 @Ignore 的实际效果。

创建一个类

创建一个要测试的java类，例如C:\>JUNIT_WORKSPACE中的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;
   }   
	
}  

创建测试用例类

• 创建一个 java 测试类，例如 TestJunit.java。

• 将测试方法 testPrintMessage() 或 testSalutationMessage() 添加到您的测试类。

• 将注释 @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());
   }
	
}

创建测试运行器类

在 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、测试用例和测试运行器类。

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

现在运行测试运行程序，它不会运行提供的测试用例类中定义的 testPrintMessage() 测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。testPrintMessage() 测试用例未经过测试。

Inside testSalutationMessage()
Hi!Robert
true

现在，更新 C:\>JUNIT_WORKSPACE 中的 TestJunit 以忽略所有测试用例。在类级别添加@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

保持您的测试运行程序不变，如下所示 -

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

现在运行测试运行程序，它不会运行提供的测试用例类中定义的任何测试用例。

C:\JUNIT_WORKSPACE>java TestRunner

验证输出。没有测试任何测试用例。

true

JUnit - 时间测试

JUnit 提供了一个方便的超时选项。如果测试用例花费的时间超过指定的毫秒数，那么 JUnit 会自动将其标记为失败。超时参数与@Test注释一起使用。让我们看看 @Test(timeout) 的实际效果。

创建一个类

创建一个要测试的java类，例如C:\>JUNIT_WORKSPACE中的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;
   }   
}  	

创建测试用例类

创建一个 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";