Object Constraint Language Constraints Research Articles

Detection of Inconsistencies in SysML/OCL Models Using OWL Reasoning

Requirement change management is a challenging issue in software development. One of the main objectives of the Intent-Defined Adaptive Software program is to verify the satisfaction of requirement changes during software development. In this paper, we develop an ontology-based method to detect inconsistencies in Systems Modeling Language (SysML) models with Object Constraint Language (OCL) constraints as a first step of requirement change management. Specifically, we map the SysML/OCL models to Web Ontology Language (OWL), so that the consistency of the corresponding ontology can be checked by OWL reasoners automatically. We propose a set of mapping rules to interpret the components of SysML state machine diagrams, along with OCL constraints, to OWL. Toward this objective, we demonstrate three consistency reasoning tasks over a state machine diagram using OWL reasoners. In each case, the result of reasoning is accompanied by an explanation of the logic behind the decision.

Automated transformation of NL to OCL constraints via SBVR

This paper presents a neoteric method to automatically generate object constraint language (OCL) constraints from natural language (NL) statements. To support the software practitioners in using OCL, we present a novel method. The aim of this method is to produce a framework so that the user of unified modelling language (UML) tool can write constraints and pre/post conditions in natural language like English and the framework converts such natural language expressions to equivalent OCL statements. Here, the state of art of the two well-known technologies, namely open natural language processing (OpenNLP) and Semantics of Business Vocabulary and Rules (SBVR) are used. OpenNLP is used as a pre-processing phase to process the natural language statements. Pre-processing includes sentence splitting, tokenisation and parts of speech (POS) tagging. Then in the second phase, i.e., the transformation phase SBVR is used to automatically transform the preprocessed natural language statements to SBVR specifications. The main aim of this research is to provide automated tool support for model processing tasks in UML models via SBVR to model transform the input SBVR specifications to OCL specifications as explained in model driven architecture (MDA).

Automated transformation of NL to OCL constraints via SBVR

This paper presents a neoteric method to automatically generate object constraint language (OCL) constraints from natural language (NL) statements. To support the software practitioners in using OC...

Formalizing UML/OCL structural features with FoCaLiZe

Unified Modeling Language (UML) is the de facto standard for the development of software models, and Object Constraint Language (OCL) is used within UML models to specify model constraints. Several UML/OCL tools provide Model-Driven Engineering transformation into general object-oriented programming languages such as Java and C++. But the latter did not provide mechanisms for the specification and the verification of OCL constraints. In this context, formal methods are largely used for the specification of UML/OCL models and the verification of their OCL constraints. However, the divergence between UML (object-oriented modeling) and formal methods (mathematical- and logical-based tools) leads in general to ignore most UML/OCL architectural and conceptual features such as OCL constraints simple and multiple inheritance, late binding, template binding and dependencies. To address the formalization of these features, we have used FoCaLiZe, an object-oriented development environment using a proof-based formal approach. More precisely, we propose a formal transformation of the essential UML/OCL features into FoCaLiZe specifications. The derived formal model reflects perfectly the structural features of the original UML/OCL model. In addition, it is possible to check and prove model properties using Zenon, the automatic theorem prover of FoCaLiZe.

Automated Refactoring of OCL Constraints with Search

