Testing coroutines with runTest in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this coroutine test using runTest?

Consider this Kotlin coroutine test using runTest. What will be printed when the test runs?

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.test.runTest

fun fetchData(): String = "Data"

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun fetchDataAsync(): String = coroutineScope {
    delay(100)
    fetchData()
}

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun main() = runTest {
    val result = fetchDataAsync()
    println(result)
}

A Data

B null

C Exception in thread "main" java.lang.IllegalStateException

D No output (test hangs)

💡 Hint

runTest executes coroutines in a controlled environment and waits for completion.

The runTest function runs the coroutine and waits for all delays to complete. The fetchDataAsync suspends for 100ms then returns "Data", which is printed.

🧠 Conceptual

intermediate

Which statement about runTest is true?

Choose the correct statement about the runTest function in Kotlin coroutine testing.

A runTest disables all coroutine dispatchers during the test.

B runTest launches coroutines but does not wait for their completion.

C runTest automatically advances virtual time to handle delays inside coroutines.

D runTest can only be used with blocking code, not suspend functions.

💡 Hint

Think about how runTest handles delays without slowing down tests.

runTest uses a TestCoroutineScheduler that advances virtual time automatically, so delays inside coroutines don't slow down tests.

🔧 Debug

advanced

What error does this coroutine test raise?

This test uses runTest but throws an error. What is the error type?

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.test.runTest

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun faultyFunction() {
    withContext(Dispatchers.IO) {
        delay(50)
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun main() = runTest {
    faultyFunction()
}

A IllegalStateException: Dispatchers.IO is not allowed inside runTest

B TimeoutCancellationException

C No error, runs successfully

D Unresolved reference: Dispatchers

💡 Hint

runTest restricts usage of certain dispatchers to keep tests deterministic.

runTest uses a TestDispatcher and disallows switching to Dispatchers.IO or Default inside its scope, causing IllegalStateException.

📝 Syntax

advanced

Which option correctly uses runTest to test a suspend function?

Select the code snippet that correctly tests a suspend function using runTest.

A

runTest {
    launch {
        val result = suspendFunction()
        assert(result == 42)
    }
}

B

runTest {
    val result = suspendFunction()
    println(result)
}
Thread.sleep(100)

C

runTest {
    suspendFunction()
}
println("Test done")

D

runTest {
    val result = suspendFunction()
    assert(result == 42)
}

💡 Hint

runTest waits for all coroutines inside its block to complete before returning.

Option D correctly calls the suspend function inside runTest and asserts the result synchronously. Option D launches a child coroutine but does not wait for it explicitly, which can cause flaky tests.

🚀 Application

expert

How many items are in the list after this runTest block?

Given this Kotlin coroutine test using runTest, how many items does the list contain after execution?

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.test.runTest

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun addItems(list: MutableList<Int>) {
    coroutineScope {
        launch {
            delay(50)
            list.add(1)
        }
        launch {
            delay(100)
            list.add(2)
        }
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun main() = runTest {
    val items = mutableListOf<Int>()
    addItems(items)
    println(items.size)
}

A Test hangs and prints nothing

B 2

C 1

D 0

💡 Hint

runTest waits for all child coroutines launched inside coroutineScope to finish.

Both launched coroutines complete before runTest returns, so both items are added to the list. The size is 2.