3.1.1 Test Generation From OCL Constraints

As the constraint specification language on models, OCL is widely used for test data generation during model-based testing (MBT). In MBT, the constraints on the models (for example, guards on the state machines, invariants) need to be resolved in order to generate test cases from models. As an example, consider the simple state machine shown in Fig. 2 containing two states. During testing, a test case triggers the call event operation: markAccountDormat with the goal of transitioning from the Active state to Dormant state. For the transition to successfully complete, the guard on the transition written as an OCL constraint: amount < minBalance and isActive = false has to be satisfied. The test case to be executed should contain the data that satisfies the target guard condition. Similarly other OCL constraints written as pre- and postconditions of operations, class invariants, and guards in states also need to be satisfied during testing.

A number of works have specifically targeted test data generation from OCL constraints that can be used during MBT. Following we discuss these techniques.

One of the earlier works in this area is by Benattou et al. [18] which discusses an approach of test data generation from OCL specifications that is inspired from existing works in the area for test generation from VDM formal specification. The approach uses partition analysis of OCL expressions written as invariants and pre- and postconditions. The expressions are converted into disjunctive normal form to identify disjoint partitions for test generation. The work is one of the initial works to deal with test generation from static structure models and OCL.

Salas et al. [43,44] present a fault-based test case generation approach for OCL pre- and postconditions. The OCL expressions are mutated with faults and test cases are generated using partition analysis and constraint solving to kill these mutants. To automate the process, a prototype test case generator tool is developed that supports OCL.

Li et al. [45] present a test case generation approach from UML sequence diagrams and OCL expressions. The input sequence diagram is converted into a tree, which is used to extract the various condition predicates. The approach generates test data from the condition predicates by applying function minimization technique. The generated test cases successfully achieves message path and constraint attribute coverage of all the objects related to a message in the sequence diagram. The effectiveness of the approach is evaluated on an order ticketing system case study.

Bouquet et al. [36] present a functional testing approach that generate and manage test generated from UML/OCL models. The approach describes a MBT process from the functional requirements till the generation and execution of test case. Currently, three models including class diagram, object diagram, and state machine diagram are used for test generation. The approach describes modeling and automated test generation of a particular functionality of the StarUML project management framework.

Wießleder et al. [46,47] present an automatic test case generation approach for UML state machine, UML class diagram, and OCL expressions to satisfy boundary-based coverage criteria. OCL expressions on operations as pre- and postconditions and guard conditions of state machines are correlated to generate input partitions. From the input partitions, test suites are generated to satisfy boundary coverage criteria. To achieve boundary coverage, multiple coverage criterion including MC/DC is used. The authors use mutation testing to evaluate the effectiveness of the approach for the above coverage criteria and use part of a model of an elevator control example for explanation.

Noikajana et al. [48] present an approach for generating test cases for web services. The contracts are written in web service semantic language (WSDL-S) which is an extension of the web service description language, and OCL is used for describing services rules. From service rules specified in web service descriptions, pre- and postconditions of the various operations are extracted. A pairwise testing technique is used to generate test cases utilizing specific expressions of pre- and postcondition. To evaluate the effectiveness of the approach mutation testing is used on two web service examples. The generated test cases achieve desired coverage and kill all introduced mutants.

Brucker et al. [49] present an extension for specification-based testing. UML and OCL are used to represent specifications formally. In specifications, object graphs are described as states and state transitions are described using class model and state charts. The work uses deductive theorem prover for generating test cases from specifications written in OCL. The approach widely supports OCL language features, including recursive query operations. Equivalence relations are used for representing object identity instead of object graphs. The technique complies with HOL test generation system. The approach is demonstrated on various Linked list examples.

Cheon et al. [50] present an automated testing approach for Java programs that use OCL constraints as test oracles. The approach uses random algorithms for test generation. The work uses OCL constraints as test oracles by translating OCL into run-time checks using AspectJ.

Ascari et al. [51] present a mutation-based testing approach for class testing using OCL specifications and aspect-oriented programming. The paper focuses on specification faults by allowing validation of the implemented code according to the specifications. The approach is illustrated on a case study. A controlled experiment is also conducted to ensure the applicability of the proposed approach.

Jalila et al. [52,53] present an automated fault-based system specification testing framework. The specification is written in OCL. Based on OCL predicate-based fault classes, possible faults in the specification are anticipated and mutated in system under test. For the generation of test cases genetic algorithms with simulated annealing technique are used. To evaluate the generated data, a fitness function based on OCL predicate is defined. The branch coverage adequacy criterion is used for test generation. The experimental results indicate that the proposed methodology provides more coverage with minimum number of generated tests.

