单元测试JUnit4快速入门

港控/mmm° 2022-03-20 08:24 423阅读 0赞

**什么是单元测试：**

所谓单元测试是测试应用程序的功能是否能够按需要正常运行，并且确保是在开发人员的水平上，单元测试生成图片。单元测试是一个对单一实体（类或方法）的测试。单元测试是每个软件公司提高产品质量、满足客户需求的重要环节。

**什么是JUnit：**

JUnit 是一个 Java 编程语言的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展，是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。

**什么是一个单元测试用例：**

单元测试用例是一部分代码，可以确保另一端代码（方法）按预期工作。为了迅速达到预期的结果，就需要测试框架。

一个正式的编写好的单元测试用例的特点是：已知输入和预期输出，即在测试执行前就已知。已知输入需要测试的先决条件，预期输出需要测试后置条件。

每一项需求至少需要两个单元测试用例：一个正检验，一个负检验。如果一个需求有子需求，每一个子需求必须至少有正检验和负检验两个测试用例。

**JUnit4环境配置：**

[https://www.w3cschool.cn/junit/fegu1hv3.html][https_www.w3cschool.cn_junit_fegu1hv3.html]

### 一.JUnit的快速入门 ###

1.测试方法上必须使用@Test进行修饰

2.测试方法必须使用public void 进行修饰，不能带任何的参数

3.新建一个源代码目录来存放我们的测试代码

4.测试类的包应该和被测试类保持一致

5.测试单元中的每个方法必须可以独立测试，测试方法间不能有任何的依赖

6.测试类使用Test作为类名的后缀（不是必须）

7.测试方法使用test作为方法名的前缀（不是必须）

**被测试类：**

package util;
    
    /**
     * 计算工具类-被测试
     * @author lc
     */
    public class Calculate {
    	/**
    	 * 加
    	 */
    	public int add(int a,int b) {
    		return a + b;
    	}
    	/**
    	 * 减
    	 */
    	public int subtract(int a, int b) {
    		return a - b;
    	}
    	/**
    	 * 乘
    	 */
    	public int multiply(int a,int b) {
    		return a * b;
    	}
    	/**
    	 * 除
    	 */
    	public int divide(int a ,int b) {
    		return a / b;
    	}
    }

**测试类：**

package junit.test;
    
    import org.junit.Test;
    import util.Calculate;
    
    import static org.junit.Assert.assertEquals;
    
    /**
     * 测试Calculate
     * @author lc
     */
    public class CalculateTest {
    
    	@Test
    	public void testAdd() {
    		assertEquals(6, new Calculate().add(3,3));
    	}
    	
    	@Test
    	public void testSubtract() {
    		assertEquals(3, new Calculate().subtract(5,2));
    	}
    	
    	@Test
    	public void testMultiply() {
    		assertEquals(4, new Calculate().multiply(2, 2));
    	}
    	
    	@Test
    	public void testDivide() {
    		assertEquals(3, new Calculate().divide(6, 2));
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70][]

![20190211215643245.png][]

### 二. Error和Failure两种错误的区别 ###

1.Failure一般由单元测试使用的断言方法判断失败所引起的，表示测试点发现了问题，就是程序输出结果和我们预期的不一样。

2.error是由代码异常引起的，它可以产生于测试代码本身的错误，也可以是被测试代码中的一个隐藏的bug。

3.测试用例不是用来证明你是对的，而是用来证明你没有错。

package junit.test;
    
    import org.junit.Test;
    import util.Calculate;
    
    import static org.junit.Assert.assertEquals;
    
    /**
     *  ErrorAndFailure两种错误的区别
     * @author lc
     */
    public class ErrorAndFailureTest {
    
    	@Test
    	public void testAdd() {
    		assertEquals(5, new Calculate().add(3,3));
    	}
    
    	@Test
    	public void testDivide() {
    		assertEquals(3, new Calculate().divide(6, 0));
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 1][]

### 三.JUnit的运行流程 ###

1.@BeforeClass修饰的方法会在所有方法被调用前被执行,而且该方法是静态的，所以当测试类被加载后接着就会运行它，而且在内存中它只会存在一份实例，它比较适合加载配置文件。

2.@AfterClass所修饰的方法通常用来对资源的清理，如关闭数据库的连接 。

3.@Before和@After会在每个测试方法的前后各执行一次。

package junit.test;
    
    import org.junit.*;
    
    /**
     * Junit的运行流程
     * @author lc
     */
    public class JunitFlowTest {
    
    	@BeforeClass
    	public static void setUpBeforeClass() throws Exception {
    		System.out.println("this is beforeClass...");
    	}
    
    	@AfterClass
    	public static void tearDownAfterClass() throws Exception {
    		System.out.println("this is afterClass...");
    	}
    
    	@Before
    	public void setUp() throws Exception {
    		System.out.println("this is before...");
    	}
    
    	@After
    	public void tearDown() throws Exception {
    		System.out.println("this is after");
    	}
    
    	@Test
    	public void test1() {
    		System.out.println("this is test1...");
    	}
    	
    	@Test
    	public void test2(){
    		System.out.println("this is test2...");
    	}
    
    }

**结果： **

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 2][]

###  四.JUnit的常用注解 ###

1.@Test:将一个普通的方法修饰成为一个测试方法  
    @Test(expected=XX.class)：捕获一个XX异常  
    @Test(timeout=毫秒)：处理超时 2000 = 2秒  
2.@BeforeClass：它会在所有的方法运行前被执行，static修饰  
3.@AfterClass:它会在所有的方法运行结束后被执行，static修饰  
4.@Before：会在每一个测试方法被运行前执行一次  
5.@After：会在每一个测试方法运行后被执行一次  
6. @Ignore:所修饰的测试方法会被测试运行器忽略 （说明为什么不被执行）  
7.@RunWith:可以更改测试运行器 可以自己写测试运行器，继承org.junit.runner.Runner

断言：静态导入 import static org.junit.Assert.assertEquals;

package junit.test;
    
    import org.junit.Ignore;
    import org.junit.Test;
    import util.Calculate;
    
    import static org.junit.Assert.assertEquals;
    
    /**
     * JUnit常用注解
     * @author lc
     */
    public class AnotationTest {
    	
    	@Test(expected=ArithmeticException.class)
    	public void testDivide() {
    		assertEquals(3, new Calculate().divide(6, 0));
    	}
    	
    	@Ignore("...")
    	@Test(timeout=2000)
    	public void testWhile() {
    		while(true) {
    			System.out.println("run forever...");
    		}
    	}
    	
    	@Test(timeout=3000)
    	public void testReadFile(){
    		try {
    			Thread.sleep(2000);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }

###  五.测试套件  ###

1.测试套件就是组织测试类一起运行的,写一个作为测试套件的入口类，这个类里不包含其他的方法,更改测试运行器Suite.class,将要测试的类作为数组传入到Suite.SuiteClasses（\{\}）

package junit.test;
    
    import org.junit.runner.RunWith;
    import org.junit.runners.Suite;
    
    /**
     * 测试套件
     * @author lc
     */
    @RunWith(Suite.class)
    @Suite.SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class})
    public class SuiteTest {
    
    }

TaskTest1.2.3.class:

package junit.test;
    
    import org.junit.Test;
    
    public class TaskTest1 {
    
    	@Test
    	public void test() {
    		System.out.println("this is TaskTest1...");
    	}
    
    }

package junit.test;
    
    import org.junit.Test;
    
    public class TaskTest2 {
    
    	@Test
    	public void test() {
    		System.out.println("this is TaskTest2...");
    	}
    
    }

package junit.test;
    
    import org.junit.Test;
    
    public class TaskTest3 {
    
    	@Test
    	public void test() {
    		System.out.println("this is TaskTest3...");
    	}
    
    }

**结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 3][]

###  六.JUnit4的参数化设置 ###

对多个参数进行测试。

1.更改默认的测试运行器为RunWith(Parameterized.class)。

2.声明变量来存放预期值和结果值。

3.声明一个返回值 为Collection的公共静态方法，并使用@Parameters进行修饰。

4.为测试类声明一个带有参数的公共构造函数，并在其中为之声明变量赋值。

package junit.test;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.Parameterized;
    import org.junit.runners.Parameterized.Parameters;
    import util.Calculate;
    
    import java.util.Arrays;
    import java.util.Collection;
    
    import static org.junit.Assert.assertEquals;
    
    /**、
     * JUnit4的参数化设置
     * @author lc
     */
    @RunWith(Parameterized.class)
    public class ParameterTest {
    
    	int expected =0;
    	int input1 = 0;
    	int input2 = 0;
    	
    	@Parameters
    	public static Collection<Object[]> t() {
    		return Arrays.asList(new Object[][]{
    				{3,1,2},
    				{4,2,2}
    		}) ;
    	}
    	
    	public ParameterTest(int expected, int input1, int input2) {
    		this.expected = expected;
    		this.input1 = input1;
    		this.input2 = input2;
    	}
    	
    	@Test
    	public void testAdd() {
    		assertEquals(expected, new Calculate().add(input1, input2));
    	}
    
    }

**结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 4][]

