文章目录
参考
- https://www.sojson.com/blog/33.html
- https://blog.csdn.net/qq_34264849/article/details/88243278
- https://wiki.jikexueyuan.com/project/junit/overview.html
Junit3.x (过时)
- import junit.framework.TestCase;
- 定义 类需要继承 TestCase
import junit.framework.TestCase;
public class Test extends TestCase{
public void testAdd(){
assertEquals(1, 1);
}
}
概念
- 测试方法
处理具体某个测试功能 - 测试类
包含多个测试方法的类 - 测试套件
JUnit 提供了一种批量运行测试类的方法,叫做测试套件
Error和Failures的区别?
- Error
- 程序有逻辑问题
- 例如: 5 / 0
- Failures
- 表示测试失败(结果与期望的值不一致)
- 例如:assertEquals(5, 3)
Juint 4.x
注解
注解 | 解释 |
---|---|
@Test | 测试注解,标记一个方法可以作为一个测试用例 。 |
@BeforeClass | eforeClass注解指出这是附着在静态方法必须执行一次并在类的所有测试之前,这种情况一般用于测试计算、共享配制方法(如数据库连接)。 |
@AfterClass | 当需要执行所有测试在JUnit测试用例类后执行,AlterClass注解可以使用以清理一些资源(如数据库连接),注意:方法必须为静态方法。 |
@Before | Before注解表示,该方法必须在类中的每个测试之前执行,以便执行某些必要的先决条件。 |
@After | After注释表示,该方法在每项测试后执行(如执行每一个测试后重置某些变量,删除临时变量等)。 |
@Ignore | 当想暂时禁用特定的测试执行可以使用这个注解,每个被注解为@Ignore的方法将不再执行 |
@Runwith | @Runwith就是放在测试类名之前,用来确定这个类怎么运行的。也可以不标注,会使用默认运行器。 |
@Parameters | 用于使用参数化功能。 |
@SuiteClasses | 用于套件测试 |
断言
- 方法说明
方法 | 解释 |
---|---|
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 |
- import进来某个Class的静态members
JAVA5新添加的新特性
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
- 例子
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;
}
}
代码运行步骤
- 运行 @Parameters 注解步骤,定义好数据
- 运行构造函数;
带有参数的公共构造函数,并在其中为声明的几个变量赋值。
- @Before (测试前的准备工作)
- @Test(实际测试用例)
异常测试
1. 有异常,符合预期
@Test(expected = ArithmeticException.class)
publicvoid 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