Testing in Kotlin

# CHAPTER 27

Testing in Kotlin #

1. Chapter Introduction #

2. Learning Objectives #

• Understand the purpose of Unit Testing.

• Understand Test-Driven Development (TDD).

• Use JUnit annotations (@Test).

• Write assertions (assertEquals, assertTrue).

• Structure a test using Arrange-Act-Assert.

3. What is Unit Testing? #

If the output matches, the test Passes (Green). If it doesn't match, the test Fails (Red).

4. The Arrange-Act-Assert Pattern #

1. 1. Arrange: Set up the test data (create variables, objects).

1. 2. Act: Call the actual function you want to test.

1. 3. Assert: Check if the result is exactly what you expected.

5. Writing a Simple Test (JUnit) #

class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
}

Now, we create a Test Class in our src/test/kotlin folder. We use the @Test annotation to tell JUnit that this is an executable test.

import org.junit.Assert.assertEquals
import org.junit.Test

class CalculatorTest {

    @Test
    fun testAdditionIsCorrect() {
        // 1. Arrange
        val calc = Calculator()
        val num1 = 5
        val num2 = 10
        
        // 2. Act
        val result = calc.add(num1, num2)
        
        // 3. Assert (Expected Value, Actual Value)
        assertEquals(15, result)
    }
}

When you run this test in IntelliJ, you will get a satisfying Green Checkmark! ✅

6. Common Assertions #

• assertEquals(expected, actual): Checks if two values are equal.

• assertNotEquals(unexpected, actual): Checks if they are different.

• assertTrue(condition): Checks if a boolean is true.

• assertFalse(condition): Checks if a boolean is false.

• assertNull(object): Checks if an object is null.

7. Edge Cases #

class CalculatorTest {

    @Test
    fun testAdditionWithNegatives() {
        val calc = Calculator()
        val result = calc.add(-5, -5)
        assertEquals(-10, result)
    }
}

8. Test-Driven Development (TDD) #

1. 1. Red: Write a test for a feature that doesn't exist yet. Run it. It fails.

1. 2. Green: Write the bare minimum Kotlin code to make the test pass.

1. 3. Refactor: Clean up the Kotlin code. The test ensures you didn't break anything!

9. Common Mistakes #

• Testing multiple things in one test: A test should focus on one specific behavior. If a test fails, you should immediately know why based on the test name. Instead of testCalculator(), write testAddition() and testDivisionByZero().

• Not running tests before committing: The purpose of tests is regression safety. Always run the entire test suite before pushing code to GitHub.

10. Best Practices #

• Descriptive Test Names: Use long, descriptive names for your test functions. Some Kotlin developers even use backticks to allow spaces in test names:

11. Exercises #

1. 1. We have a function fun isAdult(age: Int): Boolean = age >= 18.

1. 2. Write a JUnit test using @Test.

1. 3. Call isAdult(20).

1. 4. Use assertTrue() to verify the result.

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the Arrange, Act, Assert pattern in Unit Testing.

• Q: What is TDD, and what are its benefits? (Answer: TDD forces you to think about the requirements and API design before writing the logic. It also guarantees high test coverage from day one).

14. Summary #

15. Next Chapter Recommendation #