Explore the vast range of titles available.

Modern systems are rapidly evolving and increasing in complexity to satisfy growing requirements. Such systems often incorporate multiple hierarchical statecharts within their behavior modeling diagram, which significantly complicates the verification process. To address this challenge, the Common Modeling Language (CML) was introduced as an intermediate modeling language for formal verification, serving as a bridge between Unified Modeling Language (UML) Statechart and the model checkers. However, CML supports modeling only a single hierarchical statechart, which limits its applicability to complex systems. This study introduces the Enhancement Common Modeling Language (E-CML), an extension of the CML, to support the verification of systems that incorporate multiple hierarchical statecharts. We introduce the group component in E-CML, comprising an initial state, a set of states, transitions, triggers, and a region, to formally differentiate the group components from superstates. We also propose new translation rules to map E-CML into Symbolic Model Verifier (SMV) syntax. E-CML operates through two main processes: transformation and translation. The transformation process transforms an XML Metadata Interchange (XMI) file into E-CML, while the translation process translates E-CML to an Input Symbolic Model Verifier (I-SMV) file. The system is verified using the SMV model checker, with formal properties specified in Computational Tree Logic (CTL) and represented in the I-SMV file. The results demonstrate that the behavior modeling diagram satisfies all formal properties, indicating that E-CML provides an effective framework for the verification of complex systems comprising multiple hierarchical statecharts.

This work describes an empirical investigation of the cost effectiveness of well-known state-based testing techniques for classes or clusters of classes that exhibit a state-dependent behavior. This is practically relevant as many object-oriented methodologies recommend modeling such components with statecharts which can then be used as a basis for testing. Our results, based on a series of three experiments, show that in most cases state-based techniques are not likely to be sufficient by themselves to catch most of the faults present in the code. Though useful, they need to be complemented with black-box, functional testing. We focus here on a particular technique, Category Partition, as this is the most commonly used and referenced black-box, functional testing technique. Two different oracle strategies have been applied for checking the success of test cases. One is a very precise oracle checking the concrete state of objects whereas the other one is based on the notion of state invariant (abstract states). Results show that there is a significant difference between them, both in terms of fault detection and cost. This is therefore an important choice to make that should be driven by the characteristics of the component to be tested, such as its criticality, complexity, and test budget.

The main goal of this work is to present a family of empirical studies that we have carried out to investigate whether the use of composite states may improve the understandability of UML statechart diagrams derived from class diagrams. Our hypotheses derive from conventional wisdom, which says that hierarchical modeling mechanisms are helpful in mastering the complexity of a software system. In our research, we have carried out three empirical studies, consisting of five experiments in total. The studies differed somewhat as regards the size of the UML statechart models, though their size and the complexity of the models were chosen so that they could be analyzed by the subjects within a limited time period. The studies also differed with respect to the type of subjects (students vs. professionals), the familiarity of the subjects with the domains of the diagrams, and other factors. To integrate the results obtained from each of the five experiments, we performed a meta-analysis study which allowed us to take into account the differences between studies and to obtain the overall effect that the use of composite states has on the understandability of UML statechart diagrams throughout all the experiments. The results obtained are not completely conclusive. They cast doubts on the usefulness of composite states for a better understanding and memorizing of UML statechart diagrams. Composite states seem only to be helpful for acquiring knowledge from the diagrams. At any rate, it should be noted that these results are affected by the previous experience of the subjects on modeling, as well as by the size and complexity of the UML statechart diagrams we used, so care should be taken when generalizing our results.

We present a comprehensive unified modeling language (UML) statechart diagram analysis framework. This framework allows one to progressively perform different analysis operations to analyze UML statechart diagrams at different levels of model complexity. The analysis operations supported by the framework are based on analyzing Petri net models converted from UML statechart diagrams using a previously proposed transformation approach. After introducing the general framework, the paper emphasizes two simulation-based analysis operations from the framework: direct MSC inspection, which provides a visual representation of system behavior described by statechart diagrams; and a pattern-based trace query technique, which can be used to define and query system properties. Two case-study examples are presented with different emphasis. The gas station example is a simple multi-object system used to demonstrate both the visual and query-based analysis operations. The early warning system example uses only one object, but features composite states and includes analysis specifically aimed at one composite state feature, history states.

Specification-based software development can allow the development, verification and maintenance of software at the specification level and can synthesis provably correct code. However, formal specification technology is hard to apply to the industrial development of software. UML has been used widely in the CASE-based software development. But, UML is a semiformal language and lacks formal semantics to express its meaning precisely. The paper proposes an approach for the formalization of UML statecharts mapped to RSL -a specification language based on coalgebra. The purpose is to bridge between UML and formal specification language.

