Formal Specification Based Software Testing: An Automated Approach
Rajesh Bhatia2003
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
Our work focuses on the use of formal techniques in order to increase the quality of HCI software and of all the processes resulting from the development, verification, design and validation activities. This paper shows how the B formal technique can be used for user tasks modelling and validation. A trace based semantics is used to describe either the HCI or the user tasks. Each task is modelled by a sequence of fired events. Each event is defined in the abstract specification and design of the HCI system.
Related papers
From the Formal Specifications of Users Tasks to the Automatic Generation of the HCI Specifications
… of HCI 2001 and IHM 2001, 2001
From the Formal Specifications of Users Tasks to the Automatic Generation of the HCI Specifications Adel Mahfoudhi^, Mourad Abed* & Dimitri Tabary* 'Department of Computer Science, Science Faculty ofSfax, Rte Soukra km 3.5, BP: 802-3018 Sfax, Tunisia Tel:+ 2164274390 Fax:+ ...
Using formal specifications to support testing
2009
Abstract Formal methods and testing are two important approaches that assist in the development of high-quality software. While traditionally these approaches have been seen as rivals, in recent years a new consensus has developed in which they are seen as complementary. This article reviews the state of the art regarding ways in which the presence of a formal specification can be used to assist testing.
Specification-based testing of interactive systems
Proceedings of the IFIP TC13 Interantional Conference …, 1997
Achieving correct user interface software is di cult because such software is complex, highly interactive, modeless, concurrent, graphical, and has user-based real-time requirements. In this paper I propose developing a framework for applying formal methods to testing of user interface software. I survey relevant work in the areas of formal development of user interface software and speci cation-based testing. I then outline a case study based research plan to extend an existing speci cation-based testing framework to incorporate multiparadigm user interface speci cations.
Requirement-based testing through formal methods
Testing is not enough to achieve a correct and bug free system; it is necessary to maintain a cohesive set of artifacts, such as use cases, design diagrams, code and test cases. If this elements are loosely coupled, it is very probable that the implementation will not attend the clients expectations. In this context, we provide a model-based DSL editor to assist the engineer in the requirement specification edition and transform it into a formal use model in the CSP notation. This use model is further combined with test directives, or test purposes, to generate test cases using the FDR refinement checker. In addition, a strategy to execute the generated test cases in the Eclipse test platform is proposed.
Software Testing Based on Formal Specification
Lecture Notes in Computer Science, 2010
This paper addresses the problem of constructing test data sets from formal specifications. Starting from a notion of an ideal exhaustive test data set, which is derived from the notion of satisfaction of the formal specification, we show how to select by refinements a practicable test set, i.e. computable, while not rejecting correct programs (unbiased) and accepting only correct programs (valid), when assuming certain hypotheses. The hypotheses play an important role; they formalise common test practices and they express the gap between the success of the test and correctness; the size of the test set depends on the strength of the hypotheses. The paper shows an application of this theory for algebraic specifications and presents the actual procedures used to mechanically product such test sets, using Horn clause logic. These procedures are embedded in an interactive system, which, given some general hypothesis schemes and an algebraic specification, produces a test set and the corresponding hypotheses.
Formal Verification and Validation of Interactive Systems Specifications
2004
This paper proposes a development process for interactive systems based both on verification and validation methods. Our approach is formal and use at first the B Method. We show in this paper how formal B specifications can be derived from informal requirements in the informal notation UAN. Then, these B specifications are validated using the data oriented specification language EXPRESS. Several scenarios can be tested against these EXPRESS specifications.
Formal Test Automation: A Simple Experiment
Testing of Communicating Systems, 1999
In this paper 1 we study the automation of test derivation and execution in the area of conformance testing. The test scenarios are derived from multiple specification languages: LOTOS, Promela and SDL. A central theme of this study is the usability of batch-oriented and on-the-fly testing approaches. To facilitate the derivation from multiple formal description techniques and the different test execution approaches, an open, generic environment called TorX is introduced. TorX enables plugging in existing or dedicated tools. We have carried out several experiments in testing a conference protocol, resulting in requirements on automated testing and benchmarking criteria.
Approach to specification-based testing systems
At the end of a software development process, there is a need for software verification. The aim of the software verification is to assess the software product to determine conformance to its specification. There are a few methods which can be used for doing this. However, the most popular method is software testing. For software testing to be done effectively, there is a need to select proper test cases such that all aspects of the software can be tested. In this paper we describe a technique for generating test cases automatically from the formal specification of the software. We also describe a testing system based on this technique.
Automatic Testing from Formal Specifications
Lecture Notes in Computer Science
In this article, we consider model oriented formal specification languages. We generate test cases by performing symbolic execution over a model, and from the test cases obtain a Java program. This Java program acts as a test driver and when it is run in conjunction with the implementation then testing is performed in an automatic manner. Our approach makes the testing cycle fully automatic. The main contribution of our work is that we perform automatic testing even when the models are non-deterministic.
Requirement-driven Scenario-based Testing Using Formal Stepwise Development
International Journal On Advances in Software, 2010
Abstract: This article presents a scenario-based testing approach, in which user-defined abstract testing scenarios of the SUT are automatically refined based on formal specifications of the system under test (SUT). The latter are specified in a stepwise manner using the Event-B formalism until a sufficiently refined specification is obtained, which is then used to generate a Java implementation template of the system. The development of the specification is driven by the requirements of the system which are traced throughout the ...
Related papers
Tool Support for Test-Driven Development Using Formal Specifications
This paper describes how Test-Driven Development (TDD) can be conducted using formal specifications with appropriate tool support. In TDD, the test code is a formal documentation of the required behaviour of the component or system that is being developed, but this documentation is necessarily incomplete and often over-specific. We propose an alternative approach to TDD that is to develop the specification of the required behaviour in a formal notation as a part of the TDD process and to generate test oracles from that specification. This approach has the advantage that the specifications can be complete and appropriately abstract but still support TDD.
A formal analysis of requirements-based testing
2009
Abstract The aim of requirements-based testing is to generate test cases from a set of requirements for a given system or piece of software. In this paper we propose a formal semantics for the generation of test cases from requirements by revising and extending the results presented in previous works (eg:[21, 20, 13]).
Specification-Based Testing of User Interfaces
Interactive Systems. Design, …, 2003
It is proposed an approach to integrate formal methods in the software development process, with an emphasis on the user interface development. The approach covers the specification by means of formal models, early model animation and validation, construction and conformity testing of the user interface implementation with respect to the specification. These conformity tests are described in detail through a state transition model with an abstraction function mapping concrete (implementation) to abstract (specification) states and operations. In order to illustrate the approach, it is presented a simple login/password dialog specification in VDM++, using a reusable control specification library, with a straightforward translation to Java or C#.
An automated testing environment for CTI systems using concepts for specification and verification of workflows
2000
In this paper we present an automated testing environment for the system level test of Computer Telephony Integrated applications. Its novelty consists of a coordinative test management layer that instantiates a general-purpose environment for the specification and verification of workflows in the testing domain. This results in a test environment that does not only control the individual test tools but the whole life-cycle of functional system-level tests, comprising test design, test generation, test execution, test evaluation and test reporting. Special attention is devoted to the simplification of the test cases design and the checking of admissibility criteria, interdependencies between the actions of test cases, and assumptions about the state of the system's resources. The key features of our testing environment, coarse grain, workflow-like test case representation and the validation and formal verification capabilities, are illustrated along a concrete industrial application.
A Formal Ontology for Describing Interactive Behaviors and Supporting Automated Testing on User Interfaces
International Journal of Semantic Computing, 2017
Nowadays many software development frameworks implement Behavior-Driven Development (BDD) as a mean of automating the test of interactive systems under construction. Automated testing helps to simulate user’s actions on the User Interface and therefore check if the system behaves properly and in accordance to scenarios that describe functional requirements. However, tools supporting BDD run tests on implemented User Interfaces and are a suitable alternative for assessing functional requirements in later phases of the development process. However, even when BDD tests can be written in early phases of the development process they can hardly be used with specifications of User Interfaces such as prototypes. To address this problem, this paper proposes to raise the abstraction level of both system interactive behaviors and User Interfaces by means of a formal ontology that is aimed at supporting test automation using BDD. The paper presents an ontology and an ontology-based approach for...
Using formal methods to support testing
Csur, 2009
Formal methods and testing are two important approaches that assist in the development of high quality software. While traditionally these approaches have been seen as rivals, in recent years a new consensus has developed in which they are seen as complementary. This article reviews the state of the art regarding ways in which the presence of a formal specification can be used to assist testing.
ACT (Abstract to Concrete Tests) - A tool for generating Concrete test cases from Formal Specification of Web Applications
2016
As web applications are becoming more and more ubiquitous, modeling and testing web applications correctly is becoming necessary. In this paper, we have used a formal specification language, State chart to model the navigation behaviour aspect of web applications. This paper presents the ACT (Abstract to Concrete Tests) tool, an approach of generating concrete executable Selenium RC JUnit test cases from a formal State chart specification model. The ACT tool can generate concrete Selenium RC JUnit test cases from abstract test cases by utilizing data shared across different interactions of the web application with the web server. Throughout the paper, a case study of Learning Management System is used to illustrate our approach.
Synergistic modelling of tasks, users and systems using formal specification techniques
Interacting With Computers, 1997
This paper aims at clarifying the articulation between the task models and system models encountered in CHI design practices. We demonstrate how the use of a formal task model may enhance the design of interactive systems, by providing quantitative results on which designers may base their decisions. We also demonstrate that it is possible to describe both task and system models within the same formal framework. This enables us firstly to formally prove that task and system models comply with each other, and secondly to perform quantitative analysis on the combination of task and system models. The approach is illustrated by a toy example which, despite its small size, allows us to develop both task and device models and to perform several iterations of the design process. The device and tasks are modelled using the Interactive Cooperative Objects (ICO) formalism, which is based on Petri nets and on the object-oriented approach. The formality of Petri nets allows for axiomatic validation of isolated and interacting subsystems.
A formal approach to testing programs in practice
2012 International Conference on Systems and Informatics (ICSAI2012), 2012
A program required to be tested in practice often has no available source code for some reason and how to adequately test such a program is still an open problem. In this paper, we describe a formal speci cation-based testing approach to tackle this challenge. The principal idea is rst to formalize the informal requirements into formal operation speci cations that take the interface scenarios of the program into account, and then utilize the speci cations for test case generation and test result analysis. An example and case study of applying the approach to an IC card system is presented to illustrate its usage and analyze its performance.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.