# Faster Mutation Analysis via Equivalence Modulo States

## TL;DR

This paper introduces AccMut, a novel mutation analysis method that detects equivalence modulo states among mutations to reduce redundant executions, significantly accelerating the process.

## Contribution

AccMut automatically identifies equivalence modulo states among mutations, grouping them to minimize redundant executions and improve mutation analysis efficiency.

## Key findings

- Achieves an average speedup of 2.56x over existing methods.
- Effectively reduces the number of split processes needed during mutation analysis.
- Builds upon split-stream execution to further enhance scalability.

## Abstract

Mutation analysis has many applications, such as asserting the quality of test suites and localizing faults. One important bottleneck of mutation analysis is scalability. The latest work explores the possibility of reducing the redundant execution via split-stream execution. However, split-stream execution is only able to remove redundant execution before the first mutated statement. In this paper we try to also reduce some of the redundant execution after the execution of the first mutated statement. We observe that, although many mutated statements are not equivalent, the execution result of those mutated statements may still be equivalent to the result of the original statement. In other words, the statements are equivalent modulo the current state. In this paper we propose a fast mutation analysis approach, AccMut. AccMut automatically detects the equivalence modulo states among a statement and its mutations, then groups the statements into equivalence classes modulo states, and uses only one process to represent each class. In this way, we can significantly reduce the number of split processes. Our experiments show that our approach can further accelerate mutation analysis on top of split-stream execution with a speedup of 2.56x on average.