Suppress excessive exceptions in cleanup

Author: dkhalanskyjb

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

@@ -47,8 +47,8 @@ public interface TestCoroutineScope: CoroutineScope {
     /**
      * Reports an exception so that it is thrown on [cleanupTestCoroutines].
      *
-     * If several exceptions are reported, only the first one will be thrown, and the other ones will be printed to the
-     * console.
+     * If several exceptions are reported, only the first one will be thrown, and the other ones will be suppressed by
+     * it.
      *
      * @throws IllegalStateException with the [Throwable.cause] set to [throwable] if [cleanupTestCoroutines] was
      * already called.
@@ -85,7 +85,11 @@ private class TestCoroutineScopeImpl(
         val delayController = coroutineContext.delayController
         var hasUncompletedJobs = false
         if (delayController != null) {
-            delayController.cleanupTestCoroutines()
+            try {
+                delayController.cleanupTestCoroutines()
+            } catch (e: UncompletedCoroutinesError) {
+                hasUncompletedJobs = true
+            }
         } else {
             testScheduler.runCurrent()
             if (!testScheduler.isIdle()) {
@@ -98,20 +102,27 @@ private class TestCoroutineScopeImpl(
             cleanedUp = true
         }
         exceptions.apply {
-            drop(1).forEach { it.printStackTrace() }
-            singleOrNull()?.let { throw it }
-        }
-        if (hasUncompletedJobs) {
-            throw UncompletedCoroutinesError(
-                "Unfinished coroutines during teardown. Ensure all coroutines are" +
-                    " completed or cancelled by your test."
-            )
+            firstOrNull()?.let {
+                val toThrow = it
+                drop(1).forEach { toThrow.addSuppressed(it) }
+                ownJob?.completeExceptionally(toThrow)
+                throw toThrow
+            }
         }
-        val jobs = coroutineContext.activeJobs()
-        if ((jobs - initialJobs).isNotEmpty()) {
-            val exception = UncompletedCoroutinesError("Test finished with active jobs: $jobs")
-            ownJob?.completeExceptionally(exception)
-            throw exception
+        try {
+            if (hasUncompletedJobs) {
+                throw UncompletedCoroutinesError(
+                    "Unfinished coroutines during teardown. Ensure all coroutines are" +
+                        " completed or cancelled by your test."
+                )
+            }
+            val jobs = coroutineContext.activeJobs()
+            if ((jobs - initialJobs).isNotEmpty()) {
+                throw UncompletedCoroutinesError("Test finished with active jobs: $jobs")
+            }
+        } catch (e: UncompletedCoroutinesError) {
+            ownJob?.completeExceptionally(e)
+            throw e
         }
         ownJob?.complete()
     }

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

@@ -107,6 +107,22 @@ class TestCoroutineScopeTest {
         assertTrue(handlerCalled)
     }
 
+    /** Tests that the coroutine scope completes its job with an exception. */
+    @Test
+    fun testCompletesOwnJobOnFailure() {
+        val scope = createTestCoroutineScope()
+        val exception = TestException("x")
+        var caughtException: Throwable? = null
+        scope.reportException(exception)
+        scope.coroutineContext.job.invokeOnCompletion {
+            caughtException = it
+        }
+        assertFailsWith<TestException> {
+            scope.cleanupTestCoroutines()
+        }
+        assertSame(exception, caughtException)
+    }
+
     /** Tests that the coroutine scope completes its job if the job was not passed to it as an argument. */
     @Test
     fun testDoesNotCompleteGivenJob() {
@@ -169,6 +185,25 @@ class TestCoroutineScopeTest {
         }
     }
 
+    /** Tests that, when reporting several exceptions, the first one is thrown, with the rest suppressed. */
+    @Test
+    fun testSuppressedExceptions() {
+        createTestCoroutineScope().apply {
+            reportException(TestException("x"))
+            reportException(TestException("y"))
+            reportException(TestException("z"))
+            try {
+                cleanupTestCoroutines()
+                fail("should not be reached")
+            } catch (e: TestException) {
+                assertEquals("x", e.message)
+                assertEquals(2, e.suppressedExceptions.size)
+                assertEquals("y", e.suppressedExceptions[0].message)
+                assertEquals("z", e.suppressedExceptions[1].message)
+            }
+        }
+    }
+
     companion object {
         internal val invalidContexts = listOf(
             Dispatchers.Default, // not a [TestDispatcher]