Step 0: An Idea for Automatic OCL Benchmark Generation

Model Driven Engineering (MDE) is an important software development paradigm. Within this paradigm, models and constraints are essential components for expressing specifications of a software artefact. Object Constraint Language (OCL), a specification language that allows users to freely express constraints over different model features. However, one major issue is that the lack of OCL benchmarks makes difficult to evaluate existing and newly created OCL tools. In this paper, we present our initial idea about automatic OCL benchmark generation. The purpose of this paper is to show a developing idea rather than presenting a more formal and complete approach. Our idea is to use an OCL metamodel to sketch abstract syntax trees for OCL expressions, and solve generated typing constraints to produce the concrete OCL expressions. We illustrate this idea by using an example, discuss our work-in-progress and outline challenges to be tackled in the future

A formal approach to finding inconsistencies in a metamodel

Checking the consistency of a metamodel involves finding a valid metamodel instance that provably meets the set of constraints that are defined over the metamodel. These constraints are often specified in Object Constraint Language. Often, a metamodel is inconsistent due to conflicts among the constraints. Existing approaches and tools are typically incapable of pinpointing the conflicting constraints, and this makes it difficult for users to debug and fix their metamodels. In this paper, we present a formal approach for locating conflicting constraints in inconsistent metamodels. Our approach has four distinct features: (1) users can rank individual metamodel features using their own domain-specific knowledge, (2) we transform these ranked features to a weighted maximum satisfiability modulo theories problem and solve it to compute the set of maximum achievable features, (3) we pinpoint the conflicting constraints by solving the set cover problem using a novel algorithm, and (4) we have implemented our approach into a fully automated tool called MaxUSE. Our evaluation results, using our assembled set of benchmarks, demonstrate the scalability of our work and that it is capable of efficiently finding conflicting constraints

Fundamental Approaches to Software Engineering

This open access book constitutes the proceedings of the 23rd International Conference on Fundamental Approaches to Software Engineering, FASE 2020, which took place in Dublin, Ireland, in April 2020, and was held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020. The 23 full papers, 1 tool paper and 6 testing competition papers presented in this volume were carefully reviewed and selected from 81 submissions. The papers cover topics such as requirements engineering, software architectures, specification, software quality, validation, verification of functional and non-functional properties, model-driven development and model transformation, software processes, security and software evolution

Model Transformation Testing and Debugging: A Survey