Object Constraint Language (OCL) constraints are typically used to provide precise semantics to models developed with the Unified Modeling Language (UML). When OCL constraints evolve regularly, it is essential that they are easy to understand and maintain. For instance, in cancer registries, to ensure the quality of cancer data, more than one thousand medical rules are defined and evolve regularly. Such rules can be specified with OCL. It is, therefore, important to ensure the understandability and maintainability of medical rules specified with OCL. To tackle such a challenge, we propose an automated s earch- b ased O CL constraint r efactoring a pproach (SBORA) by defining and applying four semantics-preserving refactoring operators (i.e., Context Change , Swap , Split and Merge ) and three OCL quality metrics ( Complexity , Coupling, and Cohesion ) to measure the understandability and maintainability of OCL constraints. We evaluate SBORA along with six commonly used multi-objective search algorithms (e.g., Indicator-Based Evolutionary Algorithm (IBEA)) by employing four case studies from different domains: healthcare (i.e., cancer registry system from Cancer Registry of Norway (CRN)), Oil&Gas (i.e., subsea production systems), warehouse (i.e., handling systems), and an open source case study named SEPA. Results show: 1) IBEA achieves the best performance among all the search algorithms and 2) the refactoring approach along with IBEA can manage to reduce on average 29.25 percent Complexity and 39 percent Coupling and improve 47.75 percent Cohesion , as compared to the original OCL constraint set from CRN. To further test the performance of SBORA, we also applied it to refactor an OCL constraint set specified on the UML 2.3 metamodel and we obtained positive results. Furthermore, we conducted a controlled experiment with 96 subjects and results show that the understandability and maintainability of the original constraint set can be improved significantly from the perspectives of the 96 participants of the controlled experiment.

Definition of Object Constraint Language Rules in Models to Support the Development of Android Applications

The Model Driven Engineering (MDE) supports software development, promoting quality and speed enhancement in providing new products. The development of more accurate models is obtained through the employment of the Object Constraint Language (OCL). Given the increasing use of mobile devices and the need for new applications, the MDE together with the OCL constraints promote the development of quality mobile applications when the development time is reduced. This research paper focuses on the definition and use of OCL constraints to support the development of Android models in the MDE context.

Translating essential OCL invariants to nested graph constraints for generating instances of meta-models

Abstract Domain-specific modeling languages (DSMLs) are usually defined by meta-modeling using the Object Constraint Language (OCL) for specifying invariants. This approach is purely declarative in the sense that instance construction is not supported. In contrast, grammar-based language definition incorporates the stepwise construction of instances by applying production rules. Since the underlying structure of models are generally graphs, graph grammars are well suited to define modeling languages. Establishing a formal relation between meta-modeling and graph grammars opens up the possibility to integrate techniques of both fields. This integration can be advantageously used for optimizing DSML definition. We follow an approach where a meta-model is translated to a type graph with a set of nested graph constraints. While previous meta-model translations neglected OCL constraints, we focus on the translation of Essential OCL invariants to nested graph constraints in this paper. We show that a model satisfies an Essential OCL invariant iff its corresponding instance graph satisfies the corresponding nested graph constraint. In addition, nested graph constraints can be translated to application conditions of graph transformation rules. Composing both translations, an instance-generating graph grammar can be equipped with application conditions such that it generates instances of the original meta-model only.

IOCL: An interactive tool for specifying, validating and evaluating OCL constraints

The Object Constraint Language (OCL) is commonly used for specifying additional constraints on models, in addition, to the ones enforced by the semantics of the models. However, a lot of practitioners and even researchers are reluctant in using OCL to some extent due to the lack of sufficient familiarity with OCL. To facilitate practitioners and researchers in specifying OCL constraints, we designed and developed a web-based tool called interactive OCL (iOCL) for interactively specifying constraints on a given model. The core idea behind iOCL is to present and display only relevant details (e.g., operations) of OCL to users at a given step of constraint specification process, in addition to helping modelers with its syntax. We evaluated iOCL using a real-world case study from Cancer Registry of Norway and the results showed that iOCL can significantly reduce the time required to specify OCL constraints and decrease the possibility of making syntactic errors during the specification process. Thus, we conclude that iOCL can facilitate the process of OCL constraint specification. Interested users can try iOCL at: http://iocl.zen-tools.com/ . • iOCL specifies OCL constraints in an interactive manner. • iOCL dynamically interacts with users and only displays relevant details of OCL. • iOCL can help users to check the syntax of specified constraints. • iOCL was evaluated with a real-world case study from the Cancer Registry of Norway; • iOCL reduces the time of specifying OCL constraints and syntactic errors.

Automated Generation of OCL Constraints: NL based Approach vs Pattern Based Approach

