16 research outputs found
Effortless Fault Localisation:Conformance Testing of Real-Time Systems in Ecdar
Model checking of real-time systems has evolved throughout the years.
Recently, the model checker Ecdar, using timed I/O automata, was used to
perform compositional verification. However, in order to fully integrate model
checking of real-time systems into industrial development, we need a productive
and reliable way to test if such a system conforms to its corresponding model.
Hence, we present an extension of Ecdar that integrates conformance testing
into a new IDE that now features modelling, verification, and testing. The new
tool uses model-based mutation testing, requiring only the model and the system
under test, to locate faults and to prove the absence of certain types of
faults. It supports testing using either real-time or simulated time. It
parallelises test-case generation and test execution to provide a significant
speed-up. We also introduce new mutation operators that improve the ability to
detect and locate faults. Finally, we conduct a case study with 140 faulty
systems, where Ecdar detects all faults.Comment: In Proceedings GandALF 2018, arXiv:1809.0241
Bounded Determinization of Timed Automata with Silent Transitions
Deterministic timed automata are strictly less expressive than their
non-deterministic counterparts, which are again less expressive than those with
silent transitions. As a consequence, timed automata are in general
non-determinizable. This is unfortunate since deterministic automata play a
major role in model-based testing, observability and implementability. However,
by bounding the length of the traces in the automaton, effective
determinization becomes possible. We propose a novel procedure for bounded
determinization of timed automata. The procedure unfolds the automata to
bounded trees, removes all silent transitions and determinizes via disjunction
of guards. The proposed algorithms are optimized to the bounded setting and
thus are more efficient and can handle a larger class of timed automata than
the general algorithms. The approach is implemented in a prototype tool and
evaluated on several examples. To our best knowledge, this is the first
implementation of this type of procedure for timed automata.Comment: 25 page
MUPPAAL:Reducing and Removing Equivalent and Duplicate Mutants in UPPAAL
peer reviewedMutation Testing (MT) is a test quality assessment technique that creates mutants by injecting artificial faults into the system and evaluating the ability of tests to distinguish these mutants. We focus on MT for safety-critical Timed Automata (TA). MT is prone to equivalent and duplicate mutants, the former having the same behaviour as the original system and the latter other mutants. Such mutants bring no value and induce useless test case executions. We propose MUPPAAL, a tool that: (1) offers a new operator reducing the occurrence of mutant duplicates; (2) an efficient bisimulation algorithm removing remaining duplicates; (3) leverages existing equivalence-avoiding mutation operators. Our experiments on four UPPAAL case studies indicate that duplicates represent up to 32% of all mutants and that the MUPPAAL bisimulation algorithm can identify them more than 99% of the time
System Testing of Timing Requirements based on Use Cases and Timed Automata
In the context of use-case centric development and requirements-driven testing, this paper addresses the problem of automatically deriving system test cases to verify timing requirements. Inspired by engineering practice in an automotive software development context, we rely on an analyzable form of use case specifications and augment such functional descriptions with timed automata, capturing timing requirements, following a methodology aiming at minimizing modeling overhead. We automate the generation of executable test cases using a test strategy based on maximizing test suite diversity and building over the UPPAAL model checker. Initial empirical results based on an industrial case study provide evidence of the effectiveness of the approach
Performance mutation testing
Performance bugs are known to be a major threat to the success of software products. Performance tests aim to detect performance bugs by executing the program through test cases and checking whether it exhibits a noticeable performance degradation. The principles of mutation testing, a well-established testing technique for the assessment of test suites through the injection of artificial faults, could be exploited to evaluate and improve the detection power of performance tests. However, the application of mutation testing to assess performance tests, henceforth called performance mutation testing (PMT), is a novel research topic with numerous open challenges. In previous papers, we identified some key challenges related to PMT. In this work, we go a step further and explore the feasibility of applying PMT at the source-code level in general-purpose languages. To do so, we revisit concepts associated with classical mutation testing, and design seven novel mutation operators to model known bug-inducing patterns. As a proof of concept, we applied traditional mutation operators as well as performance mutation operators to open-source C++ programs. The results reveal the potential of the new performance-mutants to help assess and enhance performance tests when compared to traditional mutants. A review of live mutants in these programs suggests that they can induce the design of special test inputs. In addition to these promising results, our work brings a whole new set of challenges related to PMT, which will hopefully serve as a starting point for new contributions in the area
Performance mutation testing
Performance bugs are known to be a major threat to the success of software products. Performance tests aim
to detect performance bugs by executing the program through test cases and checking whether it exhibits a
noticeable performance degradation. The principles of mutation testing, a well-established testing technique
for the assessment of test suites through the injection of artificial faults, could be exploited to evaluate and
improve the detection power of performance tests. However, the application of mutation testing to assess
performance tests, henceforth called performance mutation testing (PMT), is a novel research topic with
numerous open challenges. In previous papers, we identified some key challenges related to PMT. In this
work, we go a step further and explore the feasibility of applying PMT at the source-code level in general purpose languages. To do so, we revisit concepts associated with classical mutation testing, and design
seven novel mutation operators to model known bug-inducing patterns. As a proof of concept, we applied
traditional mutation operators as well as performance mutation operators to open-source C++ programs. The
results reveal the potential of the new performance-mutants to help assess and enhance performance tests
when compared to traditional mutants. A review of live mutants in these programs suggests that they can
induce the design of special test inputs. In addition to these promising results, our work brings a whole new
set of challenges related to PMT, which will hopefully serve as a starting point for new contributions in the
areaMinisterio de Economía y Competitividad TIN2015-65845-C3-3-RMinisterio de Economía y Competitividad RTI2018- 093608-B-C33Ministerio de Economía y Competitividad BELI (TIN2015-70560-R)Ministerio de Economía y Competitividad (HORATIO) RTI2018-101204-B-C2