With the increasing use of models for software development and the emergence of model-driven engineering, it has become important to build accurate and precise models that present certain characteristics. Model transformation testing is a domain that requires generating a large number of models that satisfy coverage properties (cover the code of the transformation or the structure of the metamodel). However, manually building a set of models to test a transformation is a tedious task and having an automatic technique to generate models from a metamodel would be very helpful. We investigate the synthesis of models based on plans. Each plan comprises of a sequence of model synthesis rules (or mutation operators) specified as graph grammar (GG) rules. These mutation operators are primitive GG rules , automatically obtained from any meta-model. Such plans can be evolved by various artificial intelligence techniques to generate useful models for different tasks including model transformation testing.

In current hardware design flow, functional verification is widely acknowledged as the crucial step. This paper presents a new contribution to reduce the cost of this step by automating it. We address here, one of the principal challenges of dynamic verification, by providing a new approach for automatic test generation. This approach combines mutation-based test techniques and genetic algorithms to produce stimuli for design under test. The feasibility of the proposed approach is assessed with a preliminary implementation, and some framework has been tested

The current version of Java (J2SE 5.0) provides a high level of support for concurreny in comparison to previous versions. For example, programmers using J2SE 5.0 can now achieve synchronization between concurrent threads using explicit locks, semaphores, barriers, latches, or exchangers. Furthermore, built-in concurrent data structures such as hash maps and queues, built-in thread pools, and atomic variables are all at the programmer's disposal. We are interested in using mutation analysis to evaluate, compare and improve quality assurance techniques for concurrent Java programs. Furthermore, we believe that the current set of method mutation operators and class operators proposed in the literature are insufficient to evaluate concurrent Java source code because the majority of operators do not directly mutate the portions of code responsible for synchronization. In this paper we will provide an overview of concurrency constructs in J2SE 5.0 and a new set of concurrent mutation operators. We will justify the operators by categorizing them with an existing bug pattern taxonomy for concurrency. Most of the bug patterns in the taxonomy have been used to classify real bugs in a benchmark of concurrent Java applications.

Current mutation analysis tools are primarily used to compare different test suites and are tied to a particular programming language. In this paper we present the ExMAn experimental mutation analysis framework - ExMAn is automated, general and flexible and allows for the comparison of different quality assurance techniques such as testing, model checking, and static analysis. The goal of ExMAn is to allow for automatic mutation analysis that can be reproduced by other researchers. After describing ExMAn, we present a scenario of using ExMAn to compare testing with static analysis of temporal logic properties. We also provide both the benefits and the current limitations of using our framework.

The empirical assessment of test techniques plays an important role in software testing research. One common practice is to seed faults in subject software, either manually or by using a program that generates all possible mutants based on a set of mutation operators. The latter allows the systematic, repeatable seeding of large numbers of faults, thus facilitating the statistical analysis of fault detection effectiveness of test suites; however, we do not know whether empirical results obtained this way lead to valid, representative conclusions. Focusing on four common control and data flow criteria (block, decision, C-use, and P-use), this paper investigates this important issue based on a middle size industrial program with a comprehensive pool of test cases and known faults. Based on the data available thus far, the results are very consistent across the investigated criteria as they show that the use of mutation operators is yielding trustworthy results: generated mutants can be used to predict the detection effectiveness of real faults. Applying such a mutation analysis, we then investigate the relative cost and effectiveness of the above-mentioned criteria by revisiting fundamental questions regarding the relationships between fault detection, test suite size, and control/data flow coverage. Although such questions have been partially investigated in previous studies, we can use a large number of mutants, which helps decrease the impact of random variation in our analysis and allows us to use a different analysis approach. Our results are then; compared with published studies, plausible reasons for the differences are provided, and the research leads us to suggest a way to tune the mutation analysis process to possible differences in fault detection probabilities in a specific environment.

Testing interfaces of an embedded system is important since the heterogeneous layers such as hardware, OS and application are tightly coupled. We propose the mutation operators in three respects, "When?', "Where?' and "How?' in order to inject a fault into RTOS program when testing interface between RTOS and application. Injecting a fault without affecting the RTOS in run-time environment is the core of proposed mutation operators. We apply the mutation operators to interface testing during the integration of RTOS and application in the industrial programmable logic controller.

Available soon...

Available soon...

This paper attempts to subsume the existing great variety of mutation operations to two basic operations, insertion and omission and their combinations. These basic operations are applied to different elements of graph-based models of increasing representation power. A case study applies the approach to these models for generating mutants of different features and compares the fault detection capacity of the mutants generated.

We present a candidate fault model for pointcuts in AspectJ programs. The fault model identifies faults that we believe are likely to occur when writing pointcuts in the AspectJ language. Categories of fault types are identified, and each individual fault type is described as categorized. We argue that a fault model that focuses on the unique constructs of the AspectJ language is needed for the systematic and effective testing of AspectJ programs. Our pointcut fault model is a first step towards such a model.