CCmutator: A mutation generator for concurrency constructs in multithreaded C/C++ applications

Kusano, Markus; Wang, Chao

doi:10.1109/ase.2013.6693142

Cited by 30 publications

(26 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The approach of traversing the AST has also been taken in other mutation systems for mainstream languages, like Major for Java [32], whereas Clang has been used in CCMutator [25] for multithreaded C/C++ programs and MILU [33] for the C programming language. The main benefit of analyzing the AST is the consistent search of potential locations, omitting higher-level details.…”

Section: Mutation Operator Implementationmentioning

confidence: 99%

“…In the case of mutation systems for C++ [1], state-of-the-art commercial software adopting mutation testing within their testing techniques, like Insure++ and PlexTest, do not cover mutations at the class level, but only some standard operations (e.g., the removal of expressions and subexpressions in PlexTest). As for open-source systems, CCMutator [25] is a mutation generator for concurrency constructs in C or C++ applications.…”

Section: Challenges To Address In C++mentioning

confidence: 99%

See 1 more Smart Citation

Assessment of class mutation operators for C++ with the MuCPP mutation system

Delgado‐Pérez

Medina‐Bulo

Palomo-Lozano

et al. 2017

Information and Software Technology

View full text Add to dashboard Cite

Context: Mutation testing has been mainly analyzed regarding traditional mutation operators involving structured programming constructs common in mainstream languages, but mutations at the class level have not been assessed to the same extent. This fact is noteworthy in the case of C++, despite being one of the most relevant languages including object-oriented features. Objective: This paper provides a complete evaluation of class operators for the C++ programming language. MuCPP, a new system devoted to the application of mutation testing to this language, was developed to this end. This mutation system implements class mutation operators in a robust way, dealing with the inherent complexity of the language. Method: MuCPP generates the mutants by traversing the abstract syntax tree of each translation unit with the Clang API, and stores mutants as branches in the Git version control system. The tool is able to detect duplicate mutants, avoid system headers, and drive the compilation process. Then, MuCPP is used to conduct experiments with several open-source C++ programs. Results: The improvement rules listed in this paper to reduce unproductive class mutants have a significant impact in the computational cost of the technique. We also calculate the quantity and distribution of mutants generated with class operators, which generate far fewer mutants than their traditional counterparts. Conclusions: We show that the tests accompanying these programs cannot detect faults related to particular object-oriented features of C++. In order to increase the mutation score, we create new test scenarios to kill the surviving class mutants for all the applications. The results confirm that, while traditional mutation operators are still needed, class operators can complement them and help testers further improve the test suite.

show abstract

Section: Mutation Operator Implementationmentioning

confidence: 99%

Section: Challenges To Address In C++mentioning

confidence: 99%

Assessment of class mutation operators for C++ with the MuCPP mutation system

Delgado‐Pérez

Medina‐Bulo

Palomo-Lozano

et al. 2017

Information and Software Technology

View full text Add to dashboard Cite

show abstract

“…Since our metrics implemented by LLVM's intermediate representation (IR) are based on single static assignment (SSA) form, we can potentially leverage compiler front-ends to handle other languages. We leverage CCMutator [55], a concurrency mutation tool, to generate mutants of concurrent programs.…”

Section: Methodsmentioning

confidence: 99%

“…To generate higher order mutants for concurrent programs, Kaiser et al [47] propose a set of mutation operators for multithreaded Java programs based on concurrency bug patterns that include subtle concurrency faults (e.g., data races). Kusano et al [55] implemented CCmutator based on the Clang/LLVM compiler framework to inject concurrency faults for multithreaded C/C++ applications. Their work considers both first-order and higherorder mutants.…”

Section: Mutation Analysismentioning

confidence: 99%

“…To seed sequential faults, we use Clang [56] to implement a mutation generation tool applying the mutation operators described in Figure 1. For concurrency mutants, we extended CCMUTATOR [55] to create concurrency mutants of the classes described in Section 2. This process left us with the numbers of mutants reported in Column 9 of Table 4.…”

Section: Data Collectionmentioning

confidence: 99%

See 1 more Smart Citation

ConPredictor: Concurrency Defect Prediction in Real-World Applications

Wen

Han

et al. 2019

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

Concurrent programs are difficult to test due to their inherent non-determinism. To address this problem, testing often requires the exploration of thread schedules of a program; this can be time-consuming when applied to real-world programs. Software defect prediction has been used to help developers find faults and prioritize their testing efforts. Prior studies have used machine learning to build such predicting models based on designed features that encode the characteristics of programs. However, research has focused on sequential programs; to date, no work has considered defect prediction for concurrent programs, with program characteristics distinguished from sequential programs. In this paper, we present ConPredictor, an approach to predict defects specific to concurrent programs by combining both static and dynamic program metrics. Specifically, we propose a set of novel static code metrics based on the unique properties of concurrent programs. We also leverage additional guidance from dynamic metrics constructed based on mutation analysis. Our evaluation on four large open source projects shows that ConPredictor improved both within-project defect prediction and cross-project defect prediction compared to traditional features.

show abstract

Change‐aware model checking for evolving concurrent programs based on Program Dependence Net

Li,

Chen,

Huang

et al. 2023

J Software Evolu Process

View full text Add to dashboard Cite

SummaryConcurrent software needs to be maintained over time, and the differences between continuous versions tend to be localized. The expense that simply reapplying standard model checking techniques to the new version as they evolve may be infeasible. The existing methods reuse partial state‐space to reduce the scope. However, it is obviously costly to analyze on the explosive interleaving space of the evolving concurrent programs. The conservative change‐impact analysis methods without considering the specific property and leveraging the verified result from the prior version often results in exploring redundant state‐space irrelevant to this property. Moreover, the impact of the deleted elements needs to be analyzed on old version, and their impact needs to be mapped to new version, bringing some dispensable costs. In this paper, we propose a change‐aware model checking method based on program dependence net (PDNet) for linear temporal logic (LTL). We first propose an incremental modeling method to construct a PDNet of new version by modification rules. Then, we propose a reuse checking algorithm to judge whether the verified result can be reused based on the PDNet slice. Finally, we implement change‐aware model checking tool (DAMER) and validate the advantages of our methods.

show abstract

CCmutator: A mutation generator for concurrency constructs in multithreaded C/C++ applications

Cited by 30 publications

References 17 publications

Assessment of class mutation operators for C++ with the MuCPP mutation system

Assessment of class mutation operators for C++ with the MuCPP mutation system

ConPredictor: Concurrency Defect Prediction in Real-World Applications

Change‐aware model checking for evolving concurrent programs based on Program Dependence Net

Contact Info

Product

Resources

About