diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncLazyTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncLazyTest.kt
index 3f319a6..a56084d 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncLazyTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncLazyTest.kt
@@ -29,11 +29,11 @@
             42
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
-        check(d.await() == 42)
-        check(!d.isActive && d.isCompleted && !d.isCompletedExceptionally)
+        assertTrue(!d.isActive && !d.isCompleted)
+        assertTrue(d.await() == 42)
+        assertTrue(!d.isActive && d.isCompleted && !d.isCompletedExceptionally)
         expect(4)
-        check(d.await() == 42) // second await -- same result
+        assertTrue(d.await() == 42) // second await -- same result
         finish(5)
     }
 
@@ -47,11 +47,11 @@
             42
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
-        check(d.await() == 42)
-        check(!d.isActive && d.isCompleted && !d.isCompletedExceptionally)
+        assertTrue(!d.isActive && !d.isCompleted)
+        assertTrue(d.await() == 42)
+        assertTrue(!d.isActive && d.isCompleted && !d.isCompletedExceptionally)
         expect(5)
-        check(d.await() == 42) // second await -- same result
+        assertTrue(d.await() == 42) // second await -- same result
         finish(6)
     }
 
@@ -63,22 +63,22 @@
             42
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
+        assertTrue(!d.isActive && !d.isCompleted)
         launch(coroutineContext) { // see how it looks from another coroutine
             expect(4)
-            check(!d.isActive && !d.isCompleted)
+            assertTrue(!d.isActive && !d.isCompleted)
             yield() // yield back to main
             expect(6)
-            check(d.isActive && !d.isCompleted) // implicitly started by main's await
+            assertTrue(d.isActive && !d.isCompleted) // implicitly started by main's await
             yield() // yield to d
         }
         expect(3)
-        check(!d.isActive && !d.isCompleted)
+        assertTrue(!d.isActive && !d.isCompleted)
         yield() // yield to second child (lazy async is not computing yet)
         expect(5)
-        check(!d.isActive && !d.isCompleted)
-        check(d.await() == 42) // starts computing
-        check(!d.isActive && d.isCompleted && !d.isCompletedExceptionally)
+        assertTrue(!d.isActive && !d.isCompleted)
+        assertTrue(d.await() == 42) // starts computing
+        assertTrue(!d.isActive && d.isCompleted && !d.isCompletedExceptionally)
         finish(8)
     }
 
@@ -92,7 +92,7 @@
             throw TestException()
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
+        assertTrue(!d.isActive && !d.isCompleted)
         d.await() // will throw IOException
     }
 
@@ -108,7 +108,7 @@
             throw TestException()
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
+        assertTrue(!d.isActive && !d.isCompleted)
         d.await() // will throw IOException
     }
 
@@ -120,11 +120,11 @@
             throw TestException()
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
+        assertTrue(!d.isActive && !d.isCompleted)
         try {
             d.await() // will throw IOException
         } catch (e: TestException) {
-            check(!d.isActive && d.isCompleted && d.isCompletedExceptionally && !d.isCancelled)
+            assertTrue(!d.isActive && d.isCompleted && d.isCompletedExceptionally && !d.isCancelled)
             expect(4)
         }
         finish(5)
@@ -138,15 +138,15 @@
             42
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
-        check(d.start())
-        check(d.isActive && !d.isCompleted)
+        assertTrue(!d.isActive && !d.isCompleted)
+        assertTrue(d.start())
+        assertTrue(d.isActive && !d.isCompleted)
         expect(3)
-        check(!d.start())
+        assertTrue(!d.start())
         yield() // yield to started coroutine
-        check(!d.isActive && d.isCompleted && !d.isCompletedExceptionally) // and it finishes
+        assertTrue(!d.isActive && d.isCompleted && !d.isCompletedExceptionally) // and it finishes
         expect(5)
-        check(d.await() == 42) // await sees result
+        assertTrue(d.await() == 42) // await sees result
         finish(6)
     }
 
@@ -160,13 +160,13 @@
             42
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted)
-        check(d.cancel())
-        check(!d.isActive && d.isCompleted && d.isCompletedExceptionally && d.isCancelled)
-        check(!d.cancel())
-        check(!d.start())
+        assertTrue(!d.isActive && !d.isCompleted)
+        assertTrue(d.cancel())
+        assertTrue(!d.isActive && d.isCompleted && d.isCompletedExceptionally && d.isCancelled)
+        assertTrue(!d.cancel())
+        assertTrue(!d.start())
         finish(3)
-        check(d.await() == 42) // await shall throw CancellationException
+        assertTrue(d.await() == 42) // await shall throw CancellationException
         expectUnreached()
     }
 
@@ -182,19 +182,19 @@
             42
         }
         expect(2)
-        check(!d.isActive && !d.isCompleted && !d.isCancelled)
-        check(d.start())
-        check(d.isActive && !d.isCompleted && !d.isCancelled)
+        assertTrue(!d.isActive && !d.isCompleted && !d.isCancelled)
+        assertTrue(d.start())
+        assertTrue(d.isActive && !d.isCompleted && !d.isCancelled)
         expect(3)
         yield() // yield to d
         expect(5)
-        check(d.isActive && !d.isCompleted && !d.isCancelled)
-        check(d.cancel())
-        check(!d.isActive && !d.isCompletedExceptionally && d.isCancelled) // cancelling !
-        check(!d.cancel())
-        check(!d.isActive && !d.isCompletedExceptionally && d.isCancelled) // still cancelling
+        assertTrue(d.isActive && !d.isCompleted && !d.isCancelled)
+        assertTrue(d.cancel())
+        assertTrue(!d.isActive && !d.isCompletedExceptionally && d.isCancelled) // cancelling !
+        assertTrue(!d.cancel())
+        assertTrue(!d.isActive && !d.isCompletedExceptionally && d.isCancelled) // still cancelling
         finish(6)
