Extended Finite State Machine Research Articles

Test case generation of a communication protocol by an adaptive state exploration

State exploration, which is widely used for generation of executable test cases for conformance test of a protocol, often causes state explosion problem. This paper proposes an adaptive state exploration method to overcome the problem for a single module protocol. Since state explosion arises in relation to the predicate, it tries to find out efficiently predicated transitions with priority by emulating the normal and erroneous communication environments closely related to the predicates. A test case generation method using the method is also proposed, which uses an Subdivided Extended Finite State Machine (SEFSM) as a protocol model to reduce semantic loss by modeling and adjusted UIO sequences for the protocol model. The empirical results of the proposed methods show their efficacy.

Test cases selection from SDL specifications

Selecting appropriate test cases is a crucial activity in software testing. In this paper, we give an overview and discuss existing methods and tools for test case selection for communication protocols. More precisely, we are interested in techniques for test case generation from specification and description language (SDL) specifications and its underlying behavioral model, extended finite state machines (EFSM) and its variants.

A test case generation approach for conformance testing of SDL systems

This paper presents an approach for automatic executable test case and test sequence generation for a protocol modeled by an SDL system. Our methodology uses a unified method which tests an Extended Finite State Machine (EFSM) based system by using control and data flow techniques. To test an SDL system, it extracts an EFSM from each process then the system is tested by incrementally computing a partial product for each EFSM C, taking into account only transitions which influence (or are influenced by) C, and generating test cases for it. This process ends when the coverage achieved by the generated test cases is satisfactory or when the partial products for all EFSMs are tested. Experimental results show that this method can be applied to systems of practical size.

Testing a system specified using Statecharts and Z

A hybrid specification language μSZ, in which the dynamic behaviour of a system is described using Statecharts and the data and the data transformations are described using Z, has been developed for the specification of embedded systems. This paper describes an approach to testing from a deterministic sequential specification written in μSZ. By considering the Z specifications of the operations, the extended finite state machine (EFSM) defined by the Statechart can be rewritten to produce an EFSM that has a number of properties that simplify test generation. Test generation algorithms are introduced and applied to an example. While this paper considers μSZ specifications, the approaches described might be applied whenever the specification is an EFSM whose states and transitions are specified using a language similar to Z.

Test generation based on control and data dependencies within system specifications in SDL

In Specification and Description Language (SDL), a distributed system is viewed as a collection of communicating processes and its behavior is specified in terms of definitions of these processes. In particular, the desired control and data dependencies that must be established by a potential implementation of the system are expressed in SDL in terms of Extended Finite State Machine representations of communicating processes. To test the control and data flow aspects of the system, such dependencies in a system specification must be identified and utilized for the construction of tests. Based on a model which exposes the control and data dependencies within a specification of a distributed system given in SDL, this paper investigates the generation of tests for the data flow aspects of a system implementation, through the application of data flow oriented test selection criteria which have been originally proposed for testing programs written in procedural languages.

Automatic test case derivation for communication protocols in an extended FSM model

This paper considers the extended finite-state machine model (EFSM/Pres), which has several registers to retain integer values, in addition to the controller of the finite-state machine. A new method is proposed for automatically generating the test sequence for the conformance test, called the E-UIO sequence, from the formal specification of the communication protocol written by that model. In EFSM/Pres, the data type to be handled is restricted to the integer type. The condition for each transition is described by a logical expression composed of addition/subtraction and comparison of integers. For this class, the input/output sequence composed of the UIO sequence and its precedence sequence is considered. By inputting adequate values to the input variables of the sequence, if the input/output sequences are executable regardless of the register values at the start state of the precedence sequence, that input/output sequence is called an E-UIO sequence. The existence of the state to be recognized is verified by using the E-UIO sequence. If the given UIO sequence is executable, an E-UIO sequence containing the definite input values is always generated automatically. A method to generate automatically a test sequence that verifies the validity of the transition is also proposed. As an example, the proposed method is applied to the OSI session protocol. © 1999 Scripta Technica, Electron Comm Jpn Pt 1, 82(10): 50–60, 1999

