Inline lambdas passed to assertDoesNotThrows to support suspending functions (#2684)

This commit adds support for suspending functions when `assertDoesNotThrow` is called from Kotlin.

Closes #2674.

Author: williamboman

documentation/src/docs/asciidoc/release-notes/release-notes-5.8.0-M2.adoc

@@ -84,6 +84,7 @@ on GitHub.
 
 ==== New Features and Improvements
 
+* `assertDoesNotThrow` now supports suspending functions when called from Kotlin.
 * `@TempDir` can now be used to create multiple temporary directories. Instead of creating
   a single temporary directory per context (i.e. test class or method) every declaration
   of the `@TempDir` annotation on a field or method parameter now results in a separate

junit-jupiter-api/src/main/kotlin/org/junit/jupiter/api/Assertions.kt

@@ -158,8 +158,8 @@ inline fun <reified T : Throwable> assertThrows(noinline message: () -> String,
  * @param R the result type of the [executable]
  */
 @API(status = EXPERIMENTAL, since = "5.5")
-fun <R> assertDoesNotThrow(executable: () -> R): R =
-    Assertions.assertDoesNotThrow(ThrowingSupplier(executable))
+inline fun <R> assertDoesNotThrow(executable: () -> R): R =
+    Assertions.assertDoesNotThrow(evaluateAndWrap(executable))
 
 /**
  * Example usage:
@@ -172,7 +172,7 @@ fun <R> assertDoesNotThrow(executable: () -> R): R =
  * @param R the result type of the [executable]
  */
 @API(status = EXPERIMENTAL, since = "5.5")
-fun <R> assertDoesNotThrow(message: String, executable: () -> R): R =
+inline fun <R> assertDoesNotThrow(message: String, executable: () -> R): R =
     assertDoesNotThrow({ message }, executable)
 
 /**
@@ -186,8 +186,19 @@ fun <R> assertDoesNotThrow(message: String, executable: () -> R): R =
  * @param R the result type of the [executable]
  */
 @API(status = EXPERIMENTAL, since = "5.5")
-fun <R> assertDoesNotThrow(message: () -> String, executable: () -> R): R =
-    Assertions.assertDoesNotThrow(ThrowingSupplier(executable), Supplier(message))
+inline fun <R> assertDoesNotThrow(noinline message: () -> String, executable: () -> R): R =
+    Assertions.assertDoesNotThrow(
+        evaluateAndWrap(executable),
+        Supplier(message)
+    )
+
+@PublishedApi
+internal inline fun <R> evaluateAndWrap(executable: () -> R): ThrowingSupplier<R> = try {
+    val result = executable()
+    ThrowingSupplier { result }
+} catch (throwable: Throwable) {
+    ThrowingSupplier { throw throwable }
+}
 
 /**
  * Example usage:

junit-jupiter-engine/src/test/kotlin/org/junit/jupiter/api/KotlinAssertionsTests.kt

@@ -75,13 +75,31 @@ class KotlinAssertionsTests {
                 val actual = assertDoesNotThrow { 1 }
                 assertEquals(1, actual)
             },
+            dynamicTest("for no arguments variant (suspended)") {
+                runBlocking {
+                    val actual = assertDoesNotThrow { suspend { 1 }() }
+                    assertEquals(1, actual)
+                }
+            },
             dynamicTest("for message variant") {
                 val actual = assertDoesNotThrow("message") { 2 }
                 assertEquals(2, actual)
             },
+            dynamicTest("for message variant (suspended)") {
+                runBlocking {
+                    val actual = assertDoesNotThrow("message") { suspend { 2 }() }
+                    assertEquals(2, actual)
+                }
+            },
             dynamicTest("for message supplier variant") {
                 val actual = assertDoesNotThrow({ "message" }) { 3 }
                 assertEquals(3, actual)
+            },
+            dynamicTest("for message supplier variant (suspended)") {
+                runBlocking {
+                    val actual = assertDoesNotThrow({ "message" }) { suspend { 3 }() }
+                    assertEquals(3, actual)
+                }
             }
         )),
         dynamicContainer("fails when an exception is thrown", Stream.of(
@@ -94,6 +112,19 @@ class KotlinAssertionsTests {
                 assertMessageEquals(exception,
                     "Unexpected exception thrown: org.opentest4j.AssertionFailedError: fail")
             },
+            dynamicTest("for no arguments variant (suspended)") {
+                runBlocking {
+                    val exception = assertThrows<AssertionError> {
+                        assertDoesNotThrow {
+                            suspend { fail("fail") }()
+                        }
+                    }
+                    assertMessageEquals(
+                        exception,
+                        "Unexpected exception thrown: org.opentest4j.AssertionFailedError: fail"
+                    )
+                }
+            },
             dynamicTest("for message variant") {
                 val exception = assertThrows<AssertionError> {
                     assertDoesNotThrow("Does not throw") {
@@ -103,6 +134,19 @@ class KotlinAssertionsTests {
                 assertMessageEquals(exception,
                     "Does not throw ==> Unexpected exception thrown: org.opentest4j.AssertionFailedError: fail")
             },
+            dynamicTest("for message variant (suspended)") {
+                runBlocking {
+                    val exception = assertThrows<AssertionError> {
+                        assertDoesNotThrow("Does not throw") {
+                            suspend { fail("fail") }()
+                        }
+                    }
+                    assertMessageEquals(
+                        exception,
+                        "Does not throw ==> Unexpected exception thrown: org.opentest4j.AssertionFailedError: fail"
+                    )
+                }
+            },
             dynamicTest("for message supplier variant") {
                 val exception = assertThrows<AssertionError> {
                     assertDoesNotThrow({ "Does not throw" }) {
@@ -111,6 +155,19 @@ class KotlinAssertionsTests {
                 }
                 assertMessageEquals(exception,
                     "Does not throw ==> Unexpected exception thrown: org.opentest4j.AssertionFailedError: fail")
+            },
+            dynamicTest("for message supplier variant (suspended)") {
+                runBlocking {
+                    val exception = assertThrows<AssertionError> {
+                        assertDoesNotThrow({ "Does not throw" }) {
+                            suspend { fail("fail") }()
+                        }
+                    }
+                    assertMessageEquals(
+                        exception,
+                        "Does not throw ==> Unexpected exception thrown: org.opentest4j.AssertionFailedError: fail"
+                    )
+                }
             }
         ))
     )