Fixes

Author: dkhalanskyjb

kotlinx-coroutines-core/common/README.md

@@ -130,6 +130,7 @@ Low-level primitives for finer-grained control of coroutines.
 
 [kotlinx.coroutines.sync.Mutex]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/-mutex/index.html
 [kotlinx.coroutines.sync.Mutex.lock]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/-mutex/lock.html
+[kotlinx.coroutines.sync.Mutex.tryLock]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/-mutex/try-lock.html
 
 <!--- INDEX kotlinx.coroutines.channels -->
 

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

@@ -12,7 +12,8 @@ import kotlin.coroutines.*
  * Access uncaught coroutine exceptions captured during test execution.
  */
 @Deprecated(
-    "Consider whether the default mechanism of handling uncaught exceptions is sufficient. " +
+    "Deprecated for removal without a replacement. " +
+        "Consider whether the default mechanism of handling uncaught exceptions is sufficient. " +
         "If not, try writing your own `CoroutineExceptionHandler` and " +
         "please report your use case at https://github.com/Kotlin/kotlinx.coroutines/issues.",
     level = DeprecationLevel.WARNING
@@ -41,7 +42,8 @@ public interface UncaughtExceptionCaptor {
  * An exception handler that captures uncaught exceptions in tests.
  */
 @Deprecated(
-    "It's better to define one's own `CoroutineExceptionHandler` if you just need to handle '" +
+    "Deprecated for removal without a replacement. " +
+        "It may be to define one's own `CoroutineExceptionHandler` if you just need to handle '" +
         "uncaught exceptions without a special `TestCoroutineScope` integration.", level = DeprecationLevel.WARNING
 )
 public class TestCoroutineExceptionHandler :

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

@@ -183,15 +183,19 @@ public fun createTestCoroutineScope(context: CoroutineContext = EmptyCoroutineCo
         is UncaughtExceptionCaptor -> exceptionHandler
         null -> {
             val lock = SynchronizedObject()
-            CoroutineExceptionHandler { context, throwable ->
+            CoroutineExceptionHandler { _, throwable ->
                 val reported = synchronized(lock) {
                     scope!!.reportException(throwable)
                 }
                 if (!reported)
                     throw throwable // let this exception crash everything
             }
         }
-        else -> throw IllegalArgumentException("A CoroutineExceptionHandler was passed to TestCoroutineScope")
+        else -> throw IllegalArgumentException(
+            "A CoroutineExceptionHandler was passed to TestCoroutineScope. " +
+                "Please pass it as an argument to a `launch` or `async` block on an already-created scope " +
+                "if uncaught exceptions require special treatment."
+        )
     }
     val job: Job = context[Job] ?: Job()
     return TestCoroutineScopeImpl(context + scheduler + dispatcher + exceptionHandler + job).also {

kotlinx-coroutines-test/common/test/migration/TestRunBlockingTest.kt

@@ -309,6 +309,15 @@ class TestRunBlockingTest {
         }
     }
 
+    @Test
+    fun runBlockingTestBuilder_throwsOnBadHandler() {
+        assertFailsWith<IllegalArgumentException> {
+            runBlockingTest(CoroutineExceptionHandler { _, _ -> }) {
+
+            }
+        }
+    }
+
     @Test
     fun pauseDispatcher_disablesAutoAdvance_forCurrent() = runBlockingTest {
         var mutable = 0
@@ -419,4 +428,13 @@ class TestRunBlockingTest {
     fun testOverrideExceptionHandler() = runBlockingTest(exceptionHandler) {
         assertSame(coroutineContext[CoroutineExceptionHandler], exceptionHandler)
     }
+
+    @Test
+    fun testOverrideExceptionHandlerError() {
+        assertFailsWith<IllegalArgumentException> {
+            runBlockingTest(CoroutineExceptionHandler { _, _ -> }) {
+                fail("Unreached")
+            }
+        }
+    }
 }