Introduce coroutines-core-test module with API to inject custom Dispatchers.Main

Fixes #746

Author: qwwdfsad

binary-compatibility-validator/build.gradle

@@ -13,6 +13,7 @@ dependencies {
     testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
 
     testArtifacts project(':kotlinx-coroutines-core')
+    testArtifacts project(':kotlinx-coroutines-core-test')
 
     testArtifacts project(':kotlinx-coroutines-reactive')
     testArtifacts project(':kotlinx-coroutines-reactor')

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-core-test.txt

@@ -0,0 +1,6 @@
+public final class kotlinx/coroutines/test/MainDispatcherInjector {
+	public static final field INSTANCE Lkotlinx/coroutines/test/MainDispatcherInjector;
+	public final fun inject (Lkotlinx/coroutines/CoroutineDispatcher;)V
+	public final fun reset ()V
+}
+

binary-compatibility-validator/resources/api.properties

@@ -2,7 +2,7 @@
 # Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
 #
 
-module.roots=core integration native reactive ui
+module.roots=core integration native reactive ui core-test
 module.marker=build.gradle
 module.ignore=kotlinx-coroutines-rx-example stdlib-stubs
 

core/kotlinx-coroutines-core-test/build.gradle

@@ -0,0 +1,7 @@
+# ServiceLoader support
+-keepnames class kotlinx.coroutines.test.internal.InjectableDispatcherFactory {}
+
+# Most of volatile fields are updated with AFU and should not be mangled
+-keepclassmembernames class kotlinx.** {
+    volatile <fields>;
+}

core/kotlinx-coroutines-core-test/resources/META-INF/proguard/coroutines.pro

@@ -0,0 +1 @@
+kotlinx.coroutines.test.internal.InjectableDispatcherFactory

core/kotlinx-coroutines-core-test/resources/META-INF/services/kotlinx.coroutines.internal.MainDispatcherFactory

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016-2018 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 kotlinx.coroutines.test.internal.*
+
+/**
+ * Object, responsible for injecting custom implementation of [Dispatchers.Main].
+ * The main purpose of this class is to override default Main dispatcher in unit tests where main thread is inaccessible.
+ * By default, [Dispatchers.Unconfined] is used.
+ *
+ * If this class is present in the classpath, it **overrides** default [Dispatchers.Main] implementation with its own implementation,
+ * making usages of the original [Dispatchers.Main] impossible.
+ */
+@ExperimentalCoroutinesApi
+public object MainDispatcherInjector {
+
+    private val mainDispatcher = (Dispatchers.Main as? InjectableMainDispatcher)
+        ?: error("Injectable dispatcher is not found in class path (${Dispatchers.Main} was found instead). " +
+                "Please check your META-INF/services and ProGuard settings")
+
+    /**
+     * Injects given dispatcher as underlying dispatcher of [Dispatchers.Main].
+     * All consecutive usages of [Dispatchers.Main] will use [dispatcher] under the hood, though it's not guaranteed
+     * that [Dispatchers.Main] will be equal to given [dispatcher].
+     *
+     * Note that it is unsafe to call this method from coroutine, launched in [Dispatchers.Main].
+     * Such usage may lead to undefined behaviour and [IllegalStateException].
+     */
+    public fun inject(dispatcher: CoroutineDispatcher) {
+        mainDispatcher.inject(dispatcher)
+    }
+
+    /**
+     * Resets state of [Dispatchers.Main] to [Dispatchers.Unconfined].
+     * Used to cleanup all possible dependencies, should be used in tear down (`@After`) methods.
+     */
+    public fun reset() = inject(Dispatchers.Unconfined)
+}

core/kotlinx-coroutines-core-test/src/MainDispatcherInjector.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.test.internal
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.internal.*
+import kotlin.coroutines.*
+
+internal class InjectableDispatcherFactory : MainDispatcherFactory {
+
+    override fun createDispatcher(): MainCoroutineDispatcher = InjectableMainDispatcher
+
+    override val loadPriority: Int
+        get() = Int.MAX_VALUE
+}
+
+internal object InjectableMainDispatcher : MainCoroutineDispatcher() {
+
+    private var delegate: CoroutineDispatcher = Dispatchers.Unconfined
+
+    public fun inject(dispatcher: CoroutineDispatcher) {
+        delegate = dispatcher
+    }
+
+    override val immediate: MainCoroutineDispatcher = (delegate as? MainCoroutineDispatcher)?.immediate ?: this
+
+    override fun isDispatchNeeded(context: CoroutineContext): Boolean = delegate.isDispatchNeeded(context)
+
+    override fun dispatch(context: CoroutineContext, block: Runnable) = delegate.dispatch(context, block)
+}

core/kotlinx-coroutines-core-test/src/internal/InjectableMainDispatcher.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2016-2018 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 org.junit.*
+import org.junit.Test
+import kotlin.coroutines.*
+import kotlin.test.*
+
+class MainDispatcherInjectorTest : TestBase() {
+
+    @Before
+    fun setUp() {
+        MainDispatcherInjector.reset()
+    }
+
+    @Test
+    fun testInjection() = runTest {
+        val mainThread = Thread.currentThread()
+        newSingleThreadContext("testInjection").use { threadPool ->
+            withContext(Dispatchers.Main) {
+                assertSame(mainThread, Thread.currentThread())
+            }
+
+            MainDispatcherInjector.inject(threadPool)
+            withContext(Dispatchers.Main) {
+                assertNotSame(mainThread, Thread.currentThread())
+            }
+            assertSame(mainThread, Thread.currentThread())
+
+            withContext(Dispatchers.Main.immediate) {
+                assertNotSame(mainThread, Thread.currentThread())
+            }
+            assertSame(mainThread, Thread.currentThread())
+
+            MainDispatcherInjector.inject(Dispatchers.Unconfined)
+            withContext(Dispatchers.Main.immediate) {
+                assertSame(mainThread, Thread.currentThread())
+            }
+            assertSame(mainThread, Thread.currentThread())
+        }
+    }
+
+    @Test
+    fun testImmediateDispatcher() = runTest {
+        MainDispatcherInjector.inject(ImmediateDispatcher())
+        expect(1)
+        withContext(Dispatchers.Main) {
+            expect(3)
+        }
+
+        MainDispatcherInjector.inject(RegularDispatcher())
+        withContext(Dispatchers.Main) {
+            expect(6)
+        }
+
+        finish(7)
+    }
+
+    private inner class ImmediateDispatcher : CoroutineDispatcher() {
+        override fun isDispatchNeeded(context: CoroutineContext): Boolean {
+            expect(2)
+            return false
+        }
+
+        override fun dispatch(context: CoroutineContext, block: Runnable) = expectUnreached()
+    }
+
+    private inner class RegularDispatcher : CoroutineDispatcher() {
+        override fun isDispatchNeeded(context: CoroutineContext): Boolean {
+            expect(4)
+            return true
+        }
+
+        override fun dispatch(context: CoroutineContext, block: Runnable) {
+            expect(5)
+            block.run()
+        }
+    }
+}

core/kotlinx-coroutines-core-test/test/MainDispatcherInjectorTest.kt

@@ -1,6 +1,7 @@
 # ServiceLoader support
 -keepnames class kotlinx.coroutines.internal.MainDispatcherFactory {}
 -keepnames class kotlinx.coroutines.CoroutineExceptionHandler {}
+-keepnames class kotlinx.coroutines.test.internal.InjectableDispatcherFactory {}
 
 # Most of volatile fields are updated with AFU and should not be mangled
 -keepclassmembernames class kotlinx.** {

core/kotlinx-coroutines-core/resources/META-INF/proguard/coroutines.pro

@@ -23,6 +23,7 @@ module('binary-compatibility-validator')
 module('common/kotlinx-coroutines-core-common')
 
 module('core/kotlinx-coroutines-core')
+module('core/kotlinx-coroutines-core-test')
 module('core/stdlib-stubs')
 
 module('integration/kotlinx-coroutines-guava')

settings.gradle

@@ -33,15 +33,11 @@ public sealed class HandlerDispatcher : MainCoroutineDispatcher(), Delay {
 
 @Keep
 internal class AndroidDispatcherFactory : MainDispatcherFactory {
-    companion object {
-        @JvmStatic // accessed reflectively from core
-        fun getDispatcher(): MainCoroutineDispatcher = Main
-    }
 
     override fun createDispatcher(): MainCoroutineDispatcher = Main
 
     override val loadPriority: Int
-        get() = Int.MAX_VALUE
+        get() = Int.MAX_VALUE / 2
 }
 
 /**