<http://Dispatchers.IO|Dispatchers.IO>

fun test() = coroutineScope { 
   launch()
   launch() 
}

fun test() = withContext(...) { 
  launch()
  launch()
}

suspend fun cancelNow(): Nothing = suspendCancellableCoroutine<Nothing> { c -> c.cancel() }

@Test
    fun `should receive updated data when querying all challenges`() {
        val initChallenges = mutableListOf(Challenge(...),Challenge(...))

        val newSurveyChallenge = SurveyChallenge(...)

        val expectedChallenges = listOf(
            initChallenges,
            initChallenges += newSurveyChallenge
        )

        initChallenges.forEach(challengeDao::addOrUpdate)

        runBlocking {
            val channel = repository.availableChallenges(coroutineContext)

            val actualChallengesLists = async(IO) {
                channel.fold(mutableListOf<List<Challenge>>()) { list, challenges -> list.apply { add(challenges) } }
            }

            delay(300)
            challengeDao.addOrUpdate(newSurveyChallenge)
            delay(300)
            channel.cancel()

            assertThat(actualChallengesLists.await()).containsExactlyElementsIn(expectedChallenges).inOrder()
        }

delay

sqldelight

robolectric

object CoroutineCrashTest {
    private val scope = GlobalScope + Job()

    fun run() = scope.launch(Dispatchers.Default) {
        doAwaitInside()
    }

    private suspend fun doAwaitInside() {
        supervisorScope {
          try {
              testAsync().await()
          } catch (e: IllegalStateException) {
              // catched but still crash
          }
        }
    }

    private fun testAsync() = scope.async(Dispatchers.Default) {
        throw IllegalStateException("test")
    }
}

GlobalScope.rxFlowable{}

CompletableDeferred

lateinit var CompletableDeferred

null

cancelChildren()

Job

onStart()

Job

private suspend fun <E> ReceiveChannel<E>.throttle(): ReceiveChannel<E> {
    // want to launch {} in current scope
}

ObjectReader#readValue()

withScope

withContext

withContext(myScope.coroutineContext)

CoroutineScope

produce<String>(capacity = 1024) {
            input.forEachLine { async { send(it) } }
        }.map {
            async {
                val tokenized = tokenizerFactory.create(pp.preProcess(it)).tokens.joinToString(" ")
                tokenized + "\n"
            }
        }.map {
            output.appendText(it.await())
        }

Dispatchers.setMain

fun main() {
    runBlocking {
        val job = launch {
            suspendCoroutine<Unit> {}
        }

        yield()
        job.cancel()
        println("goodbye")
    }
    println("exit")
}

goodbye

yield()

launch {
        val first = async(IO) {
            transactionDataRepository.getFist()
        }
        val second = async(IO) {
            transactionDataRepository.getSecond()
        }
    }

launch {
            withContext(IO) {
                val first = async {
                    transactionDataRepository.getFist()
                }
                val second = async {
                    transactionDataRepository.getSecond()
                }
            }
        }