-        check(d.await() == 42) // await shall throw CancellationException
+        assertTrue(d.await() == 42) // await shall throw CancellationException
         expectUnreached()
     }
 
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncTest.kt
index 128b8b7..f933f72 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAsyncTest.kt
@@ -29,11 +29,11 @@
             42
         }
         expect(2)
-        check(d.isActive)
-        check(d.await() == 42)
-        check(!d.isActive)
+        assertTrue(d.isActive)
+        assertTrue(d.await() == 42)
+        assertTrue(!d.isActive)
         expect(4)
-        check(d.await() == 42) // second await -- same result
+        assertTrue(d.await() == 42) // second await -- same result
         finish(5)
     }
 
@@ -45,8 +45,8 @@
             42
         }
         expect(3)
-        check(!d.isActive)
-        check(d.await() == 42)
+        assertTrue(!d.isActive)
+        assertTrue(d.await() == 42)
         finish(4)
     }
 
@@ -90,13 +90,13 @@
         expect(2)
         launch(coroutineContext) {
             expect(6)
-            check(d.await() == 42)
+            assertTrue(d.await() == 42)
             expect(11)
         }
         expect(3)
         launch(coroutineContext) {
             expect(7)
-            check(d.await() == 42)
+            assertTrue(d.await() == 42)
             expect(12)
         }
         expect(4)
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAtomicCancellationTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAtomicCancellationTest.kt
new file mode 100644
index 0000000..65be69a
--- /dev/null
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonAtomicCancellationTest.kt
@@ -0,0 +1,82 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.test.*
+
+class CommonAtomicCancellationTest : TestBase() {
+    @Test
+    fun testCancellableLaunch() = runBlocking {
+        expect(1)
+        val job = launch(coroutineContext) {
+            expectUnreached() // will get cancelled before start
+        }
+        expect(2)
+        job.cancel()
+        finish(3)
+    }
+
+    @Test
+    fun testAtomicLaunch() = runBlocking {
+        expect(1)
+        val job = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+            finish(4) // will execute even after it was cancelled
+        }
+        expect(2)
+        job.cancel()
+        expect(3)
+    }
+
+    @Test
+    fun testDeferredAwaitCancellable() = runBlocking {
+        expect(1)
+        val deferred = async(coroutineContext) { // deferred, not yet complete
+            expect(4)
+            "OK"
+        }
+        assertEquals(false, deferred.isCompleted)
+        var job: Job? = null
+        launch(coroutineContext) { // will cancel job as soon as deferred completes
+            expect(5)
+            assertEquals(true, deferred.isCompleted)
+            job!!.cancel()
+        }
+        job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
+            expect(2)
+            try {
+                deferred.await() // suspends
+                expectUnreached() // will not execute -- cancelled while dispatched
+            } finally {
+                finish(7) // but will execute finally blocks
+            }
+        }
+        expect(3) // continues to execute when job suspends
+        yield() // to deferred & canceller
+        expect(6)
+    }
+
+    @Test
+    fun testJobJoinCancellable() = runBlocking {
+        expect(1)
+        val jobToJoin = launch(coroutineContext) { // not yet complete
+            expect(4)
+        }
+        assertEquals(false, jobToJoin.isCompleted)
+        var job: Job? = null
+        launch(coroutineContext) { // will cancel job as soon as jobToJoin completes
+            expect(5)
+            assertEquals(true, jobToJoin.isCompleted)
+            job!!.cancel()
+        }
+        job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
+            expect(2)
+            try {
+                jobToJoin.join() // suspends
+                expectUnreached() // will not execute -- cancelled while dispatched
+            } finally {
+                finish(7) // but will execute finally blocks
+            }
+        }
+        expect(3) // continues to execute when job suspends
+        yield() // to jobToJoin & canceller
+        expect(6)
+    }
+}
\ No newline at end of file
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCompletableDeferredTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCompletableDeferredTest.kt
index f3e79e8..de7aed3 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCompletableDeferredTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCompletableDeferredTest.kt
@@ -157,7 +157,7 @@
     }
 
     @Test
