Ensure runTest unsubscribes from the exception handler

Fixes #3897

Author: dkhalanskyjb

kotlinx-coroutines-test/common/src/TestScope.kt

@@ -239,6 +239,7 @@ internal class TestScopeImpl(context: CoroutineContext) :
             uncaughtExceptions
         }
         if (exceptions.isNotEmpty()) {
+            ExceptionCollector.removeOnExceptionCallback(lock)
             throw UncaughtExceptionsBeforeTest().apply {
                 for (e in exceptions)
                     addSuppressed(e)

kotlinx-coroutines-test/common/test/Helpers.kt

@@ -47,14 +47,16 @@ fun testResultMap(block: (() -> Unit) -> Unit, test: () -> TestResult): TestResu
  */
 expect fun testResultChain(block: () -> TestResult, after: (Result<Unit>) -> TestResult): TestResult
 
-fun testResultChain(vararg chained: (Result<Unit>) -> TestResult): TestResult =
+fun testResultChain(vararg chained: (Result<Unit>) -> TestResult, initialResult: Result<Unit> = Result.success(Unit)): TestResult =
     if (chained.isEmpty()) {
-        createTestResult { }
+        createTestResult {
+            initialResult.getOrThrow()
+        }
     } else {
         testResultChain(block = {
-            chained[0](Result.success(Unit))
+            chained[0](initialResult)
         }) {
-            testResultChain(*chained.drop(1).toTypedArray())
+            testResultChain(*chained.drop(1).toTypedArray(), initialResult = it)
         }
     }
 

kotlinx-coroutines-test/common/test/RunTestTest.kt

@@ -408,4 +408,67 @@ class RunTestTest {
     fun testCoroutineCompletingWithoutDispatch() = runTest(timeout = Duration.INFINITE) {
         launch(Dispatchers.Default) { delay(100) }
     }
+
+    /**
+     * Tests that [runTest] cleans up the exception handler even if it threw on initialization.
+     *
+     * This test must be run manually, because it writes garbage to the log.
+     */
+    @Test
+    @Ignore
+    fun testExceptionCaptorCleanedUpOnPreliminaryExit(): TestResult = testResultChain({
+        // step 1: installing the exception handler
+        println("step 1")
+        runTest { }
+    }, {
+        it.getOrThrow()
+        // step 2: throwing an uncaught exception to be caught by the exception-handling system
+        println("step 2")
+        createTestResult {
+            launch(NonCancellable) { throw TestException("A") }
+        }
+    }, {
+        it.getOrThrow()
+        // step 3: trying to run a test should immediately fail, even before entering the test body
+        println("step 3")
+        try {
+            runTest {
+                fail("unreached")
+            }
+            fail("unreached")
+        } catch (e: UncaughtExceptionsBeforeTest) {
+            val cause = e.suppressedExceptions.single()
+            assertIs<TestException>(cause)
+            assertEquals("A", cause.message)
+        }
+        // step 4: trying to run a test again should not fail with an exception
+        println("step 4")
+        runTest {
+        }
+    }, {
+        it.getOrThrow()
+        // step 5: throwing an uncaught exception to be caught by the exception-handling system, again
+        println("step 5")
+        createTestResult {
+            launch(NonCancellable) { throw TestException("B") }
+        }
+    }, {
+        it.getOrThrow()
+        // step 6: trying to run a test should immediately fail, again
+        println("step 6")
+        try {
+            runTest {
+                fail("unreached")
+            }
+            fail("unreached")
+        } catch (e: Exception) {
+            val cause = e.suppressedExceptions.single()
+            assertIs<TestException>(cause)
+            assertEquals("B", cause.message)
+        }
+        // step 7: trying to run a test again should not fail with an exception, again
+        println("step 7")
+        runTest {
+        }
+    })
 }