Runtime class recompilation during mutation testing

Patent metadata

Field	Value
Publication number	US-2026003771-A1
Application number	US-202519321756-A
Country	US
Kind code	A1
Filing date	Sep 8, 2025
Priority date	Apr 7, 2021
Publication date	Jan 1, 2026
Grant date	—

Abstract

In mutation testing, source code is mutated at various positions, and test suites are run against the original object code and each version of the mutated object code, to determine the quality of test suites against arbitrary changes in the object code. The present disclosure provides a mutation test manager configured to initialize multiple computing threads configuring a computing host to perform parallel computation; mutate class files within context of each computing thread; recompile mutated class files independently in each respective computing thread to generate heterogeneous mutants; and execute pending unit tests against heterogeneous mutants independently in each respective computing thread. Consequently, the mutation testing process is decoupled from computational bottlenecks which would result from linear, sequential generation, compilation, and testing of each mutation, especially in the context of JVM® programming languages configured to generate class-rich object code.

First claim

What is claimed is:

1 . A method, comprising:
executing, by a processor in a runtime environment, a first computing thread and a second computing thread, wherein each of the first computing thread and the second computing thread are executing target object code; determining, by the processor, mutant class object code compiled from a first class file containing a mutation, wherein the first class file is one of a plurality of class files of target source code; loading, by the processor, the mutant class object code into memory for the first computing thread; determining, by the processor, non-mutant class object code compiled from a second class file not containing the mutation, wherein the second class file is one of the plurality of class files of the target source code and corresponds to the first class file; loading, by the processor, the non-mutant class object code into memory for the second computing thread; executing, by the processor, a unit test against the target object code; determining, by the processor based at least in part on executing the unit test, test results; and storing, by the processor, the test results.

2 . The method of claim 1 , wherein the mutation comprises a mutated line of code of the first class file.

3 . The method of claim 1 , wherein the mutation is associated with one of a plurality of mutation patterns of a mutation configuration.

4 . The method of claim 1 , further comprising concurrently determining additional mutant class object code compiled from a third class file containing an additional mutation, wherein the third class file is one of a plurality of class files of target source code, and is distinct from the first class file and the second class file.

5 . The method of claim 4 , wherein the additional mutation is a heterogenous mutation that is distinct from the mutation.

6 . The method of claim 1 , wherein:
the non-mutant class object code is first non-mutant class object code, and loading the mutant class object code into memory for the first computing thread comprising replacing second non-mutant class object code loaded in memory for the first computing thread.

7 . The method of claim 1 , further comprising configuring, by the processor, a compiler to execute a test class tear down process before executing the unit test.

8 . A computing host, comprising:
one or more processors; and memory communicatively coupled to the one or more processors, the memory storing computer-executable instructions that, when executed by the one or more processors, perform operations comprising:
executing, in a runtime environment, a first computing thread and a second computing thread, wherein each of the first computing thread and the second computing thread are executing target object code;
determining mutant class object code compiled from a first class file containing a mutation, wherein the first class file is one of a plurality of class files of target source code;
loading the mutant class object code into memory for the first computing thread;
determining non-mutant class object code compiled from a second class file not containing the mutation, wherein the second class file is one of the plurality of class files of the target source code and corresponds to the first class file;
loading the non-mutant class object code into memory for the second computing thread;
executing a unit test against the target object code;
determining, based at least in part on executing the unit test, test results; and
storing the test results.

9 . The computing host of claim 8 , wherein
executing the unit test against the target object code comprises: executing, in parallel, the first computing thread and the second computing thread; and executing a first test of the unit test in the first computing thread concurrently with a second test of the unit test in the second computing thread.

10 . The computing host of claim 8 , wherein the operations further comprise, based at least in part on the test results, one or more of:
automatically generating a notification of the test results, or autonomously merging revisions of the target source code in a source code repository.

11 . The computing host of claim 8 , wherein the operations further comprise concurrently determining additional mutant class object code compiled from a third class file containing an additional mutation, wherein the third class file is one of a plurality of class files of target source code and distinct from the first class file and the second class file.

12 . The computing host of claim 11 , wherein the additional mutation is a heterogenous mutation that is distinct from the mutation.

13 . The computing host of claim 8 , wherein executing the unit test against the target object code comprises concurrently executing the unit test in the first computing thread and the second computing thread.

14 . The computing host of claim 8 , wherein the operations further compromise executing a compiler to execute a test class tear down process before executing the unit test.

15 . A non-transitory computer-readable storage medium storing computer-readable instructions executable by one or more processors, that when executed by the one or more processors, cause the one or more processors to perform operations comprising:
executing, in a runtime environment, a first computing thread and a second computing thread, wherein each of the first computing thread and the second computing thread are executing target object code; determining mutant class object code compiled from a first class file containing a mutation, wherein the first class file is one of a plurality of class files of target source code; loading the mutant class object code into memory for the first computing thread; determining non-mutant class object code compiled from a second class file not containing the mutation, wherein the second class file is one of the plurality of class files of the target source code and corresponds to the first class file; loading the non-mutant class object code into memory for the second computing thread; executing a unit test against the target object code; determining, based at least in part on executing the unit test, test results; and storing the test results.

16 . The non-transitory computer-readable storage medium of claim 15 , wherein mutation comprises a line of code of the first class file.

17 . The non-transitory computer-readable storage medium of claim 15 , wherein the mutation is associated with one of a plurality of mutation patterns of a mutation configuration.

18 . The non-transitory computer-readable storage medium of claim 15 , wherein
executing the unit test against the target object code comprises: executing, in parallel, the first computing thread and the second computing thread; and executing a first test of the unit test in the first computing thread concurrently with a second test of the unit test in the second computing thread.

19 . The non-transitory computer-readable storage medium of claim 15 , wherein:
the non-mutant class object code is first non-mutant class object code, and loading the mutant class object code into memory for the first computing thread comprising replacing second non-mutant class object code loaded in memory for the first computing thread.

20 . The non-transitory computer-readable storage medium of claim 15 , wherein the operations further comprise, based at least in part on the test results, one

Assignees

• State Farm Mutual Automobile Insurance Co

Inventors

• Pearson Andrew L
• Shepherd Nate

Classifications

• G06F8/447

  Target code generation · CPC title

• G06F8/315

  Object-oriented languages · CPC title

• G06F11/3692

  for test results analysis · CPC title

• G06F11/3688 Primary

  for test execution, e.g. scheduling of test suites · CPC title

• G06F8/41 Primary

  Compilation · CPC title