Maximiliano Cristiá

Implementing and Applying the Stocks-Carrington Framework for Model-Based Testing

In this paper we describe the functional features and the architecture of a tool implementing the Stocks-Carrington framework (TTF) for model based testing (MBT). The resulting prototype, called Fastest, makes it easy to generate test cases from Z specifications. We not only apply the ideas of the referred framework but we also use a technique based on finite models to find test cases, which has proved to increase the level of automation during the whole testing process. The paper also discusses problems and challenges that have appeared during the development of the tool, and introduces real case studies and an analysis of the results obtained so far.

Tool support for the Test Template Framework

This paper describes tool support that has been implemented for the Test Template Framework (TTF). The TTF is a model‐based testing (MBT) method that is especially well suited for unit testing from Z specifications. Although the TTF is a sound MBT method and it has been widely referenced since its first publication, attention in recent years has decayed. In fact, some have argued that generating abstract test cases following the TTF is a manual task requiring its users to perform complex predicate manipulations. This paper shows that these observations are dubious by describing Fastest, a tool that implements solutions for all these issues and, according to many experiments, produces abstract test cases for more than 80% of the satisfiable test specifications. Furthermore, it is claimed that Fastest fulfils the needs of the Z user community regarding MBT tools, which is supported with a range of case studies. Copyright

A language for test case refinement in the test template framework

Model-based testing (MBT) generates test cases by analysing a formal model of the system under test (SUT). In many MBT methods, these test cases are too abstract to be executed. Therefore, an executable representation of them is necessary to test the SUT. So far, the MBT community has focused on methods that automate the generation of test cases, but less has been done in making them executable. In this paper we propose a language to specify rules that can be automatically applied to produce an executable representation of test cases generated by the Test Template Framework (TTF), a MBT method for the Z notation.

Pruning Testing Trees in the Test Template Framework by Detecting Mathematical Contradictions

Fastest is an automatic implementation of Phil Stocks and David Carringtons Test Template Framework (TTF), a model-based testing (MBT) framework for the Z formal notation. In this paper we present a new feature of Fastest that helps TTF users to eliminate inconsistent test classes automatically. The method is very simple and practical, and makes use of the peculiarities of the TTF. Perhaps its most interesting features are extensibility and ease of use, since it does not assume previous knowledge on theorem proving. Also we compare the solution with a first attempt using the Z/EVES proof assistant and with the HOL-Z environment. At the end, we show the results of an empirical assessment based on applying Fastest to four real-world, industrial-strength case studies and to six toy examples.

On Comparing and Complementing two MBT approaches

At INPE1 researchers and software engineers have been using Statechart-based testing for some time to test on-board satellite software. On the other hand, a group of researchers at CIFASIS2 and Flowgate Consulting have been applying Z-based testing for unit testing. Both groups started to compare their approaches and tools a year ago. What started as a comparison to share ideas and results, is now turning into the realization that actually both techniques complement and benefit from each other, yielding a more effective and wider Model-Based Testing (MBT) approach. In this paper we present the results obtained so far in comparing and complementing these two MBT techniques.

A Family of Simulation Criteria to Guide DEVS Models Validation Rigorously, Systematically and Semi-Automatically

Abstract The most common method to validate a DEVS model against the requirements is to simulate it several times under different conditions, with some simulation tool. The behavior of the model is compared with what the system is supposed to do. The number of different scenarios to simulate is usually infinite, therefore, selecting them becomes a crucial task. This selection, actually, is made following the experience or intuition of an engineer. Here we present a family of criteria to conduct DEVS model simulations in a disciplined way and covering the most significant simulations to increase the confidence on the model. This is achieved by analyzing the mathematical representation of the DEVS model and, thus, part of the validation process can be automatized.

Applying SMT Solvers to the Test Template Framework

The Test Template Framework (TTF) is a model-based testing method for the Z notation. In the TTF,test cases are generated from test specifications, which are predicates written in Z. In turn, the Znotation is based on first-order logic with equality and Zermelo-Fraenkel set theory. In this way, atest case is a witness satisfying a formula in that theory. Satisfiability Modulo Theory (SMT) solversare software tools that decide the satisfiability of arbitrary formulas in a large number of built-inlogical theories and their combination. In this paper, we present the first results of applying twoSMT solvers, Yices and CVC3, as the engines to find test cases from TTF’s test specifications. Indoing so, shallow embeddings of a significant portion of the Z notation into the input languages ofYices and CVC3 are provided, given that they do not directly support Zermelo-Fraenkel set theoryas defined in Z. Finally, the results of applying these embeddings to a number of test specificationsof eight cases studies are analysed.

Extending the test template framework to deal with axiomatic descriptions, quantifiers and set comprehensions

The Test Template Framework (TTF) is a method for model-based testing (MBT) from Z specifications. Although the TTF covers many features of the Z notation, it does not explain how to deal with axiomatic descriptions, quantifiers and set comprehensions. In this paper we extend the TTF so it can process specifications including these features. The techniques presented here may be useful for other MBT methods for the Z notation or for other notations such as Alloy and B, since they use similar mathematical theories.

CML-DEVS: A specification language for DEVS conceptual models

Abstract DEVS models are widely used in the research community, in the industry and even in military or defense departments. Therefore, several software tools exist for modeling and simulating these models. However, each of these tools has its specific input language and a DEVS model described within a particular framework cannot be simulated by a different one. Moreover, the practitioners willing to use one of these tools must have non-trivial programming skills or must ask to a programmer to translate their models into the language of the desired tool. In this paper, we present CML-DEVS, a language that allows the conceptual, abstract or mathematical representation of DEVS models, in terms of mathematical and logical expressions without involving programming issues. Models described with CML-DEVS can be automatically translated (i.e. compiled) into the input language of different modeling and simulation tools. We also present a set of rules to translate CML-DEVS models into models that can be simulated with well-known DEVS frameworks such as DEVS-Suite and PowerDEVS. These rules allow the implementation of a multi-target compiler.

A Decision Procedure for Restricted Intensional Sets

In this paper we present a decision procedure for Restricted Intensional Sets (RIS), i.e. sets given by a property rather than by enumerating their elements, similar to set comprehensions available in specification languages such as B and Z. The proposed procedure is parametric with respect to a first-order language and theory \(\mathcal {X}\), providing at least equality and a decision procedure to check for satisfiability of \(\mathcal {X}\)-formulas. We show how this framework can be applied when \(\mathcal {X}\) is the theory of hereditarily finite sets as is supported by the language CLP(\(\mathcal {SET}\)). We also present a working implementation of RIS as part of the \(\{log\}\) tool and we show how it compares with a mainstream solver and how it helps in the automatic verification of code fragments.