Abstract Mutation testing is the state‐of‐the‐art technique for assessing the fault detection capacity of a test suite. Unfortunately, a full mutation analysis is often prohibitively expensive. The CppCheck project for instance, demands a build time of 5.8 min and a test execution time of 17 s on our desktop computer. An unoptimised mutation analysis, for 55,000 generated mutants took 11.8 days in total, of which 4.3 days is spent on (re)compiling the project. In this paper, we present a feasibility study, investigating how a number of optimisation strategies can be implemented based on the Clang front‐end. These optimisation strategies allow to eliminate the compilation and execution overhead in order to support efficient mutation testing for the C language family. We provide a proof‐of‐concept tool that achieves a speedup of between 2 and 30 . We make a detailed analysis of the speedup induced by the optimisations, elaborate on the lessons learned and point out avenues for further improvements.

Detection of design pattern occurrences is part of several solutions to software engineering problems, and high accuracy of detection is important to help solve the actual problems. The improvement in accuracy of design pattern occurrence detection requires some way of evaluating various approaches. Currently, there are several different methods used in the community to evaluate accuracy. We show that these differences may greatly influence the accuracy results, which makes it nearly impossible to compare the quality of different techniques. We propose a benchmark suite to improve the situation and a community effort to contribute to, and evolve, the benchmark suite. Also, we propose fine-grained metrics assessing the accuracy of various approaches in the benchmark suite. This allows comparing the detection techniques and helps improve the accuracy of detecting design pattern occurrences.

Pattern detection in software systems is one of several collaborating techniques for reverse engineering and program comprehension. Unfortunately, it is a hard problem in both theory and practice. A recent method to increase efficiency is based on conservatively filtering edges of a software system's structure graph, i.e., only removing edges guaranteed not to be part of any pattern instance. This leads to planar graphs in many cases allowing for efficient matching algorithms. This paper shows the feasibility of a non-conservative filtering approach, where even edges possibly part of a pattern instance can be removed to reach planarity. We show theoretically that not only decreased accuracy is possible due to non-conservative filtering, but also increased accuracy. We also perform an experimental evaluation supporting this statement. The paper complements the safe filtering method and together the two approaches allow for efficient pattern detection for all systems and patterns.

Pattern detection is part of many solutions to software engineering problems. Unfortunately, it is a hard problem in itself in both theory and practice. Both exact and approximative approaches have been used earlier to increase efficiency. We propose a novel method to improve the performance of pattern detection, which is in many cases both exact and efficient. It is based on the idea of filtering information from the program representation (graphs), which is unnecessary for detecting a particular pattern. This makes the remaining program representation graph planar, in many cases, thus allowing for linear pattern detection. We evaluate our approach experimentally: we detect six design patterns in six software systems. Filtering leads to planar program representation graphs in 14 out of 36 cases. For most of the remaining graphs, filtering makes the graphs almost planar and gives a significant reduction of the graph size, which speeds up existing heuristics.