Cleanup TestCoroutineScope documentation

README.md

@@ -39,6 +39,7 @@ suspend fun main() = coroutineScope {
  * Integration with `Window`.
 * [test](kotlinx-coroutines-test/README.md) — test utilities for coroutines
  * `Dispatchers.setMain` to override `Dispatchers.Main` in tests.
+ * `TestCoroutineScope` to test suspending functions and coroutines.
 * [debug](kotlinx-coroutines-debug/README.md) — debug utilities for coroutines.
  * `DebugProbes` API to probe, keep track of, print and dump active coroutines.
  * `CoroutinesTimeout` test rule to automatically dump coroutines on test timeout.

kotlinx-coroutines-test/README.md

@@ -73,13 +73,13 @@ coroutine. Any calls to `delay` will automatically advance time.
 
 ```kotlin
 @Test
-fun testFoo() = runBlockingTest { // a coroutine with a extra test control
+fun testFoo() = runBlockingTest { // a coroutine with an extra test control
  val actual = foo() 
  // ...
 }
 
 suspend fun foo() {
- delay(1_000)  // auto-advances without delay due to runBlockingTest
+ delay(1_000) // auto-advances without delay due to runBlockingTest
  // ...
 }
 ```
@@ -105,8 +105,8 @@ fun testFooWithLaunch() = runBlockingTest {
 fun CoroutineScope.foo() {
  // This coroutines `Job` is not shared with the test code
  launch {
- bar()  // executes eagerly when foo() is called due to runBlockingTest
- println(1)  // executes eagerly when foo() is called due to runBlockingTest
+ bar() // executes eagerly when foo() is called due to runBlockingTest
+ println(1) // executes eagerly when foo() is called due to runBlockingTest
  }
 }
 
@@ -129,24 +129,24 @@ To control time in the test you can use the [DelayController] interface. The blo
 fun testFooWithLaunchAndDelay() = runBlockingTest {
  foo()
  // the coroutine launched by foo has not completed here, it is suspended waiting for delay(1_000)
- advanceTimeBy(1_000)  // progress time, this will cause the delay to resume
+ advanceTimeBy(1_000) // progress time, this will cause the delay to resume
  // foo() coroutine launched by foo has completed here
  // ...
 }
 
 suspend fun CoroutineScope.foo() {
  launch {
- println(1)  // executes eagerly when foo() is called due to runBlockingTest
- delay(1_000)  // suspends until time is advanced by at least 1_000
- println(2)  // executes after advanceTimeBy(1_000)
+ println(1) // executes eagerly when foo() is called due to runBlockingTest
+ delay(1_000) // suspends until time is advanced by at least 1_000
+ println(2) // executes after advanceTimeBy(1_000)
  }
 }
 ```
 
 *Note:* `runBlockingTest` will always attempt to auto-progress time until all coroutines are completed just before 
 exiting. This is a convenience to avoid having to call [advanceUntilIdle][DelayController.advanceUntilIdle] 
 as the last line of many common test cases.
-If any coroutines cannot complete by advancing time, a [UncompletedCoroutinesError] is thrown.
+If any coroutines cannot complete by advancing time, an [UncompletedCoroutinesError] is thrown.
 
 ### Testing `withTimeout` using `runBlockingTest`
 
@@ -159,16 +159,16 @@ example an uncompleted `Deferred<Foo>` is provided to the function under test vi
 ```kotlin
 @Test(expected = TimeoutCancellationException::class)
 fun testFooWithTimeout() {
- val uncompleted = CompletableDeferred<Foo>()  // this Deferred<Foo> will never complete
+ val uncompleted = CompletableDeferred<Foo>() // this Deferred<Foo> will never complete
  foo(uncompleted)
- advanceTimeBy(1_000)  // advance time, which will cause the timeout to throw an exception
+ advanceTimeBy(1_000) // advance time, which will cause the timeout to throw an exception
  // ...
 }
 
 fun CoroutineScope.foo(resultDeferred: Deferred<Foo>) {
  launch {
  withTimeout(1_000) {
- resultDeferred.await()  // await() will suspend forever waiting for uncompleted
+ resultDeferred.await() // await() will suspend forever waiting for uncompleted
  // ...
  }
  }
@@ -196,19 +196,19 @@ fun testFooWithPauseDispatcher() = runBlockingTest {
  pauseDispatcher {
  foo()
  // the coroutine started by foo has not run yet
- runCurrent()  // the coroutine started by foo advances to delay(1_000)
+ runCurrent() // the coroutine started by foo advances to delay(1_000)
  // the coroutine started by foo has called println(1), and is suspended on delay(1_000)
- advanceTimeBy(1_000)  // progress time, this will cause the delay to resume
+ advanceTimeBy(1_000) // progress time, this will cause the delay to resume
  // the coroutine started by foo has called println(2) and has completed here
  }
  // ...
 }
 
 fun CoroutineScope.foo() {
  launch {
- println(1)  // executes after runCurrent() is called
- delay(1_000)  // suspends until time is advanced by at least 1_000
- println(2)  // executes after advanceTimeBy(1_000)
+ println(1) // executes after runCurrent() is called
+ delay(1_000) // suspends until time is advanced by at least 1_000
+ println(2) // executes after advanceTimeBy(1_000)
  }
 }
 ```
@@ -250,7 +250,7 @@ In simple cases, tests can use the [TestCoroutineScope] created by [runBlockingT
 ```kotlin
 @Test
 fun testFoo() = runBlockingTest { 
- foo()  // runBlockingTest passed in a TestCoroutineScope as this
+ foo() // runBlockingTest passed in a TestCoroutineScope as this
 }
 
 fun CoroutineScope.foo() {
@@ -329,7 +329,7 @@ important to ensure that [cleanupTestCoroutines][TestCoroutineDispatcher.cleanup
 
 ```kotlin
 class TestClass {
- val testDispatcher = TestCoroutineDispatcher()
+ private val testDispatcher = TestCoroutineDispatcher()
 
  @Before
  fun setup() {
@@ -398,7 +398,7 @@ either dependency injection, a service locator, or a default parameter.
 ```kotlin
 suspend fun veryExpensiveOne() = withContext(Dispatchers.Default) {
  delay(1_000)
- 1  // for very expensive values of 1
+ 1 // for very expensive values of 1
 }
 ```
 
@@ -409,7 +409,7 @@ directly, there is no need to inject a `TestCoroutineDispatcher` into this funct
 
 ```kotlin
 suspend fun veryExpensiveTwo() = withContext(Dispatchers.Default) {
- 2  // for very expensive values of 2
+ 2 // for very expensive values of 2
 }
 ```