Check cancellation on the undispatched resume

  * It allows to apply the same reasoning about cancellation as in dispatched coroutines
  * Makes cancellation modes consistent

Related to #1177

Author: qwwdfsad

kotlinx-coroutines-core/common/src/ResumeMode.kt

@@ -43,7 +43,24 @@ internal fun <T> Continuation<T>.resumeUninterceptedMode(value: T, mode: Int) {
         MODE_ATOMIC_DEFAULT -> intercepted().resume(value)
         MODE_CANCELLABLE -> intercepted().resumeCancellable(value)
         MODE_DIRECT -> resume(value)
-        MODE_UNDISPATCHED -> withCoroutineContext(context, null) { resume(value) }
+        MODE_UNDISPATCHED -> withCoroutineContext(context, null) {
+            /*
+             * This check is necessary to make a cancellable resume when coroutine's context was changed,
+             * but it dispatcher wasn't.
+             * For example, in the situation like this:
+             * ```
+             * withContext(Job()) {
+             *     // Here we know that outer job is cancelled
+             * } // <- then here CE should occur
+             * ```
+             */
+            val job = context[Job]
+            if (job != null && !job.isActive) {
+                resumeWithException(job.getCancellationException())
+            } else {
+                resume(value)
+            }
+        }
         MODE_IGNORE -> {}
         else -> error("Invalid mode $mode")
     }

kotlinx-coroutines-core/common/test/CoroutinesTest.kt

@@ -299,15 +299,15 @@ class CoroutinesTest : TestBase() {
             } finally {
                 expect(5)
                 withContext(NonCancellable) { yield() } // to test
-                expect(7)
+                expectUnreached()
             }
             expectUnreached() // will get cancelled, because parent crashes
         }
         expect(3)
         yield() // to parent
         expect(6)
         parent.join() // make sure crashed parent still waits for its child
-        finish(8)
+        finish(7)
         // make sure is cancelled
         assertTrue(child.isCancelled)
     }

kotlinx-coroutines-core/common/test/NonCancellableTest.kt

@@ -16,9 +16,6 @@ class NonCancellableTest : TestBase() {
                 yield()
                 expect(4)
             }
-
-            expect(5)
-            yield()
             expectUnreached()
         }
 
@@ -36,7 +33,7 @@ class NonCancellableTest : TestBase() {
             } else {
                 assertNull(e.cause)
             }
-            finish(6)
+            finish(5)
         }
     }
 
@@ -49,9 +46,6 @@ class NonCancellableTest : TestBase() {
                 yield()
                 expect(4)
             }
-
-            expect(5)
-            yield()
             expectUnreached()
         }
 
@@ -64,7 +58,7 @@ class NonCancellableTest : TestBase() {
             expectUnreached()
         } catch (e: TestCancellationException) {
             assertEquals("TEST", e.message)
-            finish(6)
+            finish(5)
         }
     }
 
@@ -99,39 +93,4 @@ class NonCancellableTest : TestBase() {
             finish(6)
         }
     }
-
-    @Test
-    fun testNonCancellableTwice() = runTest {
-        expect(1)
-        val job = async {
-            withContext(NonCancellable) {
-                expect(2)
-                yield()
-                expect(4)
-            }
-
-            withContext(NonCancellable) {
-                expect(5)
-                yield()
-                expect(6)
-            }
-        }
-
-        yield()
-        job.cancel()
-        expect(3)
-        assertTrue(job.isCancelled)
-        try {
-            job.await()
-            expectUnreached()
-        } catch (e: JobCancellationException) {
-            if (RECOVER_STACK_TRACES) {
-                val cause = e.cause as JobCancellationException // shall be recovered JCE
-                assertNull(cause.cause)
-            } else {
-                assertNull(e.cause)
-            }
-            finish(7)
-        }
-    }
 }

kotlinx-coroutines-core/common/test/WithContextTest.kt

@@ -7,6 +7,7 @@
 
 package kotlinx.coroutines
 
+import kotlinx.coroutines.channels.*
 import kotlin.test.*
 
 class WithContextTest : TestBase() {
@@ -369,6 +370,55 @@ class WithContextTest : TestBase() {
         finish(4)
     }
 
+    @Test
+    fun testSequentialCancellationUndispatched() = runTest {
+        val latch = Channel<Unit>(1)
+        val job = launch {
+            expect(2)
+            withContext(NonCancellable) {
+                expect(3)
+                latch.receive()
+                expect(5)
+            }
+            expectUnreached()
+        }
+
+        expect(1)
+        yield()
+        expect(4)
+        job.cancel()
+        latch.send(Unit)
+        yield()
+        finish(6)
+    }
+
+    @Test
+    fun testExceptionWithSequentialCancellationUndispatched() = runTest {
+        val latch = Channel<Unit>(1)
+        val job = launch {
+            expect(2)
+            try {
+                withContext<Int>(NonCancellable) {
+                    expect(3)
+                    latch.receive()
+                    expect(5)
+                    throw TestException()
+                }
+                expectUnreached()
+            } catch (e: TestException) {
+                expect(6)
+            }
+        }
+
+        expect(1)
+        yield()
+        expect(4)
+        job.cancel()
+        latch.send(Unit)
+        yield()
+        finish(7)
+    }
+
     private class Wrapper(val value: String) : Incomplete {
         override val isActive: Boolean
             get() =  error("")