Ali et al. [16,54,55] present a search-based test data generation approach by solving OCL constraints. Authors formulate the test data generation approach as a search problem and uses various search heuristics to guide the search to solve OCL constraints. Solving of OCL constraints using search heuristics not only supports OCL collections, but also generates test data efficiently. To evaluate the search heuristics, multiple experiments on artificial and industrial case studies have been conducted for three search algorithms: Genetic Algorithms (GA), Evolutionary Algorithms (1 + 1(EA)), and Alternating variable algorithms (AVM). The empirical evaluations suggest that approach is significantly better than the existing OCL solvers. The approach is automated and fully supported by a tool.

Ali et al. [56] present a test data generation approach by generating boundary values from OCL constraints. The authors extended their previous works [16,54,55] by generating test data at the boundaries of each of the variable in a constraint. The authors discuss various cases involving different types of variable where authors rewrite the constraints for the generation of boundary values. For automated generation of boundary values ESOCL tool is created. Empirical evaluations on industrial case studies are conducted, which show that among the three search algorithms (AVM, (1 + 1) EA, and GA) the performance of AVM in terms of success rate is significantly higher than the other two in finding all the boundary values of constraints in fewer generations.

Chunhui et al. [57] present a use case modeling approach for system tests generation (UMTG) that automatically generates executable system test cases from use case specifications and a domain model. Authors combine natural language processing (NLP) with constraints for automated identification of test scenarios and test inputs. To extract behavioral information from use case specifications by means of NLP, their approach relies on use case specifications expressed in a restricted format. OCL is used to refine guard, pre-, and postconditions which are automatically identified by NLP. An algorithm is designed that builds path conditions that capture the constraints under which alternative flows are executed. The algorithm automatically identifies test inputs by solving such path conditions with the aid of an OCL constraint solver. The approach is demonstrated on industrial case study which shows that UMTG works well with use case specifications for an automotive sensor system.

As presented in Table 4, OCL constraints on the models need to be satisfied during MBT. The approaches in literature vary from converting OCL into some sort of formalism (e.g., VDM) and then applying the existing set of tools for data generation to more sophisticated strategies specifically targeting OCL constructs. A major challenge when converting OCL to the formal approach is state explosion problem, especially when dealing with collections (e.g., OCL Bag). On the other hand, the latter approaches, including search-based test data generation approaches that solve OCL constraints, show very promising results [16,25,52,54,56,58].

3.1.2 Model Verification and Validation

This section summarizes the existing literature on OCL-based verification and validation approaches for UML models. The use of OCL in model verification and validation ensures consistency between various UML models and their specification as per the requirements. Following, we present the OCL-based model validation and verification techniques.

Chiorean et al. [59] show the use of OCL in checking UML model consistency. The paper discusses a tool Object Constraint Language Environment (OCLE) that allows specification of OCL constraints, both at model and meta-model level. The OCLE tool uses the rules specified on the models to check for inconsistencies. The work is demonstrated on two examples, where the OCLE is used to specify rules related to UML. The models for the examples are then validated using OCLE. The work is an earlier work in the area and demonstrates the usefulness of OCL in identifying inconsistencies during modeling.

Richter et al. [60,61] present UML-based Specification Environment (USE) tool to validate models and OCL constraints. The authors formally define UML class diagram and provide precise definition of OCL language such that ambiguous interpretation for both the OCL and UML class diagram are avoided. On the basis of formal specifications, the tool was developed that support analysis, simulation, transformation, and validation of UML models with OCL constraints. The developed tool was used to validate well-formedness rules in UML class diagram.

Ziemann et al. [62] discuss an application of USE tool to validate OCL specification of industrial case study of advanced automatic train control system of Bay Area Rapid Transit (BART) system. The specifications of BART are validated by specifying using OCL constraints. The OCL specification expresses train speed, acceleration, and updated positions. The OCL specifications are validated with several test scenarios using USE tool by generating object diagram for a command file comprising of object creation and link creation instructions. The generated object diagram shows violation along with some inconsistencies for a particular constraint specified in OCL.

