Model checking UML Statechart diagrams using JACK

This paper discusses a Unified Modelling Language (UML) based formal verification methodology for early error detection in the model-based software development cycle. Our approach proposes a UML-based formal verification process utilising functional and behavioural modelling artifacts of UML. It reinforces these artifacts with formal model transition and property verification. The main contribution is a UML to Labelled Transition System (LTS) Translator application that automatically converts UML Statecharts to formal models. Property specifications are derived from system requirements and corresponding Computational Tree Logic (CTL)/Linear Temporal Logic (LTL) model checking procedure verifies property entailment in LTS. With its ability to verify CTL and LTL specifications, the methodology becomes generic for verifying all types of embedded system behaviours. The steep learning curve associated with formal methods is avoided through the automatic formal model generation and thus reduces the reluctance of using formal methods in software development projects. A case study of an embedded controller used in military applications validates the methodology. It establishes how the methodology finds its use in verifying the correctness and consistency of UML models before implementation.

The Unified Modeling Language (UML) is a widely adopted standard for visualizing, specifying, constructing, and documenting software system artifacts. It enables developers to design diagrams that effectively represent complex relationships and processes. Despite its versatility, UML lacks the formal notation necessary for rigorous analysis and verification. To address this limitation, we propose an approach for transforming Statechart diagrams (STD), a type of UMLs behavioral diagram, into generalized stochastic Petri nets (GSPN). The latter is a well-established framework for representing and analyzing concurrency, timing, synchronization, precedence, and priority in processes. Using the meta-modelling tool AToM3, we create meta-models for both STDs and GSPNs. Additionally, a graph grammar is developed to facilitate automatic transformation. This approach enables the creation of a tool for modeling and verifying Statechart diagrams. The proposed method is validated through a case study.

The Unified Modeling Language - UML - is the most used specification language, and the way the world models not only application structure, behavior, and architecture, but also business process and data structure. In this paper, we aim to demonstrate a system development methodology by generating the UML diagrams from the requirements of the Automatic Banking Machine (ABM) System and discuss their relationships, differences and suitability. The high-level requirements of the system are specified by using use-case diagram, activity diagram, state chart diagram, collaboration diagram, sequence diagram, and component diagram, and the low-level requirements of each component using class diagrams. We briefly introduce each diagram, their usage, their advantages and some limitations, and then we discuss the relationships and differences between two or more diagrams, and suitability for modeling the different parts of the system.

Using the Unified Modeling Language (UML), static aspects at conceptual level are represented in structural diagrams such as class diagrams, while dynamic aspects are represented in behavioral diagrams such as state chart diagram, activity diagram, sequence diagrams and collaboration diagrams. And metric measures for those, improves the quality of design. The earlier work focuses on metrics for class diagrams. The main goal of this paper is to focus on the definition of mea -sures that applied to guarantee the validity of design through {NEntryA, NExitA, NA, NT, NS} State chart diagrams, {NM} Inter-action diagrams, and {NOA, NOUC, NOUCA}Use-Case diagrams. This measure of metric validates intrinsic understandability of all behavioral UML diagrams.KeywordsSoftware metricsUML behavioral diagramscomplexity metricstheoretical validation

There is a variety of methods and formalisms usable for writing specifications of railway interlocking and signalling systems or their subsystems. To write a consistent technical specification means to make a model with a required level of precision, clarity and economy of expression that is free of unknown spots and/or conflicts. One of possible formalisms suitable for making such models seems to be the Unified Modeling Language' (trademark of OMG). The paper presents experience and knowledge of authors who have worked over transcription of informal specification of a new railway interlocking and signallingsystem into the UML based object-oriented model. The main attention is paid to analysis and design phases. The former phase results in use case diagrams and sequential diagrams, the latter in class/object diagrams and statechart diagrams. The syntax of the discussed diagrams is in accordance with the UML ver. 1.2 as given by the software tool Rhapsody' ver. 2.2 (a trademark of I-Logix). Experiences and advantages resulting from the presented approach are summarised within conclusions.

The use of scenarios has become a popular technique for requirements elicitation and specification building. Since scenarios capture only partial descriptions of system behavior, an approach for scenario composition and integration is needed to produce more complete specifications. The Unified Modeling Language (UML), which has become a standard notation for object-oriented modeling, provides a suitable framework for scenario acquisition using Use Case diagrams and Collaboration diagrams and for behavioral specification using Statechart diagrams; yet it does not propose any specific modeling process, let alone a process for transforming scenarios into behavioral specifications. In this paper, we suggest a four-step process for synthesizing behavioral specifications from scenarios. It automatically generates from a given set of Collaboration diagrams the Statechart diagrams of all the objects involved. An automatic analysis of specifications in respect to consistency and completeness is also provided. Our approach is incremental and is fully compliant with the UML. Furthermore, it provides an elegant solution to the problem of scenario interleaving. The underlying algorithms have been implemented and validated with several examples, and they are fit for integration into CASE tools supporting the UML.

For quite some time, the Unified Modeling Language (UML) has been adopted by designers of safety critical control systems such as automotive and aviation control. This has led to an increased emphasis on setting up a validation flow over UML that can be used to guarantee the correctness of UML models. In this paper, we propose a dynamic Assertion-based verification (ABV) framework for validation of UML Statecharts over the Rhapsody platform of I-logix. We present an extension of Linear Temporal Logic (LTL), named Action-LTL that allows assertions to be specified over data attributes and events of UML models. We present a methodology for automatic generation of Rhapsody Statecharts from Action-LTL specifications. These generated Statecharts are added as simulation observers to an existing UML model to detect specification violations during simulation. In view of the capacity limitations of existing formal assertion-based verification tools, we believe that our methods are of immediate practical value to the UML-based design community.