Interactive Temporal Behaviours and Modelling for Multimedia Presentations in the WWW Environment

Due to the widespread distribution and the nature of hyperlinks on the WWW system, interactive temporal behaviours that exist in the WWW environment are different from those used in traditionally distributed multimedia presentation environments. Therefore, the control scheme and model of a new temporal synchronization that can guarantee the presentation continuity within the multimedia WWW environment is required. In this paper we will: (i) classify interactive temporal behaviours that are associated with user interactions, i.e. 'replay', 'freeze-restart', 'skipg (ii) identify the link control with some temporal constraints; (iii) derive temporal interactive synchronization control schemes to resolve the permitted interactive temporal behaviours and the system's link behaviour; and (iv) propose the extended finite state machine (EFSM) approach that is able to formally model the corresponding interactive temporal and link control architecture and schemes.

Test cases generation from UML state diagrams

The paper discusses the application of state diagrams in UML to class testing. A set of coverage criteria is proposed based on control and data flow in UML state diagrams and it is shown how to generate test cases satisfying these criteria from UML state diagrams. First, control flow is identified by transforming UML state diagrams into extended finite state machines (EFSMs). The hierarchical and concurrent structure of states is flattened and broadcast communications are eliminated in the resulting EFSMs. Second, data flow is identified by transforming EFSMs into flow graphs to which conventional data flow analysis techniques can be applied.

UIO E: a protocol test sequence generation method using the transition executability analysis (TEA)

This paper presents a new test sequence generation method for protocols that are specified in the Extended Finite State Machine (EFSM) model. The new method is called UIO E , which represents executable Unique Input/Output (UIO) sequences for EFSMs. Since EFSM-specified transitions may contain predicates in the condition parts, and may contain conditional statements, e.g., if-then-else statements, in the action parts, the executabilities of input events and output events become complex. Additionally, shorter UIOs, which are generated without considering the predicate issue, may not be the shorter executable UIOs. In EFSM-specified protocols, the switching sequence and the transition under testing can decide the executability of a state's UIO. Thus, we propose a Transition Executability Analysis (TEA) to analyze executable transition sequences based on the initial state's context variables configuration. Consequently, each state's UIO E can be selected depending on the tail state's context variables configuration of the transition under testing.

Multimedia synchronization with user interactions using interactive extended finite state machines (IEFSMS)

One of the main and required characteristics of multimedia systems is the user‐interaction service. The user‐interaction service is an essential requirement in some applications, e.g., Video‐On‐Demand (VOD) and News‐On‐Demand (NOD). The user‐interaction service provides flexible multimedia presentations with user interactions. That is, users are allowed to have on‐line adjustment of the presentation flow, e.g., skip some (boring) media units or reverse the presentation direction, to have some special features. In this paper, we propose an Interactive Extended Finite State Machine (IEFSM) model to specify synchronization issues in multimedia presentations with user interactions. By incorporating interrupt transitions and dynamic transitions in the IEFSM model, dynamic behaviors resulting from user interactions can be modeled using some IEFSMs. Using the IEFSM model, intra‐medium synchronization is handled by an Actor, which is formally represented as an IEFSM; inter‐media synchronization is handled by a Synchronizer, which is also formally represented as an IEFSM. The communication between IEFSMs is message‐passing through some First‐In‐First‐Out (FIFO) queues. In this way, the dynamic behaviors of user interactions, including reverse, skip, freeze‐restart, and scale can be represented in IEFSM‐based multimedia synchronization specifications.

EFSM-based continuous media synchronization in multicast networks