-    fun testAwait() = runBlocking {
+    fun testAwait() = runTest {
         expect(1)
         val c = CompletableDeferred<String>()
         launch(coroutineContext, CoroutineStart.UNDISPATCHED) {
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutineExceptionHandlerTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutineExceptionHandlerTest.kt
index 098c0a0..84677cc 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutineExceptionHandlerTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutineExceptionHandlerTest.kt
@@ -4,7 +4,7 @@
 
 class CommonCoroutineExceptionHandlerTest : TestBase() {
     @Test
-    fun testCoroutineExceptionHandlerCreator() = runBlocking {
+    fun testCoroutineExceptionHandlerCreator() = runTest {
         expect(1)
         var coroutineException: Throwable? = null
         val handler = CoroutineExceptionHandler { _, ex ->
@@ -17,7 +17,7 @@
         expect(2)
         job.join()
         finish(4)
-        check(coroutineException is TestException)
+        assertTrue(coroutineException is TestException)
     }
 
     private class TestException: RuntimeException()
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutinesTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutinesTest.kt
index 1d736db..b94ca92 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutinesTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutinesTest.kt
@@ -43,9 +43,9 @@
             expect(4)
         }
         expect(2)
-        check(job.isActive && !job.isCompleted)
+        assertTrue(job.isActive && !job.isCompleted)
         job.join()
-        check(!job.isActive && job.isCompleted)
+        assertTrue(!job.isActive && job.isCompleted)
         finish(5)
     }
 
@@ -58,9 +58,9 @@
             expect(4)
         }
         expect(3)
-        check(job.isActive && !job.isCompleted)
+        assertTrue(job.isActive && !job.isCompleted)
         job.join()
-        check(!job.isActive && job.isCompleted)
+        assertTrue(!job.isActive && job.isCompleted)
         finish(5)
     }
 
@@ -218,15 +218,15 @@
         expect(2)
         yield() // to job
         expect(4)
-        check(job.isActive && !job.isCompleted && !job.isCancelled)
-        check(job.cancel())  // cancels job
+        assertTrue(job.isActive && !job.isCompleted && !job.isCancelled)
+        assertTrue(job.cancel())  // cancels job
         expect(5) // still here
-        check(!job.isActive && !job.isCompleted && job.isCancelled)
-        check(!job.cancel()) // second attempt returns false
+        assertTrue(!job.isActive && !job.isCompleted && job.isCancelled)
+        assertTrue(!job.cancel()) // second attempt returns false
         expect(6) // we're still here
         job.join() // join the job, let job complete its "finally" section
         expect(8)
-        check(!job.isActive && job.isCompleted && job.isCancelled)
+        assertTrue(!job.isActive && job.isCompleted && job.isCancelled)
         finish(9)
     }
 
@@ -264,8 +264,8 @@
             job.cancelAndJoin() // join should crash on child's exception but it will be wrapped into JobCancellationException
         } catch (e: Throwable) {
             e as JobCancellationException // type assertion
-            check(e.cause is TestException)
-            check(e.job === coroutineContext[Job])
+            assertTrue(e.cause is TestException)
+            assertTrue(e.job === coroutineContext[Job])
             throw e
         }
         expectUnreached()
@@ -304,7 +304,7 @@
         parent.cancelChildren()
         expect(4)
         parent.joinChildren() // will yield to child
-        check(parent.isActive) // make sure it did not cancel parent
+        assertTrue(parent.isActive) // make sure it did not cancel parent
         finish(6)
     }
 
@@ -335,6 +335,25 @@
         finish(8)
     }
 
+    @Test
+    fun testNotCancellableChildWithExceptionCancelled() = runTest(
+        expected = { it is TestException }
+    ) {
+        expect(1)
+        // CoroutineStart.ATOMIC makes sure it will not get cancelled for it starts executing
+        val d = async(coroutineContext, start = CoroutineStart.ATOMIC) {
+            finish(4)
+            throwTestException() // will throw
+            expectUnreached()
+        }
+        expect(2)
+        // now cancel with some other exception
+        d.cancel(IllegalArgumentException())
+        // now await to see how it got crashed -- IAE should have been suppressed by TestException
+        expect(3)
+        d.await()
+    }
+
     private fun throwTestException() { throw TestException() }
 
     private class TestException : Exception {
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonJobTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonJobTest.kt
index cd4fb29..b699a0f 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonJobTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonJobTest.kt
@@ -6,9 +6,9 @@
     @Test
     fun testState() {
         val job = Job()
-        check(job.isActive)
+        assertTrue(job.isActive)
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
     }
 
     @Test
@@ -16,15 +16,15 @@
         val job = Job()
         var fireCount = 0
         job.invokeOnCompletion { fireCount++ }
-        check(job.isActive)
+        assertTrue(job.isActive)
         assertEquals(0, fireCount)
         // cancel once
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         assertEquals(1, fireCount)
         // cancel again
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         assertEquals(1, fireCount)
     }
 
@@ -34,15 +34,15 @@
         val n = 100 * stressTestMultiplier
         val fireCount = IntArray(n)
         for (i in 0 until n) job.invokeOnCompletion { fireCount[i]++ }
-        check(job.isActive)
+        assertTrue(job.isActive)
         for (i in 0 until n) assertEquals(0, fireCount[i])
         // cancel once
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         for (i in 0 until n) assertEquals(1, fireCount[i])
         // cancel again
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         for (i in 0 until n) assertEquals(1, fireCount[i])
     }
 
@@ -58,15 +58,15 @@
                 registration!!.dispose()
             }
         }
-        check(job.isActive)
+        assertTrue(job.isActive)
         for (i in 0 until n) assertEquals(0, fireCount[i])
         // cancel once
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         for (i in 0 until n) assertEquals(1, fireCount[i])
         // cancel again
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         for (i in 0 until n) assertEquals(1, fireCount[i])
     }
 
@@ -76,12 +76,12 @@
         val n = 100 * stressTestMultiplier
         val fireCount = IntArray(n)
         val registrations = Array<DisposableHandle>(n) { i -> job.invokeOnCompletion { fireCount[i]++ } }
-        check(job.isActive)
+        assertTrue(job.isActive)
         fun unreg(i: Int) = i % 4 <= 1
         for (i in 0 until n) if (unreg(i)) registrations[i].dispose()
         for (i in 0 until n) assertEquals(0, fireCount[i])
         job.cancel()
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         for (i in 0 until n) assertEquals(if (unreg(i)) 0 else 1, fireCount[i])
     }
 
@@ -95,22 +95,22 @@
             fireCount[i]++
             throw TestException()
         }
-        check(job.isActive)
+        assertTrue(job.isActive)
         for (i in 0 until n) assertEquals(0, fireCount[i])
         val tryCancel = Try<Unit> { job.cancel() }
