Junit 4.x 学习总结整理

参考

1. https://www.sojson.com/blog/33.html
2. https://blog.csdn.net/qq_34264849/article/details/88243278
3. https://wiki.jikexueyuan.com/project/junit/overview.html

Junit3.x (过时)

1. import junit.framework.TestCase;
2. 定义 类需要继承 TestCase

import junit.framework.TestCase;
public class Test extends TestCase{
	public void testAdd(){
		assertEquals(1, 1);
	}
}

概念

1. 测试方法
   处理具体某个测试功能
2. 测试类
   包含多个测试方法的类
3. 测试套件
   JUnit 提供了一种批量运行测试类的方法，叫做测试套件

Error和Failures的区别？

1. Error
   • 程序有逻辑问题
   • 例如： 5 / 0
2. Failures
   • 表示测试失败（结果与期望的值不一致）
   • 例如：assertEquals(5, 3)

Juint 4.x

注解

注解	解释
@Test	测试注解，标记一个方法可以作为一个测试用例 。
@BeforeClass	eforeClass注解指出这是附着在静态方法必须执行一次并在类的所有测试之前，这种情况一般用于测试计算、共享配制方法(如数据库连接)。
@AfterClass	当需要执行所有测试在JUnit测试用例类后执行，AlterClass注解可以使用以清理一些资源（如数据库连接），注意：方法必须为静态方法。
@Before	Before注解表示，该方法必须在类中的每个测试之前执行,以便执行某些必要的先决条件。
@After	After注释表示，该方法在每项测试后执行（如执行每一个测试后重置某些变量，删除临时变量等）。
@Ignore	当想暂时禁用特定的测试执行可以使用这个注解，每个被注解为@Ignore的方法将不再执行
@Runwith	@Runwith就是放在测试类名之前，用来确定这个类怎么运行的。也可以不标注，会使用默认运行器。
@Parameters	用于使用参数化功能。
@SuiteClasses	用于套件测试

断言

1. 方法说明
   |方法|解释|
   |:–|:–|
   |void assertEquals([String message],expected value,actual value)|断言两个值相等。值类型可能是int，short，long，byte，char，Object，第一个参数是一个可选字符串消息|
   |void assertTrue([String message],boolean condition)|断言一个条件为真|
   |void assertFalse([String message],boolean condition)|断言一个条件为假|
   |void assertNotNull([String message],java.lang.Object object)|断言一个对象不为空（null）|
   |void assertNull([String message],java.lang.Object object)|断言一个对象为空（null）|
   |void assertSame([String message],java.lang.Object expected,java.lang.Object actual)|断言两个对象引用相同的对象|
   |void assertNotSame([String message],java.lang.Object unexpected,java.lang.Object actual)|断言两个对象不是引用同一个对象|
   |void assertArrayEquals([String message],expectedArray,resultArray)|断言预期数组和结果数组相等，数组类型可能是int，short，long，byte，char，Object|

2. import进来某个Class的静态members

JAVA5新添加的新特性

import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;

3. 例子

package com.hb.demo;

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
	private static Calculator calculator = new Calculator();

	@Before
	public void setUp() throws Exception {
	}
	
	@Test
    public void testAdd() {
        int result = calculator.add(2, 3);
        org.junit.Assert.assertEquals(3, result);
    }
    @Test
    public void testSub() {
        int result = calculator.sub(10, 2);
        org.junit.Assert.assertEquals(8, result);
    }

}

###执行顺序

import static org.junit.Assert.*;
import hb.util.Calculator;
 
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 TTest {
 
	private Calculator calculator = new Calculator();
	
	//在所有方法运行之前运行
	@BeforeClass
	public static void beforeClass(){
		System.out.println("-----------beforeClass");
	}
	
	//在所有方法运行之后运行
	@AfterClass
	public static void afterClass(){
		System.out.println("---------afterClass");
	}
	
	//每个测试方法运行之前运行
	@Before
	public void before(){
		System.out.println("==============before");
	}
	
	//每个测试方法运行之后运行
	@After
	public void after(){
		System.out.println("===========after");
	}
	
	@Test
	public void testAdd(){
		int result = calculator.add(3, 6);
		assertEquals(9,result);
		System.out.println("testAdd() is OK");
	}
	
	@Test
	public void testDivision(){
		System.out.println("in test division");
	}
	
	@Ignore  //表示这个方法是不被运行的
	@Test
	(expected=java.lang.ArithmeticException.class,timeout=100) //timeout表示要求方法在100毫秒内运行完成，否则报错
    public void testDivide(){
        int z = calculator.subtration(8,2);
    }
}

