Test fixtures and lifecycle in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit 5 test lifecycle code?

Consider the following Kotlin test class using JUnit 5 lifecycle annotations. What will be printed when running all tests?

Kotlin

import org.junit.jupiter.api.*

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class LifecycleTest {

    init {
        println("Init block")
    }

    @BeforeAll
    fun beforeAll() {
        println("BeforeAll")
    }

    @BeforeEach
    fun beforeEach() {
        println("BeforeEach")
    }

    @Test
    fun testOne() {
        println("TestOne")
    }

    @Test
    fun testTwo() {
        println("TestTwo")
    }

    @AfterEach
    fun afterEach() {
        println("AfterEach")
    }

    @AfterAll
    fun afterAll() {
        println("AfterAll")
    }
}

A

BeforeAll
BeforeEach
TestOne
AfterEach
BeforeEach
TestTwo
AfterEach
AfterAll

B

Init block
BeforeAll
BeforeEach
TestOne
AfterEach
BeforeEach
TestTwo
AfterEach
AfterAll

C

Init block
BeforeEach
TestOne
AfterEach
BeforeEach
TestTwo
AfterEach

D

Init block
BeforeAll
BeforeEach
TestOne
BeforeEach
TestTwo
AfterEach
AfterAll

💡 Hint

Remember that with @TestInstance(TestInstance.Lifecycle.PER_CLASS), the test class is instantiated once, so the init block runs once.

The init block runs once when the class instance is created. @BeforeAll runs once before all tests. @BeforeEach and @AfterEach run before and after each test respectively. @AfterAll runs once after all tests.

❓ Predict Output

intermediate

What happens if @BeforeAll is not static in JUnit 5 without @TestInstance(PER_CLASS)?

Given this Kotlin test class without @TestInstance(TestInstance.Lifecycle.PER_CLASS), what will happen when running the tests?

Kotlin

import org.junit.jupiter.api.*

class StaticBeforeAllTest {

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

    @Test
    fun testA() {
        println("TestA")
    }
}

A

Tests run successfully and print:
Setup
TestA

B Tests run but 'setup' method is never called

C Runtime error: 'setup' method must be static or the test class must be annotated with @TestInstance(PER_CLASS)

D Compile error: Missing static modifier on 'setup' method

💡 Hint

In JUnit 5, @BeforeAll methods must be static unless the test class uses @TestInstance(PER_CLASS).

Without @TestInstance(PER_CLASS), JUnit 5 requires @BeforeAll methods to be static. Otherwise, it throws a runtime error.

🔧 Debug

advanced

Why does this @AfterEach method not run after tests?

Look at this Kotlin test class. The @AfterEach method is not running after tests. What is the reason?

Kotlin

import org.junit.jupiter.api.*

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class AfterEachIssue {

    @AfterEach
    fun tearDown() {
        println("TearDown")
    }

    @Test
    fun testOne() {
        println("TestOne")
    }

    @Test
    fun testTwo() {
        println("TestTwo")
    }

    fun afterEach() {
        println("This is not annotated")
    }
}

A The @AfterEach method 'tearDown' is correctly annotated and will run after each test

B The @AfterEach annotation is missing on the method that prints 'This is not annotated'

C The method named 'tearDown' is private by default and not accessible

D JUnit 5 requires @AfterEach methods to be static, so 'tearDown' is ignored

💡 Hint

Check which methods have the @AfterEach annotation and their visibility.

The method 'tearDown' is annotated with @AfterEach and will run after each test. The other method 'afterEach' is not annotated, so it won't run automatically.

❓ Predict Output

advanced

What is the output order with nested @Nested test classes and lifecycle methods?

Given this Kotlin test class with nested classes and lifecycle annotations, what is the output when running all tests?

Kotlin

import org.junit.jupiter.api.*

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class NestedLifecycleTest {

    @BeforeAll
    fun beforeAll() {
        println("Outer BeforeAll")
    }

    @BeforeEach
    fun beforeEach() {
        println("Outer BeforeEach")
    }

    @Test
    fun outerTest() {
        println("Outer Test")
    }

    @Nested
    inner class Inner {

        @BeforeAll
        fun innerBeforeAll() {
            println("Inner BeforeAll")
        }

        @BeforeEach
        fun innerBeforeEach() {
            println("Inner BeforeEach")
        }

        @Test
        fun innerTest() {
            println("Inner Test")
        }

        @AfterEach
        fun innerAfterEach() {
            println("Inner AfterEach")
        }

        @AfterAll
        fun innerAfterAll() {
            println("Inner AfterAll")
        }
    }

    @AfterEach
    fun afterEach() {
        println("Outer AfterEach")
    }

    @AfterAll
    fun afterAll() {
        println("Outer AfterAll")
    }
}

A

Outer BeforeAll
Outer BeforeEach
Outer Test
Outer AfterEach
Inner BeforeAll
Outer BeforeEach
Inner BeforeEach
Inner Test
Inner AfterEach
Outer AfterEach
Inner AfterAll
Outer AfterAll

B

Outer BeforeAll
Outer BeforeEach
Outer Test
Outer AfterEach
Outer BeforeEach
Inner BeforeEach
Inner Test
Inner AfterEach
Outer AfterEach
Outer AfterAll

C

Outer BeforeAll
Outer BeforeEach
Outer Test
Outer AfterEach
Inner BeforeAll
Inner BeforeEach
Inner Test
Inner AfterEach
Inner AfterAll
Outer AfterAll

D

Outer BeforeAll
Outer BeforeEach
Outer Test
Outer AfterEach
Inner BeforeEach
Inner Test
Inner AfterEach
Outer AfterEach
Outer AfterAll

💡 Hint

Remember that @BeforeAll and @AfterAll in nested classes run once per nested class instance.

The outer class @BeforeAll runs once first. Then the outer test runs with its @BeforeEach and @AfterEach. The nested class @BeforeAll runs once before its tests. Each nested test runs with both outer and inner @BeforeEach and @AfterEach. Finally, nested @AfterAll and outer @AfterAll run.

🧠 Conceptual

expert

How does @TestInstance(TestInstance.Lifecycle.PER_CLASS) affect test fixture lifecycle?

Which statement best describes the effect of annotating a Kotlin JUnit 5 test class with @TestInstance(TestInstance.Lifecycle.PER_CLASS)?

A JUnit requires all lifecycle methods to be static and disables instance methods for setup and teardown.

B JUnit creates a new instance of the test class for each test method, so instance variables are reset each time.

C JUnit runs all tests in parallel threads sharing the same test class instance without synchronization.

D JUnit creates a single instance of the test class for all test methods, allowing instance variables to be shared across tests.

💡 Hint

Think about how many times the test class is created and how that affects instance variables.

With @TestInstance(TestInstance.Lifecycle.PER_CLASS), JUnit creates one instance of the test class and reuses it for all tests. This allows instance variables to keep state between tests and allows non-static lifecycle methods like @BeforeAll.

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