Mutation testing concept (PIT) in JUnit - Framework Patterns

Framework Mode - Mutation testing concept (PIT)

Folder Structure for Mutation Testing with PIT and JUnit

project-root/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/example/app/
│   │           └── Calculator.java
│   └── test/
│       └── java/
│           └── com/example/app/
│               └── CalculatorTest.java
├── pom.xml  (or build.gradle)
├── pitest.properties
└── reports/
    └── pit-reports/
  

Test Framework Layers for Mutation Testing with PIT

• Production Code Layer: Contains the application code to be tested (e.g., Calculator.java).
• Test Layer: JUnit test classes that verify the production code behavior (e.g., CalculatorTest.java).
• Mutation Testing Layer: PIT tool integrates with the build to mutate production code and run tests to check if mutations are caught.
• Configuration Layer: PIT configuration files or build tool settings to specify mutation settings, target classes, and reports.
• Reporting Layer: Generates mutation testing reports showing killed and survived mutants.

Configuration Patterns for PIT Mutation Testing

Use pitest.properties or build tool plugins (Maven/Gradle) to configure:

• Target Classes: Specify which classes PIT should mutate (e.g., com.example.app.*).
• Test Classes: Specify test classes to run against mutants.
• Mutation Operators: Choose mutation types (e.g., negate conditionals, replace math operators).
• Timeouts and Threads: Control test execution time and parallelism.
• Report Directory: Define where mutation reports are saved.

Example Maven plugin snippet in pom.xml:

<plugin>
  <groupId>org.pitest</groupId>
  <artifactId>pitest-maven</artifactId>
  <version>1.9.11</version>
  <configuration>
    <targetClasses>
      <param>com.example.app.*</param>
    </targetClasses>
    <targetTests>
      <param>com.example.app.*Test</param>
    </targetTests>
    <mutationOperators>
      <param>DEFAULTS</param>
    </mutationOperators>
    <outputFormats>
      <param>HTML</param>
    </outputFormats>
  </configuration>
</plugin>
  

Test Reporting and CI/CD Integration

PIT generates detailed HTML reports showing:

• Killed Mutants: Mutations detected by tests (good).
• Survived Mutants: Mutations not detected (need better tests).
• Mutation Coverage: Percentage of mutants killed.

Reports are saved in reports/pit-reports/ folder.

Integrate PIT in CI/CD pipelines (Jenkins, GitHub Actions) by running mutation tests as part of build. Fail build if mutation coverage is below threshold.

Best Practices for Mutation Testing Framework with PIT

• Keep Tests Fast: Mutation testing runs many tests; optimize test speed.
• Use Clear Configuration: Explicitly define target classes and tests to avoid unnecessary mutations.
• Analyze Survived Mutants: Use reports to improve test cases where mutants survive.
• Integrate with CI/CD: Automate mutation testing to maintain high test quality over time.
• Run Mutation Testing Periodically: Because it is resource-intensive, run mutation tests nightly or on demand.

Self-Check Question

Where in this folder structure would you add a new JUnit test class to improve mutation coverage for the Calculator class?

Key Result

Mutation testing with PIT uses JUnit tests to check if small code changes (mutations) are caught, improving test quality.