backgroundWorkScope -> backgroundScope

Author: dkhalanskyjb

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

@@ -105,7 +105,7 @@ public final class kotlinx/coroutines/test/TestDispatchers {
 }
 
 public abstract interface class kotlinx/coroutines/test/TestScope : kotlinx/coroutines/CoroutineScope {
-	public abstract fun getBackgroundWorkScope ()Lkotlinx/coroutines/CoroutineScope;
+	public abstract fun getBackgroundScope ()Lkotlinx/coroutines/CoroutineScope;
 	public abstract fun getTestScheduler ()Lkotlinx/coroutines/test/TestCoroutineScheduler;
 }
 

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

@@ -165,7 +165,7 @@ public fun TestScope.runTest(
     it.enter()
     createTestResult {
         runTestCoroutine(it, dispatchTimeoutMs, TestScopeImpl::tryGetCompletionCause, testBody) {
-            backgroundWorkScope.cancel()
+            backgroundScope.cancel()
             testScheduler.advanceUntilIdleOr { false }
             it.leave()
         }

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

@@ -249,7 +249,7 @@ internal fun checkSchedulerInContext(scheduler: TestCoroutineScheduler, context:
 
 /**
  * A coroutine context key denoting that the work is to be executed in the background.
- * @see [TestScope.backgroundWorkScope]
+ * @see [TestScope.backgroundScope]
  */
 internal object BackgroundWork : CoroutineContext.Key<BackgroundWork>, CoroutineContext.Element {
     override val key: CoroutineContext.Key<*>

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

@@ -62,7 +62,7 @@ public sealed interface TestScope : CoroutineScope {
      * the production environment.
      */
     @ExperimentalCoroutinesApi
-    public val backgroundWorkScope: CoroutineScope
+    public val backgroundScope: CoroutineScope
 }
 
 /**
@@ -187,7 +187,7 @@ internal class TestScopeImpl(context: CoroutineContext) :
     private val uncaughtExceptions = mutableListOf<Throwable>()
     private val lock = SynchronizedObject()
 
-    override val backgroundWorkScope: CoroutineScope =
+    override val backgroundScope: CoroutineScope =
         CoroutineScope(coroutineContext + SupervisorJob() + BackgroundWork)
 
     /** Called upon entry to [runTest]. Will throw if called more than once. */

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

@@ -176,10 +176,10 @@ class TestScopeTest {
     fun testBackgroundWorkBeingRun(): TestResult = runTest {
         var i = 0
         var j = 0
-        backgroundWorkScope.launch {
+        backgroundScope.launch {
             ++i
         }
-        backgroundWorkScope.launch {
+        backgroundScope.launch {
             delay(10)
             ++j
         }
@@ -205,7 +205,7 @@ class TestScopeTest {
         }) {
             runTest {
                 var i = 0
-                backgroundWorkScope.launch {
+                backgroundScope.launch {
                     try {
                         while (isActive) {
                             ++i
@@ -228,13 +228,13 @@ class TestScopeTest {
     fun testBackgroundWorkTimeControl(): TestResult = runTest {
         var i = 0
         var j = 0
-        backgroundWorkScope.launch {
+        backgroundScope.launch {
             while (true) {
                 ++i
                 delay(100)
             }
         }
-        backgroundWorkScope.launch {
+        backgroundScope.launch {
             while (true) {
                 ++j
                 delay(50)
@@ -284,7 +284,7 @@ class TestScopeTest {
             }
         }) {
             runTest {
-                backgroundWorkScope.launch {
+                backgroundScope.launch {
                     throw exception
                 }
                 delay(1000)
@@ -311,7 +311,7 @@ class TestScopeTest {
         }) {
             runTest {
                 repeat(nTasks) {
-                    backgroundWorkScope.launch {
+                    backgroundScope.launch {
                         try {
                             while (true) {
                                 delay(1)
@@ -341,7 +341,7 @@ class TestScopeTest {
                 delay(1)
             }
         }
-        val stateFlow = myFlow.stateIn(backgroundWorkScope, SharingStarted.Eagerly, 0)
+        val stateFlow = myFlow.stateIn(backgroundScope, SharingStarted.Eagerly, 0)
         var j = 0
         repeat(100) {
             assertEquals(j++, stateFlow.value)
@@ -350,12 +350,12 @@ class TestScopeTest {
     }
 
     /**
-     * A test from the documentation of [TestScope.backgroundWorkScope].
+     * A test from the documentation of [TestScope.backgroundScope].
      */
     @Test
     fun testExampleBackgroundJob2() = runTest {
         val channel = Channel<Int>()
-        backgroundWorkScope.launch {
+        backgroundScope.launch {
             var i = 0
             while (true) {
                 channel.send(i++)
@@ -379,12 +379,12 @@ class TestScopeTest {
         }
     }) {
         runTest(dispatchTimeoutMs = 100) {
-            backgroundWorkScope.launch {
+            backgroundScope.launch {
                 while (true) {
                     yield()
                 }
             }
-            backgroundWorkScope.launch {
+            backgroundScope.launch {
                 while (true) {
                     delay(1)
                 }
@@ -407,14 +407,14 @@ class TestScopeTest {
         runTest(UnconfinedTestDispatcher(), dispatchTimeoutMs = 100) {
             /**
              * Having a coroutine like this will still cause the test to hang:
-                 backgroundWorkScope.launch {
+                 backgroundScope.launch {
                      while (true) {
                          yield()
                      }
                  }
              * The reason is that even the initial [advanceUntilIdle] will never return in this case.
              */
-            backgroundWorkScope.launch {
+            backgroundScope.launch {
                 while (true) {
                     delay(1)
                 }

kotlinx-coroutines-test/jvm/src/migration/TestBuildersDeprecated.kt

@@ -92,7 +92,7 @@ public fun runBlockingTestOnTestScope(
     } catch (e: IllegalStateException) {
         null // the deferred was not completed yet; `scope.leave()` should complain then about unfinished jobs
     }
-    scope.backgroundWorkScope.cancel()
+    scope.backgroundScope.cancel()
     scope.testScheduler.advanceUntilIdleOr { false }
     throwable?.let {
         val exceptions = try {