As the demands for multicast multimedia applications, e.g., multiparty video conference, increase rapidly, it is urgently required to provide a feasible multicast communication environment and the corresponding multimedia presentation control schemes. In this paper, we propose a Multipoint Multimedia Service Network ( M 3 SN) to achieve multicast multimedia presentations. A M 3 SN consists of a lot of LANs and a WAN. Each LAN is serviced by a multimedia server. The concept of ‘virtual server’ is adopted in M 3 SN. The physical server, which stores media sources that are requested by a group of clients locating in different LANs L i , i = 1… k, multicasts media units to servers of L i . Since servers of L i , i = 1… k, play the role of media relays, i.e., receiving media units from the physical server and then multicasting received media units to the clients that are in L i and request the same media resources, servers of L i are called ‘virtual servers’. Some jitter may occur when media units traverse across the WAN. A virtual server adopts some synchronization control schemes to smooth the occurred jitter. In this way, the clients that are located at the same LAN do not need to deal with the occurred jitter individually. We apply Extended Finite State Machines (EFSM) to formally specify multimedia synchronization in M 3 SN. Based on the EFSM model, intra-medium synchronization is handled by an Actor EFSM; inter-media synchronization is handled by a Synchronizer EFSM. Synchronizer and Actors cooperatively achieve smooth multicast multimedia presentations in M 3 SN.

Distributed multimedia synchronization specifications using M 2EST

In order to properly schedule related multimedia objects, synchronization relationships of multimedia objects should be precisely specified and dispatched. Each multimedia presentation schedule contains two parts: (1) the state-transition control part, which specifies intra-medium and inter-media synchronization information, and (2) the data variables part, which specifies the dynamic aspects of the state-transition control for dealing with jitter and skew. In this paper, we propose a specification language for specifying multimedia synchronization. The language is called M 2EST, which represents the MultiMedia Extended State Transition. M 2EST can handle both the state-transition control part and the data variables part in multimedia presentation scheduling. Using M 2EST, the temporal behavior of each medium stream is handled by an actor extended finite state machine (EFSM). The temporal relationships among media streams are handled by a synchronizer EFSM. Synchronizer and actors perform multimedia presentations cooperatively. The corresponding synchronization schemes, including both intra-stream and inter-stream synchronization schemes, which rectify the random networks delays caused on distributed presentation environment, can also be specified using M 2EST.

An EFSM-based multimedia synchronization model and the authoring system

Multimedia synchronization is one of the key issues to be resolved in order to have smooth multimedia presentations. The demand of bringing multimedia information systems into distributed environments makes multimedia synchronization more difficult. We apply extended finite state machines (EFSM) to formally specify multimedia synchronization among multiple media streams. Using the EFSM model, the intra-medium synchronization is handled by an actor, which is formally represented as an EFSM. The inter-media synchronization is handled by a synchronizer, which is also represented as an EFSM. Both centralized and distributed synchronization cases can be specified. The synchronizer and actors achieve the corresponding multimedia presentations cooperatively. We also propose some policies to rectify the random delays caused by networks in the distributed presentation case. These policies, which can be formally specified in the corresponding EFSMs, are classified as intra-stream and inter-stream synchronization policies. Using the EFSM-based model, an authoring system and an associated experimental execution environment has been developed on SUN SPARC workstations.

Automatic generation of functional vectors using the extended finite state machine model

We present a method of automatic generation of functional vectors for sequential circuits. These vectors can be used for design verification, manufacturing testing, or power estimation. A high-level description of the circuit in VHDL or C is assumed available. Our method automatically transforms the high-level description of a circuit in VHDL or C into an extended finite state machine (EFSM) model that is used to generate functional vectors. The EFSM model is a generalization of the traditional state machine model. It is a compact representation of models with local data variables and preserves many nice properties of a traditional state machine model. The theoretical background of the EFSM model is addressed in this article. Our method guarantees that the generated vectors cover every statement in the high-level description at least once. Experimental results show that a set of comprehensive functional vectors for sequential circuits with more than a hundred flip-flops can be generated automatically in a few minutes of CPU time using our prototype system.

Analysis and representation of test cases generated from LOTOS

