Patent Issued for Runtime class recompilation during mutation testing (USPTO 11720483): State Farm Mutual Automobile Insurance Company

2023 AUG 29 (NewsRx) -- By a News Reporter-Staff News Editor at Insurance Daily News -- According to news reporting originating from Alexandria, Virginia, by NewsRx journalists, a patent by the inventors Pearson, Andrew L. (Normal, IL, US), Shepherd, Nate (Bloomington, IL, US), filed on December 21, 2021, was published online on August 8, 2023.

The assignee for this patent, patent number 11720483, is State Farm Mutual Automobile Insurance Company (Bloomington, Illinois, United States).

Reporters obtained the following quote from the background information supplied by the inventors: “A versatile feature of virtual machine programming languages, targeting runtime environments such as the Java® Virtual Machine (“JVM®”), is that they may support dynamic recompilation at runtime. After source code is compiled to object code, errors in the object code may be detected by various forms of static or dynamic unit testing, where static testing is performed outside of runtime while dynamic testing is performed during runtime.

“Dynamic testing may reveal errors in object code which are not revealed by static testing, since the execution of the object code will cause read and write accesses to particular memory addresses, read and write accesses of memory blocks, read and write accesses to particular files on non-volatile storage, and such events which only take place during runtime. Dynamic testing provides a basis for more sophisticated testing techniques, such as mutation testing, wherein the underlying source code is mutated at various positions. Existing test suites are run against the original object code and each version of the mutated object code. The quality of test suites against arbitrary changes in the object code is determined by whether tests fail, as expected, against these mutations. The more mutations are generated, the more effective the mutation testing may be in detecting test quality.

“Gosu® is an example of a JVM® programming language, targeting development environments such as enterprise software applications utilized in the property and casualty insurance industry. Languages such as Gosu® are specialized to generate a large number of Java® classes with minimal coding. Consequently, in such software development environments, test suites also require large numbers of unit tests to verify the expected behavior of the object code. Gosu® implements a version of the Framework for Integrated Tests (“FIT”), a testing tool for software development wherein tests may be created based on steps and expected outcomes, allowing thousands of tests to be created using a streamlined process.

“However, using FIT testing tools as implemented presently to support Gosu®, tests are run after compiling target object code in its entirety. This is incompatible with mutation testing techniques; since each individual mutation must be tested separately, each mutation would require a full re-compilation of all of the object code. Compounded by multiple mutations for each of thousands of unit tests in a suite, full-fledged mutation testing for a typical Gosu® application may take years in real time using current testing tools. Thus, there is a need to integrate the flexibility to perform mutation testing into development tools for programming languages such as Gosu® targeting a JVM® development environment.”

In addition to obtaining background information on this patent, NewsRx editors also obtained the inventors’ summary information for this patent: “Systems and methods discussed herein are directed to implementing a programming language compiler, and more specifically implementing a compiler operative to perform iterative, per-class compilation directed to individual mutations of target object code during runtime and mutation testing of the target object code.”

The claims supplied by the inventors are:

“1. A method, comprising: mutating, by a processor running a computing thread among a plurality of computing threads each executing target object code in a target runtime environment, part of a class file to generate a mutation in the class file, wherein the class file is one of a plurality of class files of target source code; writing, by the processor, the target source code including the class file containing the mutation to non-volatile storage before configuring a compiler to compile the class file containing the mutation; causing, by the processor, the compiler executing in the computing thread to compile the class file containing the mutation without compiling other class files of the plurality of class files of the target source code, wherein compiling the class file results in generation of a mutant class object code by the processor; and replacing, by the processor, a non-mutant object class code portion of a plurality of non-mutant object class code portions of the executing target object code with the mutant class object code.

“2. The method of claim 1, wherein mutating the part of the class file comprises mutating a line of code of the class file.

“3. The method of claim 1, wherein mutating the part of the class file is performed in accordance with one of a plurality of mutation patterns of a mutation configuration.

“4. The method of claim 1, wherein the part of the class file or a different class file of the target source code is being mutated concurrently, by the processor or by a different processor, in at least one other computing thread of the plurality of computing threads.

“5. The method of claim 1, wherein the compiler is configured by the processor executing a compiler script including a parameterized call to the compiler.

“6. The method of claim 1, further comprising executing, by the processor in the computing thread, pending unit tests among a test suite against the executing target object code after replacing the non-mutant object class code portion.

“7. A computing host comprising: one or more processors; and memory communicatively coupled to the one or more processors, the memory storing computer-executable modules executable by the one or more processors that, when executed by the one or more processors, perform associated operations, the computer-executable modules comprising: a compiler module; and a mutation test managing module further comprising: a class file mutating submodule configured to mutate, in a computing thread among a plurality of computing threads each executing target object code in a target runtime environment, part of a class file to generate a mutation in the class file, wherein the class file is one of a plurality of class files of target source code; a class file read/write submodule configured to write the target source code including the class file containing the mutation to non-volatile storage before a compiler configuring submodule configures the compiler module to compile the class file containing the mutation; the compiler configuring submodule configured to configure the compiler module executing in the computing thread to compile the class file containing the mutation without compiling other class files of the plurality of class files of the target source code, wherein compiling the class file results in generation of a mutant class object code by the compiler module; and a class loading submodule configured to replace a non-mutant object class code portion of a plurality of non-mutant object class code portions of the executing target object code with the mutant class object code.

“8. The computing host of claim 7, wherein the class file mutating submodule is configured to mutate the part of the class file by mutating a line of code of the class file.

“9. The computing host of claim 7, wherein the class file mutating submodule is configured to mutate the part of the class file in accordance with one of a plurality of mutation patterns of a mutation configuration.

“10. The computing host of claim 7, wherein the class file mutating submodule is configured to mutate the part of the class file or a different class file of the target source code concurrently among the plurality of computing threads.

“11. The computing host of claim 7, wherein the compiler configuring submodule is configured to configure the compiler module by executing a compiler script including a parameterized call to the compiler module.

“12. The computing host of claim 7, wherein the computer-executable submodules further comprise a test executing submodule configured to execute, in the computing thread, pending unit tests among a test suite against the executing target object code after the class loading submodule replaces the non-mutant object class code portion.

“13. A 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: mutating, in a computing thread among a plurality of computing threads each executing target object code in a target runtime environment, part of a class file to generate a mutation in the class file, wherein the class file is one of a plurality of class files of target source code; writing, by the processor, the target source code including the class file containing the mutation to non-volatile storage before configuring a compiler to compile the class file containing the mutation; configuring the compiler executing in the computing thread to compile the class file containing the mutation without compiling other class files of the plurality of class files of the target source code, wherein compiling the class file results in generation of a mutant class object code by the one or more processors; and replacing a non-mutant object class code portion of a plurality of non-mutant object class code portions of the executing target object code with the mutant class object code.

“14. The computer-readable storage medium of claim 13, wherein mutating the part of the class file comprises mutating a line of code of the class file.

“15. The computer-readable storage medium of claim 13, wherein mutating the part of the class file is performed in accordance with one of a plurality of mutation patterns of a mutation configuration.

“16. The computer-readable storage medium of claim 13, wherein the operations further comprise mutating the part of the class file or a different class file of the target source code concurrently in at least one other computing thread of the plurality of computing threads.

“17. The computer-readable storage medium of claim 13, wherein the operations further comprise executing, in the computing thread, pending unit tests among a test suite against the executing target object code after replacing the non-mutant object class code portion.”

For more information, see this patent: Pearson, Andrew L. Runtime class recompilation during mutation testing. U.S. Patent Number 11720483, filed December 21, 2021, and published online on August 8, 2023. Patent URL (for desktop use only): https://ppubs.uspto.gov/pubwebapp/external.html?q=(11720483)&db=USPAT&type=ids

(Our reports deliver fact-based news of research and discoveries from around the world.)