This paper presents an approach used for automated generations of software constraints. In this model, the SBVR (Semantics of Business Vocabulary and Rules) based semi-formal representation is obtained from the syntactic and semantic analysis of a NL (Natural Language) (such as English) sentence. A SBVR representation is easy to translate to other formal languages as SBVR is based on higher-order logic like other formal languages such as OCL (Object Constraint Language). The proposed model endows with a systematic and powerful system of incorporating NL knowledge on the formal languages. A prototype is constructed in Java (an Eclipse plug-in) as a proof of the concept. The performance was tested for a few sample texts taken from existing research thesis reports and books.

User Assistance Characteristics of the USE Model Checking Tool

The Unified Modeling Language (UML) is a widely used general purpose modeling language. Together with the Object Constraint Language (OCL), formal models can be described by defining the structure and behavior with UML and additional OCL constraints. In the development process for formal models, it is important to make sure that these models are (a) correct, i.e. consistent and complete, and (b) testable in the sense that the developer is able to interactively check model properties. The USE tool (UML-based Specification Environment) allows both characteristics to be studied. We demonstrate how the tool supports modelers to analyze, validate and verify UML and OCL models via the use of several graphical means that assist the modeler in interpreting and visualizing formal model descriptions. In particular, we discuss how the so-called USE model validator plugin is integrated into the USE environment in order to allow non domain experts to use it and construct object models that help to verify properties like model consistency.

Improving the performance of OCL constraint solving with novel heuristics for logical operations: a search-based approach

A common practice to specify constraints on the Unified Modeling Language (UML) models is using the Object Constraint Language (OCL). Such constraints serve various purposes, ranging from simply providing precise meaning to the models to supporting complex verification and validation activities. In many applications, these constraints have to be solved to obtain values satisfying the constraints, for example, in the case of model-based testing (MBT) to generate test data for the purpose of generating executable test cases. In our previous work, we proposed novel heuristics for various OCL constructs to efficiently solve them using search algorithms. These heuristics are enhanced in this paper to further improve the performance of OCL constraint solving. We performed an empirical evaluation comprising of three case studies using three search algorithms: Alternating Variable Method (AVM), (1ź+ź1) Evolutionary Algorithm (EA), and a Genetic Algorithm (GA) and in addition Random Search (RS) was used as a comparison baseline. In the first case study, we evaluated each heuristics using carefully designed artificial problems. In the second case study, we evaluated the heuristics on various constraints of Cisco's Video Conferencing Systems defined to support MBT. Finally, the third case study is about EU-Rent Car Rental specification and is obtained from the literature. The results of the empirical evaluation showed that (1ź+ź1) EA and AVM with the improved heuristics significantly outperform the rest of the algorithms.

A comprehensive modeling framework for role-based access control policies

Prohibiting unauthorized access to critical resources and data has become a major requirement for enterprises; access control (AC) mechanisms manage requests from users to access system resources. One of the most used AC paradigms is role-based access control (RBAC), in which access rights are determined based on the user’s role.Many different types of RBAC policies have been proposed in the literature, each one accompanied by the corresponding extension of the original RBAC model. However, there is no unified framework that can be used to define all these types of policies in a coherent way, using a common model.In this paper we propose a model-driven engineering approach, based on UML and the Object Constraint Language (OCL), to enable the precise specification and verification of such policies. More specifically, we first present a taxonomy of the various types of RBAC policies proposed in the literature. We also propose the GemRBAC model, a generalized model for RBAC that includes all the entities required to define the classified policies. This model is a conceptual model that can also serve as data model to operationalize data collection and verification. Lastly, we formalize the classified policies as OCL constraints on the GemRBAC model.

Generating Test Data from OCL Constraints with Search Techniques

