Unit testing with JUnit in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main purpose of unit testing?

Unit testing checks small parts of code, like functions or methods, to make sure they work correctly on their own.

beginner

In JUnit, what annotation marks a method as a test?

The @Test annotation tells JUnit that the method below it is a test method to run.

beginner

What does the assertion assertEquals(expected, actual) do in a JUnit test?

It checks if the actual result matches the expected result. If they are not equal, the test fails.

intermediate

Why should unit tests be independent from each other?

Tests should not depend on others so that one test failing does not cause others to fail. This keeps tests reliable and easy to fix.

beginner

How do you run JUnit tests in an Android Kotlin project?

You run JUnit tests using Android Studio's test runner or Gradle commands. Tests run on the JVM without needing an Android device.

Which annotation is used to mark a method as a test in JUnit?

A @Test

B @Run

C @Check

D @Verify

The @Test annotation marks a method as a test method in JUnit.

What does assertTrue(condition) check in a JUnit test?

A That the condition is false

B That an exception is thrown

C That two values are equal

D That the condition is true

assertTrue(condition) checks if the condition is true; if not, the test fails.

Why is it important for unit tests to be fast?

A So they can run often and give quick feedback

B Because slow tests are more accurate

C To use more CPU resources

D To make debugging harder

Fast tests allow developers to run them frequently and get quick feedback on code changes.

Which of these is NOT a good practice in unit testing?

A Testing one thing per test

B Relying on external services in tests

C Making tests independent

D Using clear test names

Unit tests should not rely on external services to avoid flakiness and keep tests fast.

In Android Kotlin projects, where are JUnit unit tests usually placed?

A src/androidTest/java

B src/main/java

C src/test/java

D src/resources

JUnit unit tests are placed in src/test/java to run on the JVM without an Android device.

Explain how to write a simple JUnit test method in Kotlin for a function that adds two numbers.

Think about the structure: annotation, method, call, assertion.

Describe why unit tests are important in Android app development and how JUnit helps.

Focus on benefits and JUnit features.

Practice

1. What is the main purpose of a unit test in Android Kotlin development using JUnit?

easy

A. To deploy the app to the Play Store

B. To test the entire application UI

C. To check if a small part of code works correctly

D. To measure app performance under load

Solution

1. Step 1: Understand unit test scope

   Unit tests focus on small, isolated parts of code, like functions or classes.

2. Step 2: Differentiate from other tests

   UI tests and performance tests cover broader areas, not unit tests.

3. Final Answer:

   To check if a small part of code works correctly -> Option C

4. Quick Check:

   Unit test = small code check [OK]

Hint: Unit tests check small code parts only [OK]

Common Mistakes:

• Confusing unit tests with UI or integration tests
• Thinking unit tests deploy or measure performance
• Assuming unit tests cover the whole app

2. Which annotation is used in Kotlin with JUnit to mark a function as a test?

easy

A. @Test

B. @Before

C. @RunWith

D. @Ignore

Solution

1. Step 1: Identify JUnit test annotation

   The @Test annotation marks a function as a test method in JUnit.

2. Step 2: Understand other annotations

   @Before runs setup code, @RunWith specifies runner, @Ignore skips tests.

3. Final Answer:

   @Test -> Option A

4. Quick Check:

   @Test marks test functions [OK]

Hint: Use @Test to mark test functions [OK]

Common Mistakes:

• Using @Before instead of @Test for tests
• Confusing @RunWith with test marking
• Mistaking @Ignore as test annotation

3. Given this Kotlin JUnit test code, what will be the test result?

import org.junit.Test
import kotlin.test.assertEquals

class CalculatorTest {
    @Test
    fun testAdd() {
        val result = 2 + 3
        assertEquals(5, result)
    }
}

medium

A. Test passes successfully

B. Test fails with assertion error

C. Compilation error due to missing import

D. Runtime exception occurs

Solution

1. Step 1: Analyze the test logic

   The test adds 2 + 3 and stores in result, which equals 5.

2. Step 2: Check assertion correctness

   assertEquals expects 5 and result is 5, so assertion passes.

3. Final Answer:

   Test passes successfully -> Option A

4. Quick Check:

   2 + 3 = 5 matches assertEquals [OK]

Hint: Check if expected equals actual in assertEquals [OK]

Common Mistakes:

• Assuming test fails when values match
• Thinking imports are missing when they are correct
• Confusing runtime errors with assertion failures

4. Identify the error in this Kotlin JUnit test code:

import org.junit.Test
import kotlin.test.assertEquals

class CalculatorTest {
    @Test
    fun testSubtract() {
        val result = 5 - 2
        assertEquals(4, result)
    }
}

medium

A. Function name should start with 'test_'

B. Missing @Test annotation

C. Incorrect import statement

D. Wrong expected value in assertEquals

Solution

1. Step 1: Calculate the actual result

   5 - 2 equals 3, but expected value is 4 in assertEquals.

2. Step 2: Check annotations and imports

   @Test annotation and imports are correct; function name style is not enforced.

3. Final Answer:

   Wrong expected value in assertEquals -> Option D

4. Quick Check:

   5 - 2 = 3, expected 4 causes failure [OK]

Hint: Verify expected matches actual in assertions [OK]

Common Mistakes:

• Ignoring mismatch between expected and actual values
• Thinking function names must start with 'test_'
• Assuming missing annotations when present

5. You want to test a Kotlin function that returns null for invalid input. Which assertion correctly checks this behavior in JUnit?

hard

A. assertEquals(null, functionResult)

B. assertNull(functionResult)

C. assertTrue(functionResult == null)

D. assertNotNull(functionResult)

Solution

1. Step 1: Understand null checking assertions

   assertNull explicitly checks if a value is null, making tests clear and readable.

2. Step 2: Compare other options

   assertEquals(null, ...) works but is less clear; assertTrue(...) works but less direct; assertNotNull is opposite.

3. Final Answer:

   assertNull(functionResult) -> Option B

4. Quick Check:

   Use assertNull to check null values [OK]

Hint: Use assertNull to check if value is null [OK]

Common Mistakes:

• Using assertNotNull when expecting null
• Using assertEquals(null, ...) instead of assertNull
• Using assertTrue with complex conditions unnecessarily