UML Statechart Diagrams Research Articles

Complexity Metrics for Statechart Diagrams

Model-Driven Development and the Model-Driven Architecture paradigm have in the recent past been emphasizing on the importance of good models. In the Object-Oriented paradigm one of the key artefacts are the Statechart diagrams. Statechart diagrams have inherent complexity which keeps increasing every time the diagrams are modified, and this complexity poses problems when it comes to comprehending the diagrams. Statechart diagrams provide a foundation for analysing the dynamic behaviour of systems, and therefore, their quality should be maintained. The aim of this study is to develop and validate metrics for measuring the complexity of UML Statechart diagrams. This study used design science which involved the definition of metrics, development of a metrics tool, and theoretical and empirical validation of the metrics. For the measurement of the cognitive complexity of statechart diagrams, this study proposes three metrics. The defined metrics were further used to calculate the complexity of two sample statechart diagrams and found relevant. Also, theoretical validation of the defined metrics was done using the Weyuker’s nine properties and revealed they are mathematically sound. Empirical validations were performed on the metrics and results indicate that all the three metrics are good for the measurement of the cognitive complexity of statecharts.

COEVOLUTION PATTERNS TO DETECT AND MANAGE UML DIAGRAMS CHANGES

UML diagrams are divided into different perspectives in modelling a problem domain. Preserving coevolution among these diagrams is very crucial so that they can be updated continuously to reflect software changes. Formal methods such as Coloured Petri Nets (CPNs) are widely used in detecting and handling coevolution between software artifacts. Although ample progress has been made, it still remains much work to be done in further improving the effectiveness and accuracy of the state-of-the-art coevolution techniques in managing changes in UML diagrams. In this research, a set of 84 coevolution patterns for supporting coevolution among UML diagrams are proposed to trace the diagrams’ inconsistencies and to determine the change impact incrementally after updating diagrams elements. Coevolution patterns are applied to UML class, object, activity, statechart, and sequence diagrams to cover the different perspectives of UML diagrams. The researcher uses CPNs as a formal language of modelling case study models for the proposed patterns. CPNs tools simulation and monitoring toolboxes are used to validate and monitor the proposed coevolution patterns models and to collect quantitative data about the patterns.

Test Case Optimization and Redundancy Reduction Using GA and Neural Networks

More than 50% of software development effort is spent in testing phase in a typical software development project. Test case design as well as execution consume a lot of time. Hence, automated generation of test cases is highly required. Here a novel testing methodology is being presented to test object-oriented software based on UML state chart diagrams. In this approach, function minimization technique is being applied and generate test cases automatically from UML state chart diagrams. Software testing forms an integral part of the software development life cycle. Since the objective of testing is to ensure the conformity of an application to its specification, a test “oracle” is needed to determine whether a given test case exposes a fault or not. An automated oracle to support the activities of human testers can reduce the actual cost of the testing process and the related maintenance costs. In this paper, a new concept is being presented using an UML state chart diagram and tables for the test case generation, artificial neural network as an optimization tool for reducing the redundancy in the test case generated using the genetic algorithm. A neural network is trained by the back-propagation algorithm on a set of test cases applied to the original version of the system.

An Empirical Evaluation of Behavioral UML Diagrams Based on the Comprehension of Test Case Generation

UML activity and state chart diagrams are the most frequently UML models used for testing a system based on its specifications. Testers may choose different UML diagrams based on comprehensibility criteria. Previous studies, however, highlighted the lack of experts’ evaluation of comprehensibility of activity and state chart diagrams in test case generation. Thus, the main objective of this study is to evaluate the comprehensibility of the UML activity and state chart diagrams based on perspectives of experts. This study generated manual test cases from activity and state chart diagrams and used comprehensibility’s evaluation criteria during interviews with several software testing experts. The results of this study revealed that activity diagrams are more comprehensible than state chart diagrams in test case generation by considering comprehension variables (perceived difficulty and subjective confidence). The results of this study aim to unify the practical efforts of testers to choose MBT diagrams in generating test cases.

