JUnit5-断言

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/IO_Field/article/details/82591459

断言是编写单元测试用例的核心方式，即期望值是多少，测试的结果是多少，以此来判断测试是否通过。在JUnit Jupiter中，所有的断言都是org.junit.jupiter.api.Assertions 类中static方法。

• assertAll：断言所有提供的可执行文件都不会抛出异常。若提供的标题(heading),其将包含在MultipleFailuresError的消息字符串中。
• assertArrayEquals：断言期望的和实际的XX类型数组是相等的。若失败，将显示提供的失败消息。
• assertDoesNotThrow：虽然从测试方法抛出的任何异常都会导致测试失败，但在某些用例中，显式断言测试方法中的给定代码块不会抛出异常会很有用。若提供的标题(heading),其将包含在MultipleFailuresError的消息字符串中。
• assertEquals：断言预期和实际是相等的。如有必要，将从提供的messageSupplier中懒惰地检索失败消息。
• assertFalse：断言提供的条件不是真。失败并显示提供的失败消息。
• assertIterableEquals：断言预期和实际的迭代是完全相同的。类似于检查assertArrayEquals(Object []，Object []，String)中的完全相等，如果遇到两个迭代(包括期望和实际)，则它们的迭代器必须以相同的顺序返回相等的元素。注意：这意味着迭代器不需要是同一类型。
• assertNotNull：断言提供的条件不为null
• assertNotSame：断言预期和实际不会引用同一个对象
• assertNull：断言提供的实际为null
• assertSame：断言预期和实际引用同一个对象
• assertThrows：断言所提供的可执行代码块的执行会引发expectedType的异常并返回异常。如果没有抛出异常，或者抛出了不同类型的异常，则此方法将失败。如果不想对异常实例执行其他检查，只需忽略返回值。
• assertTimeout：断言在超出给定超时之前，所提供的可执行代码块的执行完成。注意：可执行代码块将在与调用代码相同的线程中执行。因此，如果超过超时，则不会抢先中止执行可执行代码块。
• assertTimeoutPreemptively：断言在超出给定超时之前，所提供的可执行代码块的执行完成。注意：可执行代码块将在与调用代码不同的线程中执行。此外，如果超过超时，则可抢占地执行可执行代码块。
• assertTrue：断言提供的条件为true
• fail：使用给定的失败消息以及根本原因进行测试失败。泛型返回类型V允许此方法直接用作单语句lambda表达式，从而避免需要实现具有显式返回值的代码块。 由于此方法在其return语句之前抛出AssertionFailedError，因此该方法实际上永远不会向其调用者返回值。

例如：

class AssertTest {

    @Test
    fun succeedingTest() {
        Assertions.assertAll("AssertAll Heading", Executable {
            val aa = "10".toInt()
        })

        // 断言期望的和实际的XX类型是相等的。
        // 若失败，将显示提供的失败消息。
        Assertions.assertArrayEquals(arrayOf(1, 2, 3), arrayOf(1, 2, 3), "用来测试数组相等断言")

        Assertions.assertDoesNotThrow {
            val aa = "10".toInt()
        }

        // 断言预期和实际是相等的。
        // 如有必要，将从提供的messageSupplier中懒惰地检索失败消息。
        val a = 10
        Assertions.assertEquals(10, a, "测试Assert Equals")

        // 断言提供的条件不是真。
        // 失败并显示提供的失败消息。
        val aa = 20
        Assertions.assertFalse(aa < 10, "测试 assertFalse")

        // 断言预期和实际的迭代是完全相同的。
        // 如果遇到两个迭代(包括期望和实际)，则它们的迭代器必须以相同的顺序返回相等的元素。
        // 这意味着迭代器不需要是同一类型。
        val i0 = ArrayList(Arrays.asList(1, 2, 3))
        val i1 = LinkedList(Arrays.asList(1, 2, 3))
        Assertions.assertIterableEquals(i0, i1)

        // 断言实际不为null
        Assertions.assertNotNull(10, "Test Assert Not Null")

        // 断言预期和实际不会引用同一个对象
        val aList = listOf<Int>()
        val bList = mapOf<String, String>()
        Assertions.assertNotSame(aList, bList, "Test Assert Not Same")

        // 断言预期和实际引用同一个对象
        val cList = aList
        Assertions.assertSame(aList, cList, "Test assertSame")

        // 断言提供的实际为null
        var aNull: Int? = null
        Assertions.assertNull(aNull, "Test Assert Null")


        // 断言所提供的可执行代码块的执行会引发expectedType的异常并返回异常。
        // 如果没有抛出异常，或者抛出了不同类型的异常，则此方法将失败。
        // 如果不想对异常实例执行其他检查，只需忽略返回值。
        Assertions.assertThrows(AException::class.java) {
            throw AException()
        }

        // 断言在超出给定超时之前，所提供的可执行代码块的执行完成。
        // 可执行代码块将在与调用代码相同的线程中执行。
        // 因此，如果超过超时，则不会抢先中止执行可执行代码块.
        // 也就是说，即使超时，代码块也会执行完
        Assertions.assertTimeout(Duration.ofSeconds(3), {
            println("assertTimeout Start -->")
            Thread.sleep(5000)
            println("--> assertTimeout End")
        }, "Test assertTimeOut")
    }

