The Object Constraint Language (OCL) is frequently used to specify additional constraints on models, in addition, to the ones enforced by semantics of the models. It is a wellknown fact that due to the lack of familiarity with OCL, practitioners and even researcher to some extent are reluctant in using OCL. To help practitioners and researchers in writing OCL constraints for their specific problem at hand, we developed a tool called interactive OCL (iOCL) for interactively specifying constraints on a given model. The basic philosophy behind the tool is to present only those details (e.g., operations) of OCL to modelers that are valid at a given step of constraint specification process, in addition to helping modelers with its syntax. Our ultimate aim is to reduce the effort required to specify constraints, subsequently lowering down training cost and increasing the correctness of the constraints. iOCL is a web-based application that integrates other tools including Eclipse OCL for validation and evaluation of OCL constraints, and EsOCL for automatically generating valid instances of models that satisfy the specified constraints.
To successfully apply a model-based engineering (MBE) solution in practice, the key
challenge to overcome is to construct required models in a cost-effective manner. For
example, applying a model-based testing solution requires test engineers to construct
test ready models in a particular modeling language (e.g., Unified Modeling
Language (UML) [
The underlying idea behind iOCL is to guide users through constraint specification process step by step, in an interactive manner. There are three types of user operations in iOCL: selection, basic value input, and text input. Through these three user operations, a user interacts with iOCL to specify OCL constraints. The overall aim of iOCL is to minimize the use of the value input and text input operations and maximize the use of the selection operation; therefore, chances for users to make errors can be reduced. In addition, it decreases the extent of OCL knowledge required from a modeler. The selection user operation is performed by making a choice from a list of available options provided by iOCL that are valid at a given step in constraint specification step. Depending on the type of the UML model element, an association end multiplicity, or even the type of a collection resulting from one or more navigations from the contextual classifier, iOCL dynamically updates selection options at a given step of a specification process. Regarding the basic value input user operation, users are prompted to input basic values for basic types when necessary, at a given step of a specification process. For example, iOCL displays a text box for users to input an integer value for an integer type of properties. In terms of the text input user operation, there are two situations, where users can input text in a text box.
iOCL aims to automate an OCL constraint specification process as much as possible. The key automation of iOCL is to dynamically shortlist available options at any given step, such that a user can perform the selection user operation in a more efficient way. With this objective in mind, iOCL systematically checks the UML model, the already specified partial OCL constraint and the current step of the specification process. The second key automation feature of iOCL is to categorize types of constraints, OCL operations, and properties and only display relevant ones at a given step. This feature helps to reduce specification effort and potential errors that a user might make when manually writing an OCL constraint. iOCL also allows a user to roll back to previous steps of a specification process. Moreover, iOCL automatically takes cares of bracket pairing and automatically fills out left and right brackets thus assisting a modeler with syntax.
iOCL is a web-based application, which is built on various existing technologies:
Eclipse Modeling Framework (EMF) [
The architecture of iOCL is presented in Figure 1. As shown in the figure, iOCL has
five key functionalities: 1) reading an UML model, on which OCL constraints can be
specified, 2) specifying constraints, 3) validating specified constraints, 4) evaluating
the correctness of specified constraints, and 5) exporting specified OCL constraints
and relevant information. A UML is first loaded and then parsed. The obtained model
elements are stored in a model repository, which are queried by Specifier to support
the interactive specification of OCL constraints. The implementation of Constraint
Validator and Evaluator relies on three existing technologies: Eclipse UML2, Eclipse
OCL and EsOCL [
The implementation of the iOCL tool is divided into two parts: Front End and
Back End. The Back End of iOCL implements the five functionalities described
above. The Front End of iOCL is in charge of the interaction with users via user
interfaces, which is implemented with JavaServer Faces (JSF) [
In this section, we present screenshots of the key functionalities of iOCL. The YouTube video can be found from the link below: https://www.youtube.com/watch?v=Wgi9YYMp7Q4
The screenshot above displays the initial interface of the tool. One can select a
model, which can be either .uml or .ecore file, to start with. For the convenience, in
the current interface, we also provide two examples available: the Royal and Loyal
case study and the UML 2.4 metamodel. The original Royal and Loyal case study is
from [
When one selects the context, iOCL automatically displays a list of options: Invariant, Pre Condition, Post Condition, etc. Of course, a user can also roll back to her/his previous selection via the Back button, shown in the screenshot above.
From the screenshot shown above, when a user selects the context, a list of options is displayed in the Attribute Scope pane. When the user selects the Local Attribute option, a dropdown list is displayed to show all the local attributes of class Customer, as shown in the screenshot below.
When the user finishes the specification, she/he can click the Validate button to validate the syntactic correctness of the specified constraint and results will be returned to the user in a second, as shown in the screenshot below.
One can also switch from one panel to another if needed. As shown in the screenshot below, during the specification process, one can switch to Operation Type panel, which triggers the display of a list of operation types such as Comparison Operation.
One can also evaluate the specified constraint based on predefined instances by clicking the Evaluate button, as shown below. Relying on EsOCL, iOCL also helps in assessing the correctness of the specified constraint. If EsOCL can solve the constraint provides an instance, it means that the constraint is correctly specified and is solvable. Otherwise, there are two options, either the specified constraint may have an issue and a warning will be given to the end user or EsOCL wasn’t successful in solving the constraint. 4.
We presented an interactive OCL constraint specification tool called interactive OCL (iOCL) with the aim of assisting modelers in interactively specifying OCL constraints. The underlying idea behind iOCL is to present only the relevant details to a modeler at a given step of constraint specification process in addition to pre-filling the syntax with the aim of reducing the OCL knowledge required to specify constraints and ultimately reducing the training cost of using OCL.