Generating verifiable LOTOS specifications from UML models: a graph transformation-based approach

The increasing complexity and widespread use of complex and critical systems require advanced techniques and tools to address their specification, verification and validation. The goal of this paper is to integrate two standard languages (UML and LOTOS) for the specification, verification and validation of dynamic behaviours of critical systems. The main purpose of this integration is to take benefits of the ease-of-use of the graphical notation of UML in system modelling and the formal notation of LOTOS in system verification. In this paper, we propose a graph transformation-based approach to generate automatically LOTOS specifications from UML dynamic models. This approach enables developers, in one hand to model the behaviours of systems using graphical UML statechart and communication diagrams, and in the other hand to generate automatically verifiable LOTOS specifications. The proposed approach is automated using AToM3 tool, and it is illustrated through the modelling and verification of two embedded systems.

Test Case Generation and Optimization using UML Models and Genetic Algorithm

Software testing plays an important role in software development because it can minimize the development cost. Software testing approaches are divided into three parts i.e. code based testing, specification based testing and model based testing. In model based testing, the testing begins at design phase. So, early detection of faults can be achieved by using this approach further reducing time, cost and efforts of the developer to a large extent. In this paper we propose a technique for generating test cases using both UML sequence diagram and state chart diagram. Our approach is to convert Sequence Diagram into Sequence Graph and then to convert State Chart Diagram into State chart Graph. Finally System Testing Graph (SYTG) is formed by combining the two Graphs. From the graphs different control flow sequences also called test cases are identified and then optimized using evolutionary Algorithm, called Genetic Algorithm. Although State chart did better at revealing unit level faults and sequence diagram is better at removing integration level faults, but after integrating the two graphs, generated test cases are appropriate for system testing and to identify Error handling, correctness, pre-post condition faults, interaction, message sequence faults and scenario faults.

TGG-based process for automating the transformation of UML models towards B specifications

The UML notation provides a standard framework for the purpose of object modelling by several diagrams (classes, statecharts, etc.). These form confirmed advantages: re-use of components, high level of abstraction, semantic richness, graphic and synthetic view. Nevertheless, the object-oriented notations lack of formalisation and miss of reliable bases for the analysis and verification of the applications. To overcome this problem, we suggest a solution to the UML graph transformation towards formal methods, in particular the B method. The goal of this paper is to automate the generation of B language, starting from UML class and statechart diagrams by mean of graph grammar rules. This automation is achieved by the tool TGG Interpreter. The major advantage of this transformation: it is a declarative; visual; and formal approach to handle graphs. A lift control system is developed to illustrate our study.

Consistency of UML class, object and statechart diagrams using ontology reasoners

We propose an automatic approach to analyze the consistency and satisfiability of Unified Modeling Language UML models containing multiple class, object and statechart diagrams using logic reasoners for the Web Ontology Language OWL 2. We describe how to translate UML models in OWL 2 and we present a tool chain implementing this translation that can be used with any standard compliant UML modeling tool. The proposed approach is limited in scope, but is fully automatic and does not require any expertise about OWL 2 and its reasoners from the designer.

Generation of test cases using UML models

Software Testing plays an important role in Software development because it can minimize the development cost. UML is widely used in the software development, there consists of the designing and coding of the software. Designing phase is done with the help of the UML models, which consists of the sequence diagrams, activity diagrams, use case diagrams, state chart diagrams etc. After designing of the system, the next task is coding. Since the software development is time and human resource consuming, the reduction of consumption is done with the help of the code generation automatically. This work mainly focus on the UML sequence diagram and state chart diagram as the model. We Propose a Technique for Test Case Generation using UML Models. UML models give a lot of  information that should not be ignored in testing. An innovative approach of generating test cases from the combination of UML design diagrams has been discussed in this paper. Present work used an approach where sequence diagram and state chart diagram has been used to generate test cases. The test cases thus generated are suitable for dynamic testing of system.

A new approach to generate and optimize test cases for UML state diagram using genetic algorithm

Software testing is an important part of the software development process. The testing effort is divided into three parts: test case generation, test execution and test evaluation. Test case generation is the center of testing process and automating. It saves time and efforts and reduces the number of errors and faults. To decrease the elevated cost of software testing and to increase the reliability of the testing processes, a new method has been created to automate the testing process. This paper proposes a new approach to generate and optimize test cases from UML State Chart diagram using Genetic Algorithm. To generate the new test sequence the method of crossover has been applied from the Genetic Algorithm and the efficiency of the test sequences is evaluated by Mutation Analysis

Semantics for UML model transformation and generation of regular grammar

Graphs are one of the most popular non linear data structures used to represent various data objects. These graphical structures can further be classified into directed and undirected graph representations. For modeling purpose, UML has adopted the phenomenon of directed graphical structures as statechart diagrams, to exhibit dynamic specification of any software or non software system. These diagrams are important as they are used to represent all possible values that an object can retain throughout its life cycle. Three key components are required to change the state of any object namely transition function, action and possible inputs. Statechart diagrams are also useful to determine all possible paths that an object will undergo during its entire life span, while changing its state. Further these paths can be represented with the help of various established graphical modeling techniques like Finite State Automata. The mapping and further analysis of these path structures can be very helpful in determining the correctness of the diagram as well as to highlight the possible deficiencies in the diagram. In the present work, authors have proposed semantics for automatic transformation of UML statechart diagram into its equivalent finite state automata, by taking the advantage of both of the models. Authors have also presented an approach to generate regular grammar for the generated finite state automata. This equivalent grammar can further be useful to generate various test cases, to test UML statechart diagram, against various test conditions. To better illustrate, authors have also presented a case study of an ATM machine and demonstrated that how this approach is helpful to verify the correctness of design

Automatic Test case Generation From UML State Chart Diagram

re than 50% of software development effort is spent in testing phase in a typical software development project. Test case design as well as execution consumes a lot of time. So automated generation of test cases is highly required. We present a testing methodology to test object oriented software based on UML state chart diagrams. In our approach we apply function minimization technique and generate test cases automatically from UML state chart diagrams. Here, first the state chart diagram is constructed. Then the diagram is traversed. Here, we perform a DFS to select the associated predicates. After selecting the predicates, we guess an initial dataset. These conditional predicates are, then transformed to generate test cases automatically. Our technique achieves adequate test coverage without unduly increasing the number of test cases. Our approach achieves many important coverage like state coverage, transition coverage, transition pair coverage etc.. This paper also describes how minimization technique is used in testing.

EQUIVALENCE CHECKING OF COMMUNICATING UML STATECHART DIAGRAMS

We demonstrate how a subset of UML statechart diagrams (SCDs) as distinct from statecharts is encoded in the π-calculus as a number of processes which communicate via a channel-passing interaction paradigm. An extension to the original UML semantics for communicating statechart diagrams is presented. Different sorts of equivalences of UML SCDs encompassing isomorphism, strong behavioural equivalence and weak behavioural equivalence are defined. Determining equivalence of any two UML SCDs is transformed to a problem of checking whether their respective π-calculus process expressions are equivalent. The practicality of the approach is exemplified using an industry level case study.

UML-BASED MODELING AND ANALYSIS OF SECURITY THREATS

Poor design has been a major source of software security problems. Rigorous and designer-friendly methodologies for modeling and analyzing secure software are highly desirable. A formal method for software development, however, often suffers from a gap between the rigidity of the method and the informal nature of system requirements. To narrow this gap, this paper presents a UML-based framework for modeling and analyzing security threats (i.e. potential security attacks) rigorously and visually. We model the intended functions of a software application with UML statechart diagrams and the security threats with sequence diagrams, respectively. Statechart diagrams are automatically converted into a graph transformation system, which has a well-established theoretical foundation. Method invocations in a sequence diagram of a security threat are interpreted as a sequence of paired graph transformations. Therefore, the analysis of a security threat is conducted through simulating the state transitions from an initial state to a final state triggered by method invocations. In our approach, designers directly work with UML diagrams to visually model system behaviors and security threats while threats can still be rigorously analyzed based on graph transformation.

Assessing the understandability of UML statechart diagrams with composite states—A family of empirical studies

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.

Modelling and model checking suspendible business processes via statechart diagrams and CSP

When modelling object behaviour with UML statechart diagrams, the history mechanism can be useful for modelling the suspension of a “normal” business process upon certain “abnormal” events together with the subsequent resumption, as illustrated by the examples in this paper. However, previous approaches to model checking statechart diagrams often ignore the history mechanism. We enhanced such a previous approach based on Communicating Sequential Processes (CSP) and developed a support tool for it.

A Method for Automatic Generation of OWL-S Service Ontology

We present in this paper the methodology for automatic generation of OWL-S service model ontology along with the results and issues. First, we extract information related to atomic services and their properties such as IOPE from the UML class diagram, and retrieve information related to the composition of services from the UML state-chart diagram. Then, the XSLT applications utilize the acquired information to generate the OWL-S service model ontology through the predefined mappings between OWL-S constructs for composite services and UML state-chart primitives. For the justification of generated service ontology, several validation checks are performed. Our service ontology generation method is general and fully automatic, as well as effective, in that it is achieved in an environment familiar to developers, and information needed to generate service ontology is provided necessarily during service development. It is also noticeable to facilitate representing the condition with GUI rather than a complex language such as OCL.

QoS modelling and analysis with UML-statecharts

The UML is an influential and widespread notation for high-level modelling of information processing systems. UML statechart diagrams are a graphical language to describe system behaviour. They consitute one of the most intensively-used formalisms comprised by the UML. However, statechart diagrams are lacking concepts for describing real-time, performance, dependability and quality of service (QoS) characteristics at a behavioural level.This note describes a QoS-oriented extension of UML statechart diagrams, called StoCharts. StoCharts enhance the basic statechart formalism with two distinguished features, both simple and easy to understand, yet powerful enough to model a sufficiently rich class of stochastic processes. This is illustrated by a selection of case studies performed using StoCharts. We review the main ingredients of StoCharts and survey tool support and case studies performed with the language, and place StoCharts in the context of other extensions of statechart diagrams.

On testing and conformance relations for UML statechart diagrams behaviours

In this paper we study the formal relationship between testing preorder/equivalences for a behavioural subset of UML Statechart Diagrams and a conformance relation for implementations with respect to specifications given using such diagrams. We study the impact of stuttering on the above mentioned relationship. In the context of UMLSDs, stuttering occurs when no transition of the UMLSD is enabled by the current event in the current (global) state of the underlying state-machine. We consider both the case in which the semantics underlying the testing relations does not model stuttering explicitly - we call it the non-stuttering semantics - and the case in which it does it - i.e. the stuttering semantics. We show that in the first case the conformance relation is stronger than the reverse of the MUST preorder and, consequently, stronger than the MAY preorder. Much more interesting results can be proven in the second case, possibly under proper conditions on the sets of events under consideration. In fact the conformance relation is shown to coincide with the MAY preorder, and thus be implied by the reverse MUST preorder. Finally, we show important substitutivity properties which hold in the case of stuttering semantics.

Minimally adequate teacher synthesizes statechart diagrams

We consider the problem of synthesizing UML statechart diagrams from sequence diagrams as a language inference problem, and we solve it in Angluin's framework of minimally adequate teacher. The designer has the role of the teacher who answers membership and equivalence queries made by the algorithm. It turns out that there are several natural methods to decrease the number of membership queries needed, and thus, to make the algorithm practically applicable.