Testing coroutines with runTest in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of runTest in Kotlin coroutine testing?

runTest is used to run coroutine code in a controlled test environment. It helps to test suspend functions by providing a special coroutine scope and controlling the virtual time.

intermediate

How does runTest help with timing in coroutine tests?

runTest controls virtual time, allowing you to advance time manually without waiting in real time. This makes tests faster and deterministic.

intermediate

What happens if a coroutine launched inside runTest is not completed by the end of the test?

The test will fail because runTest checks for uncompleted coroutines to avoid leaks and ensure all work is done.

beginner

Show a simple example of using runTest to test a suspend function.

<pre>import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals

class MyTest {
    @Test
    fun testSuspendFunction() = runTest {
        val result = suspendFunction()
        assertEquals("Hello", result)
    }

    suspend fun suspendFunction(): String {
        return "Hello"
    }
}</pre>

intermediate

Why should you avoid using Thread.sleep() inside runTest?

Thread.sleep() blocks the thread and does not advance virtual time in runTest. Instead, use advanceTimeBy() or delay() to simulate time passing.

What does runTest provide when testing coroutines?

A A replacement for <code>Thread.sleep()</code>

B A way to run blocking code only

C Automatic UI updates

D A controlled coroutine scope with virtual time

runTest provides a coroutine scope that controls virtual time, allowing precise testing of suspend functions.

Which function should you use inside runTest to simulate time passing?

A wait()

B Thread.sleep()

C advanceTimeBy()

D sleep()

advanceTimeBy() advances the virtual clock inside runTest. Thread.sleep() blocks real time and should be avoided.

What happens if a coroutine is still running after runTest finishes?

A The test fails due to unfinished coroutines

B The test passes anyway

C The coroutine is cancelled silently

D The coroutine runs on a new thread

runTest ensures all coroutines complete. If not, the test fails to prevent leaks.

Which annotation is commonly used with runTest in Kotlin tests?

A @RunWith

B @Test

C @CoroutineTest

D @SuspendTest

@Test marks the test function, and runTest is called inside it to run coroutine code.

Why is runTest preferred over runBlocking for coroutine tests?

A Because <code>runTest</code> controls virtual time and detects leaks

B Because <code>runBlocking</code> is deprecated

C Because <code>runTest</code> runs faster on the UI thread

D Because <code>runBlocking</code> cannot run suspend functions

runTest offers better control over time and coroutine lifecycle, making tests more reliable and faster.

Explain how runTest helps in testing Kotlin coroutines and why controlling virtual time is important.

Think about how waiting in real time can slow tests and how virtual time solves that.

Describe a simple test case using runTest to verify a suspend function returns the expected result.

Imagine you want to check a function that says 'Hello' after a delay.