Mutation testing concept (PIT) in JUnit

Introduction

Mutation testing helps check if your tests are strong by making small changes in your code and seeing if tests catch them.

You want to find out if your tests really check important parts of your code.

You want to improve weak tests that miss bugs.

You want to measure how good your test coverage really is.

You want to catch hidden mistakes before releasing software.

Syntax

JUnit

No direct code syntax; mutation testing is done by running PIT tool on your project which modifies your code and runs tests automatically.

PIT (Pitest) is a popular mutation testing tool for Java and JUnit.

You configure PIT in your build tool (like Maven or Gradle) and run it to see mutation reports.

Examples

This Maven command runs PIT mutation testing on your Java project.

JUnit

mvn org.pitest:pitest-maven:mutationCoverage

This Gradle command runs PIT mutation testing if PIT plugin is configured.

JUnit

gradle pitest

Sample Program

This simple Calculator class has an add method. The test checks if adding 2 and 3 equals 5.

PIT will change the '+' to '-' in add method and run the test. If the test fails, it means the test caught the mutation, so the test is strong.

JUnit

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

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

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

Important Notes

Mutation testing can take longer than normal tests because it runs tests many times with small code changes.

Tests that do not fail on mutations are weak and should be improved.

Summary

Mutation testing checks how well your tests find bugs by changing code slightly.

PIT is a tool that automates mutation testing for Java projects using JUnit.

Strong tests fail when mutations are introduced, showing good 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