Model-based testing (MBT) aims at automated, scalable, and systematic testing solutions for complex industrial software systems. To increase chances of adoption in industrial contexts, software systems can be modeled using well-established standards such as the Unified Modeling Language (UML) and the Object Constraint Language (OCL). Given that test data generation is one of the major challenges to automate MBT, we focus on test data generation from OCL constraints in this paper. This endeavor is all the more challenging given the numerous OCL constructs and operations that are designed to facilitate the definition of constraints. Though search-based software testing has been applied to test data generation for white-box testing (e.g., branch coverage), its application to the MBT of industrial software systems has been limited. In this paper, we propose a set of search heuristics targeted to OCL constraints to guide test data generation and automate MBT in industrial applications. We evaluate these heuristics for three search algorithms: Genetic Algorithm, (1+1) Evolutionary Algorithm, and Alternating Variable Method. We empirically evaluate our heuristics using complex artificial problems, followed by empirical analyses of the feasibility of our approach on one industrial system in the context of robustness testing. Our approach is also compared with the most widely referenced OCL solver (UMLtoCSP) in the literature and shows to be significantly more efficient.

Translating natural language constraints to OCL

Object Constraint Language (OCL) is the only available language to annotate the Unified Modeling Language (UML) based conceptual schema (CS) of a software application. In practice, the constraints are captured in a natural language (NL) such as English and then an OCL expert manually transforms the NL expressions to OCL syntax. However, it is a common knowledge that OCL is difficult to write specifically for the novel users with little or no prior knowledge of OCL. In recent times, model transformation technology has made transformation of one language to another simpler and easier. In this paper we present a novel approach to automatically transform NL specification of software constraints to OCL constraints. In NL to OCL transformation, Semantics of Business Vocabulary and Rules (SBVR) standard is used as an intermediate representation due to a couple of reasons: first of all, SBVR is based on higher order logic that simplifies the transformation of SBVR to other formal languages such as OCL. Moreover, SBVR used syntax of natural language and thus is close to human beings. The presented NL to OCL transformation via SBVR will not only simplify the process of generating OCL constraints but also generate accurate models in less time.

Application of the Ontology Axioms for the Development of OCL Constraints from PAL Constraints

Nowadays, ontologies play a central role in many computer science problems such as data modelling, data exchange, integration of heterogeneous data and models or software reuse. Yet, if many methods of ontology based conceptual data modelling have been proposed, only few attempts have been made to ontology axioms based modelling of business rules, which make an integral part of each conceptual data model. In this paper, we present the approach how ontology axioms can be used for business rules implementation. Our proposal we apply for the transformation of PAL (Protege Axiom Language) constraints (ontology axioms), which is based on KIF (Knowledge Interchange Format) and is part of KIF ontology, into OCL (Object Constraint Language) constraints, which are part of a UML class diagram. Z language is used to formalise the proposal and describe the transformation. The Axiom2OCL plug-in is created for automation of the transformation and a case study is carried out.

Test data generation for web application using a UML class diagram with OCL constraints

In this paper, we report on our current work toward efficient and effective verification of web application's basic design. We use a UML class diagram with Object Constraint Language (OCL) to describe the application behaviors and data constraints. Then we generate test data from the formally represented specifications. We make the observation that key web application behaviors can be captured through table size constraints as well as data constraints like foreign key constraints. Based on the observation, we translate the OCL specification into the equivalent constraints using table size expressions. We present a scheme to generate test data from the translated constraints using a Satisfiability Modulo Theories solver. We employ two techniques to reduce constraints. The first is string handling and the other is decomposition of table structures. We also report on an experimental result of test data generation. The result indicates a potential that our scheme works well for real applications in reasonable times.

Using Hierarchical Transformation to Generate Assertion Code from OCL Constraints

Object Constraint Language (OCL) is frequently applied in software development for stipulating formal constraints on software models. Its platform-independent characteristic allows for wide usage during the design phase. However, application in platform-specific processes, such as coding, is less obvious because it requires usage of bespoke tools for that platform. In this paper we propose an approach to generate assertion code for OCL constraints for multiple platform specific languages, using a unified framework based on structural similarities of programming languages. We have succeeded in automating the process of assertion code generation for four different languages using our tool. To show effectiveness of our approach in terms of development effort, an experiment was carried out and summarised.

Validation of Temporary Delegation and Revocation of Roles with UML and OCL

