Small refactoring

Author: dkhalanskyjb

kotlinx-coroutines-test/api/kotlinx-coroutines-test.api

@@ -23,17 +23,14 @@ public final class kotlinx/coroutines/test/TestCoroutineDispatcher : kotlinx/cor
 	public fun advanceTimeBy (J)J
 	public fun advanceUntilIdle ()J
 	public fun cleanupTestCoroutines ()V
-	public fun delay (JLkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun dispatch (Lkotlin/coroutines/CoroutineContext;Ljava/lang/Runnable;)V
 	public fun dispatchYield (Lkotlin/coroutines/CoroutineContext;Ljava/lang/Runnable;)V
 	public fun getCurrentTime ()J
 	public fun getScheduler ()Lkotlinx/coroutines/test/TestCoroutineScheduler;
-	public fun invokeOnTimeout (JLjava/lang/Runnable;Lkotlin/coroutines/CoroutineContext;)Lkotlinx/coroutines/DisposableHandle;
 	public fun pauseDispatcher ()V
 	public fun pauseDispatcher (Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun resumeDispatcher ()V
 	public fun runCurrent ()V
-	public fun scheduleResumeAfterDelay (JLkotlinx/coroutines/CancellableContinuation;)V
 	public fun toString ()Ljava/lang/String;
 }
 
@@ -77,9 +74,12 @@ public final class kotlinx/coroutines/test/TestCoroutineScopeKt {
 	public static final fun runCurrent (Lkotlinx/coroutines/test/TestCoroutineScope;)V
 }
 
-public abstract class kotlinx/coroutines/test/TestDispatcher : kotlinx/coroutines/CoroutineDispatcher {
+public abstract class kotlinx/coroutines/test/TestDispatcher : kotlinx/coroutines/CoroutineDispatcher, kotlinx/coroutines/Delay {
 	public fun <init> ()V
+	public fun delay (JLkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public abstract fun getScheduler ()Lkotlinx/coroutines/test/TestCoroutineScheduler;
+	public fun invokeOnTimeout (JLjava/lang/Runnable;Lkotlin/coroutines/CoroutineContext;)Lkotlinx/coroutines/DisposableHandle;
+	public fun scheduleResumeAfterDelay (JLkotlinx/coroutines/CancellableContinuation;)V
 }
 
 public final class kotlinx/coroutines/test/TestDispatchers {

kotlinx-coroutines-test/common/src/TestCoroutineDispatcher.kt

@@ -6,7 +6,6 @@ package kotlinx.coroutines.test
 
 import kotlinx.coroutines.*
 import kotlin.coroutines.*
-import kotlin.jvm.*
 
 /**
  * [CoroutineDispatcher] that performs both immediate and lazy execution of coroutines in tests
@@ -35,6 +34,7 @@ public class TestCoroutineDispatcher(public override val scheduler: TestCoroutin
             }
         }
 
+    /** @suppress */
     override fun processEvent(time: Long, marker: Any) {
         check(marker is Runnable)
         marker.run()
@@ -51,25 +51,11 @@ public class TestCoroutineDispatcher(public override val scheduler: TestCoroutin
     }
 
     /** @suppress */
-    @InternalCoroutinesApi
     override fun dispatchYield(context: CoroutineContext, block: Runnable) {
         checkSchedulerInContext(scheduler, context)
         post(block)
     }
 
-    /** @suppress */
-    override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
-        checkSchedulerInContext(scheduler, continuation.context)
-        val timedRunnable = CancellableContinuationRunnable(continuation, this)
-        scheduler.registerEvent(this, timeMillis, timedRunnable, ::cancellableRunnableIsCancelled)
-    }
-
-    /** @suppress */
-    override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
-        checkSchedulerInContext(scheduler, context)
-        return scheduler.registerEvent(this, timeMillis, block) { false }
-    }
-
     /** @suppress */
     override fun toString(): String = "TestCoroutineDispatcher[scheduler=$scheduler]"
 
@@ -97,17 +83,3 @@ public class TestCoroutineDispatcher(public override val scheduler: TestCoroutin
         dispatchImmediately = true
     }
 }
-
-/**
- * This class exists to allow cleanup code to avoid throwing for cancelled continuations scheduled
- * in the future.
- */
-private class CancellableContinuationRunnable(
-    @JvmField val continuation: CancellableContinuation<Unit>,
-    private val dispatcher: CoroutineDispatcher
-) : Runnable {
-    override fun run() = with(dispatcher) { with(continuation) { resumeUndispatched(Unit) } }
-}
-
-private fun cancellableRunnableIsCancelled(runnable: CancellableContinuationRunnable): Boolean =
-    !runnable.continuation.isActive

kotlinx-coroutines-test/common/src/TestCoroutineScheduler.kt

@@ -39,6 +39,7 @@ public class TestCoroutineScheduler: AbstractCoroutineContextElement(TestCorouti
     private val count = atomic(0L)
 
     /** The current virtual time. */
+    @ExperimentalCoroutinesApi
     public var currentTime: Long = 0
         private set
 

kotlinx-coroutines-test/common/src/TestCoroutineScope.kt

@@ -20,6 +20,7 @@ public interface TestCoroutineScope: CoroutineScope, UncaughtExceptionCaptor {
      * @throws UncompletedCoroutinesError if any pending tasks are active, however it will not throw for suspended
      * coroutines.
      */
+    @ExperimentalCoroutinesApi
     public fun cleanupTestCoroutines()
 
     /**

kotlinx-coroutines-test/common/src/TestDispatcher.kt

@@ -5,14 +5,46 @@
 package kotlinx.coroutines.test
 
 import kotlinx.coroutines.*
+import kotlin.coroutines.*
+import kotlin.jvm.*
 
 /**
  * A test dispatcher that can interface with a [TestCoroutineScheduler].
  */
-public abstract class TestDispatcher: CoroutineDispatcher() {
+@ExperimentalCoroutinesApi
+public abstract class TestDispatcher: CoroutineDispatcher(), Delay {
     /** The scheduler that this dispatcher is linked to. */
+    @ExperimentalCoroutinesApi
     public abstract val scheduler: TestCoroutineScheduler
 
     /** Notifies the dispatcher that it should process a single event marked with [marker] happening at time [time]. */
+    @ExperimentalCoroutinesApi
     internal abstract fun processEvent(time: Long, marker: Any)
-}
+
+    /** @suppress */
+    override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
+        checkSchedulerInContext(scheduler, continuation.context)
+        val timedRunnable = CancellableContinuationRunnable(continuation, this)
+        scheduler.registerEvent(this, timeMillis, timedRunnable, ::cancellableRunnableIsCancelled)
+    }
+
+    /** @suppress */
+    override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
+        checkSchedulerInContext(scheduler, context)
+        return scheduler.registerEvent(this, timeMillis, block) { false }
+    }
+}
+
+/**
+ * This class exists to allow cleanup code to avoid throwing for cancelled continuations scheduled
+ * in the future.
+ */
+private class CancellableContinuationRunnable(
+    @JvmField val continuation: CancellableContinuation<Unit>,
+    private val dispatcher: CoroutineDispatcher
+) : Runnable {
+    override fun run() = with(dispatcher) { with(continuation) { resumeUndispatched(Unit) } }
+}
+
+private fun cancellableRunnableIsCancelled(runnable: CancellableContinuationRunnable): Boolean =
+    !runnable.continuation.isActive