Richter et al. [63] present an aspect-oriented approach that helps in validating and testing of software program against the constraints specified on UML models. The focus of the approach is on defining monitors that observe the behavior of program and maps it to the model. For defining monitors aspect orientation is used that instruments the program without making any change in the application code. The monitoring approach provides mapping that ensures clear separation of abstraction level between the program behavior and the model behavior. The approach is applied on multiple examples.

Gogolla et al. [64–66] propose an automated snapshot generation-based validation approach for UML and OCL models. A snapshot represents system states that consist of objects having attributes’, values, and links. A language ASSL (A Snapshot Sequence Language) is also proposed for constructing snapshots. The USE tool is extended to support ASSL and automated generation of consistent snapshots. The approach is also applied on multiple case studies and is successfully able to generate various snapshots.

Sohr et al. [67] proposed an approach to specify and validate authorization constraints. Authorization constraints are used to express high-level security policies for an organization. The paper focuses on nontemporal and history-based authorization constraints which are specified using OCL. The paper addresses the challenges for identification of conflicting and missing constraints. The paper also demonstrates how role-based access control (RBAC) constraints are validated using the USE tool.

Gogolla et al. [68] describe how USE tool can be utilized for ensuring consistency, independence, and checking of UML and OCL models using test scenarios. A test scenario used in the approach is a test case comprising of UML object or sequence diagram. To achieve consistency, a positive test case is created such that all invariants on model must hold. To achieve independence, a test case keeps UML models small such that no single invariant can be concluded from other stated invariants. For drawing conclusions (consequence) only basic properties are formulated as invariants. OCL plays key role in the approach since it is used for formulating constraints, reducing the test search space, and formulating search space properties.

Kuhlmann et al. [69–71] present a lightweight validation approach that uses model instances and relational logic for performing model validation. The existence or nonexistence of certain properties in model instances is used to draw conclusion about various model properties. The approach translates UML and OCL model to a relational logic and the USE tool is used for SAT solving. The approach uses bidirectional transformation in which UML class diagram and OCL concepts are transformed to and from relational logic. A uniform representation for OCL collection and string operations is also provided that helps in automated model validation [70]. Various OCL collections kinds such as set, bag, ordered set, sequence, and string-based operations are successfully represented in relational form to be used for the purpose of validation. The approach is implemented and applied on several examples.

Gogolla et al. [72] present an approach that performs automatic checking of features in UML and OCL model. The approach relies on USE tool and targets invariant independence. The approach is applied on a model transformation case study. The model transformation used as an example is a transformation from an entity relationship (ER) to relational database schema. The approach uses UML and OCL models for describing system structures. The approach is able to provide proof for the properties like model constraint independence and checking of redundancy absence in invariant sets.

Clavel et al. [73] present a rewriting-based automated UML class diagram validation tool. The tool validates the UML class diagram with respect to OCL constraints. The tool implementation is based on the equational specification of UML and OCL models which are written in Maude. Maude is a reflective programming language that implements membership equational logic and rewriting logic.

Chae et al. [74] propose an OCL-based approach for validating constraints written on class diagrams. The approach detect potential problem by performing analysis on constraint specified at class diagram. The approach is applied on four case studies related to information systems. The classes used in the case studies are classified as boundary classes, entity classes, and control classes to show the diversity. The approach is integrated in a UML modeling tool that generates warning at design time whenever a change made in analysis class.

Rull et al. [75] present a tool called AuRUS that analyze UML/OCL conceptual schemas to ensure their correctness. The tool instantiates a sample conceptual schema representing a particular situation and ensures that the required property in a schema does hold. The tool also provides explanation for unsatisfiability when a property is contradicting.

Czarnecki et al. [76] present an automated model verification technique for product lines. The technique uses feature-based model templates against the well formedness of OCL constraints. The methodology aims to ensure that no nonconforming template instance will be generated from a correct configuration. The OCL constraints are mapped to propositional formulas, which are solved by using SAT solver. The approach is implemented as a plug in to IBM Rational Software Modeler. The methodology ensures that no nonconforming template instance is generated from a correct configuration. OCL constraints are mapped to propositional formulas, which are solved by using SAT solver.

Cabot et al. [23,24,77] present an automated constraint programming methodology to verify UML models extended with OCL and operation contracts. Both the dynamic and static aspect of the system were successfully translated into constraint satisfaction problem (CSP) using UML to CSP tool and formally verified. Their methodology transforms a UML class diagram annotated with OCL constraints into a CSP. The resulting CSP is able to be verified against the original UML/OCL properties.

