Requirements to Analysis Core

R2A core metamodel

The core metamodel of the R2A platform has been initially designed to capture the structural and the functional properties of a system. To this end, the metamodel has been organized into two parts: an analysis metamodel and a functional metamodel. The analysis model captures the static structures of the system described by the requirements in an object-oriented way. The different actors of the system are represented by classes, that have observable properties (attributes and references to other classes) and provide a number of services. The services available for a class correspond to the service activations that are initiated by the actor in a RDL description. The analysis model describes the type system (including classes and primitive data types) of the instances that are manipulated during the requirements simulations (see below).

The functional behavior of the described system is captured by a dedicated functional metamodel. This metamodel consists in a use cases system in which each use case is associated with a pre and a post condition, both expressed as logical expressions.  Each use case is associated with a given service activation (ie a service offered by a class of the analysis model). Its pre condition can be viewed as a predicate the simulated system must validate for the service to be raised. A use case post condition defines a predicate that must be validated by the system once the service has been executed. Each use case has a set of parameters that corresponds to the parameters of the predicates of the use case pre and post conditions.

The R2A core metamodel is currently enriched to provide support for non functional aspects, such as time constraints.

Import of requirements

As illustrated in the platform overview, the R2A prototype has been designed to accept different kinds of requirements descriptions as input. Beside the R2A textual specification that can be directly be parsed into the corresponding R2A model, the platform allows to import requirements from any existing requirements metamodel, or system specification metamodel. For this purpose, the R2A platform integrates a semantic interpreter that makes it possible, for designers, to specify the way the concepts of their input metamodel have to be interpreted into R2A concepts.

The semantic interpreter consists in a pattern interpretation engine that builds R2A model elements (ie both analysis and functional models) from the matched input model elements. Designers who want to directly feed the R2A platform with their own requirements models just have to provide a pattern interpretation model (conform to the pattern interpretation metamodel) that defines the way tye concepts of their metamodel must be interpreted into R2A concepts.

The R2A platform provides a full support for RDL-based requirements import. Therefore, beside the Sts model for RDL, that enables to build a RDM model from a RDL text, it includes a pattern interpretation model for RDM models. Note that a new pattern interpretation model, dedicated to UML activity diagrams, will also be integrated to the prototype.

Requirements simulation

The R2A platform allows to simulate the functional requirements of the described system. The system simulation is a step-by-step simulation that manipulates instances of the analysis model elements. The set of existing instances (ie class instances, including instances of their attributes and references) represent the state of the simulated system at a given time.

At each step, the simulation engine computes the set of use case instances that can be raised in the context of the system current state. A use case instance associates of use case definition (from the functional model) to a set of effective parameters (instances of the system state). Raisable use case instances are those for which the passed effective parameters validate the use case pre condition. In this context, a simulation step consists in applying the post condition of the chosen raisable use case instance to the current system state.

Export of the R2A core model

The R2A platform also includes export functionalities in order to allow designers to reinject the R2A model into external tools. Export feature currently targets three main formalisms:

• UML class diagram and use case model. The UML formalism allows to easily communicate and exchange the information captured by the analysis and the functional models.
  
• Finite state machine model dedicated to time constraints checking.
• Test objective models. They will be used to check that the future implementation correctly meets the requirements.