-        check(!job.isActive)
+        assertTrue(!job.isActive)
         for (i in 0 until n) assertEquals(1, fireCount[i])
-        check(tryCancel.exception is CompletionHandlerException)
-        check(tryCancel.exception!!.cause is TestException)
+        assertTrue(tryCancel.exception is CompletionHandlerException)
+        assertTrue(tryCancel.exception!!.cause is TestException)
     }
 
     @Test
     fun testCancelledParent() {
         val parent = Job()
         parent.cancel()
-        check(!parent.isActive)
+        assertTrue(!parent.isActive)
         val child = Job(parent)
-        check(!child.isActive)
+        assertTrue(!child.isActive)
     }
 
     @Test
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonLaunchLazyTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonLaunchLazyTest.kt
index 22fe3fd..29651f5 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonLaunchLazyTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonLaunchLazyTest.kt
@@ -30,9 +30,9 @@
         expect(2)
         yield() // does nothing, was not started yet
         expect(3)
-        check(!job.isActive && !job.isCompleted)
+        assertTrue(!job.isActive && !job.isCompleted)
         job.join()
-        check(!job.isActive && job.isCompleted)
+        assertTrue(!job.isActive && job.isCompleted)
         finish(6)
     }
 
@@ -47,17 +47,17 @@
         expect(2)
         yield() // does nothing, was not started yet
         expect(3)
-        check(!job.isActive && !job.isCompleted)
-        check(job.start())
-        check(job.isActive && !job.isCompleted)
-        check(!job.start()) // start again -- does nothing
-        check(job.isActive && !job.isCompleted)
+        assertTrue(!job.isActive && !job.isCompleted)
+        assertTrue(job.start())
+        assertTrue(job.isActive && !job.isCompleted)
+        assertTrue(!job.start()) // start again -- does nothing
+        assertTrue(job.isActive && !job.isCompleted)
         expect(4)
         yield() // now yield to started coroutine
         expect(6)
-        check(job.isActive && !job.isCompleted)
+        assertTrue(job.isActive && !job.isCompleted)
         yield() // yield again
-        check(!job.isActive && job.isCompleted) // it completes this time
+        assertTrue(!job.isActive && job.isCompleted) // it completes this time
         expect(8)
         job.join() // immediately returns
         finish(9)
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithContextTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithContextTest.kt
index fb75b57..24b922a 100644
--- a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithContextTest.kt
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithContextTest.kt
@@ -144,7 +144,7 @@
             } catch (e: Throwable) {
                 expect(7)
                 // make sure IOException, not CancellationException is thrown!
-                check(e is TestException)
+                assertTrue(e is TestException)
             }
         }
         expect(2)
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithTimeoutOrNullTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithTimeoutOrNullTest.kt
new file mode 100644
index 0000000..60f5bd8
--- /dev/null
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithTimeoutOrNullTest.kt
@@ -0,0 +1,113 @@
+
+@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED") // KT-21913
+
+package kotlinx.coroutines.experimental
+
+import kotlin.test.*
+
+class CommonWithTimeoutOrNullTest : TestBase() {
+    /**
+     * Tests a case of no timeout and no suspension inside.
+     */
+    @Test
+    fun testBasicNoSuspend() = runTest {
+        expect(1)
+        val result = withTimeoutOrNull(10_000) {
+            expect(2)
+            "OK"
+        }
+        assertEquals("OK", result)
+        finish(3)
+    }
+
+    /**
+     * Tests a case of no timeout and one suspension inside.
+     */
+    @Test
+    fun testBasicSuspend() = runTest {
+        expect(1)
+        val result = withTimeoutOrNull(10_000) {
+            expect(2)
+            yield()
+            expect(3)
+            "OK"
+        }
+        assertEquals("OK", result)
+        finish(4)
+    }
+
+    /**
+     * Tests property dispatching of `withTimeoutOrNull` blocks
+     */
+    @Test
+    fun testDispatch() = runTest {
+        expect(1)
+        launch(coroutineContext) {
+            expect(4)
+            yield() // back to main
+            expect(7)
+        }
+        expect(2)
+        // test that it does not yield to the above job when started
+        val result = withTimeoutOrNull(1000) {
+            expect(3)
+            yield() // yield only now
+            expect(5)
+            "OK"
+        }
+        assertEquals("OK", result)
+        expect(6)
+        yield() // back to launch
+        finish(8)
+    }
+
+    /**
+     * Tests that a 100% CPU-consuming loop will react on timeout if it has yields.
+     */
+    @Test
+    fun testYieldBlockingWithTimeout() = runTest {
+        expect(1)
+        val result = withTimeoutOrNull(100) {
+            while (true) {
+                yield()
+            }
+        }
+        assertEquals(null, result)
+        finish(2)
+    }
+
+    @Test
+    fun testInnerTimeoutTest() = runTest(
+        expected = { it is CancellationException }
+    ) {
+        withTimeoutOrNull(200) {
+            withTimeout(100) {
+                while (true) {
+                    yield()
+                }
+            }
+            expectUnreached() // will timeout
+        }
+        expectUnreached() // will timeout
+    }
+
+    @Test
+    fun testOuterTimeoutTest() = runTest {
+        var counter = 0
+        val result = withTimeoutOrNull(250) {
+            while (true) {
+                val inner = withTimeoutOrNull(100) {
+                    while (true) {
+                        yield()
+                    }
+                }
+                assertEquals(null, inner)
+                counter++
+            }
+        }
+        assertEquals(null, result)
+        // under load counter may be equal to 1, so the check is lenient here
+        println("Executed: $counter times")
+        check(counter in 1..2)
+    }
+}
\ No newline at end of file
diff --git a/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithTimeoutTest.kt b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithTimeoutTest.kt
new file mode 100644
index 0000000..9ee34ec
--- /dev/null
+++ b/common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithTimeoutTest.kt
@@ -0,0 +1,97 @@
+
+@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED") // KT-21913
+
+package kotlinx.coroutines.experimental
+
+import kotlin.test.*
+
+class CommonWithTimeoutTest : TestBase() {
+    /**
+     * Tests a case of no timeout and no suspension inside.
+     */
+    @Test
+    fun testBasicNoSuspend() = runTest {
+        expect(1)
+        val result = withTimeout(10_000) {
+            expect(2)
+            "OK"
+        }
+        assertEquals("OK", result)
+        finish(3)
+    }
+
+    /**
+     * Tests a case of no timeout and one suspension inside.
+     */
+    @Test
+    fun testBasicSuspend() = runTest {
+        expect(1)
+        val result = withTimeout(10_000) {
+            expect(2)
+            yield()
+            expect(3)
+            "OK"
+        }
+        assertEquals("OK", result)
+        finish(4)
+    }
+
+    /**
+     * Tests proper dispatching of `withTimeout` blocks
+     */
+    @Test
+    fun testDispatch() = runTest {
+        expect(1)
+        launch(coroutineContext) {
+            expect(4)
+            yield() // back to main
+            expect(7)
+        }
+        expect(2)
+        // test that it does not yield to the above job when started
+        val result = withTimeout(1000) {
+            expect(3)
+            yield() // yield only now
+            expect(5)
+            "OK"
+        }
+        assertEquals("OK", result)
+        expect(6)
+        yield() // back to launch
+        finish(8)
+    }
+
+
+    /**
+     * Tests that a 100% CPU-consuming loop will react on timeout if it has yields.
+     */
+    @Test
+    fun testYieldBlockingWithTimeout() = runTest(
+        expected = { it is CancellationException }
+    ) {
+        withTimeout(100) {
+            while (true) {
+                yield()
+            }
+        }
+    }
+
+    /**
+     * Tests that [withTimeout] waits for children coroutines to complete.
+     */
+    @Test
+    fun testWithTimeoutChildWait() = runTest {
+        expect(1)
+        withTimeout(100) {
+            expect(2)
+            // launch child with timeout
+            launch(coroutineContext) {
+                expect(4)
+            }
+            expect(3)
+            // now will wait for child before returning
+        }
+        finish(5)
+    }
+}
+
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/AtomicCancellationTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/AtomicCancellationTest.kt
index 14b2b53..6d43cc1 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/AtomicCancellationTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/AtomicCancellationTest.kt
@@ -19,33 +19,9 @@
 import kotlinx.coroutines.experimental.channels.Channel
 import kotlinx.coroutines.experimental.selects.select
 import kotlinx.coroutines.experimental.sync.Mutex
