Syntactic Abstraction of B Models to Generate Tests

In a model-based testing approach as well as for the verification of properties, B models provide an interesting solution. However, for industrial applications, the size of their state space often makes them hard to handle. To reduce the amount of states, an abstraction function can be used, often combining state variable elimination and domain abstractions of the remaining variables. This paper complements previous results, based on domain abstraction for test generation, by adding a preliminary syntactic abstraction phase, based on variable elimination. We define a syntactic transformation that suppresses some variables from a B event model, in addition to a method that chooses relevant variables according to a test purpose. We propose two methods to compute an abstraction A of an initial model M. The first one computes A as a simulation of M, and the second one computes A as a bisimulation of M. The abstraction process produces a finite state system. We apply this abstraction computation to a Model Based Testing process.Comment: Tests and Proofs 2010, Malaga : Spain (2010

Montana Kaimin, February 7, 1985

Student newspaper of the University of Montana, Missoula.https://scholarworks.umt.edu/studentnewspaper/8739/thumbnail.jp

The Amplifier - v. 17, no. 7

In this issue...Marcus Daly, Life Insurance, Butte Walk for Mankind, library Building, peace Corps, VISTA, Egg Drop, College Days, Student Council, Mountaineer Clubhttps://digitalcommons.mtech.edu/amplifier/1212/thumbnail.jp

Teaching Model-Based Testing with {L}eirios {T}est {G}enerator

International audienceThis paper proposes a technique to encourage the interest of students in learning formal methods. Our course is focused on the B method, involving basic knowledge of set theory, invariance proofs, refinement techniques and so on. While lectures and tutorials cover a large range of such concepts, the practical work is focused on applying the principles of a model-based approach in the context of test generation. This paper explains the pratical outcome of the course, through the Leirios Test Generator tool, that gives an interesting and playful use of the B method, by simulating the execution of the model through animation, and by generating tests –based on the B model– that can be run on an implementation. In order to make sure that students will be interested in applying these techniques, we challenge them to play a game consisting in detecting mutants of a program with their model-based tests. The feedback from the students is very positive here, and suggests that formal methods are more likely to be understood if their interest is shown through a concrete application

Project for the analysis of technology transfer Quarterly report, 13 Jul. - 12 Oct. 1968

Statistical characteristics of transfer data bank users, and outline of technology transfer and utilization instruction cours

B Model Slicing and Predicate Abstraction to Generate Tests

Accepted manuscript. Revised and extended version of a TAP'10 paper. To appear.International audienceIn a model-based testing approach as well as for the verification of properties, B models provide an interesting modeling solution. However, for industrial applications, the size of their state space often makes them hard to handle. To reduce the amount of states, an abstraction function can be used. The abstraction is often a domain abstraction of the state variables that requires many proof obligations to be discharged, which can be very time-consuming for real applications. This paper presents a contribution to this problem that complements an approach based on domain abstraction for test generation, by adding a preliminary syntactic abstraction phase, based on variable elimination. We define a syntactic transformation that suppresses some variables from a B event model, in addition to three methods that choose relevant variables according to a test purpose. In this way, we propose a method that computes an abstraction of a source model {\mathsf{M}} according to a set of selected relevant variables. Depending on the method used, the abstraction can be computed as a simulation or as a bisimulation of {\mathsf{M}}. With this approach, the abstraction process produces a finite state system. We apply this abstraction computation to a model-based testing process. We evaluate experimentally the impact of the model simplification by variables' elimination on the size of the models, on the number of proof obligations to discharge, on the precision of the abstraction and on the coverage achieved by the test generation

A feasibility Study: The Succinct Solver v2.0, XSB Prolog v2.6, and Flow-Logic Based Program Analysis for Carmel

Number: SECSAFE-IMM-008-1.0 Classification: Internal Abstract. We perform a direct comparison of the Succinct Solver v2.0 and XSB Prolog v2.6 based on experiments with Control Flow Analyses of scalable Discretionary Ambient programs and Carmel programs. To facilitate this comparison we expand ALFP clauses accepted by the Succinct Solver into more general Normal clauses accepted by both solvers and run the experiments for all three possible combinations of input and solver. This allows the solvers to be tested on even ground and enables the reuse of existing analyses and their corresponding ALFP constraint generators. The performance of the Succinct Solver is at worst a small constant factor worse than XSB Prolog. In optimum cases the Succinct Solver outperforms XSB Prolog by having

Test Generation Based on Abstraction and Test Purposes to Complement Structural Tests

International audienceThis paper presents a computer aided model-based test generation method. We propose this approach as a complement to the LTG (Leirios Test Generator) method, which extracts functional tests out of a formal behavioral model M by means of static (or structural) selection criteria. Our method computes additional tests by applying dynamic (or behavioral) selection criteria (test purposes called TP). Applying TP directly to M is usually not possible for industrial applications due to the huge (possibly infinite) size of their state space. We compute an abstraction A of M by predicate abstraction. We propose a method to define a set of abstraction predicates from information of TP. We generate symbolic tests from A by using TP as a dynamic selection criterion. Then we instantiate them on M, which allows us play the tests on the implementation the same way as we play the functional ones. Our experimental results show that our tests are complementary to the structural ones

The Zircon, November 14, 2013 [Spoof Issue]

Note: Issue incorrectly lists the date as 2012 instead of 2013.https://digitalcollections.dordt.edu/dordt_diamond/1004/thumbnail.jp

Verification of class liveness properties with Java modeling language

International audienceStatic checking is key for the security of software components. As a component model, this paper considers a Java class enriched with annotations from the Java Modeling Language (JML). It defines a formal execution semantics for repetitive method invocations from this annotated class, called the class in isolation semantics. Afterwards, a pattern of liveness properties is defined, together with its formal semantics, providing a foundation for both static and runtime checking. This pattern is then inscribed in a complete language of temporal properties, called JTPL (Java Temporal Pattern Language), extending JML. We particularly address the verification of liveness properties by auto- matically translating the temporal properties into JML annotations for this class. This automatic translation is implemented in a tool called JAG (JML Annotation Generator). Correctness of the generated annotations ensures that the temporal property is established for the executions of the class in isolation