Demuth et al. [30] present use of Dresden OCL toolkit for model verification. Dresden toolkit is typically extended by the developer and designers to provide OCL support. The applications show how precise semantics are specified on both the model and the meta-models using OCL for verification. Authors have classified and discussed several OCL use cases supported by Dresden including model verification, testing design by contract, model transformation, code generation, etc.

Soeken et al. [78] present a Boolean satisfiability-based approach for verifying UML/OCL models. Authors describe how various states of UML model along with OCL constraint and respective verification task are encoded as SAT instance and automatically solved using off the shelf SAT solver. Furthermore, the authors perform an experiment to evaluate SAT-based UML/OCL model verification. The results show that SAT-based verification is faster when compared with other approaches.

Shaikh et al. [22] present a slicing technique that partitions the model into slices and verifies each slice independently. During slicing the property under verification is preserved. However, the approach is applicable only on class diagram which is annotated with unrestricted OCL constraints and other specific properties required to be verified.

Hilken et al. [20] present the idea of a base model that can be used in automatic verification. The base model represents core elements that can be used to express the important aspects of the system. Authors use transformations for expressing complex language constructs into relatively smaller one. This transformation enables the base model to be used with various verification engines.

Hilken et al. [21] present a comparison of two verification approaches for UML and OCL behavioral model and highlight their advantages and disadvantages. The approaches used for the comparison are filmstrip and unrolling. In filmstrip, UML/OCL descriptions which represent all the behavioral model elements are represented as static description and afterward are checked for interesting properties. In unrolling the dynamic behavior of the UML model is represented as skeleton and verification tasks are directly applied using Satisfiability Modulo Theory (SMT) and solving engines.

Przigoda et al. [79] present a methodology that translates UML behavioral and structural models enriched with OCL constraints into symbolic formulation. The authors also discuss how the symbolic formulation helps to perform various verification tasks such as consistency, reachability, etc. The authors proposed approach is almost fully automatable with limited human intervention. The presented framework used SMT solver to solve the symbolic formulation efficiently.

Anwar et al. [19] present a model verification technique for embedded systems. The authors use model-based software engineering and system verilog assertions (SVA) to handle the design verification aspect of embedded system. They have proposed an extension for system verilog as system verilog OCL (SVOCL) to represent the design verification requirements by means of SVA’s. Transformation engine is also developed to ensure automation. The approach is evaluated on multiple case studies.

Fu et al. [80] present an approach that translates OCL invariants into web ontology language (OWL) axioms for inconsistency checking. The approach is evaluated using the TUCO prototype tool. The approach translates wide range of OCL expression into OWL axioms. The authors present the semantics and other preliminaries of OCL for proving correctness of the translation. To prove the correctness, induction on OCL structure is used. The TUCO tool successfully translates the OCL constraints and performed consistency checking on example study.

As presented in Table 5, OCL is extensively used for the verification and validation of systems and models. The USE tool [60] is widely used by researchers [61–66] for validating UML models. There are also numerous applications of model verification such as verifying configurations of the feature model with OCL constraints in product lines [76], design verification of embedded systems using SVA [19], transformation of OCL constraints to CSP [77], slicing of UML models for verification using OCL constraints [22], and translation of UML models into symbolic formulation using SMT solvers [79]. An important benefit of using OCL for verification and validation is tool support for automation. Most of the approaches related to model validation and verification convert OCL to some sort of formalism and a number of these only support a limited subset of OCL.

3.5.1 Formalizing OCL

Since OCL is considered as a semiformal constraint specification language, a number of research works have focused on formalization of semantics of OCL. The formalization helps in automation and removes ambiguities in syntax and semantics of OCL.

Rickters et al. [99] highlight early efforts in formalizing the semantics for OCL. The paper describes and defines the syntax and semantics of OCL expressions and provides examples for their evaluations. The authors identify basic syntactic structures and assign semantics to them based on the set theory. The authors also provide solution to implicit flattening of complex results. The paper also discusses various issues resulting in an illegal expression evaluation and suggests various language improvements.

Brucker et al. [100] present a new formal model of OCL by embedding it into Isabelle/HOL language. The work provides automated reasoning support to OCL using a formal calculus to encode OCL semantics. The work also discusses an automated deduction technique based on derived rules from OCL semantics. The proposed methodology is applied on the application of test case generation for the triangle problem.