参考：

怎样在IDEA中使用JUnit4和JUnitGenerator V2.0自动生成测试模块：[https://www.cnblogs.com/libingbin/p/6007203.html][https_www.cnblogs.com_libingbin_p_6007203.html]

IDEA中创建单元测试过程 JUnit：[https://blog.csdn.net/tuntun1120/article/details/79569064][https_blog.csdn.net_tuntun1120_article_details_79569064]

慕课网入门教程：[https://www.imooc.com/video/6849][https_www.imooc.com_video_6849]

w3cschool: [https://www.w3cschool.cn/junit/fegu1hv3.html][https_www.w3cschool.cn_junit_fegu1hv3.html]

[https_www.w3cschool.cn_junit_fegu1hv3.html]: https://www.w3cschool.cn/junit/fegu1hv3.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70]: /images/20220320/3bdf49852d444f698d8fd2cff6199d93.png
[20190211215643245.png]: /images/20220320/9b46f7e87d5749d5bf1ea21b83f6c112.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 1]: /images/20220320/bcfd36b40898416dbd9e2f9d6ecaf06b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 2]: /images/20220320/b11c660f7f0a444f9a4b247fcc9789c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 3]: /images/20220320/5b29cf90f483439f863ae1b2c889b4db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjZ29pbmc_size_16_color_FFFFFF_t_70 4]: /images/20220320/3f0ef96e28b64483922b0c0a4362b84e.png
[https_www.cnblogs.com_libingbin_p_6007203.html]: https://www.cnblogs.com/libingbin/p/6007203.html
[https_blog.csdn.net_tuntun1120_article_details_79569064]: https://blog.csdn.net/tuntun1120/article/details/79569064
[https_www.imooc.com_video_6849]: https://www.imooc.com/video/6849