-import org.hamcrest.core.IsEqual
-import org.junit.Assert.assertThat
-import org.junit.Test
+import kotlin.test.*
 
-class AtomicCancellationTest: TestBase() {
-    @Test
-    fun testCancellableLaunch() = runBlocking {
-        expect(1)
-        val job = launch(coroutineContext) {
-            expectUnreached() // will get cancelled before start
-        }
-        expect(2)
-        job.cancel()
-        finish(3)
-    }
-
-    @Test
-    fun testAtomicLaunch() = runBlocking {
-        expect(1)
-        val job = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
-            finish(4) // will execute even after it was cancelled
-        }
-        expect(2)
-        job.cancel()
-        expect(3)
-    }
-
+class AtomicCancellationTest : TestBase() {
     @Test
     fun testLockAtomicCancel() = runBlocking {
         expect(1)
@@ -74,7 +50,7 @@
                     "OK"
                 }
             }
-            assertThat(result, IsEqual("OK"))
+            assertEquals("OK", result)
             expect(5) // should execute despite cancellation
         }
         expect(3)
@@ -94,7 +70,7 @@
             expect(4) // should execute despite cancellation
         }
         expect(3)
-        assertThat(channel.receive(), IsEqual(42)) // will schedule sender for further execution
+        assertEquals(42, channel.receive()) // will schedule sender for further execution
         job.cancel() // cancel the job next
         yield() // now yield
         finish(5)
@@ -112,11 +88,11 @@
                     "OK"
                 }
             }
-            assertThat(result, IsEqual("OK"))
+            assertEquals("OK", result)
             expect(5) // should execute despite cancellation
         }
         expect(3)
-        assertThat(channel.receive(), IsEqual(42)) // will schedule sender for further execution
+        assertEquals(42, channel.receive()) // will schedule sender for further execution
         job.cancel() // cancel the job next
         yield() // now yield
         finish(6)
@@ -128,7 +104,7 @@
         val channel = Channel<Int>()
         val job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
             expect(2)
-            assertThat(channel.receive(), IsEqual(42)) // suspends
+            assertEquals(42, channel.receive()) // suspends
             expect(4) // should execute despite cancellation
         }
         expect(3)
@@ -146,12 +122,12 @@
             expect(2)
             val result = select<String> { // suspends
                 channel.onReceive {
-                    assertThat(it, IsEqual(42))
+                    assertEquals(42, it)
                     expect(4)
                     "OK"
                 }
             }
-            assertThat(result, IsEqual("OK"))
+            assertEquals("OK", result)
             expect(5) // should execute despite cancellation
         }
         expect(3)
