Test fixtures and lifecycle in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to run setup before each test in Kotlin.

Kotlin

import org.junit.jupiter.api.[1]

class CalculatorTest {
    @[1]
    fun setup() {
        // setup code here
    }
}

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

ATest

BAfterEach

CBeforeEach

DBeforeAll

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Test instead of @BeforeEach

Using @BeforeAll which runs only once before all tests

The @BeforeEach annotation runs the setup method before each test method.

2fill in blank

medium

Complete the code to run cleanup after each test in Kotlin.

Kotlin

import org.junit.jupiter.api.[1]

class CalculatorTest {
    @[1]
    fun cleanup() {
        // cleanup code here
    }
}

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

AAfterEach

BBeforeAll

CTest

DBeforeEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeEach instead of @AfterEach

Using @AfterAll which runs only once after all tests

The @AfterEach annotation runs the cleanup method after each test method.

3fill in blank

hard

Fix the error in the annotation to run code once before all tests in Kotlin.

Kotlin

import org.junit.jupiter.api.[1]

class CalculatorTest {
    companion object {
        @JvmStatic
        @[1]
        fun initAll() {
            // initialization code
        }
    }
}

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

ABeforeAll

BBeforeEach

CAfterEach

DTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeEach which runs before every test instead of once

Not using companion object and @JvmStatic for @BeforeAll

The @BeforeAll annotation runs the method once before all tests. It must be static in Kotlin, so it's inside companion object with @JvmStatic.

4fill in blank

hard

Fill both blanks to create a test class with setup and cleanup methods using JUnit 5 in Kotlin.

Kotlin

import org.junit.jupiter.api.[1]
import org.junit.jupiter.api.[2]

class SampleTest {
    @[1]
    fun setup() {
        // setup code
    }

    @[2]
    fun cleanup() {
        // cleanup code
    }
}

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

ABeforeEach

BTest

CAfterEach

DBeforeAll

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up @BeforeAll and @BeforeEach

Using @Test instead of lifecycle annotations

Use @BeforeEach for setup before each test and @AfterEach for cleanup after each test.

5fill in blank

hard

Fill all three blanks to define a test with setup, test method, and cleanup using JUnit 5 in Kotlin.

Kotlin

import org.junit.jupiter.api.[1]
import org.junit.jupiter.api.[2]
import org.junit.jupiter.api.[3]

class MathTest {
    @[1]
    fun setup() {
        // setup code
    }

    @[2]
    fun testAddition() {
        // test code
    }

    @[3]
    fun cleanup() {
        // cleanup code
    }
}

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

ABeforeEach

BTest

CAfterEach

DBeforeAll

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting @Test on the test method

Using @BeforeAll or @AfterAll instead of per-test lifecycle annotations

Use @BeforeEach for setup, @Test for the test method, and @AfterEach for cleanup.

Practice

1. What is the main purpose of test fixtures in Kotlin testing?

easy

A. To prepare and clean the test environment before and after tests

B. To write the actual test cases

C. To generate random test data automatically

D. To compile the Kotlin code before running tests

Solution

1. Step 1: Understand what test fixtures do

   Test fixtures set up the environment needed for tests and clean it afterward to avoid side effects.

2. Step 2: Identify the correct purpose

   Among the options, only preparing and cleaning the test environment matches the role of test fixtures.

3. Final Answer:

   To prepare and clean the test environment before and after tests -> Option A

4. Quick Check:

   Test fixtures = prepare and clean environment [OK]

Hint: Remember: fixtures setup and cleanup tests [OK]

Common Mistakes:

• Confusing fixtures with test case logic
• Thinking fixtures generate test data
• Assuming fixtures compile code

2. Which annotation in Kotlin testing runs a method once before all tests in a class?

easy

A. @AfterEach

B. @BeforeAll

C. @BeforeEach

D. @AfterAll

Solution

1. Step 1: Recall lifecycle annotations

   @BeforeAll runs once before all tests; @BeforeEach runs before each test.

2. Step 2: Match annotation to description

   The annotation that runs once before all tests is @BeforeAll.

3. Final Answer:

   @BeforeAll -> Option B

4. Quick Check:

   @BeforeAll = run once before all tests [OK]

Hint: BeforeAll runs once before all tests [OK]

Common Mistakes:

• Mixing @BeforeEach with @BeforeAll
• Confusing @AfterAll with @BeforeAll
• Using @AfterEach instead of @BeforeAll

3. Given the following Kotlin test class, what will be the output order of the print statements?

class SampleTest {
    @BeforeAll
    fun setupAll() = println("SetupAll")

    @BeforeEach
    fun setup() = println("Setup")

    @Test
    fun test1() = println("Test1")

    @Test
    fun test2() = println("Test2")

    @AfterEach
    fun tearDown() = println("TearDown")

    @AfterAll
    fun tearDownAll() = println("TearDownAll")
}

medium

A. Setup
Test1
Setup
Test2
TearDown
TearDownAll
SetupAll

B. Setup
Test1
TearDown
Setup
Test2
TearDown
SetupAll
TearDownAll

C. SetupAll
Setup
Test1
Test2
TearDown
TearDownAll

D. SetupAll
Setup
Test1
TearDown
Setup
Test2
TearDown
TearDownAll

Solution

1. Step 1: Understand lifecycle order

   @BeforeAll runs once before all tests, then for each test @BeforeEach, test, @AfterEach run, and finally @AfterAll runs once after all tests.

2. Step 2: Trace the print statements

   Output order: SetupAll (once), then for test1: Setup, Test1, TearDown; for test2: Setup, Test2, TearDown; finally TearDownAll.

3. Final Answer:

   SetupAll Setup Test1 TearDown Setup Test2 TearDown TearDownAll -> Option D

4. Quick Check:

   Lifecycle order = D [OK]

Hint: BeforeAll once, BeforeEach per test, AfterEach per test, AfterAll once [OK]

Common Mistakes:

• Assuming @BeforeEach runs once only
• Mixing order of AfterEach and AfterAll
• Forgetting @BeforeAll and @AfterAll run once

4. Identify the error in this Kotlin test fixture code snippet:

@BeforeAll
fun setup() {
    println("Setup")
}

@Test
fun testExample() {
    println("Test")
}

medium

A. @BeforeAll method must be static or inside a companion object

B. setup() should return a value

C. Missing @Test annotation on setup()

D. testExample() must be private

Solution

1. Step 1: Recall @BeforeAll requirements in Kotlin

   @BeforeAll methods must be static or placed inside a companion object to run once before all tests.

2. Step 2: Check the code snippet

   The setup() method is annotated with @BeforeAll but is not static nor inside a companion object, causing an error.

3. Final Answer:

   @BeforeAll method must be static or inside a companion object -> Option A

4. Quick Check:

   @BeforeAll requires static or companion object [OK]

Hint: @BeforeAll needs static or companion object [OK]

Common Mistakes:

• Thinking @BeforeAll can be a normal instance method
• Assuming test methods must be private
• Believing setup() needs a return value

5. You want to ensure a database connection is opened once before all tests and closed once after all tests in a Kotlin test class. Which is the best way to implement this using test fixtures?

hard

A. Use @BeforeEach to open and @AfterEach to close the connection

B. Open the connection in the constructor and close it in a test method

C. Use @BeforeAll inside a companion object to open and @AfterAll inside the companion object to close

D. Use @BeforeAll and @AfterAll as instance methods without companion object

Solution

1. Step 1: Understand lifecycle for shared resources

   Resources like database connections should open once before all tests and close once after all tests to save time and avoid repeated setup.

2. Step 2: Apply Kotlin @BeforeAll/@AfterAll rules

   In Kotlin, @BeforeAll and @AfterAll must be inside a companion object or be static to run once per class.

3. Step 3: Evaluate options

   Use @BeforeAll inside a companion object to open and @AfterAll inside the companion object to close correctly uses @BeforeAll and @AfterAll inside a companion object for one-time setup and teardown.

4. Final Answer:

   Use @BeforeAll inside a companion object to open and @AfterAll inside the companion object to close -> Option C

5. Quick Check:

   Shared setup/teardown = @BeforeAll/@AfterAll in companion object [OK]

Hint: Use companion object for @BeforeAll/@AfterAll in Kotlin [OK]

Common Mistakes:

• Using @BeforeEach/@AfterEach for expensive shared setup
• Placing @BeforeAll/@AfterAll outside companion object
• Opening connection in constructor instead of fixture