The unified modeling language (UML) is used for the specification, visualization, and documentation of object-oriented software systems. Mobile UML (M-UML) is an extension of UML that considers mobility aspects, and a mobile statechart is an extension of the standard UML diagram that deals with the requirements for modeling, specifying, and visualizing mobile agent-based systems. However, mobile statecharts inherit UML’s lack of formal notation for analysis and verification purposes. The rewriting logic language Maude is a formal method that deals with mobile computations. In this paper, we propose a formalization of M-UML statechart diagrams using Maude to provide formal semantics for such diagrams. The generated Maude specifications are then used to analyze and check the systems using Maude analytical tools. This approach is illustrated through an example.

A model transformation method based on state refinement and semantic mapping is proposed to address the challenges of high modeling complexity and resource consumption in symbolic validation of industrial software requirements. First, a rule-based semantic mapping system is constructed through the explicit definition of element correspondence between statechart components and verification models, coupled with a composite state-level refinement strategy to structurally optimize model hierarchy. Second, an automated transformation algorithm is developed to bridge graphical modeling tools with formal verification environments, supported by quantitative evaluation metrics for mapping validity. To demonstrate its practical applicability, the methodology is systematically applied to railway infrastructure safety—specifically the railroad turnout control system—as a critical case study. The experimental implementation converts operational statecharts of turnout control logic into optimized NuSMV models. Not only did the models remain intact, but the state space was also effectively reduced through the optimization of the hierarchical structure. In the validation phase, the converted model is tested for robustness using the fault injection method, and boundary condition anomalies that are not explicitly stated in the requirement specification are successfully detected. The experimental results show that the validation model generated by this method has improved validation efficiency in the NuSMV tool, which is significantly better than the traditional conversion method.

The specification of modeling and analysis of real-time and embedded systems (MARTE) is an extension of the unified modeling language (UML) in the domain of real-time and embedded systems. Even though MARTE time model offers a support to describe both discrete and dense clocks, the biggest effort has been put so far on the specification and analysis of discrete MARTE models. To address hybrid real-time and embedded systems, we propose to extend statecharts using both MARTE and the theory of hybrid automata. We call this extension hybrid MARTE statecharts. It provides an improvement over the hybrid automata in that: the logical time variables and the chronometric time variables are unified. The formal syntax and semantics of hybrid MARTE statecharts are given based on labeled transition systems and live transition systems. As a case study, we model the behavior of a train control system with hybrid MARTE statecharts to demonstrate the benefit.

Unified modelling language (UML) is a visual modelling language, which has gained popularity among software practitioners. In a model-driven software development environment, the existing UML tools mainly support automatic generation of structural code from UML class diagrams. However, the code generation from UML diagrams such as statechart, activity, collaboration and sequence diagrams (SDs) are not supported by most UML tools and also have scarcely been reported in the literatures. This work proposes an approach to automatic generation of code from UML 2.x SDs of use cases. From the XML metadata interchange (XMI) representation of an SD of a use case, the authors construct a graph model called sequence integration graph (SIG). The SIG encapsulates information related to messages, control flow and method scope of interactions. These information are then used to generate code. The proposed approach has been tested using a number of real-life application systems and the results substantiate the efficacy of the approach to synthesise the code for controller classes. The authors observe that approximately 48% of the total lines of code within controller class methods can be generated with the proposed approach. The proposed approach can be easily extended to other behavioural UML models such as interaction-overview diagrams, communication diagrams and activity diagrams.

With the popularity of model-driven methodologies and the abundance of modelling languages, a major question for a requirements engineer is: which language is suitable for modelling a system under study? We address this question from a semantic point-of-view for big-step modelling languages (BSMLs) . BSMLs are a class of popular behavioural modelling languages in which a model can respond to an input by executing multiple transitions, possibly concurrently. We deconstruct the operational semantics of a large class of BSMLs into eight high-level, mostly orthogonal semantic aspects and their common semantic options. We analyse the characteristics of each semantic option. We use feature diagrams to present the design space of BSML semantics that arises from our deconstruction, as well as to taxonomize the syntactic features of BSMLs that exhibit semantic variations. We enumerate the dependencies between syntactic and semantic features. We also discuss the effects of certain combinations of semantic options when used together in a BSML semantics. Our goal is to empower a requirements engineer to compare and choose an appropriate BSML from the plethora of existing BSMLs, or to articulate the semantic features of a new desired BSML when such a BSML does not exist.