This paper presents a method to generate, analyse and represent test cases from protocol specification. The language of temporal ordering specification (LOTOS) is mapped into an extended finite state machine (EFSM). Test cases are generated from EFSM. The generated test cases are modelled as a dependence graph. Predicate slices are used to identify infeasible test cases that must be eliminated. Redundant assignments and predicates in all the feasible test cases are removed by reducing the test case dependence graph. The reduced test case dependence graph is adapted for a local single-layer (LS) architecture. The reduced test cases for the LS architecture are enhanced to represent the tester's behaviour. The dynamic behaviour of the test cases is represented in the form of control graphs by inverting the events, assigning verdicts to the events in the enhanced dependence graph.

Rapid prototyping of protocols from LOTOS specifications

AbstractA new tool for generating implementation prototypes of communication protocols and concurrent systems specified using the ISO LOTOS language is presented in this paper. A brief introduction to LOTOS and a discussion of the main problems related to the efficient execution of specifications written in LOTOS are presented first. The design and implementation of the tool are then considered: LOTOS specifications are analysed and translated into C functions which are executed by co‐operating processes in the Unix environment. The set of LOTOS process definitions is first translated into a suitable number of extended finite‐state machines (EFSMs). The method proposed allows the problem of deriving unbounded EFSMs to be circumvented and a sort of control on the process number/size trade‐off to be obtained at the same time.The problem of implementing the LOTOS multi‐way rendezvous mechanism for process synchronization is solved by using an algorithm based on message‐passing techniques. An example of prototype derivation is also described, showing the form of C code generated by translating a simple specification. Finally, some performance figures are presented.

Estelle-based test generation tool

A test design tool for functional analysis and test derivation of protocols formally specified using an extended finitestate machine model is presented. The formal description language supported is Estelle. The tool's main components include a compiler, a normalizer, a multiple module transition tour generator and several interactive programs. The tool is based on a static analysis of Estelle called normalization, which is explained in detail with various examples. The normalized specification facilitates graphical displays of the control and data flow in the specification by the interactive tools. Next discussed is test generation, which is based on verifying the control and data flow. First the data flow graph must be decomposed into blocks where each block represents the data flow in a protocol function. From the control graph the tool generates transition tours, and then test sequences are derived from the transition tour to test each function. The performance of the tool on various applications is also included.

Test generation from LOTOS specifications

A novel approach is proposed for generating test cases from LOTOS specifications for protocol conformance testing. A set of transformation rules is applied to the specification, and the specification is mapped to an extended finite state machine called a chart. The flow of data in the chart is modeled by a data flow graph. Test cases are generated from the chart. Program testing strategies are applied for test case selection. A tool implementing this methodology on a workstation is also discussed. >

Method of analysing extended finite-state machine specifications

Formal specifications are the basis for automated verification and implementation in communication software. The paper gives a method of dynamic analysis for modular specifications which is based on symbolic execution and reachability analysis. Symbolic execution is a technique for static analysis and applied first to the specification. It is effective in detecting syntactic and semantic errors. A form of reachability analysis, called limited reachability, is used to dynamically analyse the intermodule communication. It has two applications: combining modules and detecting any errors in intermodule communication. The technique is first applied to the specifications in a nondeterministic finite-state machine model and then applied to an extended finite-state machine model for which two standard formal description languages exist.

Estelle formal specification of ISO virtual terminal

The ISO Virtual Terminal Protocol (VTP) is specified in Estelle, an ISO International Standard (IS) formal description technique. VTP allows heterogeneous terminals to communicate without each having to know the details of the other. This is accomplished by having two virtual terminal users negotiate a common subset of capabilities. The Estelle specification herein consists of an architecture model, a behavior model, and channel descriptions. The architecture model includes modules and their appropriate interconnections (channels). The behavior model specifies each module's underlying extended finite state machine, i.e. sequencing of events and activities. Channel descriptions declare the message elements (PDUs and service primitives) that are communicated between modules. Inconsistencies in an earlier draft ISO VTP document were discovered while specifying it in Estelle; these inconsistencies and the decisions how to formally specify them are discussed. The result is a formal specification that is precise, easy to follow, and as close to the ISO VTP IS as possible. Suggestions are given for making Estelle a more powerful and convenient formal description technique.