Organizations having a large number of employees face several difficulties to separate job assignments to individual users. The situation becomes more complex when job assignments are delegated to those users who fulfill some explicit conditions. The delegation models developed so far discuss various issues regarding delegation of roles, but no mechanism has been developed to specify and validate constraints which are applied in course of temporary delegating (temporal delegation) and revoking a role to and from a user. This paper proposes a validation mechanism for flexible delegation and revocation of job roles to and from users with specific conditions. Also, we attempt to specify and validate n-level delegation and cascading/non-cascading revocation processes in an organization. I. INTRODUCTION Security has been a major issue in the development of software for networked organizations. As the number of employees of an organization may vary with variable job assignments, therefore it becomes complicated to manage job assignments to various users. To cope with such situations Role Based Access Control Model (RBAC) (1) was proposed for advanced access control as it reduces complexity and cost of security administration in specifically those applications which are networked and are accessed by large number of users with variable job assignments. In various organizations, users have permissions to delegate their job rights to other users at specific time periods with some restrictions. In the same way users can revoke the delegated rights after some time period. Almost all major organizations facilitate their users to delegate their job assignments to other users when work load of users cross certain limits or when the authorized user is unavailable. Therefore, delegation of rights and roles are followed by certain constraints which must be accomplished and only after that, job assignments be delegated to other users. For example, Ahmed delegates task review voucher to Mariam on wednesdays during a staff meeting or Dr. Sohail delegates treat patient task to a nurse when he is at home. The delegation models developed by (3), (4), (5) deal with on delegation of rights to other users, but have not specified any constraint in a formal language which limit temporal delegation of rights of one user to others. Therefore, it is required to develop a mechanism to specify and validate constraints applied on temporary delegation of roles and revocation of roles, that is, for short period of time when the actual user is engaged in some other activity or not available, with the help of a formal language so as to ensure that job assignments are granted and revoked accurately. In this article, we propose a delegation/revocation mechanism with the help of pre conditions and post conditions applied on delegation and revocation methods of an organization. In addition, the reason behind this paper is to specify constraints on delegation in a formal language and validate them with the help of a tool. We use the Unified Modeling language (UML) and the Object Constraint Language (OCL) for the specification of delegation and revocation schemes. We validate the delegation constraints with the help of the USE tool (UML-based specification environment), a validation tool for UML models and OCL constraints (2).

Toward an Integrated Tool Environment for Static Analysis of UML Class and Sequence Models

There is a need for more rigorous analysis techniques that developers can use for verifying the critical properties in UML models. The UML-based Specification Environment (USE) tool supports verification of invariants, preconditions, and post- conditions specified in the Object Constraint Language (OCL). Due to its animation and analysis power, it is useful when checking critical non-functional properties such as security policies. However, the USE requires one to specify a model using its own textual language and does not allow one to import any model specification files created by other UML modeling tools. Hence, you would create a model with OCL constraints using a modeling tool such as the IBM Rational Software Architect (RSA) and then use the USE for the model verification. This approach, however, requires a manual transformation between two different specification formats, which diminishes advan- tage of using tools for model-level verification. In this paper, we describe our own implementation of a specification transformation engine based on the Model-Driven Architecture (MDA) framework. Our approach currently supports automatic tool-level transformations to USE from UML modeling tools built on the Eclipse-based Modeling Framework (EMF).

Precise design of environmental data warehouses

People use data warehouses to help them make decisions. For example, public policy decision-makers can improve their decisions by using this technology to analyze the environmental effects of human activity. In production systems, data warehouses provide structures for extracting the knowledge required to optimize systems. Designing data warehouses is a complex task; designers need flexible and precise methods to help them create data warehouses and adapt their analysis criteria to developments in the decision-making process. In this paper, we introduce a flexible method based on UML (Unified Modeling Language). We introduce a UML profile for building multi-dimensional models and for choosing different criteria according to analysis requirements. This profile makes it possible to specify integrity constraints in OCL (Object Constraint Language). We apply our method to the construction of an environmental system for analyzing the use of certain agricultural fertilizers. We integrate various data sources into a multi-dimensional model showing several categories of analysis, and the consistency of data can be checked with OCL constraints.