    @Test
    fun failingAssertAllTest() {
        // 断言所有提供的可执行文件,不再抛出异常。
        // 提供的标题将包含在MultipleFailuresError的消息字符串中。
        Assertions.assertAll("AssertAll Heading", Executable {
            val aa = "aaa".toInt()
        })

    }

    @Test
    fun failingAssertArrayEquals() {
        // 断言期望的和实际的XX类型是相等的。
        // 若失败，将显示提供的失败消息。
        Assertions.assertArrayEquals(arrayOf(1, 2, 3), arrayOf(1, 2, 3, 4), "用来测试数组相等断言")
    }

    @Test
    fun failingAssertDoesNotThrow() {

        // 虽然从测试方法抛出的任何异常都会导致测试失败，
        // 但在某些用例中，显式断言测试方法中的给定代码块不会抛出异常会很有用。
        // 提供的标题将包含在MultipleFailuresError的消息字符串中。
        Assertions.assertDoesNotThrow({
            val aa = "aaa".toInt()
        }, "This is a Assert Does Not Throw Test")
    }

    @Test
    fun failingAssertEquals() {
        val a = 10

        // 断言预期和实际是相等的。
        // 如有必要，将从提供的messageSupplier中懒惰地检索失败消息。
        Assertions.assertEquals(20, a, "测试 assertEquals")
    }

    @Test
    fun failingAssertFalse() {
        // 断言提供的条件不是真。
        // 失败并显示提供的失败消息
        Assertions.assertFalse({
            val aa = 10
            aa > 5
        }, "测试 Assert False")
    }

    @Test
    fun failingAssertIterable() {
        val i0 = ArrayList(Arrays.asList(1, 2, 3))
        val i1 = LinkedList(Arrays.asList('A', 'B', 'C'))
        // 断言预期和实际的迭代是完全相同的。
        // 如果遇到两个迭代(包括期望和实际)，则它们的迭代器必须以相同的顺序返回相等的元素。
        // 这意味着迭代器不需要是同一类型。
        Assertions.assertIterableEquals(i0, i1, "Test assertIterable")
    }

    @Test
    fun failAssertNotNull() {

        // 断言提供的条件不为null
        Assertions.assertNotNull(null, "Test assertNotNull")
    }

    @Test
    fun failingNotSame() {

        // 断言预期和实际不会引用同一个对象
        val a = listOf<Int>()
        val c = a
        Assertions.assertNotSame(a, c, "Test assertNotSame")
    }

    @Test
    fun failingAssertNull() {
        // 断言提供的实际为null, 其默认预期值为null
        Assertions.assertNull(10, "Test assertNull")
    }

    @Test
    fun failingAssertSame() {
        // 断言预期和实际不会引用同一个对象
        // 注意：在List中，泛型的擦除效应
        val a = listOf<Int>()

        val b = mapOf<String, String>()

        Assertions.assertSame(a, b, "Test assertSame")
    }

    @Test
    fun failingAssertThrows() {

        // 断言所提供的可执行代码块的执行会引发expectedType的异常并返回异常。
        // 如果没有抛出异常，或者抛出了不同类型的异常，则此方法将失败。
        // 如果不想对异常实例执行其他检查，只需忽略返回值。
        Assertions.assertThrows(AException::class.java) {
            val aa = Random()
            val b = aa.nextInt()

            if (b > 10) {
                println("b: $b")
            } else {
                throw BException()
            }
        }
    }

    @Test
    fun failingAssertTimeout() {
        // 断言在超出给定超时之前，所提供的可执行代码块的执行完成。
        // 可执行代码块将在与调用代码相同的线程中执行。
        // 因此，如果超过超时，则不会抢先中止执行可执行代码块.
        // 也就是说，即使超时，代码块也会执行完
        Assertions.assertTimeout(Duration.ofSeconds(3), {
            println("assertTimeout Start -->")
            Thread.sleep(5000)
            println("--> assertTimeout End")
        }, "Test assertTimeOut")
    }

    @Test
    fun failingAssertTimeoutPreemptively() {

        // 断言在超出给定超时之前，所提供的可执行代码块的执行完成。'
        // 可执行代码块将在与调用代码不同的线程中执行。
        // 如果超过超时，则可抢占地执行可执行代码块。
        // 也就是说，如果超时，代码块不会执行完
        Assertions.assertTimeoutPreemptively(Duration.ofSeconds(3), {
            println("assertTimeout Start -->")
            Thread.sleep(5000)
            println("--> assertTimeout End")
        }, "Test assertTimeoutPreemptively")
    }

    @Test
    fun failingAssertTrue() {

        // 断言提供的条件为true
        Assertions.assertTrue({
            val random = Random()
            val b = random.nextInt()
            b > 10
        }, "Test assertTrue")
    }

    @Test
    fun testFail() {
        Assertions.fail<String>("这是一次失败的测试")
    }
}

在JUnit5中，断言提供了对Java 8 Lambda的支持，更便于使用断言。例如：

Assertions.assertTimeoutPreemptively(Duration.ofSeconds(3), {
        println("assertTimeout Start -->")
        Thread.sleep(5000)
        println("--> assertTimeout End")
    }, "Test assertTimeoutPreemptively")