Automatic Transformation from SOFL Formal Specifications to Functional Scenario Forms for Verification and Validation

Abstract— Specification-based testing and inspection are two important techniques in the SOFL method for verifying programs, but both of them are established on the basis of the concept known as functional scenario form (FSF). In this paper, we describe how a SOFL formal specification can be automatically transformed into a FSF. The transformation is realized in four steps: lexical analysis of the formal specification, conversion from the specification to Reverse Polish Notation (RPN), transformation from RPN to Disjunctive Normal Form (DNF), and derivation of a FSF from the DNF. Our discussion focuses on the first three steps that have already been realized, but we will also discuss how an existing algorithm can be used for the conversion from the DNF to a FSF for verification and validation. We present the related algorithms and ilustrate them with examples. Finally, we evaluate our algorithms implemented in the tool by testing. Keywords— SOFL specification, Lexical Analyzer, RPN, DNF, FSF, verification and validatio

Making Specifications Executable--- Using IPTES Meta-IV

This article discusses the extra effort required to make specifications executable. With an origin in essential (but in general non-executable) specification techniques and specification language constructs the limitations of writing specifications in an executable language are discussed. The (executable) example specifications are written in IPTES Meta-IV which is a subset of BSI/VDM-SL.

On the execution of high level formal specifications

Executable specifications can serve as prototypes of the specified system and as oracles for automated testing of implementations, and so are more useful than non-executable specifications. Executable specifications can also be debugged in much the same way as programs, allowing errors to be detected and corrected at the specification level rather than in later stages of software development. However, existing executable specification languages often force the specifier to work at a low level of abstraction, which negates many of the advantages of non-executable specifications. This dissertation shows how to execute specifications written at a level of abstraction comparable to that found in specifications written in non-executable specification languages. The key innovation is an algorithm for evaluating and satisfying first order predicate logic assertions written over abstract model types. This is important because many specification languages use such assertions. Some of the features of this algorithm were inspired by techniques from constraint logic programming

The 14th Overture Workshop: Towards Analytical Tool Chains

This report contains the proceedings from the 14th Overture workshop organized in connection with the Formal Methods 2016 symposium. This includes nine papers describing different technological progress in relation to the Overture/VDM tool support and its connection with other tools such as Crescendo, Symphony, INTO-CPS, TASTE and ViennaTalk

Prototyping Z specifications in extended Lisp.

Much research has identified shortcomings in the Requirements Description to be the key factor in the failure of many software development projects; the development of formal specification techniques and notations allows the unambiguous statement of requirements, against which an implementation can generally be verified or even proved. While this approach will resolve many of the difficulties, it is impossible to formally confirm that such a specification is correct with respect to the intention of the customer; the abstraction that is characteristic of such languages can make the formal specification inaccessible without specialist skills. Z is one such, model-based, specification notation and this thesis reports on a CASE tool, the Z Animator in Lisp, that supports a process of specification validation through animation. A specification in the proprietary ZAL format, a high-level, largely functional, executable notation based on extended Lisp, can be executed by the Animation Engine within the ZAL animation environment. Using a graphical environment running under Microsoft Windows, schemas representing the operations upon the state are animated by populating their inputs, evaluating their predicates and reporting the outcomes to the user; these outcomes can be used to directly update the state, prior to further executions. The animator ensures the consistency of the on-going model state by the execution of the system invariant. The user can identify precisely which elements of the state should be displayed and can thereby focus on the particular areas of interest. This interaction is significantly more accessible to the customer and can be used to explore properties of the specification and thereby confirm, or not, that it exhibits the desired behaviour. This process validates the specification with respect to customer intention.Because the transformation into the proprietary ZAL language can be largely automated, using a companion CASE tool called TranZit, the process supports theiterative development of an improved specification, since at each stage the Z document reflects the system being animated