Roe et al. [101] present a mapping of UML models having OCL constraints to Object Z. The mapping uses the modeling constructs and generates Class skeleton in Object Z. The OCL constraints are also converted to Object Z schema. The authors also discuss the tool developed and the comparison of the proposed mapping with the existing approaches.

Kyas et al. [102] present a prototype tool that analyzes the syntax and semantics of OCL constraints together with UML model and translates them to the Prototype Verification System (PVS) theorem prover language. The UML class diagrams and state machines are translated to PVS. The translation process has successfully been applied on multiple industrial case studies.

Formalization of OCL has been an active area of research in which syntax and semantics of the OCL language are converted into a formal language for better reasoning. Formalization also helps in the extraction of illegal expressions. As presented in Table 9, the literature addresses numerous approaches [24,77,95] that focuses on the conversion of OCL semiformal syntax and semantics into more formal models. Formalizing OCL is still an open research direction to remove ambiguities and allow automated reasoning on OCL constraints. The major challenge in this regard is to introduce formalism without significantly complicating the syntax of the language.

3.5.2 Use of OCL in Model Transformations

Transformations are a fundamental part of MDE that deals with transforming models from one representation to another. Transformations take as input a source model that conforms to a source meta-model as input and generate a target model that conforms to a target meta-model based on a set of rules that map the source meta-model elements to target meta-model elements. The meta-models typically comprise of a large set of elements, which are restricted by a number of constraints usually written in OCL. In addition to constraints at meta-level, OCL is also used as a part of transformation language. In the following, we discuss the use of OCL in the area of model transformation.

Schürr et al. [103] describe the challenges associated with use of OCL as a graph transformation language. The OCL is compared with a graph transformation, PROGRESS, which is a path expression-based language. The PROGRESS language is similar to OCL in many ways, for example, operation manipulation in both works on class diagrams, both languages support collections and single object path expressions. However, in contrast with OCL, PROGRESS path expression supports functional abstraction and offers additional operators for conditions that are required for a graph transformation language.

Cariou et al. [104] present a method to verify transformation results with respect to the transformation specification. The work focuses on transforming contracts written in OCL for the verification of target transformation. A transformation contract represents expected transformation behavior using pre- and postcondition and invariants on transformation rules. A precondition of a transformation contract specifies state of a model before a transformation and postcondition contract specifies the state of a model after transformation. The proposed verification method is generic and can be applied on both manual and automatic transformations.

Cabot et al. [105] present an automated transformation approach from UML to SBVR (semantics of business vocabulary and rules) specification. The approach is able to extract OCL expressions used in the UML. The SBVR specification is used to describe business policies and rules in a language models that is closer to natural language. The proposed transformation aims to reduce the communication gap between modelers and business managers.

Bajwa et al. [106] present rule-based transformation approach to translate SBVR business rules into OCL. The automated transformation from SBVR rules to OCL constraints reduces the manual effort which is complex and time-consuming. The approach is implemented in SBVR2OCL prototype tool. The transformation is based on rules that are derived from the abstract syntax of SBVR and OCL. The approach is fully automated and requires business rules and target UML model as input.

González et al. [107] present a test data generation approach for model transformations by combining the partition and constraint analysis. For the generation of test data, the approach analyzes the OCL constraints in the source meta-model to fine-tune the partitions. The approach provides support of various OCL constructs and offers three different test model generation modes: a simple mode, multiple partition mode, and unique partition mode. A supporting tool is also implemented that can be used with other model generation approaches.

Jilani et al. [108] present a search-based test data generation approach for model transformation testing. The proposed approach uses search-based algorithms for test data generation. The approach is able to solve OCL constraints which are specified at meta-model level. The search algorithms used for generation are based on meta-heuristics (such as adoptive random testing). The approach also provides structural coverage of the transformation code and assures that generated test models achieve desired transformation code coverage. MOTTER tool is developed and successfully applied on Class to Relation database transformation example.

In the area of model transformations, Table 10 shows the approaches that used OCL as a transformation specification language as well as for verification and test generation of model transformations. A number of model transformation languages follow an OCL-like syntax for model query operations, which shows the acceptance of OCL by practitioners.

3.5.3 Instance Generation of Models

The OCL constraints at modeling language definition level (meta-model) typically define the well-formedness rules. These rules define the restrictions that the models developed in the modeling language should follow. A common task during model manipulation is automated generation of models from meta-models (i.e., instances of meta-models). This is typically referred to as instance generation. Following we discuss the works dealing with instance generation of models by resolving OCL constraints on meta-models.

