WIP: unify the tests for all Main dispatchers

dkhalanskyjb · dkhalanskyjb · commit b08a5168cba9 · 2023-11-07T16:11:15.000+01:00
diff --git a/kotlinx-coroutines-core/common/test/MainDispatcherTestBase.kt b/kotlinx-coroutines-core/common/test/MainDispatcherTestBase.kt
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2016-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines
+
+import kotlin.test.*
+
+abstract class MainDispatcherTestBase: TestBase() {
+
+    open fun shouldSkipTesting(): Boolean = false
+
+    open fun checkIsMainThread() {}
+
+    open fun checkNotMainThread() {}
+
+    /** Runs the given block as a test, unless [shouldSkipTesting] indicates that the environment is not suitable. */
+    fun runTestOrSkip(block: suspend CoroutineScope.() -> Unit) {
+        if (shouldSkipTesting()) return
+        runTest(block = block)
+    }
+
+    /** Tests the [toString] behavior of [Dispatchers.Main] and [MainCoroutineDispatcher.immediate] */
+    @Test
+    fun testMainDispatcherToString() {
+        // TODO: workaround for not having module-info.java for the `test` source set
+        if (Dispatchers.Main.toString() != "Dispatchers.Main") {
+            throw AssertionError("Expected Dispatchers.Main, but had ${Dispatchers.Main}")
+        }
+        if (Dispatchers.Main.immediate.toString() != "Dispatchers.Main.immediate") {
+            throw AssertionError("Expected Dispatchers.Main.immediate, but had ${Dispatchers.Main.immediate}")
+        }
+    }
+
+    /** Tests that the tasks scheduled earlier from [MainCoroutineDispatcher.immediate] will be executed earlier,
+     * even if the immediate dispatcher was entered from the main thread. */
+    @Test
+    fun testMainDispatcherOrderingInMainThread() = runTestOrSkip {
+        withContext(Dispatchers.Main) {
+            testMainDispatcherOrdering()
+        }
+    }
+
+    /** Tests that the tasks scheduled earlier from [MainCoroutineDispatcher.immediate] will be executed earlier
+     * if the immediate dispatcher was entered from outside the main thread. */
+    @Test
+    fun testMainDispatcherOrderingOutsideMainThread() = runTestOrSkip {
+        testMainDispatcherOrdering()
+    }
+
+    /** Tests that [Dispatchers.Main] and its [MainCoroutineDispatcher.immediate] are treated as different values. */
+    @Test
+    fun testHandlerDispatcherNotEqualToImmediate() {
+        // TODO: workaround for not having module-info.java for the `test` source set
+        if (Dispatchers.Main == Dispatchers.Main.immediate) {
+            throw AssertionError("Expected Dispatchers.Main and Dispatchers.Main.immediate not to be equal")
+        }
+    }
+
+    /** Tests that after a delay, the execution gets back to the main thread. */
+    @Test
+    @Ignore // TODO: hangs on Android
+    fun testDelay() = runTestOrSkip {
+        expect(1)
+        withContext(Dispatchers.Main) {
+            checkIsMainThread()
+            expect(2)
+            delay(100)
+            checkIsMainThread()
+            expect(3)
+        }
+        finish(4)
+    }
+
+    /** Tests that [Dispatchers.Main] shares its queue with [MainCoroutineDispatcher.immediate]. */
+    @Test
+    fun testImmediateDispatcherYield() = runTestOrSkip {
+        withContext(Dispatchers.Main) {
+            expect(1)
+            checkIsMainThread()
+            // launch in the immediate dispatcher
+            launch(Dispatchers.Main.immediate) {
+                expect(2)
+                yield()
+                expect(4)
+            }
+            expect(3) // after yield
+            yield() // yield back
+            finish(5)
+        }
+    }
+
+    /** Tests that launching a coroutine in [MainScope] will execute it in the main thread. */
+    @Test
+    fun testLaunchInMainScope() = runTestOrSkip {
+        var executed = false
+        withMainScope {
+            launch {
+                checkIsMainThread()
+                executed = true
+            }.join()
+            if (!executed) throw AssertionError("Should be executed")
+        }
+    }
+
+    /** Tests that a failure in [MainScope] will not propagate upwards. */
+    @Test
+    fun testFailureInMainScope() = runTestOrSkip {
+        var exception: Throwable? = null
+        withMainScope {
+            launch(CoroutineExceptionHandler { ctx, e -> exception = e }) {
+                checkIsMainThread()
+                throw TestException()
+            }.join()
+        }
+        if (exception!! !is TestException) throw AssertionError("Expected TestException, but had $exception")
+    }
+
+    /** Tests cancellation in [MainScope]. */
+    @Test
+    fun testCancellationInMainScope() = runTestOrSkip {
+        withMainScope {
+            cancel()
+            launch(start = CoroutineStart.ATOMIC) {
+                checkIsMainThread()
+                delay(Long.MAX_VALUE)
+            }.join()
+        }
+    }
+
+    private suspend fun <R> withMainScope(block: suspend CoroutineScope.() -> R): R {
+        MainScope().apply {
+            return block().also { coroutineContext[Job]!!.cancelAndJoin() }
+        }
+    }
+
+    private suspend fun testMainDispatcherOrdering() {
+        withContext(Dispatchers.Main.immediate) {
+            expect(1)
+            launch(Dispatchers.Main) {
+                expect(2)
+            }
+            withContext(Dispatchers.Main) {
+                finish(3)
+            }
+        }
+    }
+}
diff --git a/kotlinx-coroutines-core/js/test/ImmediateDispatcherTest.kt b/kotlinx-coroutines-core/js/test/ImmediateDispatcherTest.kt
@@ -6,7 +6,7 @@ package kotlinx.coroutines
 
 import kotlin.test.*
 
-class ImmediateDispatcherTest : TestBase() {
+class ImmediateDispatcherTest : MainDispatcherTestBase(Dispatchers.Main) {
 
     @Test
     fun testImmediate() = runTest {
diff --git a/kotlinx-coroutines-core/nativeDarwin/test/MainDispatcherTest.kt b/kotlinx-coroutines-core/nativeDarwin/test/MainDispatcherTest.kt
@@ -9,19 +9,19 @@ import platform.darwin.*
 import kotlin.coroutines.*
 import kotlin.test.*
 
-class MainDispatcherTest : TestBase() {
+class MainDispatcherTest : MainDispatcherTestBase() {
 
     private fun isMainThread(): Boolean = CFRunLoopGetCurrent() == CFRunLoopGetMain()
-    private fun canTestMainDispatcher() = !isMainThread()
 
-    private fun runTestNotOnMainDispatcher(block: suspend CoroutineScope.() -> Unit) {
-        // skip if already on the main thread, run blocking doesn't really work well with that
-        if (!canTestMainDispatcher()) return
-        runTest(block = block)
-    }
+    override fun checkIsMainThread() = assertTrue(isMainThread())
+
+    override fun checkNotMainThread() = assertFalse(isMainThread())
+
+    // skip if already on the main thread, run blocking doesn't really work well with that
+    override fun shouldSkipTesting(): Boolean = isMainThread()
 
     @Test
-    fun testDispatchNecessityCheckWithMainImmediateDispatcher() = runTestNotOnMainDispatcher {
+    fun testDispatchNecessityCheckWithMainImmediateDispatcher() = runTestOrSkip {
         val main = Dispatchers.Main.immediate
         assertTrue(main.isDispatchNeeded(EmptyCoroutineContext))
         withContext(Dispatchers.Default) {
@@ -34,96 +34,96 @@ class MainDispatcherTest : TestBase() {
     }
 
     @Test
-    fun testWithContext() = runTestNotOnMainDispatcher {
+    fun testWithContext() = runTestOrSkip {
         expect(1)
-        assertFalse(isMainThread())
+        checkNotMainThread()
         withContext(Dispatchers.Main) {
-            assertTrue(isMainThread())
+            checkIsMainThread()
             expect(2)
         }
-        assertFalse(isMainThread())
+        checkNotMainThread()
         finish(3)
     }
 
     @Test
-    fun testWithContextDelay() = runTestNotOnMainDispatcher {
+    fun testWithContextDelay() = runTestOrSkip {
         expect(1)
         withContext(Dispatchers.Main) {
-            assertTrue(isMainThread())
+            checkIsMainThread()
             expect(2)
             delay(100)
-            assertTrue(isMainThread())
+            checkIsMainThread()
             expect(3)
         }
-        assertFalse(isMainThread())
+        checkNotMainThread()
         finish(4)
     }
 
     @Test
-    fun testWithTimeoutContextDelayNoTimeout() = runTestNotOnMainDispatcher {
+    fun testWithTimeoutContextDelayNoTimeout() = runTestOrSkip {
         expect(1)
         withTimeout(1000) {
             withContext(Dispatchers.Main) {
-                assertTrue(isMainThread())
+                checkIsMainThread()
                 expect(2)
                 delay(100)
-                assertTrue(isMainThread())
+                checkIsMainThread()
                 expect(3)
             }
         }
-        assertFalse(isMainThread())
+        checkNotMainThread()
         finish(4)
     }
 
     @Test
-    fun testWithTimeoutContextDelayTimeout() = runTestNotOnMainDispatcher {
+    fun testWithTimeoutContextDelayTimeout() = runTestOrSkip {
         expect(1)
-         assertFailsWith<TimeoutCancellationException> {
+        assertFailsWith<TimeoutCancellationException> {
             withTimeout(100) {
                 withContext(Dispatchers.Main) {
-                    assertTrue(isMainThread())
+                    checkIsMainThread()
                     expect(2)
                     delay(1000)
                     expectUnreached()
                 }
             }
             expectUnreached()
         }
-        assertFalse(isMainThread())
+        checkNotMainThread()
         finish(3)
     }
 
     @Test
-    fun testWithContextTimeoutDelayNoTimeout() = runTestNotOnMainDispatcher {
+    fun testWithContextTimeoutDelayNoTimeout() = runTestOrSkip {
         expect(1)
         withContext(Dispatchers.Main) {
             withTimeout(1000) {
-                assertTrue(isMainThread())
+                checkIsMainThread()
                 expect(2)
                 delay(100)
-                assertTrue(isMainThread())
+                checkIsMainThread()
                 expect(3)
             }
         }
-        assertFalse(isMainThread())
+        checkNotMainThread()
         finish(4)
     }
 
     @Test
-    fun testWithContextTimeoutDelayTimeout() = runTestNotOnMainDispatcher {
+    fun testWithContextTimeoutDelayTimeout() = runTestOrSkip {
         expect(1)
         assertFailsWith<TimeoutCancellationException> {
             withContext(Dispatchers.Main) {
                 withTimeout(100) {
-                    assertTrue(isMainThread())
+                    checkIsMainThread()
                     expect(2)
                     delay(1000)
                     expectUnreached()
                 }
             }
             expectUnreached()
         }
-        assertFalse(isMainThread())
+        checkNotMainThread()
         finish(3)
     }
 }
diff --git a/ui/kotlinx-coroutines-android/test/HandlerDispatcherTest.kt b/ui/kotlinx-coroutines-android/test/HandlerDispatcherTest.kt
@@ -17,27 +17,7 @@ import kotlin.test.*
 @RunWith(RobolectricTestRunner::class)
 @Config(manifest = Config.NONE, sdk = [28])
 @LooperMode(LooperMode.Mode.LEGACY)
-class HandlerDispatcherTest : TestBase() {
-    @Test
-    fun testImmediateDispatcherYield() = runBlocking(Dispatchers.Main) {
-        expect(1)
-        // launch in the immediate dispatcher
-        launch(Dispatchers.Main.immediate) {
-            expect(2)
-            yield()
-            expect(4)
-        }
-        expect(3) // after yield
-        yield() // yield back
-        finish(5)
-    }
-
-    @Test
-    fun testMainDispatcherToString() {
-        assertEquals("Dispatchers.Main", Dispatchers.Main.toString())
-        assertEquals("Dispatchers.Main.immediate", Dispatchers.Main.immediate.toString())
-    }
-
+class HandlerDispatcherTest : MainDispatcherTestBase() {
     @Test
     fun testDefaultDelayIsNotDelegatedToMain() = runTest {
         val mainLooper = Shadows.shadowOf(Looper.getMainLooper())
@@ -132,11 +112,4 @@ class HandlerDispatcherTest : TestBase() {
         mainLooper.scheduler.advanceBy(51, TimeUnit.MILLISECONDS)
         finish(5)
     }
-
-    @Test
-    fun testHandlerDispatcherNotEqualToImmediate() {
-        val main = AndroidDispatcherFactory().createDispatcher(listOf())
-        val immediate = main.immediate
-        assertNotEquals(main, immediate)
-    }
 }
diff --git a/ui/kotlinx-coroutines-javafx/test/JavaFxDispatcherTest.kt b/ui/kotlinx-coroutines-javafx/test/JavaFxDispatcherTest.kt
diff --git a/ui/kotlinx-coroutines-swing/test/SwingTest.kt b/ui/kotlinx-coroutines-swing/test/SwingTest.kt