Model transformations are the key technique in Model-Driven Engineering (MDE) to manipulate and construct models. As a consequence, the correctness of software systems built with MDE approaches relies mainly on the correctness of model transformations, and thus, detecting and locating bugs in model transformations have been popular research topics in recent years. This surge of work has led to a vast literature on model transformation testing and debugging, which makes it challenging to gain a comprehensive view of the current state of the art. This is an obstacle for newcomers to this topic and MDE practitioners to apply these approaches. This paper presents a survey on testing and debugging model transformations based on the analysis of \nPapers~papers on the topics. We explore the trends, advances, and evolution over the years, bringing together previously disparate streams of work and providing a comprehensive view of these thriving areas. In addition, we present a conceptual framework to understand and categorise the different proposals. Finally, we identify several open research challenges and propose specific action points for the model transformation community.This work is partially supported by the European Commission (FEDER) and Junta de Andalucia under projects APOLO (US-1264651) and EKIPMENT-PLUS (P18-FR-2895), by the Spanish Government (FEDER/Ministerio de Ciencia e Innovación – Agencia Estatal de Investigación) under projects HORATIO (RTI2018-101204-B-C21), COSCA (PGC2018-094905-B-I00) and LOCOSS (PID2020-114615RB-I00), by the Austrian Science Fund (P 28519-N31, P 30525-N31), and by the Austrian Federal Ministry for Digital and Economic Affairs and the National Foundation for Research, Technology and Development (CDG

SEMI-AUTOMATED TEST MODEL GENERATION

Appropriate test models that can satisfy complex constraints are required for testing model management programs in order to build confidence in their correctness. Models have inherently complex structures and are often required to satisfy non-trivial constraints which makes them time consuming, labour intensive and error prone to construct manually. Automated capabilities are therefore required, however, existing fully-automated model generation tools cannot generate models that satisfy arbitrarily complex constraints. This thesis addresses this problem by proposing a semi-automated approach towards the generation of such models. A new framework named Epsilon Model Generator (EMG) that implements this approach is presented. The framework supports the development of model generators that can produce random and reproducible test models that satisfy complex constraints

A modular metamodel and refactoring rules to achieve software product line interoperability.

Emergent application domains, such as cyber–physical systems, edge computing or industry 4.0. present a high variability in software and hardware infrastructures. However, no single variability modeling language supports all language extensions required by these application domains (i.e., attributes, group cardinalities, clonables, complex constraints). This limitation is an open challenge that should be tackled by the software engineering field, and specifically by the software product line (SPL) community. A possible solution could be to define a completely new language, but this has a high cost in terms of adoption time and development of new tools. A more viable alternative is the definition of refactoring and specialization rules that allow interoperability between existing variability languages. However, with this approach, these rules cannot be reused across languages because each language uses a different set of modeling concepts and a different concrete syntax. Our approach relies on a modular and extensible metamodel that defines a common abstract syntax for existing variability modeling extensions. We map existing feature modeling languages in the SPL community to our common abstract syntax. Using our abstract syntax, we define refactoring rules at the language construct level that help to achieve interoperability between variability modeling languages.Work supported by the projects MEDEA RTI2018-099213-B-I00, IRIS PID2021-122812OB-I00 (co-financed by FEDER funds), Rhea P18-FR-1081 (MCI/AEI/FEDER, UE), LEIA UMA18-FEDERIA-157, and DAEMON H2020-101017109. // Funding for open access: Universidad de Málaga / CBUA

Konsistente Feature Modell gesteuerte Softwareproduktlinien Evolution

SPLs are an approach to manage families of closely related software systems in terms of configurable functionality. A feature model captures common and variable functionalities of an SPL on a conceptual level in terms of features. Reusable artifacts, such as code, documentation, or tests are related to features using a feature-artifact mapping. A product of an SPL can be derived by selecting features in a configuration. Over the course of time, SPLs and their artifacts are subject to change. As SPLs are particularly complex, their evolution is a challenging task. Consequently, SPL evolution must be thoroughly planned well in advance. However, plans typically do not turn out as expected and, thus, replanning is required. Feature models lean themselves for driving SPL evolution. However, replanning of feature-model evolution can lead to inconsistencies and feature-model anomalies may be introduced during evolution. Along with feature-model evolution, other SPL artifacts, especially configurations, need to consistently evolve. The work of this thesis provides remedy to the aforementioned challenges by presenting an approach for consistent evolution of SPLs. The main contributions of this thesis can be distinguished into three key areas: planning and replanning feature-model evolution, analyzing feature-model evolution, and consistent SPL artifact evolution. As a starting point for SPL evolution, we introduce Temporal Feature Models (TFMs) that allow capturing the entire evolution timeline of a feature model in one artifact, i.e., past history, present changes, and planned evolution steps. We provide an execution semantics of feature-model evolution operations that guarantees consistency of feature-model evolution timelines. To keep feature models free from anomalies, we introduce analyses to detect anomalies in feature-model evolution timelines and explain these anomalies in terms of their causing evolution operations. To enable consistent SPL artifact evolution, we generalize the concept of modeling evolution timelines in TFMs to be applicable for any modeling language. Moreover, we provide a methodology that enables involved engineers to define and use guidance for configuration evolution.Softwareproduktlinien (SPLs) ermöglichen es, konfigurierbare Funktionalität von eng verwandten Softwaresystemen zu verwalten. In einem Feature Modell werden gemeinsame und variable Funktionalitäten einer SPL auf Basis abstrakter Features modelliert. Wiederverwendbare Artefakte werden in einem Feature-Artefakt Mapping Features zugeordnet. Ein Produkt einer SPL kann abgeleitet werden, indem Features in einer Konfiguration ausgewählt werden. Im Laufe der Zeit müssen sich SPLs und deren Artefakte verändern. Da SPLs ganze Softwarefamilien modellieren, ist deren Evolution eine besonders herausfordernde Aufgabe, die gründlich im Voraus geplant werden muss. Feature Modelle eignen sich besonders als Planungsmittel einer SPL. Umplanung von Feature Modell Evolution kann jedoch zu Inkonsistenzen führen und Feature Modell Anomalien können im Zuge der Evolution eingeführt werden. Im Anschluss an die Feature Modell Evolution muss die Evolution anderer SPL Artefakte, insbesondere Konfigurationen, konsistent modelliert werden. In dieser Arbeit wird ein Ansatz zur konsistenten Evolution von SPLs vorgestellt, der die zuvor genannten Herausforderungen adressiert. Die Beiträge dieser Arbeit lassen sich in drei Kernbereiche aufteilen: Planung und Umplanung von Feature Modell Evolution, Analyse von Feature Modell Evolution und konsistente Evolution von SPL Artefakten. Temporal Feature Models (TFMs) werden als Startpunkt für SPL Evolution eingeführt. In einem TFM wird die gesamte Evolutionszeitlinie eines Feature Modells in einem Artefakt abgebildet, was sowohl vergangene Änderungen, den aktuellen Zustand, als auch geplante Änderungen beinhaltet. Auf Basis einer Ausführungssemantik wird die Konsistenz von Feature Modell Evolutionszeitlinien sichergestellt. Um Feature Modelle frei von Anomalien zu halten, werden Analysen eingeführt, welche die gesamte Evolutionszeitlinie eines Feature Modells auf Anomalien untersucht und diese mit verursachenden Evolutionsoperationen erklärt. Das Konzept zur Modellierung von Feature Modell Evolutionszeitlinien aus TFMs wird verallgemeinert, um die gesamte Evolution von Modellen beliebiger Modellierungssprachen spezifizieren zu können. Des Weiteren wird eine Methodik vorgestellt, die beteiligten Ingenieuren eine geführte Evolution von Konfigurationen ermöglicht

Formal verification of automotive embedded UML designs

Software applications are increasingly dominating safety critical domains. Safety critical domains are domains where the failure of any application could impact human lives. Software application safety has been overlooked for quite some time but more focus and attention is currently directed to this area due to the exponential growth of software embedded applications. Software systems have continuously faced challenges in managing complexity associated with functional growth, flexibility of systems so that they can be easily modified, scalability of solutions across several product lines, quality and reliability of systems, and finally the ability to detect defects early in design phases. AUTOSAR was established to develop open standards to address these challenges. ISO-26262, automotive functional safety standard, aims to ensure functional safety of automotive systems by providing requirements and processes to govern software lifecycle to ensure safety. Each functional system needs to be classified in terms of safety goals, risks and Automotive Safety Integrity Level (ASIL: A, B, C and D) with ASIL D denoting the most stringent safety level. As risk of the system increases, ASIL level increases and the standard mandates more stringent methods to ensure safety. ISO-26262 mandates that ASILs C and D classified systems utilize walkthrough, semi-formal verification, inspection, control flow analysis, data flow analysis, static code analysis and semantic code analysis techniques to verify software unit design and implementation. Ensuring software specification compliance via formal methods has remained an academic endeavor for quite some time. Several factors discourage formal methods adoption in the industry. One major factor is the complexity of using formal methods. Software specification compliance in automotive remains in the bulk heavily dependent on traceability matrix, human based reviews, and testing activities conducted on either actual production software level or simulation level. ISO26262 automotive safety standard recommends, although not strongly, using formal notations in automotive systems that exhibit high risk in case of failure yet the industry still heavily relies on semi-formal notations such as UML. The use of semi-formal notations makes specification compliance still heavily dependent on manual processes and testing efforts. In this research, we propose a framework where UML finite state machines are compiled into formal notations, specification requirements are mapped into formal model theorems and SAT/SMT solvers are utilized to validate implementation compliance to specification. The framework will allow semi-formal verification of AUTOSAR UML designs via an automated formal framework backbone. This semi-formal verification framework will allow automotive software to comply with ISO-26262 ASIL C and D unit design and implementation formal verification guideline. Semi-formal UML finite state machines are automatically compiled into formal notations based on Symbolic Analysis Laboratory formal notation. Requirements are captured in the UML design and compiled automatically into theorems. Model Checkers are run against the compiled formal model and theorems to detect counterexamples that violate the requirements in the UML model. Semi-formal verification of the design allows us to uncover issues that were previously detected in testing and production stages. The methodology is applied on several automotive systems to show how the framework automates the verification of UML based designs, the de-facto standard for automotive systems design, based on an implicit formal methodology while hiding the cons that discouraged the industry from using it. Additionally, the framework automates ISO-26262 system design verification guideline which would otherwise be verified via human error prone approaches