The domain of transformation systems has been introduced to provide a general integration framework for formal specifications. In this chapter an application of the integration approach to less formal software specifications is discussed. For that purpose models given in the Unified Modeling Language (UML) are considered: class diagrams for the specification of the structure and architecture of the system, and statechart and sequence diagrams for the specification of its behaviour. Analogous to the applications to specification formalisms presented in the previous chapters, the basic idea here is to interpret specifications semantically by sets of transformation systems, exhibit their correspondences, and thereby to check whether a common interpretation of all considered specifications is possible. As opposed to the former examples, however, the investigation cannot be completely formal, since the semantics of the given UML languages is not formally defined. That means the correctness of the transformation system semantics cannot be formally proved. To cope with this situation the interpretation will be open w.r.t. certain semantic decisions, which is then treated as parameters of possible admissible interpretations. On the other hand, the interpretation in the transformation system reference model provides the means for the formalisation and thus precision of the considered software specification languages.KeywordsState MachineUnify Modeling LanguageClass DiagramSequence DiagramClass GraphThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

An approach on modeling traversing features in concurrent software system was presented, which is based on aspect-oriented techniques and statecharts of unified modeling language (UML). Modeled with UML statecharts diagrams, the primary system functions and corresponding traversal features are enveloped into various orthogonal regions of a composite state respectively. The mutual relationships between orthogonal regions are implied by the orders of broadcast events. With modular transition system, a basic computational model, the formalization description of aspect-oriented statechart models was proposed. The precise semantics of model elements and modeling procedures was also given. The case study indicates that the strategy of separation of traversing features is implemented in design phrase of concurrent software system with this method. And, the advantages of this software modeling approach are loose couple, adaptability and traceability.

Building a simplified model for testing complex software system has been highlighted for optimizing test generation. This paper presents an approach to generating the constrained FSM with the scenario. Firstly, we use FSM to describe the behavior model of the target system. Then, we study the method of modeling scenarios with UML diagrams, including use case diagram, activity diagram, sequence diagram and statechart diagram. We describe how to achieve the constraint process by means of mapping and projection operations between FSM and UML diagrams. Finally, we obtain a reduced FSM by using UML activity diagrams to constrain FSM. The main contribution of the paper is to present an effective modeling method to optimize testing generation from the model.

As a powerful and object-oriented graphical modeling language, Unified Modeling Language (UML) has been introduced into the design and development of safety-critical computer systems. However, UML model is difficult to reflect the concurrency and consistency of constraint rules between objects and impossible to completely demonstrate the dynamic behavior characteristics of a system. Further, it cannot be directly expressed and analyzed by mathematical tools. Petri net modeling technology uses graphical element place and transition to clearly describe the internal interactions of a system. Meanwhile, Petri net has mature mathematical analysis methods. We have proposed to combine these two tools for designing and analyzing a system with a set of transformation rules from UML statecharts to Petri net. In this paper, an automatic conversion tool is introduced. The tool performs the transformation with three steps as follows: (1) Transforming UML model into XML document, which makes information extraction of the UML model become easier. (2) Analyzing semantics of UML model and Petri net model, then designing data structure for transformation, and completing the transformation based on the transformation rules. (3) Analyzing the transformed Petri net model to verify the characteristics of the UML model. The transformation rules and the tools are developed based on a new railway interlocking system.

The Unified Modeling Language (UML) has been designed to be a full standard notation for Object-Oriented Modelling. UML is a rather complete set of notations, but it lacks of formal semantics. This article introduces formal semantics for UML based on algebraic abstract data types. We currently consider only class and object diagrams. These diagrams include class structures, associations, multiplicities, constraints, instances as well as specialization relationships. We give a formal semantics for each of these elements by interpreting the structure of a class as an abstract data type, associations as values of type Association, and specialization as structural projection. We show that a tool like Larch Prover is able to support proofs over UML diagrams. We use the critical pair computation to find out inconsistencies. Several different inconsistencies of class diagrams are shown on a library example.

Informal and graphical modeling techniques enable developers to construct abstract representations of systems. Object-oriented modeling techniques further facilitate the development process. The Unified Modeling Language (UML), an object-oriented modeling approach, could be broad enough in scope to represent a variety of domains and gain widespread use. Currently, UML comprises several different notations with no formal semantics attached to the individual diagrams. Therefore, it is not possible to apply rigorous automated analysis or to execute a UML model in order to test its behavior, short of writing code and performing exhaustive testing. We introduce a general framework for formalizing a subset of UML diagrams in terms of different formal languages based on a homomorphic mapping between metamodels describing UML and the formal language. This framework enables the construction of a consistent set of rules for transforming UML models into specifications in the formal language. The resulting specifications derived from UML diagrams enable either execution through simulation or analysis through model checking, using existing tools. This paper describes the use of this framework for formalizing UML to model and analyze embedded systems. A prototype system for generating the formal specifications and results from an industrial case study are also described.

The embedded electronics in the Ranger Telerobotic Shuttle Experiment require a system specific verification tool to perform the necessary tests in order to come to a conclusion as to the systems functionality. The ability to create an automated system verification tool is feasible, but is it the most efficient? Is a human needed for making decisions as to the functionality of the electronics, or can we automate this process and eliminate the human from the loop? If an automated verification tool is to be used, what will be its architecture? The following paper will address these issues and evaluate the use of a visual verification tool versus an automated verification tool for the testing.

Specification and automated verification of real-time behaviour — a case study