USMMC: a self-contained model checker for UML state machines

The Unified Modeling Language is becoming more and more popular in the software development. However because of its ambiguisity in its semantic model, few verification tool has been built. Abstract State Machines have been successfully applied in giving semantics for programming language like C. In this report, we try to use the Abstract State Machines to give a semantics model for UML and then use ASM Model Checker to design a verification tool for UML. Last we give a toy example to show how the verification tool works.

Kuzniarz et al.[15], 2002

UML is nowadays a de-facto standard for design and development of (object-oriented) software. With version 2.0 UML has achieved a more precise formal semantics. The same happened to OCL, a specification language which is an integral part of UML that allows to embed software contracts in the model. In this work we propose an approach for a static verification of consistency of UML models which relies on OCL constraints. Many approaches for model validation and verification rely on generation of suitable code which dynamically (i.e., at run-time) checks the validity of OCL constraints. This approach has several drawbacks. For example, it cannot generally guarantee that a constraint will never be violated, unless an infinite number of tests is performed. Also the generation of just a significative finite subset is not so feasible because, on one hand, a considerable manual effort is needed even to produce a single test scenario and, on the other hand, test-case generation is well-known to be a hard problem. On the other hand, static approaches based on model checking suffer of the state explosion problem and thus cannot scale to real system sizes. In this paper we propose a static verification technique that, by using OCL constraints together with class diagrams, certifies that the dynamic part of the model is satisfied. This encompasses the weaknesses of the other mentioned methods as it does not require users to build test scenarios and also performs the verification of all system properties at the same time.

2006

UML State Machines constitute an integral part of software behavior specification within the Unified Modeling Language (UML). The development of realistic software applications often results in complex and distributed models. Hence, potential errors can be very subtle and hard to locate for the developer. In this paper, we present a set of robustness rules that seek to avoid common types of errors by ruling out certain modelling constructs. Furthermore, adherence to these rules can improve model readability and maintainability. The robustness rules constitute a general Statechart style guide for different dialects, such as UML State Machines, Statemate, and Esterel Studio. Based on this style guide, an automated checking framework has been implemented as a plug-in for the prototypical Statechart modeling tool KIEL. Simple structural checks can be formulated in a compact, abstract manner in the Object Constraint Language (OCL). The framework can also incorporate checks that go beyond...

First International Conference onSoftware Engineering and Formal Methods, 2003.Proceedings., 2003

UML provides several kinds of diagrams to model the behavior and structure of a system under development. A consistency problem may arise due to the fact that some aspects of the model may be described by more than one diagram. Hence, it is important that the consistency of the system description should be checked before implementing it.

Journal of Object Technology, 2002

Model Checking is currently one of the most exciting techniques to improve the quality of complex software systems. It is a computer aided verification method that, in many cases, has discovered design bugs in early development steps, thus saving time and costs to produce the final code. Although this technique is successfully applied to many formal description techniques, it is not commonly used by the object oriented programming community, in general, nor by UML developers, in particular. In this paper, we provide a comprehensive overview and rules to integrate model checking into UML-based designs, showing its usefulness from a practical point of view, and giving some guidelines to exploit the benefits of the integration.

FM 2012: Formal Methods, 2012

This work presents a novel approach for the verification of Behavioral UML models, by means of software model checking. We propose adopting software model checking techniques for verification of UML models. We translate UML to verifiable C code which preserves the high level structure of the models, and abstracts details that are not needed for verification. We combine of static analysis and bounded model checking for verifying LTL safety properties and absence of livelocks. We implemented our approach on top of the bounded software model checker CBMC. We compared it to an IBM research tool that verifies UML models via a translation to IBM's hardware model checker RuleBasePE. Our experiments show that our approach is more scalable and more robust for finding long counterexamples. We also demonstrate the usefulness of several optimizations that we introduced into our tool.

Proceedings of the 2009 World Academic of …, 2009

Abstract—Unified Modeling Language (UML) is a standard language for modeling of a system. UML is used to visually specify the structure and behavior of a system. The system requirements are captured and then converted into UML specification. UML specification uses a set of rules and notations, and diagrams to specify the system requirements. In this paper, we present a tool for developing the UML specification. The tool will ease the use of the notations and diagrams for UML specification as well as increase the understanding ...

2009

The paper presents a new approach to model checking of systems specified in UML. All the executions of an UML system (unfolded to a given depth) are encoded directly into a boolean propositional formula, satisfiability of which is checked using a SAT-solver. Contrary to other UML verification tools we do not use any of the existing model checkers as we do not translate UML specifications into an intermediate formalism. The method has been implemented as the (prototype) tool BMC4UML and some experimental results are presented.

International Journal of Computer Applications, 2012

The Unified Modeling Language (UML) is an independent to programming language which has a collection of modeling tools through which software engineers and researcher represent the complex research problems in the diagrammatic form. The various tools represent the static as well as the dynamic behavior of an object-oriented software system. The state chart diagram is a well known tool of UML which shows the dynamic behavior of states of an object-oriented system. The entire life of an object is represented by this tool. The state transformation of an object is depending on the three major components like transition function, action and possible inputs. The paths through which an object changes its state are determined by the state chart diagrams. These paths can be represented in the graphical form with the use of Finite State Machine (FSM). The graphical representation is very useful for determining the correctness of the diagram. In the present work, an approach to validate the UML class model through FSM is described with a creation of the transition table. For testing purpose, some test cases are generated to test the correctness of UML state chart diagram by taking a real case study of Life Insurance Corporation (LIC) of India. An approach to verify the correctness of UML diagram is presented.

2004

This paper presents a simulation framework for UML models based upon a mapping schema of UML metamodel elements into Abstract State Machines (ASMs). Structural model elements are translated into an ASM vocabulary as collections of domains and functions, whereas the dynamic view is captured by multi-agent ASMs reflecting the behavior modeled by UML state machines. In the toolkit presented, input UML models can be drawn using any UML CASE Tool able to produce the XMI format for diagrams. This textual representation is exploited to initialize the ASM model for UML state machines which can be symbolically executed by AsmGofer, an advanced Abstract State Machine programming system. Tool features are described through the simulation of a simple stack-printer UML model showing the interactions among state machines by signals exchange and operation calls.