Add API binary compatibility listing

- Removed some added-as-deprecated APIs that might have helped with
automatic refactoring via ReplaceWith. Not sure if these should be
shipped.

Author: objcode

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

@@ -1,5 +1,79 @@
+public abstract interface class kotlinx/coroutines/test/DelayController {
+	public abstract fun advanceTimeBy (JLjava/util/concurrent/TimeUnit;)J
+	public abstract fun advanceTimeToNextDelayed ()J
+	public abstract fun advanceUntilIdle ()J
+	public abstract fun cleanupTestCoroutines ()V
+	public abstract fun currentTime (Ljava/util/concurrent/TimeUnit;)J
+	public abstract fun pauseDispatcher ()V
+	public abstract fun pauseDispatcher (Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public abstract fun resumeDispatcher ()V
+	public abstract fun runCurrent ()V
+}
+
+public final class kotlinx/coroutines/test/DelayController$DefaultImpls {
+	public static synthetic fun advanceTimeBy$default (Lkotlinx/coroutines/test/DelayController;JLjava/util/concurrent/TimeUnit;ILjava/lang/Object;)J
+	public static synthetic fun currentTime$default (Lkotlinx/coroutines/test/DelayController;Ljava/util/concurrent/TimeUnit;ILjava/lang/Object;)J
+}
+
+public final class kotlinx/coroutines/test/TestBuilders {
+	public static final fun runBlockingTest (Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function2;)V
+	public static final fun runBlockingTest (Lkotlinx/coroutines/test/TestCoroutineDispatcher;Lkotlin/jvm/functions/Function2;)V
+	public static final fun runBlockingTest (Lkotlinx/coroutines/test/TestCoroutineScope;Lkotlin/jvm/functions/Function2;)V
+	public static synthetic fun runBlockingTest$default (Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)V
+	public static final fun withTestContext (Lkotlinx/coroutines/test/TestCoroutineScope;Lkotlin/jvm/functions/Function2;)V
+}
+
+public final class kotlinx/coroutines/test/TestCoroutineCoroutineExceptionHandler : kotlinx/coroutines/CoroutineExceptionHandler, kotlinx/coroutines/test/UncaughtExceptionCaptor {
+	public fun <init> ()V
+	public fun cleanupTestCoroutines ()V
+	public fun fold (Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
+	public fun get (Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext$Element;
+	public synthetic fun getKey ()Lkotlin/coroutines/CoroutineContext$Key;
+	public fun getKey ()Lkotlinx/coroutines/CoroutineExceptionHandler$Key;
+	public fun getUncaughtExceptions ()Ljava/util/List;
+	public fun handleException (Lkotlin/coroutines/CoroutineContext;Ljava/lang/Throwable;)V
+	public fun minusKey (Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext;
+	public fun plus (Lkotlin/coroutines/CoroutineContext;)Lkotlin/coroutines/CoroutineContext;
+}
+
+public final class kotlinx/coroutines/test/TestCoroutineDispatcher : kotlinx/coroutines/CoroutineDispatcher, kotlinx/coroutines/Delay, kotlinx/coroutines/test/DelayController {
+	public fun <init> ()V
+	public fun advanceTimeBy (JLjava/util/concurrent/TimeUnit;)J
+	public fun advanceTimeToNextDelayed ()J
+	public fun advanceUntilIdle ()J
+	public fun cleanupTestCoroutines ()V
+	public fun currentTime (Ljava/util/concurrent/TimeUnit;)J
+	public fun delay (JLkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public fun dispatch (Lkotlin/coroutines/CoroutineContext;Ljava/lang/Runnable;)V
+	public fun invokeOnTimeout (JLjava/lang/Runnable;)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;
+}
+
+public abstract interface class kotlinx/coroutines/test/TestCoroutineScope : kotlinx/coroutines/CoroutineScope, kotlinx/coroutines/test/DelayController, kotlinx/coroutines/test/UncaughtExceptionCaptor {
+}
+
+public final class kotlinx/coroutines/test/TestCoroutineScopeKt {
+	public static final fun TestCoroutineScope (Lkotlin/coroutines/CoroutineContext;)Lkotlinx/coroutines/test/TestCoroutineScope;
+	public static synthetic fun TestCoroutineScope$default (Lkotlin/coroutines/CoroutineContext;ILjava/lang/Object;)Lkotlinx/coroutines/test/TestCoroutineScope;
+}
+
 public final class kotlinx/coroutines/test/TestDispatchers {
 	public static final fun resetMain (Lkotlinx/coroutines/Dispatchers;)V
 	public static final fun setMain (Lkotlinx/coroutines/Dispatchers;Lkotlinx/coroutines/CoroutineDispatcher;)V
 }
 
+public abstract interface class kotlinx/coroutines/test/UncaughtExceptionCaptor {
+	public abstract fun cleanupTestCoroutines ()V
+	public abstract fun getUncaughtExceptions ()Ljava/util/List;
+}
+
+public final class kotlinx/coroutines/test/UncompletedCoroutinesError : java/lang/AssertionError {
+	public fun <init> (Ljava/lang/String;Ljava/lang/Throwable;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Throwable;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+}
+

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

@@ -36,7 +36,7 @@ import kotlin.coroutines.CoroutineContext
  * @throws UncompletedCoroutinesError If the [testBody] does not complete (or cancel) all coroutines that it launches
  * (including coroutines suspended on join/await).
  *
- * @param context An optional context that MUST contain a [DelayController] and/or [TestCoroutineCoroutineExceptionHandler]
+ * @param context An optional context that MUST contain a [DelayController] and/or [TestCoroutineExceptionHandler]
  * @param testBody The code of the unit-test.
  */
 @ExperimentalCoroutinesApi
@@ -83,7 +83,7 @@ fun TestCoroutineDispatcher.runBlockingTest(block: suspend TestCoroutineScope.()
 }
 
 private fun CoroutineContext?.checkArguments(): Pair<CoroutineContext, ContinuationInterceptor> {
-    var safeContext= this ?: TestCoroutineCoroutineExceptionHandler() + TestCoroutineDispatcher()
+    var safeContext= this ?: TestCoroutineExceptionHandler() + TestCoroutineDispatcher()
 
     val dispatcher = safeContext[ContinuationInterceptor].run {
         this?.let {
@@ -96,7 +96,7 @@ private fun CoroutineContext?.checkArguments(): Pair<CoroutineContext, Continuat
         this?.let {
             require(this is UncaughtExceptionCaptor) { "coroutineExceptionHandler must implement UncaughtExceptionCaptor" }
         }
-        this ?: TestCoroutineCoroutineExceptionHandler()
+        this ?: TestCoroutineExceptionHandler()
     }
 
     val job = safeContext[Job] ?: SupervisorJob()
@@ -108,7 +108,7 @@ private fun CoroutineContext?.checkArguments(): Pair<CoroutineContext, Continuat
 /**
  * This method is deprecated.
  *
- * @see [cleanupTestCoroutines]
+ * @see [runBlocking]
  */
 @Deprecated("This API has been deprecated to integrate with Structured Concurrency.",
         ReplaceWith("scope.runBlockingTest(testBody)", "kotlinx.coroutines.test"),

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

@@ -99,24 +99,6 @@ interface DelayController {
      */
     @ExperimentalCoroutinesApi
     fun resumeDispatcher()
-
-    @Deprecated("This API has been deprecated to integrate with Structured Concurrency.",
-            ReplaceWith("if (targetTime > currentTime(unit)) { advanceTimeBy(targetTime - currentTime(unit), unit) }",
-                    "kotlinx.coroutines.test"),
-            level = DeprecationLevel.WARNING)
-    fun advanceTimeTo(targetTime: Long, unit: TimeUnit = TimeUnit.MILLISECONDS) {
-        advanceTimeBy(targetTime - currentTime(unit), unit)
-    }
-
-    @Deprecated("This API has been deprecated to integrate with Structured Concurrency.",
-            ReplaceWith("currentTime(unit)", "kotlinx.coroutines.test"),
-            level = DeprecationLevel.WARNING)
-    fun now(unit: TimeUnit = TimeUnit.MILLISECONDS) = currentTime(unit)
-
-    @Deprecated("This API has been deprecated to integrate with Structured Concurrency.",
-            ReplaceWith("runCurrent()", "kotlinx.coroutines.test"),
-            level = DeprecationLevel.WARNING)
-    fun triggerActions() = runCurrent()
 }
 
 /**
@@ -195,7 +177,7 @@ class TestCoroutineDispatcher:
                     }
 
 
-    private fun triggerActions(targetTime: Long) {
+    private fun doActionsUntil(targetTime: Long) {
         while (true) {
             val current = queue.removeFirstIf { it.time <= targetTime } ?: break
             // If the scheduled time is 0 (immediate) use current virtual time
@@ -221,7 +203,7 @@ class TestCoroutineDispatcher:
      */
     private fun advanceUntilTime(targetTime: Long, unit: TimeUnit) {
         val nanoTime = unit.toNanos(targetTime)
-        triggerActions(nanoTime)
+        doActionsUntil(nanoTime)
         if (nanoTime > time) time = nanoTime
     }
 
@@ -241,7 +223,7 @@ class TestCoroutineDispatcher:
         return time - oldTime
     }
 
-    override fun runCurrent() = triggerActions(time)
+    override fun runCurrent() = doActionsUntil(time)
 
     override suspend fun pauseDispatcher(block: suspend () -> Unit) {
         val previous = dispatchImmediately
@@ -263,7 +245,7 @@ class TestCoroutineDispatcher:
 
     override fun cleanupTestCoroutines() {
         // process any pending cancellations or completions, but don't advance time
-        triggerActions(time)
+        doActionsUntil(time)
 
         // run through all pending tasks, ignore any submitted coroutines that are not active
         val pendingTasks = mutableListOf<TimedRunnable>()

core/kotlinx-coroutines-test/src/TestCoroutineCoroutineExceptionHandler.kt renamed to core/kotlinx-coroutines-test/src/TestCoroutineExceptionHandler.kt

@@ -30,7 +30,7 @@ interface UncaughtExceptionCaptor {
  * An exception handler that can be used to capture uncaught exceptions in tests.
  */
 @ExperimentalCoroutinesApi
-class TestCoroutineCoroutineExceptionHandler: UncaughtExceptionCaptor, CoroutineExceptionHandler {
+class TestCoroutineExceptionHandler: UncaughtExceptionCaptor, CoroutineExceptionHandler {
 
     override fun handleException(context: CoroutineContext, exception: Throwable) {
         synchronized(_exceptions) {

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

@@ -1,3 +1,4 @@
+
 /*
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
@@ -13,20 +14,10 @@ import kotlin.coroutines.CoroutineContext
  * A scope which provides detailed control over the execution of coroutines for tests.
  */
 @ExperimentalCoroutinesApi
-interface TestCoroutineScope: CoroutineScope, UncaughtExceptionCaptor, DelayController {
-    /**
-     * This method is deprecated.
-     *
-     * @see [cleanupTestCoroutines]
-     */
-    @Deprecated("This API has been deprecated to integrate with Structured Concurrency.",
-            ReplaceWith("cleanupTestCoroutines()"),
-            level = DeprecationLevel.WARNING)
-    fun cancelAllActions() = cleanupTestCoroutines()
-}
+interface TestCoroutineScope: CoroutineScope, UncaughtExceptionCaptor, DelayController
 
 private class TestCoroutineScopeImpl (
-        context: CoroutineContext = TestCoroutineDispatcher() + TestCoroutineCoroutineExceptionHandler()):
+        context: CoroutineContext = TestCoroutineDispatcher() + TestCoroutineExceptionHandler()):
         TestCoroutineScope,
         UncaughtExceptionCaptor by context.uncaughtExceptionDelegate,
         DelayController by context.delayDelegate
@@ -55,7 +46,7 @@ fun TestCoroutineScope(context: CoroutineContext? = null): TestCoroutineScope {
         safeContext += TestCoroutineDispatcher()
     }
     if (context[CoroutineExceptionHandler] == null) {
-        safeContext += TestCoroutineCoroutineExceptionHandler()
+        safeContext += TestCoroutineExceptionHandler()
     }
 
     return TestCoroutineScopeImpl(safeContext)
@@ -66,7 +57,7 @@ private inline val CoroutineContext.uncaughtExceptionDelegate: UncaughtException
         val handler = this[CoroutineExceptionHandler]
         return handler as? UncaughtExceptionCaptor ?: throw
             IllegalArgumentException("TestCoroutineScope requires a UncaughtExceptionCaptor such as " +
-                    "TestCoroutineCoroutineExceptionHandler as the CoroutineExceptionHandler")
+                    "TestCoroutineExceptionHandler as the CoroutineExceptionHandler")
     }
 
 private inline val CoroutineContext.delayDelegate: DelayController

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

@@ -113,51 +113,4 @@ class TestCoroutineDispatcherTest {
         }
         subject.cleanupTestCoroutines()
     }
-
-    @Test
-    fun whenCallingAdvanceTimeTo_itAdvancesToTheFuture() {
-        val subject = TestCoroutineDispatcher()
-        subject.advanceTimeTo(1_000)
-        subject.advanceTimeTo(500)
-
-        assertEquals(1_000, subject.currentTime())
-    }
-
-    @Test
-    fun whenCallingAdvanceTimeTo_itOnlyAdvancesByDelta() {
-        val subject = TestCoroutineDispatcher()
-        subject.advanceTimeTo(1000)
-        subject.advanceTimeTo(2000)
-
-        assertEquals(2_000, subject.currentTime())
-    }
-
-    @Test
-    fun whenNowCalled_returnsCurrentTime() {
-        val subject = TestCoroutineDispatcher()
-        subject.advanceTimeBy(1000)
-
-        assertEquals(1_000, subject.now())
-    }
-
-    @Test
-    fun whenCallingTriggerActions_currentActionsRun() {
-        val subject = TestCoroutineDispatcher()
-        subject.pauseDispatcher()
-        val scope = CoroutineScope(subject)
-        var executed = 0
-
-        scope.launch {
-            executed++
-            delay(1000)
-            executed++
-        }
-
-        assertEquals(0, executed)
-        subject.triggerActions()
-        assertEquals(1, executed)
-        subject.advanceUntilIdle()
-        assertEquals(2, executed)
-    }
-
 }

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

@@ -1,11 +1,11 @@
-import kotlinx.coroutines.test.TestCoroutineCoroutineExceptionHandler
+import kotlinx.coroutines.test.TestCoroutineExceptionHandler
 import org.junit.Test
 import kotlin.test.assertEquals
 
 class TestCoroutineExceptionHandlerTest {
     @Test
     fun whenExceptionsCaught_avaliableViaProperty() {
-        val subject = TestCoroutineCoroutineExceptionHandler()
+        val subject = TestCoroutineExceptionHandler()
         val expected = IllegalArgumentException()
         subject.handleException(subject, expected)
         assertEquals(listOf(expected), subject.uncaughtExceptions)

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

@@ -1,27 +1,22 @@
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.newSingleThreadContext
-import kotlinx.coroutines.test.TestCoroutineDispatcher
-import kotlinx.coroutines.test.TestCoroutineCoroutineExceptionHandler
 import kotlinx.coroutines.test.TestCoroutineScope
 import org.junit.Test
+import kotlin.test.assertFails
 
 class TestCoroutineScopeTest {
-    @Test(expected = IllegalArgumentException::class)
+    @Test
     fun whenGivenInvalidExceptionHandler_throwsException() {
         val handler = CoroutineExceptionHandler {  _, _ -> Unit }
-        val subject = TestCoroutineScope(handler)
+        assertFails {
+            TestCoroutineScope(handler)
+        }
     }
 
-    @Test(expected = IllegalArgumentException::class)
+    @Test
     fun whenGivenInvalidDispatcher_throwsException() {
-        val subject = TestCoroutineScope(newSingleThreadContext("incorrect call"))
+        assertFails {
+            TestCoroutineScope(newSingleThreadContext("incorrect call"))
+        }
     }
-
-    @Test(expected = IllegalArgumentException::class)
-    fun whenCancelAllActions_callsCleanupTestCoroutines() {
-        val handler = TestCoroutineCoroutineExceptionHandler()
-        val subject = TestCoroutineScope(handler + TestCoroutineDispatcher())
-        handler.handleException(handler, IllegalArgumentException())
-        subject.cancelAllActions()
-    }
-}
+}