Verification Of Model Transformations Research Articles

Fault localization in DSLTrans model transformations by combining symbolic execution and spectrum-based analysis

The verification of model transformations is important for realizing robust model-driven engineering technologies and quality-assured automation. Many approaches for checking properties of model transformations have been proposed. Most of them have focused on the effective and efficient detection of property violations by contract checking. However, there remains the fault localization step between identifying a failing contract for a transformation based on verification feedback and precisely identifying the faulty rules. While there exist fault localization approaches in the model transformation verification literature, these require the creation and maintenance of test cases, which imposes an additional burden on the developer. In this paper, we combine transformation verification based on symbolic execution with spectrum-based fault localization techniques for identifying the faulty rules in DSLTrans model transformations. This fault localization approach operates on the path condition output of symbolic transformation checkers instead of requiring a set of test input models. In particular, we introduce a workflow for running the symbolic execution of a model transformation, evaluating the defined contracts for satisfaction, and computing different measures for tracking the faulty rules. We evaluate the effectiveness of spectrum-based analysis techniques for tracking faulty rules and compare our approach to previous works. We evaluate our technique by introducing known mutations into five model transformations. Our results show that the best spectrum-based analysis techniques allow for effective fault localization, showing an average EXAM score below 0.30 (less than 30% of the transformation needs to be inspected). These techniques are also able to locate the faulty rule in the top-three ranked rules in 70% of all cases. The impact of the model transformation, the type of mutation and the type of contract on the results is discussed. Finally, we also investigate the cases where the technique does not work properly, including discussion of a potential pre-check to estimate the prospects of the technique for a certain transformation.

CoqTL: a Coq DSL for rule-based model transformation

In model-driven engineering, model transformation (MT) verification is essential for reliably producing software artifacts. While recent advancements have enabled automatic Hoare-style verification for non-trivial MTs, there are certain verification tasks (e.g. induction) that are intrinsically difficult to automate. Existing tools that aim at simplifying the interactive verification of MTs typically translate the MT specification (e.g. in ATL) and properties to prove (e.g. in OCL) into an interactive theorem prover. However, since the MT specification and proof phases happen in separate languages, the proof developer needs a detailed knowledge of the translation logic. Naturally, any error in the MT translation could cause unsound verification, i.e. the MT executed in the original environment may have different semantics from the verified MT. We propose an alternative solution by designing and implementing an internal domain-specific language, namely CoqTL, for the specification of declarative MTs directly in the Coq interactive theorem prover. Expressions in CoqTL are written in Gallina (the specification language of Coq), increasing the possibilities of reusing native Coq libraries in the transformation definition and proof. CoqTL specifications can be directly executed by our transformation engine encoded in Coq, or a certified implementation of the transformation can be generated by the native Coq extraction mechanism. We ensure that CoqTL has the same expressive power of Gallina (i.e. if a MT can be computed in Gallina, then it can also be represented in CoqTL). In this article, we introduce CoqTL, evaluate its practical applicability on a use case, and identify its current limitations.

Verification of Model Transformations Using Isabelle/HOL and Scala

Model transformations have proved to be powerful in the development of critical systems. According to their intents, they have been used in many domains such as models refinement, simulation, and domain semantics. The formal methods have been successful in the verification and validation of critical systems, and in particular, in the formalization of UML, BPMN, and AADL. However, little research has been done on verifying the transformation itself. In this paper, we extend our previous work using Isabelle/HOL that transforms UML State Machine Diagrams (SMD) to Colored Petri nets (CPN) models and proves that certain structural properties of this transformation are correct. For example, the structural property: “for each final state of a SMD model a corresponding place in CPN model should be generated by the transformation” is described and checked using Isabelle/HOL as invariant property. In the current work, we use Scala as environment of executing Isabelle/HOL specifications and we perform the verified transformation using Scala. Moreover, we demonstrate our approach using another case study of transforming BPMN (Business Process Model and Notation) models into Petri nets models and verify the correctness of certain structural properties of this transformation.

A formal verification technique for behavioural model-to-model transformations

In Model Driven Software Engineering, models and model transformations are the primary artifacts when developing a software system. In such a workflow, model transformations are used to incrementally transform initial abstract models into concrete models containing all relevant system details. Over the years, various formal methods have been proposed and further developed to determine the functional correctness of models of concurrent systems. However, the formal verification of model transformations has so far not received as much attention. In this article, we propose a formal verification technique to determine that formalisations of such transformations in the form of rule systems are guaranteed to preserve functional properties, regardless of the models they are applied on. This work extends our earlier work in various ways. Compared to our earlier approaches, the current technique involves only up to n individual checks, with n the number of rules in the rule system, whereas previously, up to 2n − 1 checks were required. Furthermore, a full correctness proof for the technique is presented, based on a formal proof conducted with the Coq proof assistant. Finally, we report on two sets of conducted experiments. In the first set, we compared traditional model checking with transformation verification, and in the second set, we compared the verification technique presented in this article with the previous version.

