Junit知识总结

谁借莪１个温暖的怀抱￠ 2021-09-20 15:50 222阅读 0赞

# 背景知识 #

JUnit 是针对Java 编程语言的最流行的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展，是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。目前最新的Junit版本是Junit5，要求java8以上的版本。

什么是单元测试

所谓单元测试是测试应用程序的功能是否能够按需要正常运行的代码。单元测试是一个对单一实体（类或方法）的测试。  
单元测试可以由两种方式完成：

<table> 
 <thead> 
  <tr> 
   <th>人工测试</th> 
   <th>自动测试</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>手动执行测试用例并不借助任何工具的测试被称为人工测试。<br> - 消耗时间并单调：由于测试用例是由人力资源执行，所以非常缓慢并乏味。<br> - 人力资源上投资巨大：由于测试用例需要人工执行，所以在人工测试上需要更多的试验员。<br> - 可信度较低：人工测试可信度较低是可能由于人工错误导致测试运行时不够精确。<br> - 非程序性的：编写复杂并可以获取隐藏的信息的测试的话，这样的程序无法编写。</td> 
   <td> <p>借助工具支持并且利用自动工具执行用例被称为自动测试。<br> - 快速自动化运行测试用例时明显比人力资源快。&nbsp;</p> <p><br> - 人力资源投资较少：测试用例由自动工具执行，所以在自动测试中需要较少的试验员。<br> - 可信度更高：自动化测试每次运行时精确地执行相同的操作。<br> - 程式化的：试验员可以编写复杂的测试来显示隐藏信息。</p> </td> 
  </tr> 
 </tbody> 
</table>

Junit有下面这些特点：

*  JUnit 是一个开源框架，用于编写和运行测试。
 *  **提供注释来识别测试方法。**
 *  **提供断言来测试预期结果。**
 *  **提供测试运行来运行测试。**
 *  JUnit 测试允许你编写代码更快，并能提高质量。
 *  JUnit 优雅简洁。没那么复杂，花费时间较少。
 *  JUnit 测试可以自动运行并且检查自身结果并提供即时反馈。所以也没有必要人工梳理测试结果的报告。
 *  JUnit 测试可以被组织为测试套件，包含测试用例，甚至其他的测试套件。
 *  JUnit 在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。

junit运行环境

JUnit 是 Java 的一个框架，所以只需要有java环境即可。

一个单元测试的用例是怎样的？

单元测试用例是代码的一部分，它确保代码的另一部分（方法）按预期工作。

正式的书面单元测试用例的特征在于已知输入和预期输出，其在测试执行之前得出。 已知输入应测试前提条件，预期输出应测试后置条件。

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

## Junit框架里的类 ##

JUnit 中的最重要的程序包是 **junit.framework** 它包含了所有的核心类。其中比较常用的有下面这些：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>类的名称</th> 
   <th>类的功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>Assert</td> 
   <td>assert 方法的集合</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>TestCase</td> 
   <td>一个定义了运行多重测试的固定装置</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>TestResult</td> 
   <td>TestResult 集合了执行测试样例的所有结果</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>TestSuite</td> 
   <td>TestSuite 是测试的集合</td> 
  </tr> 
 </tbody> 
</table>

### 使用断言 ###

所有的断言都包含在 Assert 类中。这个类提供了很多有用的断言方法来编写测试用例。只有失败的断言才会被记录。**Assert** 类中的一些有用的方法列式如下：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法和描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><strong>void assertEquals(boolean expected, boolean actual)</strong><br> 检查两个变量或者等式是否平衡</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><strong>void assertTrue(boolean expected, boolean actual)</strong><br> 检查条件为真</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><strong>void assertFalse(boolean condition)</strong><br> 检查条件为假</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><strong>void assertNotNull(Object object)</strong><br> 检查对象不为空</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><strong>void assertNull(Object object)</strong><br> 检查对象为空</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><strong>void assertSame(boolean condition)</strong><br> assertSame() 方法检查两个相关对象是否指向同一个对象</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><strong>void assertNotSame(boolean condition)</strong><br> assertNotSame() 方法检查两个相关对象是否不指向同一个对象</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><strong>void assertArrayEquals(expectedArray, resultArray)</strong><br> assertArrayEquals() 方法检查两个数组是否相等</td> 
  </tr> 
 </tbody> 
</table>

## Junit方法执行过程 ##

执行过程指的是JUnit 中的方法执行过程，即哪一个方法首先被调用，哪一个方法在一个方法之后调用。我们以下面的例子为例：

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

其执行结果如下：

in before class
    in before
    in test case 1
    in after
    in before
    in test case 2
    in after
    in after class

观察以上的输出，JUnit执行过程如下：

*  beforeClass() 方法首先执行，并且只执行一次。
 *  afterClass() 方法最后执行，并且只执行一次。
 *  before() 方法针对每一个测试用例执行，但是是在执行测试用例之前。
 *  after() 方法针对每一个测试用例执行，但是是在执行测试用例之后。
 *  在 before() 方法和 after() 方法之间，执行每一个测试用例。

## 套件测试 ##

**测试套件**意味着捆绑几个单元测试用例并且一起执行他们。在 JUnit 中，**@RunWith** 和 **@Suite** 注释用来运行套件测试。

例子代码如下：

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

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

在上面的代码当中我们创建了两个测试类，分别是TestJunit1以及TestJunit2。接着我们按照下面步骤创建TestSuite

*  创建一个 java 类。
 *  在类中附上 @RunWith(Suite.class) 注释。
 *  使用 @Suite.SuiteClasses 注释给 JUnit 测试类加上引用。

import org.junit.runner.RunWith;
    import org.junit.runners.Suite;
    @RunWith(Suite.class)
    @Suite.SuiteClasses({
       TestJunit1.class,
       TestJunit2.class
    })
    public class JunitTestSuite {   
    }

此时我们就可以一起运行这两个测试类。

## 忽略测试 ##

有时可能会发生我们的代码还没有准备好的情况，这时测试用例去测试这个方法或代码的时候会造成失败。**@Ignore** 注释会在这种情况时帮助我们。

*  一个含有 @Ignore 注释的测试方法将不会被执行。
 *  如果一个测试类有 @Ignore 注释，则它的测试方法将不会执行。

下面是一个使用@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());
       }
    }

## 异常测试 ##

Junit 提供了一个追踪异常的选项。可以测试代码是否它抛出了想要得到的异常。方法是将**expected** 参数和 @Test 注释一起使用。

例子如下：

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