Improve platform-specific tests in the test module

Author: dkhalanskyjb

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

@@ -66,3 +66,9 @@ open class OrderedExecutionTestBase {
 }
 
 internal fun <T> T.void() { }
+
+@OptionalExpectation
+expect annotation class NoJs()
+
+@OptionalExpectation
+expect annotation class NoNative()

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

@@ -84,7 +84,7 @@ class RunTestTest {
 
     /** Tests that too low of a dispatch timeout causes crashes. */
     @Test
-    @Ignore // TODO: timeout leads to `Cannot execute task because event loop was shut down` on Native
+    @NoNative // TODO: timeout leads to `Cannot execute task because event loop was shut down` on Native
     fun testRunTestWithSmallTimeout() = testResultMap({ fn ->
         assertFailsWith<UncompletedCoroutinesError> { fn() }
     }) {
@@ -107,7 +107,7 @@ class RunTestTest {
 
     /** Tests uncaught exceptions taking priority over dispatch timeout in error reports. */
     @Test
-    @Ignore // TODO: timeout leads to `Cannot execute task because event loop was shut down` on Native
+    @NoNative // TODO: timeout leads to `Cannot execute task because event loop was shut down` on Native
     fun testRunTestTimingOutAndThrowing() = testResultMap({ fn ->
         assertFailsWith<IllegalArgumentException> { fn() }
     }) {
@@ -174,12 +174,12 @@ class RunTestTest {
 
     /** Tests that, once the test body has thrown, the child coroutines are cancelled. */
     @Test
-    fun testChildrenCancellationOnTestBodyFailure() {
+    fun testChildrenCancellationOnTestBodyFailure(): TestResult {
         var job: Job? = null
-        testResultMap({
+        return testResultMap({
             assertFailsWith<AssertionError> { it() }
             assertTrue(job!!.isCancelled)
-        }, {
+        }) {
             runTest {
                 job = launch {
                     while (true) {
@@ -188,34 +188,34 @@ class RunTestTest {
                 }
                 throw AssertionError()
             }
-        })
+        }
     }
 
     /** Tests that [runTest] reports [TimeoutCancellationException]. */
     @Test
     fun testTimeout() = testResultMap({
         assertFailsWith<TimeoutCancellationException> { it() }
-    }, {
+    }) {
         runTest {
             withTimeout(50) {
                 launch {
                     delay(1000)
                 }
             }
         }
-    })
+    }
 
     /** Checks that [runTest] throws the root cause and not [JobCancellationException] when a child coroutine throws. */
     @Test
     fun testRunTestThrowsRootCause() = testResultMap({
         assertFailsWith<TestException> { it() }
-    }, {
+    }) {
         runTest {
             launch {
                 throw TestException()
             }
         }
-    })
+    }
 
     /** Tests that [runTest] completes its job. */
     @Test
@@ -224,13 +224,13 @@ class RunTestTest {
         return testResultMap({
             it()
             assertTrue(handlerCalled)
-        }, {
+        }) {
             runTest {
                 coroutineContext.job.invokeOnCompletion {
                     handlerCalled = true
                 }
             }
-        })
+        }
     }
 
     /** Tests that [runTest] doesn't complete the job that was passed to it as an argument. */
@@ -245,11 +245,11 @@ class RunTestTest {
             it()
             assertFalse(handlerCalled)
             assertEquals(0, job.children.filter { it.isActive }.count())
-        }, {
+        }) {
             runTest(job) {
                 assertTrue(coroutineContext.job in job.children)
             }
-        })
+        }
     }
 
     /** Tests that, when the test body fails, the reported exceptions are suppressed. */
@@ -267,14 +267,14 @@ class RunTestTest {
             assertEquals("y", suppressed[1].message)
             assertEquals("z", suppressed[2].message)
         }
-    }, {
+    }) {
         runTest {
             launch(SupervisorJob()) { throw TestException("x") }
             launch(SupervisorJob()) { throw TestException("y") }
             launch(SupervisorJob()) { throw TestException("z") }
             throw TestException("w")
         }
-    })
+    }
 
     /** Tests that [TestCoroutineScope.runTest] does not inherit the exception handler and works. */
     @Test
@@ -287,10 +287,10 @@ class RunTestTest {
             } catch (e: TestException) {
                 scope.cleanupTestCoroutines() // should not fail
             }
-        }, {
+        }) {
             scope.runTest {
                 launch(SupervisorJob()) { throw TestException("x") }
             }
-        })
+        }
     }
 }

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

@@ -20,8 +20,8 @@ class TestDispatchersTest: OrderedExecutionTestBase() {
         Dispatchers.resetMain()
     }
 
-    /** Tests that asynchronous execution of tests does not happen concurrently with [AfterTest] (in fact, it does). */
-    @Ignore // fails on JS.
+    /** Tests that asynchronous execution of tests does not happen concurrently with [AfterTest]. */
+    @NoJs
     @Test
     fun testMainMocking() = runTest {
         val mainAtStart = mainTestDispatcher

kotlinx-coroutines-test/js/test/FailingTests.kt

@@ -0,0 +1,37 @@
+package kotlinx.coroutines.test
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.test.internal.*
+import kotlin.test.*
+
+/** These are tests that we want to fail. They are here so that, when the issue is fixed, their failure indicates that
+ * everything is better now. */
+class FailingTests {
+
+    private var tearDownEntered = false
+
+    @BeforeTest
+    fun setUp() {
+        Dispatchers.setMain(StandardTestDispatcher())
+    }
+
+    @AfterTest
+    fun tearDown() {
+        Dispatchers.resetMain()
+        tearDownEntered = true
+    }
+
+    /** [TestDispatchersTest.testMainMocking]. */
+    @Test
+    fun testAfterTestIsConcurrent() = runTest {
+        try {
+            val mainAtStart = (Dispatchers.Main as? TestMainDispatcher)?.delegate as? TestDispatcher ?: return@runTest
+            withContext(Dispatchers.Default) {
+                // context switch
+            }
+            assertNotSame(mainAtStart, (Dispatchers.Main as TestMainDispatcher).delegate)
+        } finally {
+            assertTrue(tearDownEntered)
+        }
+    }
+}

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

@@ -4,6 +4,8 @@
 
 package kotlinx.coroutines.test
 
+import kotlin.test.*
+
 actual fun testResultMap(block: (() -> Unit) -> Unit, test: () -> TestResult): TestResult =
     test().then(
         {
@@ -14,3 +16,5 @@ actual fun testResultMap(block: (() -> Unit) -> Unit, test: () -> TestResult): T
                 throw it
             }
         })
+
+actual typealias NoJs = Ignore

kotlinx-coroutines-test/native/test/FailingTests.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.test
+
+import kotlinx.coroutines.*
+import kotlin.test.*
+
+/** These are tests that we want to fail. They are here so that, when the issue is fixed, their failure indicates that
+ * everything is better now. */
+class FailingTests {
+    @Test
+    fun testRunTestLoopShutdownOnTimeout() = testResultMap({ fn ->
+        assertFailsWith<IllegalStateException> { fn() }
+    }) {
+        runTest(dispatchTimeoutMs = 1) {
+            withContext(Dispatchers.Default) {
+                delay(10000)
+            }
+            fail("shouldn't be reached")
+        }
+    }
+
+}

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

@@ -3,8 +3,12 @@
  */
 package kotlinx.coroutines.test
 
+import kotlin.test.*
+
 actual fun testResultMap(block: (() -> Unit) -> Unit, test: () -> TestResult) {
     block {
         test()
     }
 }
+
+actual typealias NoNative = Ignore