20 research outputs found
Extracting Object Oriented Software Architecture from C++ Source Code
Software architecture strongly influences the ability to satisfy quality attributes
such as modifiability, performance, and security. It is important to be able to analyse
and extract information about that architecture. However, architectural documentation
frequently does not exist, and when it does, it is often out of sync with the implemented
system. In addition, it is not all that software development begins with a clean slate;
systems are almost always constrained by the existing legacy code. As a consequence,
there is a need to extract information from existing system implementations and reason
architecturally about this information.
This research presents a reverse engineering tool VOO++ that will read an Object-
Oriented C++ source code using UML notation in order to visualise its Class structure
and the various relationships that may exist including, inheritance, aggregation, and
dependency relationships based on the modified Cohen-Sutherland clipping algorithm. The idea of clipping is reversed, instead of clipping inside the rectangle, the clipping is
done out side the rectangle in terms of four directions (left, right, top, and bottom) and
two points represent the centre point for each rectangle.
An Object-Oriented approach is used to design and implement the tool. Reverse
engineering, design pattern, and graphics are the underlying techniques supplied.
VOO++ aids an analyst in extracting, manipulating and interpreting the Object-Oriented
static model information. By assisting in the reconstruction of static architectures from
extracted information, VOO++ helps an analyst to redocument and understand
architectures and discover the relationship between "as-implemented" and "asdesigned"
architectures
Assessment of C++ object-oriented mutation operators: A selective mutation approach
Mutation testing is an effective but costly testing technique. Several studies have observed that some mutants can be redundant and therefore removed without affecting its effectiveness. Similarly, some mutants may be more effective than others in guiding the tester on the creation of high‐quality test cases. On the basis of these findings, we present an assessment of C++ class mutation operators by classifying them into 2 rankings: the first ranking sorts the operators on the basis of their degree of redundancy and the second regarding the quality of the tests they help to design. Both rankings are used in a selective mutation study analysing the trade‐off between the reduction achieved and the effectiveness when using a subset of mutants. Experimental results consistently show that leveraging the operators at the top of the 2 rankings, which are different, lead to a significant reduction in the number of mutants with a minimum loss of effectiveness
Coverage-based quality metric of mutation operators for test suite improvement
The choice of mutation operators is a fundamental aspect in mutation testing to guide the tester to an effective test suite. Designing a set of mutation operators is subject to a trade-off between effectiveness and computational cost: a larger mutation population might uncover more faults, but will take longer to analyse. With the aim of resolving this trade-off, several authors have defined an assortment of metrics to determine the most valuable operators. In this work, we extend an existing quality metric by incorporating an additional source of data and coverage information and therefore investigate the extent to which mutants that are often covered but rarely killed can improve the evaluation of mutation operators for the refinement of the test suite. As a case study, we analyse C++ class-level operators based on the new coverage-based quality metric to assess whether the original metric is enhanced. The results when selecting the best-valued operators show that this metric has great potential to help the tester in finding effective mutation operators. In comparison with the metric from which it is derived, the use of coverage data allows to reduce the number of mutants but often loses fewer test cases and, in addition, retains those that seem hard to design
Assessment of Class Mutation Operators for C++ with the MuCPP Mutation System
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
On the efficiency of selective mutation for software testing
SIGLEAvailable from British Library Document Supply Centre-DSC:DXN027746 / BLDSC - British Library Document Supply CentreGBUnited Kingdo
Model-Based Higher-Order Mutation Analysis
International Conference on Advanced Software Engineering and Its Applications, ASEA 2010; Jeju Island; South Korea; 13 December 2010 through 15 December 2010Mutation analysis is widely used as an implementation-oriented method for software testing and test adequacy assessment. It is based on creating different versions of the software by seeding faults into its source code and constructing test cases to reveal these changes. However, in case that source code of software is not available, mutation analysis is not applicable. In such cases, the approach introduced in this paper suggests the alternative use of a model of the software under test. The objectives of this approach are (i) introduction of a new technique for first-order and higher-order mutation analysis using two basic mutation operators on graph-based models, (ii) comparison of the fault detection ability of first-order and higher-order mutants, and (iii) validity assessment of the coupling effect. © 2010 Springer-Verlag Berlin Heidelberg