Formalised EMFTVM bytecode language for sound verification of model transformations

Model-driven engineering is an effective approach for addressing the full life cycle of software development. Model transformation is widely acknowledged as one of its central ingredients. With the increasing complexity of model transformations, it is urgent to develop verification tools that prevent incorrect transformations from generating faulty models. However, the development of sound verification tools is a non-trivial task, due to unimplementable or erroneous execution semantics encoded for the target model transformation language. In this work, we develop a formalisation for the EMFTVM bytecode language by using the Boogie intermediate verification language. It ensures the model transformation language has an implementable execution semantics by reliably prototyping the implementation of the model transformation language. It also ensures the absence of erroneous execution semantics encoded for the target model transformation language by using a translation validation approach.

An OCL-Based Framework for Model Transformations

Model transformation is an important building block for model-driven approaches. It puts forward a necessity and a challenge to specify and realize model transformation as well as to ensure the correctness of transformations. This paper proposes an OCL-based framework for model transformations. The formal foundation of the framework is the integration of Triple Graph Grammars and the Object Constraint Language (OCL). The OCL-based transformation framework offers an on-the-fly verification of model transformations and means for transformation quality assurance.

Open issues in model transformations for multimodal applications

Multimodal human–computer interaction refers to the interaction with the virtual and physical environment through natural modes of communication. Multimodal input user interfaces have significant role in different domains, for example industrial plants or hospitals, also they have implications for accessibility. To develop multimodal applications in formally rigorous settings, software developer teams may use tools or a software development kit to increase the efficiency and the quality of the resulted software artifacts. Such a technique is performing the design with software modeling and applying model transformations to generate well-defined components of the software. Furthermore, representation-bridging communication is a discipline of cognitive infocommunications, where the sensory information transferred to the receiver entity is filtered and/or converted. Whenever such approaches are used, the challenges associated with the modeling of information requirements, user capabilities and cross-model interactions are compounded and further increase the need for formal design and verification tools. Applying model transformations is a way to support this activity. Communication-intensive solutions often require complex methods, i.e. significant model transformation efforts between the different representations. Important semantic information should be preserved and not misinterpreted in a complex model transformations. Therefore, methods are required to verify that the semantics used during the application generation and analysis are indeed preserved across the transformation. As a case in point, such a model transformation could yield embedded code for a given type of electronic driver assistant system based on a high-level characterizations of the information to be transferred and the driver’s cognitive capabilities. Later, a multimodal interactions expert could easily modify those characterizations on demand, and regenerate a modified version of the software without having to know about the low-level details of the embedded platform. This paper provides a strong motivation regarding the necessity of methods to support verification and validation of model transformations supporting multimodal application development and cognitive infocommunications. As the main result of the paper, we compile a list of open issues in the field of verification/validation of model transformations, and link those issues to the development of multimodal interfaces. Through its discussions, the paper makes the point that the design practices behind multimodal interfaces could strongly benefit from the use of formal modeling techniques in general, and model transformation approaches in particular.

Test-driven verification/validation of model transformations

Why is it important to verify/validate model transformations? The motivation is to improve the quality of the transformations, and therefore the quality of the generated software artifacts. Verified/validated model transformations make it possible to ensure certain properties of the generated software artifacts. In this way, verification/validation methods can guarantee different requirements stated by the actual domain against the generated/modified/optimized software products. For example, a verified/validated model transformation can ensure the preservation of certain properties during the model-to-model transformation. This paper emphasizes the necessity of methods that make model transformation verified/validated, discusses the different scenarios of model transformation verification and validation, and introduces the principles of a novel test-driven method for verifying/validating model transformations. We provide a solution that makes it possible to automatically generate test input models for model transformations. Furthermore, we collect and discuss the actual open issues in the field of verification/validation of model transformations.

Formal Verification Techniques for Model Transformations: A Tridimensional Classification .

In Model Driven Engineering (MDE), models are first-class citizens, and model transformation is MDE's heart and soul. Since model transformations are executed for a family of (conforming) models, their validity becomes a crucial issue. This paper proposes to explore the question of the formal verification of model transformation properties through a tridimensional approach: the transformation involved, the properties of interest addressed, and the formal verification techniques used to establish the properties. This work is intended for a double audience. For newcomers, it provides a tutorial introduction to the field of formal verification of model transformations. For readers more familiar with formal methods and model transformations, it proposes a literature review (although not systematic) of the contributions of the field. Overall, this work allows to better understand the evolution, trends and current practice in the domain of model transformation verification. This work opens an interesting research line for building an engineering of model transformation verification guided by the notion of model transformation intent.