@@ -162,45 +138,17 @@
     }
 
     @Test
-    fun testDeferredAwaitCancellable() = runBlocking {
-        expect(1)
-        val deferred = async(coroutineContext) { // deferred, not yet complete
-            expect(4)
-            "OK"
-        }
-        assertThat(deferred.isCompleted, IsEqual(false))
-        var job: Job? = null
-        launch(coroutineContext) { // will cancel job as soon as deferred completes
-            expect(5)
-            assertThat(deferred.isCompleted, IsEqual(true))
-            job!!.cancel()
-        }
-        job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
-            expect(2)
-            try {
-                deferred.await() // suspends
-                expectUnreached() // will not execute -- cancelled while dispatched
-            } finally {
-                finish(7) // but will execute finally blocks
-            }
-        }
-        expect(3) // continues to execute when job suspends
-        yield() // to deferred & canceller
-        expect(6)
-    }
-
-    @Test
     fun testSelectDeferredAwaitCancellable() = runBlocking {
         expect(1)
         val deferred = async(coroutineContext) { // deferred, not yet complete
             expect(4)
             "OK"
         }
-        assertThat(deferred.isCompleted, IsEqual(false))
+        assertEquals(false, deferred.isCompleted)
         var job: Job? = null
         launch(coroutineContext) { // will cancel job as soon as deferred completes
             expect(5)
-            assertThat(deferred.isCompleted, IsEqual(true))
+            assertEquals(true, deferred.isCompleted)
             job!!.cancel()
         }
         job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
@@ -220,43 +168,16 @@
     }
 
     @Test
-    fun testJobJoinCancellable() = runBlocking {
-        expect(1)
-        val jobToJoin = launch(coroutineContext) { // not yet complete
-            expect(4)
-        }
-        assertThat(jobToJoin.isCompleted, IsEqual(false))
-        var job: Job? = null
-        launch(coroutineContext) { // will cancel job as soon as jobToJoin completes
-            expect(5)
-            assertThat(jobToJoin.isCompleted, IsEqual(true))
-            job!!.cancel()
-        }
-        job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
-            expect(2)
-            try {
-                jobToJoin.join() // suspends
-                expectUnreached() // will not execute -- cancelled while dispatched
-            } finally {
-                finish(7) // but will execute finally blocks
-            }
-        }
-        expect(3) // continues to execute when job suspends
-        yield() // to jobToJoin & canceller
-        expect(6)
-    }
-
-    @Test
     fun testSelectJobJoinCancellable() = runBlocking {
         expect(1)
         val jobToJoin = launch(coroutineContext) { // not yet complete
             expect(4)
         }
-        assertThat(jobToJoin.isCompleted, IsEqual(false))
+        assertEquals(false, jobToJoin.isCompleted)
         var job: Job? = null
         launch(coroutineContext) { // will cancel job as soon as jobToJoin completes
             expect(5)
-            assertThat(jobToJoin.isCompleted, IsEqual(true))
+            assertEquals(true, jobToJoin.isCompleted)
             job!!.cancel()
         }
         job = launch(coroutineContext, start = CoroutineStart.UNDISPATCHED) {
@@ -274,6 +195,4 @@
         yield() // to jobToJoin & canceller
         expect(6)
     }
-
-
 }
\ No newline at end of file
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/CoroutinesTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/CoroutinesTest.kt
index b9cc888..29a03e0 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/CoroutinesTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/CoroutinesTest.kt
@@ -1,6 +1,6 @@
 package kotlinx.coroutines.experimental
 
-import org.junit.Test
+import kotlin.test.*
 
 class CoroutinesTest : TestBase() {
     @Test
@@ -18,25 +18,6 @@
     }
 
     @Test
-    fun testNotCancellableChildWithExceptionCancelled() = runTest(
-        expected = { it is TestException }
-    ) {
-        expect(1)
-        // CoroutineStart.ATOMIC makes sure it will not get cancelled for it starts executing
-        val d = async(coroutineContext, start = CoroutineStart.ATOMIC) {
-            finish(4)
-            throwTestException() // will throw
-            expectUnreached()
-        }
-        expect(2)
-        // now cancel with some other exception
-        d.cancel(IllegalArgumentException())
-        // now await to see how it got crashed -- IAE should have been suppressed by TestException
-        expect(3)
-        d.await()
-    }
-
-    @Test
     fun testCancelManyCompletedAttachedChildren() = runTest {
         val parent = launch(coroutineContext) { /* do nothing */ }
         val n = 10_000 * stressTestMultiplier
@@ -51,8 +32,5 @@
 
     private fun throwTestException(): Unit = throw TestException()
 
-    private class TestException : Exception {
-        constructor(message: String): super(message)
-        constructor(): super()
-    }
+    private class TestException() : Exception()
 }
\ No newline at end of file
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithContextTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithContextTest.kt
index 29f240e..ee26c07 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithContextTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithContextTest.kt
@@ -16,9 +16,7 @@
 
 package kotlinx.coroutines.experimental
 
-import org.hamcrest.MatcherAssert.assertThat
-import org.hamcrest.core.IsEqual
-import org.junit.Test
+import kotlin.test.*
 
 class WithContextTest : TestBase() {
     @Test
@@ -28,7 +26,7 @@
             expect(2)
             "OK"
         }
-        assertThat(result, IsEqual("OK"))
+        assertEquals("OK", result)
         finish(3)
     }
 
@@ -41,7 +39,7 @@
             expect(3)
             "OK"
         }
