Junit

Junit

1、Junit 是什么？

JUnit 是一个用于 Java 编程语言的开源测试框架。它提供了一组用于编写和运行测试的工具，帮助开发人员轻松地进行单元测试。JUnit 是单元测试的标准框架之一，被广泛应用于 Java 项目的测试和持续集成过程中。

2、断言

Method Summary

• static void assertArrayEquals(boolean[] expecteds, boolean[] actuals)：断言两个 boolean 数组相等。
• static void assertArrayEquals(byte[] expecteds, byte[] actuals)：断言两个 byte 数组相等。
• static void assertArrayEquals(char[] expecteds, char[] actuals)：断言两个 char 数组相等。
• static void assertArrayEquals(double[] expecteds, double[] actuals, double delta)：断言两个 double 数组相等。
• static void assertArrayEquals(float[] expecteds, float[] actuals, float delta)：断言两个 float 数组相等。
• static void assertArrayEquals(int[] expecteds, int[] actuals)：断言两个 int 数组相等。
• static void assertArrayEquals(long[] expecteds, long[] actuals)：断言两个 long 数组相等。
• static void assertArrayEquals(Object[] expecteds, Object[] actuals)：断言两个对象数组相等。
• static void assertArrayEquals(short[] expecteds, short[] actuals)：断言两个 short 数组相等。
• static void assertArrayEquals(String message, boolean[] expecteds, boolean[] actuals)：断言两个 boolean 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, byte[] expecteds, byte[] actuals)：断言两个 byte 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, char[] expecteds, char[] actuals)：断言两个 char 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, double[] expecteds, double[] actuals, double delta)：断言两个 double 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, float[] expecteds, float[] actuals, float delta)：断言两个 float 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, int[] expecteds, int[] actuals)：断言两个 int 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, long[] expecteds, long[] actuals)：断言两个 long 数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, Object[] expecteds, Object[] actuals)：断言两个对象数组相等，并提供自定义错误信息。
• static void assertArrayEquals(String message, short[] expecteds, short[] actuals)：断言两个 short 数组相等，并提供自定义错误信息。
• static void assertEquals(double expected, double actual)：断言两个 double 值相等。
• static void assertEquals(double expected, double actual, double delta)：断言两个 double 值在指定精度范围内相等。
• static void assertEquals(float expected, float actual, float delta)：断言两个 float 值在指定精度范围内相等。
• static void assertEquals(long expected, long actual)：断言两个 long 值相等。
• static void assertEquals(Object[] expecteds, Object[] actuals)：断言两个对象数组相等。
• static void assertEquals(Object expected, Object actual)：断言两个对象相等。
• static void assertEquals(String message, double expected, double actual)：断言两个 double 值相等，并提供自定义错误信息。
• static void assertEquals(String message, double expected, double actual, double delta)：断言两个 double 值在指定精度范围内相等，并提供自定义错误信息。
• static void assertEquals(String message, float expected, float actual, float delta)：断言两个 float 值在指定精度范围内相等，并提供自定义错误信息。
• static void assertEquals(String message, long expected, long actual)：断言两个 long 值相等，并提供自定义错误信息。
• static void assertEquals(String message, Object[] expecteds, Object[] actuals)：断言两个对象数组相等，并提供自定义错误信息。
• static void assertEquals(String message, Object expected, Object actual)：断言两个对象相等，并提供自定义错误信息。
• static void assertFalse(boolean condition)：断言条件为 false。
• static void assertFalse(String message, boolean condition)：断言条件为 false，并提供自定义错误信息。
• static void assertNotEquals(double unexpected, double actual, double delta)：断言两个 double 值在指定精度范围内不相等。
• static void assertNotEquals(float unexpected, float actual, float delta)：断言两个 float 值在指定精度范围内不相等。
• static void assertNotEquals(long unexpected, long actual)：断言两个 long 值不相等。
• static void assertNotEquals(Object unexpected, Object actual)：断言两个对象不相等。
• static void assertNotEquals(String message, double unexpected, double actual, double delta)：断言两个 double 值在指定精度范围内不相等，并提供自定义错误信息。
• static void assertNotEquals(String message, float unexpected, float actual, float delta)：断言两个 float 值在指定精度范围内不相等，并提供自定义错误信息。
• static void assertNotEquals(String message, long unexpected, long actual)：断言两个 long 值不相等，并提供自定义错误信息。
• static void assertNotEquals(String message, Object unexpected, Object actual)：断言两个对象不相等，并提供自定义错误信息。
• static void assertNotNull(Object object)：断言对象不为 null。
• static void assertNotNull(String message, Object object)：断言对象不为 null，并提供自定义错误信息。
• static void assertNotSame(Object unexpected, Object actual)：断言两个对象不引用同一个对象。
• static void assertNotSame(String message, Object unexpected, Object actual)：断言两个对象不引用同一个对象，并提供自定义错误信息。
• static void assertNull(Object object)：断言对象为 null。
• static void assertNull(String message, Object object)：断言对象为 null，并提供自定义错误信息。
• static void assertSame(Object expected, Object actual)：断言两个对象引用同一个对象。
• static void assertSame(String message, Object expected, Object actual)：断言两个对象引用同一个对象，并提供自定义错误信息。
• static<T> void assertThat(String reason, T actual, Matcher<? super T> matcher)：使用 Hamcrest Matcher 断言 actual 值符合 matcher 对应的条件。
• static<T> void assertThat(T actual, Matcher<? super T> matcher)：使用 Hamcrest Matcher 断言 actual 值符合 matcher 对应的条件。
• static<T extends Throwable>T assertThrows(Class expectedThrowable, ThrowingRunnable runnable)：断言执行 runnable 时会抛出指定类型的异常。
• static<T extends Throwable>T assertThrows(String message, Class expectedThrowable, ThrowingRunnable runnable)：断言执行 runnable 时会抛出指定类型的异常，并提供自定义错误信息。
• static void assertTrue(boolean condition)：断言条件为 true。
• static void assertTrue(String message, boolean condition)：断言条件为 true，并提供自定义错误信息。
• static void fail()：测试失败，无错误信息。
• static void fail(String message)：测试失败，并提供自定义错误信息。