A framework for model transformation verification

AbstractA model transformation verification task may involve a number of different transformations, from one or more of a wide range of different model transformation languages, each transformation may have a particular transformation style, and there are a number of different verification properties which can be verified for each language and style of transformation. Transformations may operate upon many different modelling languages. This diversity of languages and properties indicates the need for a suitably generic framework for model transformation verification, independent of particular model transformation languages, and able to provide support for systematic procedures for verification across a range of languages, and for a range of properties. In this paper we describe the elements of such a framework, and apply this framework to some example transformation verification problems. The paper is novel in covering a wide range of different verification techniques for a wide range of MT languages, within an integrated framework.

APPLYING BLACK-BOX TESTING TO MODEL TRANSFORMATIONS IN THE MODEL DRIVEN ARCHITECTURE CONTEXT

Testing model transformations has played a leading role with the dissemination of MDA in software development processes. Software testing based on bl ack-box testing, together with the “category partitioning” method, can be efficiently used in or der to conduct the verification of model transforma tions. This study employs software testing techniques to a n ATL model transformation in the MDA context and points out their benefits. The black-box testing me thod was adapted to the MT-PROAPES model transformation based on profiles and platform model s. The platform models define the range of input models of the MT-PROAPES and are used for the creation of the test cases. The test cases were selected so as to meet certain requirements and increase the ab ility to detect errors in the model transformation. This approach makes the test process more agile and does not require any abstraction of behavioral properti es of the transformations. The field of transformation te sting and verification still faces significant chal lenges and requires a lot of research. Although having some li mitations, black-box testing conforms to various situations, besides allowing its integration with o ther test strategies.

Model transformation verification using similarity and graph comparison algorithm

Regarding the software development, MDA (Model Driven Architecture) of OMG can be regarded as the concept of making an independently-designed model according to the development environment and language and reusing it according to the desired development environment and language by expanding the reusable unit into the software model when developing software. The problem with these traditional research methods, but the first model, design model for checking the information with the model by defining a formal representation in the form of an abstract syntax tree, as you've shown how to perform validation of UML design model. Additional steps need to define more complex due to a software problem that is not the way to the model suitable for model transformation verification. In this paper, as defined in the verification based meta model for input and target model. And we also suggest how to perform model transformation verification using property matching based transformation similarity and graph comparison algorithm. This paper proposes model transformation verification using verification meta information and transformation similarity by property matching. In addition, in order to support verification of the target model generated from the source model, we define verification meta model for UML model, RDBMS model and RT-UML model. Recent researches from model-based architecture did partial tests focusing on phrase-correctness about the re-use in the perspective of converted software model. To overcome such limitations, this study suggests the ways to define transformation profiles using property information of system structure models as the test-based meta-model and transformation rules, improve graph comparison algorithm, and even supports the correctness of meanings. There were problems in existing methods of model transformation verification such as graph comparison or the one considering only syntax-correctness through pattern-matching. To remedy such problems, this study suggests a new verification method by defining the meta-model which has additional structural attributes and property information and the transformation profile, and using graph comparison algorithm which checks whether the information acquired from transformation is correct.

A survey of approaches for verifying model transformations

As with other software development artifacts, model transformations are not bug-free and so must be systematically verified. Their nature, however, means that transformations require specialist verification techniques. This paper brings together current research on model transformation verification by classifying existing approaches along two dimensions. Firstly, we present a coarse-grained classification based on the technical details of the approach (e.g., testing, theorem proving, model checking). Secondly, we present a finer-grained classification which categorizes approaches according to criteria such as level of formality, transformation language, properties verified. The purpose of the survey is to bring together research in model transformation verification to act as a resource for the community. Furthermore, based on the survey, we identify a number of trends in current and past research on model transformation verification.

Formal specification and analysis of functional properties of graph rewriting‐based model transformation

SUMMARYModel processing programs are regularly used when working with models or synthetizing the code from them; therefore, their verification has become an essential component of constructing reliable software in model‐based software engineering. Models are usually formalized and visualized as graphs; therefore, model processing programs based on algebraic graph rewriting systems—such programs are called model transformations—are often applied, and their verification has become an important research area. The goal of our research is to support offline transformation analysis by automated methods, where offline means that only the definition of the program itself, the language definitions of its source and target models are used during the analysis. Therefore, the results are independent from concrete source models, and the analysis needs to be performed only once. Based on previous work, this paper provides the synthesis and of a set of individual components and improves them to provide a complete verification solution: (i) a language is introduced to specify the properties to be verified; (ii) a formalism to describe model transformations in a declarative way; and (iii) automated algorithms that can analyse the declarative transformations as well as the properties expressed by the language. Besides its theoretical basis, the implementation of a verification framework is presented, and its operation is illustrated on a case study. Although the formal verification of model transformation properties is algorithmically undecidable in general, our goal is to provide a practically usable, scoped framework that can largely facilitate the manual verification of model transformations. Copyright © 2013 John Wiley & Sons, Ltd.

