目录
一.什么是junit
二.引入maven环境
三.Assert 类
1.assertArrayEquals
2.assertEquals
3.assertNotNull
4.assertSame
5.assertTrue
6.assertFalse
7.assertNull
8. fail
四.执行过程-注解的使用
1. 注解
2.忽略
3.时间测试
4.异常测试
5.参数化测试
五. assertThat--- Hamcrest
一.什么是junit
JUnit 是一个 Java 编程语言的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展，是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。
JUnit 促进了“先测试后编码”的理念，强调建立测试数据的一段代码，可以先测试，然后再应用。这个方法就好比“测试一点，编码一点，测试一点，编码一点……”，增加了程序员的产量和程序的稳定性。
二.引入maven环境
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.1</version>
<scope>test</scope>
</dependency>
三.Assert 类
序号 | 方法和描述 |
void assertEquals(boolean expected, boolean actual) | 检查两个变量或者等式是否平衡 |
void assertFalse(boolean condition) | 检查条件是假的 |
void assertNotNull(Object object) | 检查对象不是空的 |
void assertNull(Object object) | 检查对象是空的 |
void assertTrue(boolean condition) | 检查条件为真 |
void fail() | 在没有报告的情况下使测试不通过 |
1.assertArrayEquals
JUnit为所有原始类型和对象以及（原始或对象的）数组提供了重载的断言方法。参数顺序是期望值，然后是实际值。
@Test
public void testAssertArrayEquals() {
byte[] expected = "trial".getBytes();
byte[] actual = "trial".getBytes();
//比较两个 数组是否相等 期望值和实际值
assertArrayEquals(" 期望值和实际值不一样", expected, actual);
//不一致的时候会报出来
// array lengths differed, expected.length=5 actual.length=6; arrays first differed at element [5];
// Expected :end of array
// Actual :49
}
运行结果
2.assertEquals
检查两个变量或者等式是否平衡
@Test
public void testAssertEquals() {
//如果期望值和实际值相等则通过测试
//如果期望值和实际值不相等则无法通过测试同时打印message数值
assertEquals("failure - String are not equa;", "test", "test");
}
运行结果
3.assertNotNull
检查对象不是空的
@Test
public void testAssertNotNull() {
// 断言某个值 不为空
//
// 如果为空就抛出异常
assertNotNull("should not be null", new Object());
assertNotNull("should not be null", null);
}
运行结果：
4.assertSame
检查两个相关对象是否指向同一个对象
@Test
public void testAssertSame() {
Integer aNumber = Integer.valueOf(111111);
//assertSame() 方法检查两个相关对象是否指向同一个对象
assertSame("should be same", aNumber, aNumber);
}
运行结果
5.assertTrue
检查条件为真
@Test
public void testAssertTrue() {
assertTrue("failure -should be true", true);
}
运行结果
6.assertFalse
则如果条件是false则通过测试，如果条件是true则为错误
@Test
public void testAssertFalse() {
//assertFalse 则如果条件是false则通过测试，如果条件是true则为为错误
assertFalse("failure -should be false", true);
assertFalse("failure -should be false", false);
}
运行结果如下：
7.assertNull
@Test
public void testAssertNull() {
//检查对象为空
assertNull("should be null", null);
}
运行结果如下：
8. fail
在没有报告的情况下使测试不通过
运行结果：
四.执行过程-注解的使用
1.
注解 | 相关注释 |
@beforeClass | 方法首先执行，并且只执行一次。 |
@afterClass | 方法最后执行，并且只执行一次。 |
@before | 方法针对每一个测试用例执行，但是是在执行测试用例之前。 |
@after | 方法针对每一个测试用例执行，但是是在执行测试用例之后。 |
| |
在 before() 方法和 after() 方法之间，执行每一个测试用例。
package TestJunit4Demo;
import org.junit.*;
public class ExecutionProcedureJunit {
// beforeClass() 方法首先执行，并且只执行一次。
// afterClass() 方法最后执行，并且只执行一次。
// before() 方法针对每一个测试用例执行，但是是在执行测试用例之前。
// after() 方法针对每一个测试用例执行，但是是在执行测试用例之后。
// 在 before() 方法和 after() 方法之间，执行每一个测试用例。
@BeforeClass
public static void beforeClass() {
System.out.println("in before class");
}
@AfterClass
public static void afterClass() {
System.out.println("in after class");
}
@Before
public void before() {
System.out.println("in before");
}
@After
public void after() {
System.out.println("in after");
}
//test case 1
@Ignore
//如果该测试没有准备好，将不准备走这个测试用例
@Test(timeout = 100)
//timeout 参数和 @Test 注释一起使用。 @test(timeout)。
public void testCase1() throws InterruptedException {
System.out.println("in test case 1");
Thread.sleep(1000);
}
//test case 2
@Test(expected =Exception.class)
public void testCase2() throws Exception {
throw new Exception();
}
}
运行结果如下：
2.忽略
有时可能会发生我们的代码还没有准备好的情况，这时测试用例去测试这个方法或代码的时候会造成失败。@Ignore 注释会在这种情况时帮助我们。
- 一个含有 @Ignore 注释的测试方法将不会被执行。
- 如果一个测试类有 @Ignore 注释，则它的测试方法将不会执行。
//test case 1
@Ignore
//如果该测试没有准备好，将不准备走这个测试用例
@Test(timeout = 100)
//timeout 参数和 @Test 注释一起使用。 @test(timeout)。
public void testCase1() throws InterruptedException {
System.out.println("in test case 1");
Thread.sleep(1000);
}
运行结果：
3.时间测试
Junit 提供了一个暂停的方便选项。如果一个测试用例比起指定的毫秒数花费了更多的时间，那么 Junit 将自动将它标记为失败。timeout 参数和 @Test 注释一起使用。
@Test(timeout = 100)
//timeout 参数和 @Test 注释一起使用。 @test(timeout)。
public void testCase1() throws InterruptedException {
System.out.println("in test case 1");
Thread.sleep(1000);
}
运行结果：
4.异常测试
抛出了想要得到的异常。expected 参数和@Test 注释一起使用
@Test(expected =Exception.class)
public void testCase2() throws Exception {
throw new Exception();
}
运行结果：
6.参数化测试
允许开发人员使用不同的值反复运行同一个测试
@RunWith(Parameterized.class) 来注释 test 类。
2.创建一个由 @Parameters 注释的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。
3.创建一个公共的构造函数，它接受和一行测试数据相等同的东西。
4.为每一列测试数据创建一个实例变量。
用实例变量作为测试数据的来源来创建你的测试用例。
代码示例：
package TestJunit5Demo;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
//
// 用 @RunWith(Parameterized.class) 来注释 test 类。
// 创建一个由 @Parameters 注释的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。
// 创建一个公共的构造函数，它接受和一行测试数据相等同的东西。
// 为每一列测试数据创建一个实例变量。
// 用实例变量作为测试数据的来源来创建你的测试用例。
private Integer inputNumber;
private Boolean expectedResult;
private PrimeNumberChecker primeNumberChecker;
@Before
public void initialize() {
primeNumberChecker = new PrimeNumberChecker();
}
// Each parameter should be placed as an argument here
// Every time runner triggers, it will pass the arguments
// from parameters we defined in primeNumbers() method
public PrimeNumberCheckerTest(Integer inputNumber,
Boolean expectedResult) {
this.inputNumber = inputNumber;
this.expectedResult = expectedResult;
}
@Parameterized.Parameters
public static Collection primeNumbers() {
return Arrays.asList(new Object[][] {
{ 2, true },
{ 6, false },
{ 19, true },
{ 22, false },
{ 23, true }
});
}
// This test will run 4 times since we have 5 parameters defined
@Test
public void testPrimeNumberChecker() {
System.out.println("Parameterized Number is : " + inputNumber);
assertEquals(expectedResult,
primeNumberChecker.validate(inputNumber));
}
}
package TestJunit5Demo;
public class PrimeNumberChecker {
public Boolean validate(final Integer primeNumber) {
for (int i = 2; i < (primeNumber / 2); i++) {
if (primeNumber % i == 0) {
return false;
}
}
return true;
}
}
运行结果如下：
五. assertThat--- Hamcrest
Hamcrest 是一款用于校验的 Java 的单元测试框架，可以组合创建灵活的表达的匹配器进行断言。
提醒：
/** @Deprecated
// 因为在一个项目中，工程比较大，代码比较多，而在后续开发过程中，
// 可能之前的某个方法实现的并不是很合理，这个时候就要新加一个方法，
// 而之前的方法又不能随便删除，因为可能在别的地方有调用它，
// 所以加上这个注解，就方便以后开发人员的方法调用了。*/
1.startsWith：匹配字符串以 XX 开头
@Test
public void testHamcrest(){
//startsWith：匹配字符串以 XX 开头
assertThat("myStringOfNote", startsWith("my"));
}
2.containsString：匹配是否包含指定字符串
assertThat("myStringOfNote", containsString("ring"));3.equalTo：基于传入对象的 equals 方法匹配方式，如果是数组比较每个元素是否相等。
assertThat("foo", equalTo("foo"));
assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));4.allOf：匹配所有指定的匹配项，可指定多个匹配条件
assertThat("myValue", allOf(startsWith("my"), containsString("Val")));5.anyOf：匹配其中任意一个匹配项，可指定多个匹配条件
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))6.both：两个选项都匹配
assertThat("fab", both(containsString("a")).and(containsString("b")))7.either：匹配其中任意一个匹配项
assertThat("fan", either(containsString("a")).or(containsString("b")))8.describedAs：自定义描述匹配
// describedAs( // 参数1：自定义描述，可以使用占位符%0,%1,%2... // 参数2：匹配器 // 参数3：自定义描述中需要替换的变量按先后顺序匹配);
assertThat(120,describedAs("自定义期望值：%0", equalTo(110), 120));
9.everyItem：匹配现实 Iterable 接口类中的每个元素是否符合要求
assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))10.instanceOf：匹配对象是属于哪个类
assertThat(new Canoe(), instanceOf(Canoe.class));
六.TestSuite
如果有多个测试类, 可以合并成一个测试套件进行测试, 运行一个 Test Suite, 那么就会运行在这个 Test Suite 中的所用的测试.
例如:
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith( Suite.class )
@SuiteClasses( { JUnitTest1.class, JUnitTest2.class } )
public class AllTests {
}
七.idea快捷方式的分享
在 CalculatorTest类名上按下 alt + enter 后, 就可以自动生成测试类了:
