UML Class Models Research Articles

UCLAONT: Ontology-Based UML Class Models Verification Tool

The software design model performs an important role in modern software engineering methods. Especially in Model-Driven Engineering (MDE), it is treated as an essential asset of software development; even programming language code is produced by the models. If the model has errors, then they can propagate into the code. Model verification tools check the presence of errors in the model. This paper shows how a UML class model verification tool has been built to support complex models and unsupported elements such as XOR constraints and dependency relationships. This tool uses ontology for verifying the UML class model. It takes a class model in XMI format and generates the OWL file. Performs verification of model in two steps: (1) uses the ontology-based algorithm to verify association multiplicity constraints; and (2) uses ontology reasoner for the verification of XOR constraints and dependency relationships. The results show the proposed tool improves the verification efficiency and supports the verification of UML class model elements that have not been supported by any existing tool.

Ontology-Based Transformation and Verification of UML Qualified Association

UML class model is an essential element of today's software development process. In modern software development methodologies, it is considered a key contributor in every phase of software development. It may be automatically converted into other UML models and even in programming code. However, the erroneous model generates other erroneous models. The model verification technique checks the presence of error in the UML class model. This paper's main objective is to introduce a technique for the completely automatic and expressive transformation of the UML class model's qualified association into ontology. Because the current verification method does not support the transformation and verification of qualified associations. Later on, the ontology-based reasoning method is presented to verify qualified associations and their constraints.

More Than Two Decades of Research on Verification of UML Class Models: A Systematic Literature Review

Error checking is easy and inexpensive in the initial stages as compared to later stages due to when the development cycle precedes the development cost and efforts also increase. UML class model is a key element of modern software methodologies and creates in the initial stage of software development. Therefore, error detection and rectification of the UML class model may save software development costs and time. This paper presents an overview of UML Class model verification approaches and identifies open issues, current research trends, and other improvement areas. This study uses a systematic literature review as an investigation method with six research questions and assesses 65 papers dated January 1997 to December 2020. From 2124 published research papers, 65 papers are selected and distributed into 7 studies. This work provides an analysis of verification approaches and the automation level of proposed approaches. As a result, it is found that the existing UML class model verification methods provide great efforts to check correctness. However, in some situations (when dealing with large and complex models), they consume a significant amount of time and do not support many important features of the UML class model.

Ontology-Based Verification of UML Class Model XOR Constraint and Dependency Relationship Constraints

Ontology-Based Verification of UML Class Model XOR Constraint and Dependency Relationship Constraints

Notice of Retraction: "Natural Language Processing Approach for UML Class Model Generation from Software Requirement Specifications via SBVR"

This article has been retracted due to partial plagiarism and the author Murali Mohanan takes full responsibility for the partial plagiarism detected. A notice of retraction is published in Vol. 27...

Removing redundant multiplicity constraints in UML class models

Models are central for the development and management of complex systems. In order to be useful along the entire life cycle of software they must provide reliable support and enable automatic management. For that purpose, they must be precise, consistent, correct, and be subject to stringent quality verification and control criteria. Model automation calls for deep formal study of models, so that tools can provide inclusive support to users. This paper deals with optimization of multiplicity constraints in Class Models, i.e., models that provide abstraction on the static structure of software. The paper introduces an in-depth analysis of redundancy of multiplicity constraints, i.e., multiplicities that cannot be realized in any legal instance. The analysis includes: (1) a formal study of gaps of redundancies in multiplicity intervals; (2) algorithmic and rule-based methods for removing redundancies in multiplicity constraints; (3) a formal study of completeness of the algorithmic procedures, with respect to most UML class model constraints. The algorithmic procedures are implemented in our FiniteSatUSE tool. To the best of our knowledge, there is no previous study of properties of multiplicity redundancy, no completeness analysis of tightening methods, and no systematic study of these features with respect to most UML class model constraints.

Natural Language Processing Approach for UML Class Model Generation from Software Requirement Specifications via SBVR

This article has been retracted due to partial plagiarism and the author Murali Mohanan takes full responsibility for the partial plagiarism detected. A notice of retraction is published in Vol. 27 No. 8

Checking Consistency between UML Class and State Models Based on CSP and B

The B Abstract Machine Notation (AMN) and the notation of Commu- nicating Sequential Processes (CSP) have previously been applied to formalise the UML class and state diagrams, respectively. This paper discusses their integrated use in checking the consistency between the two kinds of UML diagrams based on some recent results of research in integrated formal methods. Through a small information system example, the paper illustrates a clear-cut separation of concerns in employing the two formal methods. Of particular interest is the treatment of recursive calls within a single class of objects.

Ontology-Based Finite Satisfiability of UML Class Model

Software models are core artifacts in model driven engineering (MDE) and processable by computer. They are automatically transformed into other models and in MDE, programming code is also produced by the models. The automatic transformation provides a systematic reuse of existing artifacts. However, sometimes models are developed with defects and the defects can implicitly shift into the code, which may be difficult to discover and repair. A promising solution to this problem is model verification. UML class model is a key ingredient of MDE. However, UML only offers graphical components without the support of reasoning, due to lack of the formal foundation. Therefore, the verification of formal properties, such as consistency and finite satisfiability is not possible in UML. This paper proposes an ontology-based optimized verification method for important correctness property “finite satisfiability” of UML class model.

The OntoREA Accounting Model: Ontology-based Modeling of the Accounting Domain

McCarthy developed a framework for modeling the economic rationale of different business transactions along the enterprise value chain described in his seminal article “The REA Accounting Model – A Generalized Framework for Accounting Systems in a Shared Data Environment” Originally, the REA accounting model was specified in the entity-relationship (ER) language. Later on other languages – especially in form of generic data models and UML class models (UML language) – were used. Recently, the OntoUML language was developed by Guizzardi and used by Gailly et al. for a metaphysical reengineering of the REA enterprise ontology. Although the REA accounting model originally addressed the accounting domain, it most successfuly is applied as a reference framework for the conceptual modeling of enterprise systems. The primary research objective of this article is to anchor the REA-based models more deeply in the accounting domain. In order to achieve this objective, essential primitives of the REA model are identified and conceptualized in the OntoUML language within the Asset Liability Equity (ALE) context of the traditional ALE accounting domain.

Round-trip Engineering UML Class Models and Java Models

Model transformations constitute the key technology for model-driven software development, a software engineering discipline which became more and more important during the last decade. While tool support for unidirectional batch transformations is rather mature, bidirectional and incremental transformations are only weakly investigated. Nevertheless, several usage scenarios demand for incremental and bidirectional transformations, like round-trip engineering between UML class models and Java source code. This paper presents a bidirectional transformation between UML class models and a Java model which is obtained from Java source code. The transformation is written in QVT Relations, a declarative model transformation language provided by the OMG. While the case study demonstrates that it is possible to specify bidirectional transformations between heterogeneous metamodels in a single relational specification, it also reveals some inherent limitations of the language and the corresponding tool support.

An Approach to Checking Consistency between UML Class Model and Its Java Implementation

Model Driven Engineering (MDE) aims to expedite the software development process by providing support for transforming models to running systems. Many modeling tools provide forward engineering features, which automatically translate a model into a skeletal program that developers must complete. Inconsistencies between a design model and its implementation, however, can arise, particularly when a final implementation is developed dependently on the code from which it was generated. Manually checking that an implementation conforms to its model is a daunting task. Thus, an MDE tool that developers can use to check that implementations conform to their models can significantly improve a developer's productivity. This paper presents a model-based approach for testing whether or not an implementation satisfies the constraints imposed by its design model. Our model-based testing approach aims to efficiently reduce the test input space while supporting branch coverage criteria. To evaluate the approach's ability to uncover inconsistencies, we developed a prototypical tool and applied it to the Eclipse UML2 projects. We were able to uncover inconsistencies between the models and their implementations using the tool.

Editorial for the special issue of STVR on tests and proofs volume 1: tests and proofs in model‐based testing

The increasing use of IT systems in security or safety critical areas as well as growing system complexity creates challenges for both formal verification and testing. It might initially appear that these are competing techniques: it can be argued that once a program is proven to be correct, there is no need for additional tests. Similarly, if it is not feasible to produce a formal proof, then one cannot do better than testing your program thoroughly. As a consequence of this perception, proofs and tests have been pursued by distinct communities using rather different techniques and tools. Despite this historical separation of work on testing and proof, research in these areas has led to the discovery of common issues and to the realisation that each may need the other. The emergence of model checking was one of the first signs that contradictions contribute to testing, but in the past few years an increasing number of researchers have encountered the need to combine proofs and tests, dropping earlier dogmatic views of incompatibility and taking instead the best of what each of these software engineering domains has to offer. This special issue of STVR tries to bring together researchers and practitioners working in the converging fields of testing and proving. We received 16 submissions for this special issue. Reviewing followed the same process as for regular papers. Each paper was reviewed by at least three reviewers, and after a rigorous selection process requiring a total of 33 revisions and 75 reviews, seven papers remain for publication. These papers are spread across two special issues of STVR and discuss two different aspects of tests and proofs: model-based testing and approaches for improving the quality of generated test data. This first volume includes the first three papers, covering the use of tests and proof in model-based testing. The first paper, “Test generation with SMT solvers in Model-Based Testing” by Jérôme Cantenot, Fabrice Ambert, and Fabrice Bouquet presents a framework for generating test cases from a subset of UML (class models, object models, and state modes) that are enriched with constraints expressed in OCL. The developed test generation methods ensure that each operation and transition of the model is stimulated at least once during test execution. The second paper, “Test Generation from Recursive Tile Systems” by Sébastien Chédor, Thierry Jéron, and Christophe Morvan explores the generation of conformance test cases from recursive tile systems models. The authors discuss both on-line and off-line test cases for recursive tile systems within the ioco framework. The third paper, “Model Based Testing for Concurrent Systems with Labeled Event Structures” by Hernán Ponce de León, Stefan Haar, and Delphine Longuet presents a model-based approach for testing concurrent systems. The concurrent systems are modeled using labeled event structures and their test case generation algorithm is able to derive a sound and exhaustive test suite from these models. All the contributions presented in this and the upcoming special issue on Tests and Proofs reveal the broad and dynamic community that works on the intersection of tests and proofs. This was only possible through the combined efforts of all authors and reviewers, and we wish to thank them all for their time and energy. The following persons were reviewers: Paul Ammann, Lukas Brügger, Fabian Büttner, Cristian Cadar, George Candea, John Derrick, Catherine Dubois, Alessandro Fantechi, Vijay Ganesh, Angelo Gargantini, Ryszard Janicki, Thierry Jéron, Tomoji Kishi, Nils Klarlund, Nikolai Kosmatov, Moez Krichen, Pascale Le Gall, Bruno Legeard, Zdenek Letko, Xuandong Li, Karl Meinke, Magnus Myreen, Joseph Near, Virginia Papailiopoulou, Jan Peleska, Dennis Peters, Alexander Pretschner, Antoine Rollet, Kristin Y. Rozier, Andy Schurr, Thomas Sewell, Tomohiko Takagi, Andreas Teucke, T.H. Tse, Mark Utting, Machiel van der Bijl, Luca Viganò, Birgit Vogel-Heuser, Tjark Weber, Stephan Weissleder, Tim A.C. Willemse, Christoph Wintersteiger, Burkhart Wolff, Dianxiang Xu, and Steve Zdancewic. Last but not least, the STVR chief editors, Robert Hierons and Jeff Offutt, provided expert guidance and important advice throughout the process.

Clone detection in UML class models using class metrics

This paper presents a technique to detect clones in UML class models. Class metrics (number of attributes, number of operations) of a class, class attribute names, root nodes, child nodes and class method names are compared with corresponding metrics, attribute names, root node, child nodes and method names of another class. Based on the number of matched attributes, operations and metrics, a percentage of cloning is calculated. We declare two classes as clones of each other if the matching percentage of the class metrics, class attribute names and class method names is greater than a specific threshold.

Deadlock Detection and Avoidance in Static Step Topology under Distributed Environment

During the past years, the distributed computing approach has become very popular due to various advantages over centralized approach. In the distributed approach, the execution of a process has reduced and also it requires low cost for installation. Many of the researchers are using the modeling approach for solution of the software and hardware architecture research problems. The most popular approach of modeling is known as Unified Modeling Language based on the object-oriented technology. In the present work, a method of deadlock detection is explained for the newly proposed static step topology for the distributed network. In the step topology, the processes are taken as a task, sub task, macro, subroutine, etc which are executed in reflexive and symmetric manners when the systems are interconnected to each other under distributed environment and avoidance technique is also presented for the same. The deadlock detection technique is presented through a UML class model.

Conceptualising and structuring semantics in cooperative enterprise information systems models

Enterprise performance is, now more than ever, one of the key points for reaching the market success. In order to increase it, economics paradigms focus on how to better manage knowledge acquiring, sharing and update. Knowledge management can be approached with the possibility offered by the sustainability goals trying to optimise different enterprise strategic domains. The modern architecture of information systems (ISs) is based on distributed networks with a grand challenge of representing and sharing knowledge managed by ISs and consequently, to remove semantics interoperability barriers. First, this paper analyses interoperability issues between cooperative enterprise information systems (CEIS). Based on this analysis, the authors propose a conceptualisation approach for semantics discovery and management in enterprise information systems models, based on applying fact-oriented transformation rules. The input of the transformation process is a conceptualised UML class model, reverse-engineered from an implemented model, and transformed into a fact-oriented model (FOM), which makes explicit the finest-grained semantics. Semantics aggregates are then computed for structuring the whole semantics embedded in enterprise applications. They define independent set of concepts with their own minimal mandatory semantics. Finally a case study is proposed to validate the practicability of our approach in a real scaled scenario involving an enterprise resource planning (ERP) and a manufacturing execution system (MES).

An iterative requirements engineering framework based on Formal Concept Analysis and C–K theory

In this paper, we propose an expert system for iterative requirements engineering using Formal Concept Analysis. The requirements engineering approach is grounded in the theoretical framework of C–K theory. An essential result of this approach is that we obtain normalized class models. Compared to traditional UML class models, these normalized models are free of ambiguities such as many-to-many, optional-to-optional or reflexive associations which cause amongst others problems at design time. FCA has the benefit of providing a partial ordering of the objects in the conceptual model based on the use cases in which they participate. The four operators of the C–K design square give a clear structure to the requirements engineering process: elaboration, verification, modification and validation. In each of these steps the FCA lattice visualization plays a pivotal role. We empirically show how the strategy works by applying it to a set of case studies and a modeling experiment in which 20 students took part.

Parsed use case descriptions as a basis for object-oriented class model generation

Abstract Object-oriented analysis and design has become a major approach in the design of software systems. Recent developments in CASE tools provide help in documenting the analysis and design stages and in detecting incompleteness and inconsistency in analysis. However, these tools do not contribute to the initial and difficult stage of the analysis process of identifying the objects/classes, attributes and relationships used to model the problem domain. This paper presents a tool, Class-Gen, which can partially automate the identification of objects/classes from natural language requirement specifications for object identification. Use case descriptions (UCDs) provide the input to Class-Gen which parses and analyzes the text written in English. A parsed use case description (PUCD) is generated which is then used as the basis for the construction of an initial UML class model representing object classes and relationships identified in the requirements. PUCDs enable the extraction of nouns, verbs, adjectives and adverbs from traditional UCDs for the identification process. Finally Class-Gen allows the initial class model to be refined manually. Class-Gen has been evaluated against a collection of unseen requirements. The results of the evaluation are encouraging as they demonstrate the potential for such tools to assist with the software development process.

Evolution of XML schemas and documents from stereotyped UML class models: A traceable approach

Context UML and XML are two of the most commonly used languages in software engineering processes. One of the most critical of these processes is that of model evolution and maintenance. More specifically, when an XML schema is modified, the changes should be propagated to the corresponding XML documents, which must conform with the new, modified schema. Objective The goal of this paper is to provide an evolution framework by which the XML schema and documents are incrementally updated according to the changes in the conceptual model (expressed as a UML class model). In this framework, we include the transformation and evolution of UML profiles specified in UML class models because they are widely used to capture domain specific semantics. Method We have followed a metamodeling approach which allowed us to achieve a language independent framework, not tied to the specific case of UML–XML. Besides, our proposal considers a traceability setting as a key aspect of the transformation process which allows changes to be propagated from UML class models to both XML schemas and documents. Results As a general framework, we propose a Generic Evolution Architecture ( GEA) for the model-driven engineering context. Within this architecture and for the particular case of the UML-to-XML setting, our contribution is a UML-to-XML framework that, to our knowledge, is the only approach that incorporates the following four characteristics. Firstly, the evolution tasks are carried out in a conceptual model. Secondly, our approach includes the transformation to XML of UML profiles. Thirdly, the proposal allows stereotyped UML class models to be evolved, propagating changes to XML schemas and documents in such a way that the different elements are kept in synch. Finally, we propose a traceability setting that enables evolution tasks to be performed seamlessly. Conclusions Generic frameworks such as that proposed in this paper help to reduce the work overload experienced by software engineers in keeping different software artifacts synchronized.

Barriers to systematic model transformation testing

Introduction Model Driven Engineering (MDE) techniques support extensive use of models in order to manage the increasing complexity of software systems. Appropriate abstractions of software system elements can ease reasoning and understanding and thus limit the risk of errors in large systems. Automatic model transformations play a critical role in MDE since they automate complex, tedious, error-prone, and recurrent software development tasks. Airbus uses automatic code synthesis from SCADE models to generate the code for embedded controllers in the Airbus A380. Commercial tools for model transformations exist. Objecteering and Together from Borland are tools that can automatically add design patterns in a UML class model. Esterel Technologies have a tool for automatic code synthesis for safety critical systems. Other examples of transformations are refinement of a design model by adding details pertaining to a particular target platform, refactoring a model by changing its structure to enhance design quality, or reverse engineering code to obtain an abstract model. These software development tasks are critical and thus the model transformations that automate them must be validated. A fault in a transformation can introduce a fault in the transformed model, which if undetected and not removed, can propagate to other models in successive development steps. As a fault propagates across transformations, it becomes more difficult to detect and isolate. Since model transformations are meant to be reused, faults present in them may result in many faulty models. Model transformations constitute a class of programs with unique characteristics that make testing them challenging. The complexity of input and output data, lack of model management tools, and the heterogeneity of transformation languages pose special problems to testers of transformations. In this paper we identify current model transformation characteristics that contribute to the difficulty of systematically testing transformations. We present promising solutions and propose possible ways to overcome these barriers.