例子：

import org.junit.Assert;
import org.junit.Test;

public class AssertionTest {
    @Test
    public void test() {
        String obj1 = "junit";
        String obj2 = "junit";
        String obj3 = "test";
        String obj4 = "test";
        String obj5= null;

        int var1 = 1;
        int var2 = 2;

        int[] arr1 = {1,2,3};
        int[] arr2 = {1,2,3};

        Assert.assertEquals(obj1,obj2);
        Assert.assertSame(obj3,obj4);
        Assert.assertNotEquals(obj1,obj2);
        Assert.assertNotSame(obj1,obj4);
        Assert.assertNotNull(obj1);
        Assert.assertNull(obj5);

        Assert.assertTrue(var1 < var2);
        Assert.assertFalse(var1 > var2);

        Assert.assertArrayEquals(arr1, arr2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

需要注意，一旦有断言错误，程序不会向下执行。

3、Junit 执行顺序

import org.junit.*;

public class JunitLifeCycle {
    // 只执行一次
    @BeforeClass
    public static void before1() {
        System.out.println("before class ...");
    }

    // 只执行一次
    @AfterClass
    public static void after1() {
        System.out.println("after class ...");
    }
    

    /**
     * 执行了多少个@Test就执行几次
     */
    @Before
    public void before() {
        System.out.println("in before");
    }

    /**
     * 执行了多少个@Test就执行了几次
     */
    @After
    public void after() {
        System.out.println("in after");
    }

    @Test
    public void testCase1() {
        System.out.println("in test case 1");
    }

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

注意 @BeforeClass、@AfterClass 要使用 static 在方法上。

4、忽略一个注解

import org.junit.Ignore;
import org.junit.Test;

public class IgnoreDemo {
    @Test
    public void test1() {
        System.out.println("会不会执行");
    }

    @Ignore
    @Test
    public void test2() {
        System.out.println("会不会执行");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5、时间测试

import org.junit.Test;

public class TimeDemo {
    @Test(timeout = 1000)
    public void demo1() throws InterruptedException {
        Thread.sleep(999);
        System.out.println("会不会执行。。。");
    }
}
1
2
3
4
5
6
7
8
9

import org.junit.Test;

public class TimeDemo {
    @Test(timeout = 1000)
    public void demo1() throws InterruptedException {
        Thread.sleep(1000);
        System.out.println("会不会执行。。。");
    }
}

1
2
3
4
5
6
7
8
9
10

6、异常测试

import org.junit.Test;

public class ExceptionDemo {
    @Test(expected = ArithmeticException.class)
    public void demo1() {
        int a = 1 / 0;
        System.out.println("会不会执行。。");
    }
}
1
2
3
4
5
6
7
8
9

7、参数化测试

JUnit参数化测试是JUnit框架的一个功能，允许您在同一个测试方法中使用不同的参数运行多个测试。这样可以更方便地编写、组织和管理测试用例。以下是使用JUnit 5的示例来说明如何创建参数化测试：

首先，您需要在项目的pom.xml文件（如果使用Maven）中添加JUnit Jupiter的依赖：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.8.0</version>
    <scope>test</scope>
</dependency>
1
2
3
4
5
6

然后，您可以创建一个测试类，并使用@ParameterizedTest注解标记要进行参数化的测试方法。在测试方法上方，使用@MethodSource注解指定提供测试参数的方法。下面是一个示例：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import java.util.stream.Stream;

public class ParameterizedTestExample {

    @ParameterizedTest
    @MethodSource("provideNumbers")
    void testIsEven(int number, boolean expected) {
        Assertions.assertEquals(expected, isEven(number));
    }

    private static Stream<Arguments> provideNumbers() {
        return Stream.of(
                Arguments.of(2, true),
                Arguments.of(3, false),
                Arguments.of(4, true)
        );
    }

    private boolean isEven(int number) {
        return number % 2 == 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在上面的示例中，我们定义了一个参数化测试方法 testIsEven，它接受一个整数参数 number 和一个预期的布尔值 expected。通过使用 @MethodSource 注解，我们指定了一个名为 provideNumbers 的方法来提供测试参数。provideNumbers 方法返回一个Stream，其中包含要测试的参数组合。在这种情况下，我们使用 Arguments.of() 来创建参数对，每个参数对包含一个整数和一个布尔值。

当运行参数化测试时，JUnit会使用提供的参数组合逐个执行测试，并为每个参数组合生成单独的测试结果。

通过使用JUnit的参数化测试功能，您可以更方便地测试不同的输入组合，减少测试代码的冗余，并提高测试覆盖度。

8、套件测试

在JUnit中，测试套件是一种组织和运行多个测试类的方法。测试套件允许您将相关的测试类分组在一起，以便一次性运行它们，并获得一个综合的测试报告。以下是使用JUnit 5创建测试套件的示例：

首先，您需要在项目的pom.xml文件（如果使用Maven）中添加JUnit Jupiter的相关依赖：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.8.0</version>
    <scope>test</scope>
</dependency>
1
2
3
4
5
6

接下来，创建多个测试类，每个类都包含一组相关的测试方法。以下是两个示例测试类：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class MathUtilsTest {
    
    @Test
    void testAddition() {
        Assertions.assertEquals(5, MathUtils.add(2, 3));
    }
    
    @Test
    void testSubtraction() {
        Assertions.assertEquals(2, MathUtils.subtract(5, 3));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class StringUtilsTest {

    @Test
    void testConcatenate() {
        Assertions.assertEquals("Hello, World!", StringUtils.concatenate("Hello", ", ", "World"));
    }
    
    @Test
    void testStringLength() {
        Assertions.assertEquals(5, StringUtils.getLength("Hello"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

创建一个新的测试套件类，并使用@RunWith注解（如果您使用JUnit 4）或@ExtendWith注解（如果您使用JUnit 5）将测试套件运行器指定为Suite，并在@Suite.SuiteClasses注解中列出要执行的测试类。以下是一个示例：

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.SuiteDisplayName;
import org.junit.jupiter.api.DisplayName;

@RunWith(Suite.class)
@Suite.SuiteClasses({MathUtilsTest.class, StringUtilsTest.class})
@SuiteDisplayName("Sample Test Suite")
public class TestSuite {
}
1
2
3
4
5
6
7
8
9
10
11
12

在上面的示例中，我们使用JUnit 4的方式创建了一个测试套件类。@Suite.SuiteClasses注解指定了要执行的测试类列表，即MathUtilsTest.class和StringUtilsTest.class。@SuiteDisplayName注解指定了测试套件的显示名称。

接下来，您可以运行TestSuite类来执行整个测试套件，或使用您的构建工具（如Maven）运行测试命令。

测试套件将会依次运行所有列出的测试类，并收集所有测试结果，生成一个综合的测试报告。这样，您可以方便地组织和管理多个测试，并获得一次性的测试运行结果。

当您运行测试套件时，测试套件将会依次运行所有列出的测试类，并收集所有测试结果。结果是基于每个测试类中的测试方法的执行情况生成的。

如果所有的测试都通过，那么测试套件会返回一个“成功”的结果，并显示每个测试类中的每个测试方法的执行时间和通过的数量。

如果其中一个或多个测试失败，那么测试套件会返回一个“失败”的结果，并显示失败的测试方法的详细结果，包括失败原因和堆栈跟踪信息。此外，还会显示每个测试类中的每个测试方法的执行时间、通过的数量和失败的数量。

测试套件的结果可以通过控制台输出、测试报告或集成开发环境（IDE）中的测试运行窗口来查看和分析。

测试套件将会依次运行所有列出的测试类，并收集所有测试结果，生成一个综合的测试报告。这样，您可以方便地组织和管理多个测试，并获得一次性的测试运行结果。

当您运行测试套件时，测试套件将会依次运行所有列出的测试类，并收集所有测试结果。结果是基于每个测试类中的测试方法的执行情况生成的。

如果所有的测试都通过，那么测试套件会返回一个“成功”的结果，并显示每个测试类中的每个测试方法的执行时间和通过的数量。

如果其中一个或多个测试失败，那么测试套件会返回一个“失败”的结果，并显示失败的测试方法的详细结果，包括失败原因和堆栈跟踪信息。此外，还会显示每个测试类中的每个测试方法的执行时间、通过的数量和失败的数量。

测试套件的结果可以通过控制台输出、测试报告或集成开发环境（IDE）中的测试运行窗口来查看和分析。

测试套件提供了一种方便的方式来执行一组相关的测试，并在单个报告中查看所有测试结果。这样，可以轻松地了解整个测试集的通过情况，并定位和解决任何失败的测试用例。