JUnit5-断言

断言是编写单元测试用例的核心方式，即期望值是多少，测试的结果是多少，以此来判断测试是否通过。在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")

最后

以上就是听话枫叶为你收集整理的JUnit5-断言的全部内容，希望文章能够帮你解决JUnit5-断言所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。