Bird
Raised Fist0
Kotlinprogramming~5 mins

Test fixtures and lifecycle in Kotlin

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Introduction

Test fixtures help set up the environment before tests run and clean up after. This makes tests reliable and easy to manage.

When you need to prepare data or objects before running tests.
When you want to reset or clean resources after tests finish.
When multiple tests share the same setup steps.
When you want to avoid repeating setup code in every test.
When you want to ensure tests do not affect each other.
Syntax
Kotlin
import org.junit.jupiter.api.*

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

    @BeforeAll
    fun setupAll() {
        // Runs once before all tests
    }

    @BeforeEach
    fun setup() {
        // Runs before each test
    }

    @Test
    fun testExample() {
        // Test code here
    }

    @AfterEach
    fun tearDown() {
        // Runs after each test
    }

    @AfterAll
    fun tearDownAll() {
        // Runs once after all tests
    }
}

@BeforeAll and @AfterAll methods run once for the whole test class.

@BeforeEach and @AfterEach run before and after every single test method.

Examples
This example shows setup and cleanup running before and after each test.
Kotlin
import org.junit.jupiter.api.*

class SimpleTest {

    @BeforeEach
    fun prepare() {
        println("Setup before each test")
    }

    @Test
    fun testOne() {
        println("Running test one")
    }

    @Test
    fun testTwo() {
        println("Running test two")
    }

    @AfterEach
    fun cleanup() {
        println("Cleanup after each test")
    }
}
This example shows setup and cleanup running once for the whole test class.
Kotlin
import org.junit.jupiter.api.*

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

    @BeforeAll
    fun initAll() {
        println("Setup once before all tests")
    }

    @AfterAll
    fun cleanupAll() {
        println("Cleanup once after all tests")
    }

    @Test
    fun testA() {
        println("Test A running")
    }

    @Test
    fun testB() {
        println("Test B running")
    }
}
Sample Program

This program shows a simple Calculator test class. It creates a Calculator before each test and clears it after. It prints messages to show the test lifecycle.

Kotlin
import org.junit.jupiter.api.*

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

    private var calculator: Calculator? = null

    @BeforeAll
    fun setupAll() {
        println("Starting Calculator tests")
    }

    @BeforeEach
    fun setup() {
        calculator = Calculator()
        println("Calculator created")
    }

    @Test
    fun testAdd() {
        val result = calculator?.add(2, 3)
        println("Add result: $result")
        Assertions.assertEquals(5, result)
    }

    @AfterEach
    fun tearDown() {
        calculator = null
        println("Calculator cleared")
    }

    @AfterAll
    fun tearDownAll() {
        println("Finished Calculator tests")
    }
}

class Calculator {
    fun add(a: Int, b: Int): Int = a + b
}
OutputSuccess
Important Notes

Use @BeforeAll and @AfterAll for expensive setup or cleanup done once.

Use @BeforeEach and @AfterEach to prepare fresh state for every test.

Remember to annotate the test class with @TestInstance(TestInstance.Lifecycle.PER_CLASS) if you want non-static @BeforeAll and @AfterAll methods.

Summary

Test fixtures prepare and clean the test environment.

@BeforeAll/@AfterAll run once per class; @BeforeEach/@AfterEach run per test.

They help keep tests independent and easy to maintain.

Practice

(1/5)
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
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard