Testing coroutines with runTest in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a coroutine test using runTest.

Kotlin

import kotlinx.coroutines.test.runTest

fun main() = runTest([1]) {
    // test code here
}

Drag options to blanks, or click blank then click option'

A(

B{

C[

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using curly braces directly after runTest without parentheses causes a syntax error.

The runTest function takes a lambda as a parameter, so it requires parentheses before the lambda block.

2fill in blank

medium

Complete the code to launch a coroutine inside runTest.

Kotlin

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.launch

fun main() = runTest {
    val job = [1] {
        // coroutine work
    }
}

Drag options to blanks, or click blank then click option'

Alaunch

Basync

CrunBlocking

Ddelay

Attempts:

3 left

💡 Hint

Common Mistakes

Using async instead of launch when no result is needed.

Using runBlocking inside runTest causes blocking issues.

Inside runTest, you use launch to start a new coroutine job.

3fill in blank

hard

Fix the error in the test code by completing the runTest call correctly.

Kotlin

import kotlinx.coroutines.test.runTest

fun testSomething() = runTest([1]) {
    // test logic
}

Drag options to blanks, or click blank then click option'

A[

B{

C(

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using curly braces directly after runTest without parentheses.

runTest requires parentheses before the lambda block to be called correctly.

4fill in blank

hard

Complete the code to correctly create a test coroutine that delays and asserts a value.

Kotlin

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.delay
import kotlin.test.assertEquals

fun main() = runTest() {
    delay(100)
    val result = 5
    assertEquals([1], result)
}

Drag options to blanks, or click blank then click option'

A(

B5

C10

D{

Attempts:

3 left

💡 Hint

Common Mistakes

Using curly braces instead of parentheses for runTest.

Using wrong expected value in assertEquals.

runTest needs parentheses before the lambda, and assertEquals compares expected value 5 to result.

5fill in blank

hard

Fill both blanks to create a test that launches a coroutine, delays, and cancels the job.

Kotlin

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.launch
import kotlinx.coroutines.delay

fun main() = runTest() {
    val job = [1] {
        delay(1000)
    }
    [2].cancel()
}

Drag options to blanks, or click blank then click option'

A(

Blaunch

Cjob

D{

Attempts:

3 left

💡 Hint

Common Mistakes

Using curly braces instead of parentheses for runTest.

Using wrong variable name instead of job to cancel.

runTest needs parentheses before the lambda, launch starts the coroutine, and job.cancel() cancels it.

Practice

1. What is the main purpose of using runTest in Kotlin coroutine testing?

easy

A. To run coroutine tests quickly and safely

B. To create new threads for coroutines

C. To convert coroutines into blocking calls

D. To disable coroutine dispatchers

Solution

1. Step 1: Understand the role of runTest

   runTest is designed to run coroutine tests in a controlled environment that is fast and safe.

2. Step 2: Compare options with runTest purpose

   Options A, B, and D describe unrelated or incorrect behaviors. Only To run coroutine tests quickly and safely correctly states the purpose.

3. Final Answer:

   To run coroutine tests quickly and safely -> Option A

4. Quick Check:

   runTest purpose = run coroutine tests quickly and safely [OK]

Hint: Remember: runTest runs coroutine tests safely and fast [OK]

Common Mistakes:

• Thinking runTest creates new threads
• Confusing runTest with blocking calls
• Assuming runTest disables dispatchers

2. Which of the following is the correct syntax to start a coroutine test using runTest?

easy

A. runTest[] { val result = suspendFunction() }

B. runTest() => { val result = suspendFunction() }

C. runTest { val result = suspendFunction() }

D. runTest -> { val result = suspendFunction() }

Solution

1. Step 1: Recall the correct runTest syntax

   The correct syntax uses parentheses with a lambda block: runTest { ... }.

2. Step 2: Check each option's syntax

   runTest { val result = suspendFunction() } matches the correct syntax. Options B, C, and D use invalid Kotlin syntax for lambdas.

3. Final Answer:

   runTest { val result = suspendFunction() } -> Option C

4. Quick Check:

   Correct runTest syntax = runTest { ... } [OK]

Hint: Use curly braces {} after runTest for coroutine tests [OK]

Common Mistakes:

• Using parentheses with arrow syntax incorrectly
• Using square brackets instead of braces
• Using arrow (->) instead of braces for lambda

3. What will be the output of this Kotlin test code using runTest?

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.delay

fun suspendFunction(): String {
    delay(100)
    return "Done"
}

fun main() {
    println(suspendFunction())
}

medium

A. Done

B. Compilation error

C. Runtime exception

D. No output

Solution

1. Step 1: Analyze the suspend function usage

   suspendFunction contains delay(100) call, which requires a suspend function context, but suspendFunction itself is not marked as suspend.

2. Step 2: Check for compilation errors

   Calling suspend functions like delay inside a non-suspend function causes a compilation error.

3. Final Answer:

   Compilation error -> Option B

4. Quick Check:

   Calling delay requires suspend context = compilation error if missing [OK]

Hint: delay must be called from suspend context [OK]

Common Mistakes:

• Assuming suspend functions like delay can be called from normal functions
• Expecting output without suspend keyword
• Ignoring suspend function rules

4. Identify the error in this coroutine test code using runTest and how to fix it:

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.delay

fun suspendFunction(): String {
    delay(100)
    return "Done"
}

fun main() = runTest {
    val result = suspendFunction()
    println(result)
}

medium

A. suspendFunction should be marked suspend

B. runTest cannot be called inside main

C. delay cannot be used inside runTest

D. println cannot be used inside runTest

Solution

1. Step 1: Check suspendFunction declaration

   suspendFunction calls delay(100) but is not marked as suspend, which is incorrect for coroutine code.

2. Step 2: Fix by marking suspendFunction as suspend

   Marking suspendFunction as suspend allows it to be called inside runTest properly.

3. Final Answer:

   suspendFunction should be marked suspend -> Option A

4. Quick Check:

   suspendFunction missing suspend keyword = error [OK]

Hint: Mark functions calling coroutines as suspend [OK]

Common Mistakes:

• Not marking suspendFunction as suspend
• Thinking runTest can't be in main
• Believing delay is disallowed in runTest

5. You want to test a suspend function fetchData() that returns a string after a delay. Which is the best way to write a test using runTest to verify it returns "Success"?

hard

A. runTest { val result = fetchData(); assert(result == "Success") }

B. runTest { val result = fetchData(); println(result) }

C. runBlocking { val result = fetchData(); assert(result == "Success") }

D. runTest { val result = fetchData(); assertEquals("Success", result) }

Solution

1. Step 1: Choose correct test function and assertion

   runTest is the recommended coroutine test runner. Using assertEquals is the standard way to check expected results in tests.

2. Step 2: Compare options for best practice

   runTest { val result = fetchData(); assertEquals("Success", result) } uses runTest and assertEquals, making it the best choice. runTest { val result = fetchData(); assert(result == "Success") } uses assert but not the standard function. runTest { val result = fetchData(); println(result) } only prints result. runBlocking { val result = fetchData(); assert(result == "Success") } uses runBlocking which is less preferred for coroutine tests.

3. Final Answer:

   runTest { val result = fetchData(); assertEquals("Success", result) } -> Option D

4. Quick Check:

   Use runTest + assertEquals for coroutine tests [OK]

Hint: Use runTest with assertEquals to verify coroutine results [OK]

Common Mistakes:

• Using runBlocking instead of runTest
• Using print instead of assertions
• Using assert instead of assertEquals