11824549
An approach to detecting domain errors using formal specification-based testing
Domain testing, a technique for testing software or portions of software dominated by numerical processing, is intended to detect domain errors that usually arise from incorrect implementations of desired domains. This paper describes our recent work aiming to provide support for revealing domain errors using formal specifications. In our approach, formal specifications serve as a means for domain modeling. We describe a strong domain testing strategy that guide testers to select a set of test points so that the potential domain errors can be effectively detected, and apply our approach in two case studies for test cases generation.
36526611
Formal Engineering for Industrial Software Development - An Introduction to the SOFL Specification Language and Method
Formal methods have been developed as a rigorous approach to computer systems development over last three decades, but have been facing challenges in fighting for industrial acceptance in general. Most commonly used formal methods do not offer comprehensible structuring mechanism for building complex systems; formal refinement is not sufficient to deal with real development situations; and formal verification requires high skills and is time-intensive, and is therefore expensive to be adopted by industry.
14632854
An Approach to Integration Testing Based on Data Flow Specifications
Integration testing of programs based on formal specifications can benefit considerably from the comprehensibility of specifications. In this paper, we describe an approach to testing programs based on data-flow-oriented specifications by analyzing data flow paths and discussing criteria for test case generation. This approach suggests a specific way to generate test cases directly from formalized data flow diagrams and the associated textual specifications. We apply the approach in a case study of testing part of an ATM system to evaluate its effectiveness in fault detection and to uncover its weakness for further improvement.
14515232
An investigation of the approach to specification-based program review through case studies
Software review is an effective means to enhance the quality of software systems. However, traditional review methods emphasize the importance of the way to organize reviews and rely on the quality of the reviewers' experience and personal skills. In this paper we propose a new approach to rigorously reviewing programs based on their formal specifications. The fundamental idea of the approach is to use a formal specification as a standard to check whether all the required functions and properties in the specification are correctly implemented by its program. To help investigate the effectiveness and the weakness of the approach, we conduct two case studies of reviewing two program systems that implement the same formal specification of "A Research Management Policy" using different strategies, and present the evaluation of the case studies. The results show that the review approach is effective in detecting faults when the reviewer is different from the programmer, but less effective when the reviewer is the same as the programmer.
10225840
Generating test data from SOFL specifications
Abstract Software testing can only be formalized and quantified when a solid basis for test generation can be defined. Tests are commonly generated from the source code, control flow graphs, design representations, and specifications/requirements. Formal specifications represent a significant opportunity for testing because they precisely describe what functions the software is supposed to provide in a form that can be easily manipulated. This paper presents a new method for generating tests from formal specifications. This method is comprehensive in specification coverage, applies at several levels of abstraction, and can be highly automated. The paper applies the method to SOFL specifications, describes the technique, and demonstrates the application on a case study. A preliminary evaluation using a code-level coverage criterion (mutation testing), indicates that the method can result in very effective tests.
14954145
Interacting frameworks in Catalysis
In current OO design, most of the existing (semi-formal) methods use classes or objects as the basic unit of design. However it is increasingly recognised that classes are not the best focus for design. Typical design artefacts are about groups of objects and the way they interact In the Catalysis project, we use the term frameworks for descriptions of groups of objects, their relationships, division of responsibilities, and interactions. The power of frameworks lies in the fact that interactions can also occur at the level of frameworks. In a previous paper we defined a framework formally as a (first-order) many-sorted theory with a model theoretic semantics and showed how it can be represented using a pictorial notation for practical system development. However we considered only frameworks that do not interact with one another In this paper we discuss frameworks that interact with one another and show that such frameworks are very powerful tools for formal OO design.
8818712
A silicon retina with controllable winner-take-all properties
The winner-take-all (WTA) circuit is a useful computational circuit for signal processing and learning tasks. By adding spatial coupling between pixels, local regions of competition can be delineated. Recently, we described a normalising circuit which enhances Lazzaro's WTA circuit (1989) only with the addition of a transistor and a global bias to each pixel. This new circuit allows the network to transition between a soft-max and a WTA function through the global bias. The WTA network of Lazzaro together with spatial coupling forms the current-mode silicon retina of Boahen and Andreou (1992). This retina models the center surround processing performed in biological retinas to enhance responses to spatial contrasts. Here, we show how our normalising network together with spatial coupling performs as a silicon retina. Results are presented from a fabricated circuit in a 2 /spl mu/m CMOS process.
18693305
Verifying Consistency and Validity of Formal Specifications by Testing
Detecting faults in specifications can help reduce the cost and risk of software development because incorrect implementation can be prevented early. This goal can be achieved by verifying the consistency and validity of specifications. In this paper we put forward specification testing as a practical technique for verification and validation of formal specifications. Our approach is to derive proof obligations from a specification and then test them, in order to detect faults leading to the violation of consistency or validity of the specification. We describe proof obligations for various consistency properties of a specification, and suggest the use of five strategies for testing them. We provide a method for testing implicit specifications by evaluation rather than by prototyping, and criteria for interpreting the meaning of test results.
1399991
Validation of Distributed Real-Time and Embedded System composition in UniFrame
Distributed Real-Time and Embedded (DRE) Systems are widely applied to large scale and mission critical application domains such as avionics systems and medical imaging. Due to the rapid lifecycle and the complexity of design of the systems, there is an urgent demand to manage the development of robust, COTS, and effective software for vendors. The UniFrame project is a unified framework for seamless integration of distributed heterogeneous software components. This paper describes how the UniFrame approach is applicable to DRE software components. Leveraging the Two-Level Grammar (TLG) specification language and the Vienna Development Method (VDM), a formal methodology for developing DRE components and system code generation is developed for UniFrame.