Mutation testing concept (PIT) in JUnit - Test Execution Trace

Test Overview

This test runs a simple JUnit test on a Calculator class to verify addition. Mutation testing with PIT will modify the code to check if the test detects errors, ensuring test quality.

Test Code - JUnit 5

JUnit

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
}

public class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calc = new Calculator();
        assertEquals(5, calc.add(2, 3));
    }
}

Execution Trace - 9 Steps

Step	Action	System State	Assertion	Result
1	Test starts	JUnit test runner initialized	—	PASS
2	CalculatorTest.testAdd() method invoked	Calculator instance created	—	PASS
3	calc.add(2, 3) called, returns 5	Method returns sum of 2 and 3	—	PASS
4	assertEquals checks if returned value equals 5	Expected=5, Actual=5	assertEquals(5, 5)	PASS
5	Test completes successfully	Test passed	—	PASS
6	PIT mutation testing runs, changes '+' to '-' in add method	Calculator.add method mutated to return a - b	—	PASS
7	Mutated testAdd() runs, calc.add(2, 3) returns -1	Method returns 2 - 3 = -1	—	FAIL
8	assertEquals checks if returned value equals 5	Expected=5, Actual=-1	assertEquals(5, -1)	FAIL
9	Mutation detected by test failure	Test failed due to mutation	—	PASS

Failure Scenario

Failing Condition: Test does not fail when mutation changes '+' to '-'

Execution Trace Quiz - 3 Questions

What does the original test verify?

A That subtracting 2 and 3 returns -1

B That adding 2 and 3 returns 5

C That multiplication works correctly

D That the Calculator class exists

Key Result

Mutation testing helps check if your tests can catch small code changes that introduce errors, improving test quality.

Practice

1. What is the main purpose of mutation testing using PIT in JUnit projects?

easy

A. To check if tests can detect small changes (mutations) in the code

B. To improve the performance of the application

C. To generate new test cases automatically

D. To refactor the code for better readability

Solution

1. Step 1: Understand mutation testing concept

   Mutation testing changes code slightly to see if tests catch the changes.

2. Step 2: Identify PIT's role in JUnit projects

   PIT automates mutation testing to check test effectiveness.

3. Final Answer:

   To check if tests can detect small changes (mutations) in the code -> Option A

4. Quick Check:

   Mutation testing = detect code changes [OK]

Hint: Mutation testing checks test strength by code changes [OK]

Common Mistakes:

• Thinking mutation testing improves app speed
• Confusing mutation testing with test generation
• Assuming mutation testing refactors code

2. Which of the following is the correct way to run PIT mutation testing with Maven in a JUnit project?

easy

A. mvn test:pitest

B. mvn pitest:mutationCoverage

C. mvn mutation:test

D. mvn pit:run

Solution

1. Step 1: Recall PIT Maven command

   The standard Maven command to run PIT is mvn pitest:mutationCoverage.

2. Step 2: Check other options for correctness

   Other options are invalid or do not match PIT's official command syntax.

3. Final Answer:

   mvn pitest:mutationCoverage -> Option B

4. Quick Check:

   PIT Maven command = mvn pitest:mutationCoverage [OK]

Hint: PIT Maven command always starts with 'mvn pitest:' [OK]

Common Mistakes:

• Using incorrect Maven goals like test:pitest
• Confusing PIT commands with other plugins
• Missing the 'mutationCoverage' goal

3. Given the following code snippet and its test, what will PIT report if the test does NOT fail after mutation?

public int add(int a, int b) { return a + b; }

Mutation changes '+' to '-'. The test asserts add(2,3) == 5.

medium

A. Mutation killed (test failed)

B. Syntax error in mutation

C. Mutation survived (test passed)

D. Test skipped due to mutation

Solution

1. Step 1: Understand mutation effect

   The '+' operator is changed to '-', so add(2,3) returns -1 instead of 5.

2. Step 2: Analyze test result

   If the test still passes, it means it did not detect the mutation, so mutation survived.

3. Final Answer:

   Mutation survived (test passed) -> Option C

4. Quick Check:

   Mutation survived = test missed bug [OK]

Hint: If test passes despite mutation, mutation survived [OK]

Common Mistakes:

• Assuming mutation killed when test passes
• Confusing mutation survival with syntax errors
• Thinking mutation causes test to skip

4. You run PIT on a JUnit project but notice no mutations are detected. Which of the following is the MOST likely cause?

medium

A. Tests are missing or not executed during mutation testing

B. PIT does not support JUnit tests

C. Mutation testing always reports zero mutations

D. Code has no executable statements

Solution

1. Step 1: Consider PIT and JUnit compatibility

   PIT supports JUnit tests, so PIT does not support JUnit tests is incorrect.

2. Step 2: Analyze why no mutations detected

   If tests are missing or not run, PIT cannot detect mutations, causing zero mutations reported.

3. Final Answer:

   Tests are missing or not executed during mutation testing -> Option A

4. Quick Check:

   No tests run = no mutations detected [OK]

Hint: No tests run means no mutation detection [OK]

Common Mistakes:

• Believing PIT doesn't support JUnit
• Thinking mutation testing always reports mutations
• Assuming code has no executable statements

5. In a JUnit project using PIT, you notice that mutation coverage is low even though your tests pass. What is the BEST way to improve mutation coverage?

hard

A. Ignore mutation coverage and focus on code coverage

B. Increase the number of mutations PIT generates

C. Disable mutation testing for complex classes

D. Add more tests that fail when code is mutated

Solution

1. Step 1: Understand mutation coverage meaning

   Low mutation coverage means tests do not fail when code is changed (mutated).

2. Step 2: Identify how to improve mutation coverage

   Adding tests that detect mutations (fail on changes) improves mutation coverage.

3. Final Answer:

   Add more tests that fail when code is mutated -> Option D

4. Quick Check:

   Better tests = higher mutation coverage [OK]

Hint: Stronger tests catch mutations, raising coverage [OK]

Common Mistakes:

• Trying to increase mutations instead of test quality
• Disabling mutation testing to hide low coverage
• Ignoring mutation coverage in favor of code coverage only