-        assertThat(result, IsEqual("OK"))
+        assertEquals("OK", result)
         finish(4)
     }
 }
\ No newline at end of file
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullTest.kt
index e4619b8..6c43f76 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullTest.kt
@@ -16,68 +16,9 @@
 
 package kotlinx.coroutines.experimental
 
-import org.hamcrest.core.IsEqual
-import org.hamcrest.core.IsNull
-import org.junit.Assert.assertThat
-import org.junit.Test
-import java.io.IOException
+import kotlin.test.*
 
 class WithTimeoutOrNullTest : TestBase() {
-    /**
-     * Tests a case of no timeout and no suspension inside.
-     */
-    @Test
-    fun testBasicNoSuspend() = runTest {
-        expect(1)
-        val result = withTimeoutOrNull(10_000) {
-            expect(2)
-            "OK"
-        }
-        assertThat(result, IsEqual("OK"))
-        finish(3)
-    }
-
-    /**
-     * Tests a case of no timeout and one suspension inside.
-     */
-    @Test
-    fun testBasicSuspend() = runTest {
-        expect(1)
-        val result = withTimeoutOrNull(10_000) {
-            expect(2)
-            yield()
-            expect(3)
-            "OK"
-        }
-        assertThat(result, IsEqual("OK"))
-        finish(4)
-    }
-
-    /**
-     * Tests property dispatching of `withTimeoutOrNull` blocks
-     */
-    @Test
-    fun testDispatch() = runTest {
-        expect(1)
-        launch(coroutineContext) {
-            expect(4)
-            yield() // back to main
-            expect(7)
-        }
-        expect(2)
-        // test that it does not yield to the above job when started
-        val result = withTimeoutOrNull(1000) {
-            expect(3)
-            yield() // yield only now
-            expect(5)
-            "OK"
-        }
-        assertThat(result, IsEqual("OK"))
-        expect(6)
-        yield() // back to launch
-        finish(8)
-    }
-
     @Test
     fun testNullOnTimeout() = runTest {
         expect(1)
@@ -87,7 +28,7 @@
             expectUnreached()
             "OK"
         }
-        assertThat(result, IsNull())
+        assertEquals(null, result)
         finish(3)
     }
 
@@ -103,13 +44,13 @@
             }
             "OK"
         }
-        assertThat(result, IsNull())
+        assertEquals(null, result)
         finish(4)
     }
 
     @Test
     fun testSuppressExceptionWithAnotherException() = runTest(
-        expected = { it is IOException }
+        expected = { it is TestException }
     ) {
         expect(1)
         val result = withTimeoutOrNull(100) {
@@ -118,7 +59,7 @@
                 delay(1000)
             } catch (e: CancellationException) {
                 finish(3)
-                throw IOException(e)
+                throw TestException()
             }
             expectUnreached()
             "OK"
@@ -126,56 +67,8 @@
         expectUnreached()
     }
 
-    /**
-     * Tests that a 100% CPU-consuming loop will react on timeout if it has yields.
-     */
     @Test
-    fun testYieldBlockingWithTimeout() = runBlocking {
-        expect(1)
-        val result = withTimeoutOrNull(100) {
-            while (true) {
-                yield()
-            }
-        }
-        assertThat(result, IsNull())
-        finish(2)
-    }
-
-    @Test(expected = CancellationException::class)
-    fun testInnerTimeoutTest() = runBlocking {
-        withTimeoutOrNull(200) {
-            withTimeout(100) {
-                while (true) {
-                    yield()
-                }
-            }
-            expectUnreached() // will timeout
-        }
-        expectUnreached() // will timeout
-    }
-
-    @Test
-    fun testOuterTimeoutTest() = runBlocking {
-        var counter = 0
-        val result = withTimeoutOrNull(250) {
-            while (true) {
-                val inner = withTimeoutOrNull(100) {
-                    while (true) {
-                        yield()
-                    }
-                }
-                assertThat(inner, IsNull())
-                counter++
-            }
-        }
-        assertThat(result, IsNull())
-        // under load counter may be equal to 1, so the check is lenient here
-        println("Executed: $counter times")
-        check(counter in 1..2)
-    }
-
-    @Test
-    fun testOuterTimeoutFiredBeforeInner() = runBlocking<Unit> {
+    fun testOuterTimeoutFiredBeforeInner() = runTest {
         val result = withTimeoutOrNull(100) {
             Thread.sleep(200) // wait enough for outer timeout to fire
             withContext(NonCancellable) { yield() } // give an event loop a chance to run and process that cancellation
@@ -186,6 +79,8 @@
             expectUnreached() // should not be reached, because it is outer timeout
         }
         // outer timeout results in null
-        assertThat(result, IsNull())
+        assertEquals(null, result)
     }
+
+    private class TestException : Exception()
 }
\ No newline at end of file
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullThreadDispatchTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullThreadDispatchTest.kt
index 6ffb153..df1387c 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullThreadDispatchTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutOrNullThreadDispatchTest.kt
@@ -16,11 +16,7 @@
 
 package kotlinx.coroutines.experimental
 
-import org.hamcrest.core.IsEqual
-import org.hamcrest.core.IsNull
-import org.junit.After
-import org.junit.Assert
-import org.junit.Test
+import kotlin.test.*
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.ThreadFactory
@@ -30,7 +26,7 @@
 class WithTimeoutOrNullThreadDispatchTest : TestBase() {
     var executor: ExecutorService? = null
 
-    @After
+    @AfterTest
     fun tearDown() {
         executor?.shutdown()
     }
@@ -78,7 +74,7 @@
         val dispatcher = factory(ThreadFactory { Thread(it).also { thread = it } })
         withContext(dispatcher) {
             expect(2)
-            Assert.assertThat(Thread.currentThread(), IsEqual(thread))
+            assertEquals(thread, Thread.currentThread())
             val result = withTimeoutOrNull(100) {
                 try {
                     expect(3)
@@ -86,12 +82,12 @@
                     expectUnreached()
                 } catch (e: CancellationException) {
                     expect(4)
-                    Assert.assertThat(Thread.currentThread(), IsEqual(thread))
+                    assertEquals(thread, Thread.currentThread())
                     throw e // rethrow
                 }
             }
-            Assert.assertThat(Thread.currentThread(), IsEqual(thread))
-            Assert.assertThat(result, IsNull())
+            assertEquals(thread, Thread.currentThread())
+            assertEquals(null, result)
             expect(5)
         }
         finish(6)
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutTest.kt
index aa51f23..a793a1e 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutTest.kt
@@ -14,70 +14,14 @@
  * limitations under the License.
  */
 
+@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED") // KT-21913
+
 package kotlinx.coroutines.experimental
 
-import org.hamcrest.core.IsEqual
-import org.junit.Assert.assertThat
-import org.junit.Test
+import kotlin.test.*
 import java.io.IOException
 
 class WithTimeoutTest : TestBase() {
-    /**
-     * Tests a case of no timeout and no suspension inside.
-     */
-    @Test
-    fun testBasicNoSuspend() = runTest {
-        expect(1)
-        val result = withTimeout(10_000) {
-            expect(2)
-            "OK"
-        }
-        assertThat(result, IsEqual("OK"))
-        finish(3)
-    }
-
-    /**
-     * Tests a case of no timeout and one suspension inside.
-     */
-    @Test
-    fun testBasicSuspend() = runTest {
-        expect(1)
-        val result = withTimeout(10_000) {
-            expect(2)
-            yield()
-            expect(3)
-            "OK"
-        }
-        assertThat(result, IsEqual("OK"))
-        finish(4)
-    }
-
-    /**
-     * Tests proper dispatching of `withTimeout` blocks
-     */
-    @Test
-    fun testDispatch() = runTest {
-        expect(1)
-        launch(coroutineContext) {
-            expect(4)
-            yield() // back to main
-            expect(7)
-        }
-        expect(2)
-        // test that it does not yield to the above job when started
-        val result = withTimeout(1000) {
-            expect(3)
-            yield() // yield only now
-            expect(5)
-            "OK"
-        }
-        assertThat(result, IsEqual("OK"))
-        expect(6)
-        yield() // back to launch
-        finish(8)
-    }
-
-
     @Test
     fun testExceptionOnTimeout() = runTest {
         expect(1)
@@ -89,7 +33,7 @@
                 "OK"
             }
         } catch (e: CancellationException) {
-            assertThat(e.message, IsEqual("Timed out waiting for 100 MILLISECONDS"))
+            assertEquals("Timed out waiting for 100 MILLISECONDS", e.message)
             finish(3)
         }
     }
@@ -129,34 +73,4 @@
         }
         expectUnreached()
     }
-
-    /**
-     * Tests that a 100% CPU-consuming loop will react on timeout if it has yields.
-     */
-    @Test(expected = CancellationException::class)
-    fun testYieldBlockingWithTimeout() = runTest {
-        withTimeout(100) {
-            while (true) {
-                yield()
-            }
-        }
-    }
-
-    /**
-     * Tests that [withTimeout] waits for children coroutines to complete.
-     */
-    @Test
-    fun testWithTimeoutChildWait() = runTest {
-        expect(1)
-        withTimeout(100) {
-            expect(2)
-            // launch child with timeout
-            launch(coroutineContext) {
-                expect(4)
-            }
-            expect(3)
-            // now will wait for child before returning
-        }
-        finish(5)
-    }
 }
\ No newline at end of file
diff --git a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutThreadDispatchTest.kt b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutThreadDispatchTest.kt
index 806a30c..8529b8c 100644
--- a/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutThreadDispatchTest.kt
+++ b/core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/WithTimeoutThreadDispatchTest.kt
@@ -16,10 +16,7 @@
 
 package kotlinx.coroutines.experimental
 
-import org.hamcrest.core.IsEqual
-import org.junit.After
-import org.junit.Assert
-import org.junit.Test
+import kotlin.test.*
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.ThreadFactory
@@ -29,7 +26,7 @@
 class WithTimeoutThreadDispatchTest : TestBase() {
     var executor: ExecutorService? = null
 
-    @After
+    @AfterTest
     fun tearDown() {
         executor?.shutdown()
     }
@@ -76,7 +73,7 @@
         val dispatcher = factory(ThreadFactory { Thread(it).also { thread = it } })
         withContext(dispatcher) {
             expect(2)
-            Assert.assertThat(Thread.currentThread(), IsEqual(thread))
+            assertEquals(thread, Thread.currentThread())
             try {
                 withTimeout(100) {
                     try {
@@ -85,13 +82,13 @@
                         expectUnreached()
                     } catch (e: CancellationException) {
                         expect(4)
-                        Assert.assertThat(Thread.currentThread(), IsEqual(thread))
+                        assertEquals(thread, Thread.currentThread())
                         throw e // rethrow
                     }
                 }
             } catch (e: CancellationException) {
                 expect(5)
-                Assert.assertThat(Thread.currentThread(), IsEqual(thread))
+                assertEquals(thread, Thread.currentThread())
             }
             expect(6)
         }