Verification of Model Transformations: A Survey of the State-of-the-Art

Within the Model-Driven Engineering paradigm, software development is based on the definition of models providing different views of the system to be constructed and model transformations supporting a (semi)automatic development process. The verification of models and model transformations is crucial in order to improve the quality and the reliability of the products developed using this paradigm. In this context, the verification of a model transformation has three main components: the transformation itself, the properties of interest addressed, and the verification techniques used to establish the properties. In this paper we present an exhaustive review of the literature on the verification of model transformations analyzing these three components. We also take a problem-based approach exemplifying those aspects of interest that could be verified on a model transformation and show how this can be done. Finally, we conclude the need of an integrated environment for addressing the heterogeneous verification of model transformations.

Design of MDA Based Model Transformation Profile for Model Verification

Validation of existing software design models and transformed target models for the study, mainly checking (Model Checking) with a code-based software designed to define in the abstract syntax tree or on the models generated using refactoring on design models for refinery operations and define how to perform. The problem with these traditional research methods, but the first model, design model for checking the information with the model by defining a formal representation in the form of an abstract syntax tree, as you've shown how to perform validation of UML design model. Additional steps need to define more complex due to a software problem that is not the way to the model suitable for model transformation verification. In this paper, as defined in the MDA based model transformation studies of a graph based mode transformation, and how to perform model transformation verification through improving graph comparison algorithm and model property information.

Editorial: ASE 2012 conference trip report

– Models are becoming essential and integral to software engineering efforts, and often multiple types of models are used in engineering of a single product or line. Yet multiple models bring the added complexity of not only their individual correctness, but the correctness of the relationships among them. In “Automated verification of model transformations based on visual contracts”, Guerra, de Lara, Wimmer, Kappel, Kusel, Retschitzegger, Schonbock, and Schwinger provide a declarative language for specifying correctness contracts governing transformations and explore tool support for verifying them. – Automatically detecting and correcting code defects, especially those that lead to problems in the maintenance phase, has potential to significantly improve the economics of the software lifecycle by reducing the human time needed for this essential task. In “Maintainability defects detection and correction: a multi-objective approach”, Ouni, Kessentini, Sahraoui, and Boukadoum describe a search-based approach to automating this activity. – Refactoring of code is a critical and never-ending task in real world software development. One is constantly discovering new ways of modularizing, grouping, and generalizing the conceptual constructs and structural relationships in one’s code in order to better accommodate future change, clarify or improve correctness, and even to improve performance. One important type of refactoring is when

Graph Based Model Transformation Verification using Mapping Patterns and Graph Comparison Algorithm

Graph Based Model Transformation Verification using Mapping Patterns and Graph Comparison Algorithm

Automated verification of model transformations based on visual contracts

Model-Driven Engineering promotes the use of models to conduct the different phases of the software development. In this way, models are transformed between different languages and notations until code is generated for the final application. Hence, the construction of correct Model-to-Model (M2M) transformations becomes a crucial aspect in this approach. Even though many languages and tools have been proposed to build and execute M2M transformations, there is scarce support to specify correctness requirements for such transformations in an implementation-independent way, i.e., irrespective of the actual transformation language used. In this paper we fill this gap by proposing a declarative language for the specification of visual contracts, enabling the verification of transformations defined with any transformation language. The verification is performed by compiling the contracts into QVT to detect disconformities of transformation results with respect to the contracts. As a proof of concept, we also report on a graphical modeling environment for the specification of contracts, and on its use for the verification of transformations in several case studies.

Specification and Verification of Model Transformations

Model transformations are a key concept within model driven development and there is an enormous need for suitable formal analysis techniques for model transformations, in particular with respect to behavioural equivalence of source models and their corresponding target models. For this reason, we discuss the general challenges that arise for the specification and verification of model transformations and present suitable formal techniques that are based on graph transformation. In this context, triple graph grammars show many benefits for the specification process, e.g. modelers can work on an intuitive level of abstraction and there are formal results for syntactical correctness, completeness and efficient execution. In order to verify model transformations with respect to behavioural equivalence we apply well-studied techniques based on the double pushout approach with borrowed context, for which the model transformations specified by triple graph transformation rules are flattened to plain (in-situ) graph transformation rules. The potential and adequateness of the presented techniques are demonstrated by an intuitive example, for which we show the correctness of the model transformation with respect to bisimilarity of source and target models.