结论： @BeforeClass --> @Before --> @Test --> @After --> @AfterClass

忽略测试 @Ignore

@Ignore
@Test
public void testCase2() {
	System.out.println("in test case 2");
}

时间测试

如果一个测试用例比起指定的毫秒数花费了更多的时间，那么JUnit将自动将它标记为失败

@Test(timeout = 1000)
public void testCase1() throws InterruptedException {
	TimeUnit.SECONDS.sleep(5000);
	System.out.println("in test case 1");
}

参数化测试(重难点)

编写代码步骤

（1）为准备使用参数化测试的测试类指定特殊的运行器org.junit.runners.Parameterized。@RunWith(Parameterized.class)
（2）为测试类声明几个变量，分别用于存放期望值和测试所用数据，期望值可能只有一个，但测试数据变量可能有好几个，比如加法中有两个变量才能得出一个结果。
（3）为测试类声明一个带有参数的公共构造函数，并在其中为第二个环节中声明的几个变量赋值，构造方法是Junit调用的 ☆关键点☆
（4）为测试类声明一个使用注解org.junit.runners.Parameterized.Parameters修饰的，返回值为 java.util.Collection的公共静态方法，并在此方法中初始化所有需要测试的参数对。 ☆关键点☆
（5）编写测试方法，使用定义的变量作为参数进行测试。

package com.hb.demo;

import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class) // 第一步：指定特殊的运行器org.junit.runners.Parameterized
public class FirstDemoTestParameterization {

	// 要测试的类
	private FirstDemo firstDemo;

//第二步：为测试类声明几个变量，分别用于存放期望值和测试所用数据。    
	private int input1;
	private boolean expected;

	@Before // 执行每个测试方法之前都执行一次
	public void setUp() throws Exception {
		System.out.println("我是第三步");
		firstDemo = new FirstDemo();
	}

	// 第三步：带有参数的公共构造函数，并在其中为声明的几个变量赋值。

	public FirstDemoTestParameterization(int input1, boolean expected) {
		System.out.println("我是第二步");
		this.input1 = input1; // 参数1
		this.expected = expected; // 期待的结果值
	}

//-------------------（1）参数赋值 &&&（2）写出期望值----------------------------            

//第四步：为测试类声明一个注解@Parameters，返回值为Collection的公共静态方法，并初始化所有需要测试的参数对。    
	@Parameters
	public static Collection prepareData() {
		System.out.println("我是第一步");
		Object[][] object = { { -1, true }, { 13, true } }; // 测试数据
		return Arrays.asList(object); // 将数组转换成集合返回
	}

	@Test
	public void testParameterization() {
		System.out.println("我是第二步");
		//-----------（3）获取实际值&&&（4）断言--比较期望值和实际值。---------------            
		//第五步：编写测试方法，使用定义的变量作为参数进行测试。    
		assertEquals(expected, firstDemo.Parameterization(input1));
	}
}

class FirstDemo {
	public boolean Parameterization(int num) {
		return num <= 0 ? false : true; 
	}
}

代码运行步骤

1. 运行 @Parameters 注解步骤，定义好数据
2. 运行构造函数；

   带有参数的公共构造函数，并在其中为声明的几个变量赋值。

3. @Before (测试前的准备工作)
4. @Test(实际测试用例)

异常测试

1. 有异常，符合预期

@Test(expected = ArithmeticException.class)
    public void testCase3() {
        System.out.println("in test case 3");
        int a = 0;
        int b = 1 / a;
 }

2. 无异常，不符合预期

@Test(expected = ArithmeticException.class)
public void testCase3() {
	System.out.println("in test case 3");
	int a = 0;
	int b = 1 / 1;
}

会抛出 java.lang.AssertionError: Expected exception: java.lang.ArithmeticException