Winkelmann et al. [109] present an instance generation approach. The approach is based on graph grammar and provides translation of restricted OCL constraints into graph grammar constraints. The approach automatically creates a graph grammar from a given meta-model. The grammar ensures typing and cardinality constraints. A restricted set of OCL constraints is also translated into the grammar that is checked during the process of instance generation. The approach is demonstrated on a state chart example.

Francisco et al. [110] present an approach for automated generation of test models following property-based testing. Property-based testing uses properties for specifying constraints written in OCL and generating tests based on it. The approach uses properties to generate test suites. For automated generation of test cases, QuickCheck tool is used. QuickCheck is an automatic property-based testing tool that allows test case generation, execution, and result analysis. The paper also shows advantages and disadvantages of the proposed approach as compared with the manual test suite generation.

Wu et al. [111] present a SMT-based approach for generating coverage-oriented meta-model instances. The approach uses two techniques for generating the instances. The first technique relies on a standard UML class diagram coverage criterion, while the second technique focuses on satisfying graph-based coverage criterion. Both the criteria defined in the techniques are translated to SMT formula, which are solved using an SMT solver.

Since OCL constraints allow specifying restrictions on UML models, these constraints need to be satisfied during instance generation. Table 11 summarizes the existing instance generation approaches [109–111] satisfy the OCL constraints during the instance generation process. Some of the works transform the applied OCL constraints into an intermediate model, e.g., graphs for better verification and generation of the correct instance. The examples of UML class diagram and state charts are typically used in the literature to demonstrate the results. The OCL constraint solving is a fundamental activity in such approaches. Although the challenge of meta-model instance generation from complex meta-models has not been completely resolved, the existing approaches have potential to be extended for this purpose. There is a vital need for a scalable and efficient approach for automated instance generation from models.

3.5.4 Refactoring and Simplifying OCL Constraints

OCL has been introduced with the intention of being the standard language for specifying constraints on models. Ease of use and understandability are important factors in acceptance of the language by practitioners. While OCL aims to be an easier to use language than the other formalisms, at times OCL expressions and constraints can be quite complex and difficult to understand [112]. Consequently, there have been a number of efforts aimed at making OCL simpler to understand and apply.

Correa et al. [112] proposed a number of refactoring to improve understandability of OCL specifications. The work discusses a number of “OCL smells,” similar to code smells and propose corresponding refactoring. An experimental study is presented to evaluate the impact of OCL smells and refactoring on the understandability of OCL expressions. The results of the study show that the presence of OCL smells has a negative impact on the understandability of OCL expressions. OCL specifications containing OCL smells take longer to understand and are less correct than specifications without them. The work provides useful guidelines for writing OCL constraints in more readable way.

Opoka et al. [113] present a set of OCL libraries, with the aim of simplifying the writing of OCL expressions. The libraries provide a set of useful and reusable OCL expressions. The developed libraries have been successfully used in sample projects demonstrating the feasibility of the approach. The libraries provide reusability, validation support, and documentation support.

Giese et al. [114] discuss the problem of redundancies in OCL specification. Such redundancies reduce the readability of the OCL specifications. The paper presents an approach to transform OCL expressions to simpler forms in the context of constraints expressing requirements. A prototype OCL simplifier is implemented to automate the simplification process.

Aspect orientation has emerged as widely used practice to avoid redundancies in software artifacts. Aspects allow the designers to separate core design elements from various crosscutting behaviors. The crosscutting behaviors are modeled separately in the form of aspects. Khan et al. [115] present an extension to OCL that bring the benefits of aspect orientation to constraint specification. The proposed approach allows the designer to specify core constraints separately from crosscutting constraints. The crosscutting constraints are written separately as constraint aspects, which are then woven in the core constraints using as aspect weaver. One benefit of the approach is that while at design time the crosscutting aspect is written separately, the woven output is a standard OCL specification. This allows the approach to remain compatible with the existing tools and API developed for OCL. The results show that AspectOCL language can be effectively used to capture constraints in industry-scale case studies and can significantly reduce the constraint modeling effort.

Over the years, researchers and practitioners have faced challenges in applying OCL to particular domains due to a lack of constructs in the standard language. To overcome such challenges, new constructs have been added in the form of language extensions. Table 12 summarizes the refactoring techniques presented earlier. The works discussing code smells and libraries can be useful in making OCL more useable and easy to comprehend. However, significant empirical evaluations are further required to evaluate their effectiveness.