The document discusses mutation testing for ATL model transformations. It introduces mutation testing and how it can be applied to ATL. The key contributions are new mutation operators for ATL that mimic common developer errors, evaluation of test generation techniques and operators, and an open-source tool for mutation testing of ATL.
The document provides information about Java programming concepts including:
- How to download, install Java, and write a simple "Hello World" program.
- Common operators in Java like arithmetic, assignment, logical, and comparison operators.
- How to compile and run a Java program from the command line.
- Core Java concepts like variables, data types, classes, and methods.
- The document is intended as an introduction to Java programming for beginners.
This document provides instructions for Assignment 2 of the BMI 214 course on machine learning for expression data and genotype-phenotype associations. It includes instructions on using the Weka machine learning tool to perform supervised and unsupervised learning on gene expression datasets. For supervised learning, it has students classify leukemia samples and evaluate different classifiers. For unsupervised learning, it has students perform k-means clustering on a yeast gene expression dataset. It also includes exercises on feature selection to identify informative genes for classification.
This document provides an overview of Java generics through examples. It begins with simple examples demonstrating how generics can be used to define container classes (BoxPrinter) and pair classes (Pair). It discusses benefits like type safety and avoiding duplication. Further examples show generics with methods and limitations like erasure. Wildcard types are presented as a way to address subtyping issues. In general, generics provide flexibility in coding but their syntax can sometimes be complex to read.
This document provides an overview of Java generics through examples. It begins with simple examples demonstrating how generics can be used to define container classes (BoxPrinter) and pair classes (Pair). It discusses benefits like type safety and avoiding duplication. Further examples show generics with classes, methods, and limitations like erasure. Wildcard types are introduced as a way to overcome some limitations. Key points covered include generic methods, wildcards, raw types and warnings, limitations of wildcards, and issues with readability of generic code.
Generic Types in Java (for ArtClub @ArtBrains Software)Andrew Petryk
This document discusses generics in Java. It provides an overview of generics, including:
- How generics allow for stronger type checking and elimination of casts compared to non-generic code.
- The benefits of generics include type safety and implementation of generic algorithms.
- Key concepts related to generics include type erasure, bounds/restrictions, wildcards, and type inference.
- Examples are provided to illustrate generic classes, methods, and common issues like heap pollution.
This document provides an overview of key concepts in the Java programming language, including:
- Java is an object-oriented language that is simpler than C++ and supports features like platform independence.
- The Java development environment includes tools for compiling, debugging, and running Java programs.
- Java programs work with basic data types like int and double, as well as user-defined classes, variables, and arrays.
- The document explains operators, control structures, formatting output, and the basics of classes and objects in Java.
Ever wonder what this "new" Kotlin thing is? Curious what the syntax looks like? Unsure how to implement this at your own company? Or do you just want to know what Nick and Cody's favorite things are about this language?
All that and (maybe) more are revealed in Privet Kotlin.
This document discusses objects and classes in Java. It defines a class as defining the properties and behaviors of objects. An object represents a real-world entity with a unique identity, state, and behavior. The document discusses declaring objects using the new keyword, defining and calling methods in classes, arrays of objects, constructors, the this keyword, and static members. It provides examples of defining classes, declaring objects, defining methods with and without return values, and passing objects as parameters.
The document provides information about Java programming concepts including:
- How to download, install Java, and write a simple "Hello World" program.
- Common operators in Java like arithmetic, assignment, logical, and comparison operators.
- How to compile and run a Java program from the command line.
- Core Java concepts like variables, data types, classes, and methods.
- The document is intended as an introduction to Java programming for beginners.
This document provides instructions for Assignment 2 of the BMI 214 course on machine learning for expression data and genotype-phenotype associations. It includes instructions on using the Weka machine learning tool to perform supervised and unsupervised learning on gene expression datasets. For supervised learning, it has students classify leukemia samples and evaluate different classifiers. For unsupervised learning, it has students perform k-means clustering on a yeast gene expression dataset. It also includes exercises on feature selection to identify informative genes for classification.
This document provides an overview of Java generics through examples. It begins with simple examples demonstrating how generics can be used to define container classes (BoxPrinter) and pair classes (Pair). It discusses benefits like type safety and avoiding duplication. Further examples show generics with methods and limitations like erasure. Wildcard types are presented as a way to address subtyping issues. In general, generics provide flexibility in coding but their syntax can sometimes be complex to read.
This document provides an overview of Java generics through examples. It begins with simple examples demonstrating how generics can be used to define container classes (BoxPrinter) and pair classes (Pair). It discusses benefits like type safety and avoiding duplication. Further examples show generics with classes, methods, and limitations like erasure. Wildcard types are introduced as a way to overcome some limitations. Key points covered include generic methods, wildcards, raw types and warnings, limitations of wildcards, and issues with readability of generic code.
Generic Types in Java (for ArtClub @ArtBrains Software)Andrew Petryk
This document discusses generics in Java. It provides an overview of generics, including:
- How generics allow for stronger type checking and elimination of casts compared to non-generic code.
- The benefits of generics include type safety and implementation of generic algorithms.
- Key concepts related to generics include type erasure, bounds/restrictions, wildcards, and type inference.
- Examples are provided to illustrate generic classes, methods, and common issues like heap pollution.
This document provides an overview of key concepts in the Java programming language, including:
- Java is an object-oriented language that is simpler than C++ and supports features like platform independence.
- The Java development environment includes tools for compiling, debugging, and running Java programs.
- Java programs work with basic data types like int and double, as well as user-defined classes, variables, and arrays.
- The document explains operators, control structures, formatting output, and the basics of classes and objects in Java.
Ever wonder what this "new" Kotlin thing is? Curious what the syntax looks like? Unsure how to implement this at your own company? Or do you just want to know what Nick and Cody's favorite things are about this language?
All that and (maybe) more are revealed in Privet Kotlin.
This document discusses objects and classes in Java. It defines a class as defining the properties and behaviors of objects. An object represents a real-world entity with a unique identity, state, and behavior. The document discusses declaring objects using the new keyword, defining and calling methods in classes, arrays of objects, constructors, the this keyword, and static members. It provides examples of defining classes, declaring objects, defining methods with and without return values, and passing objects as parameters.
The document provides an overview of the Open Verification Methodology (OVM) framework. OVM is a SystemVerilog library that implements object-oriented design patterns to provide base classes for verification components. It includes features for component hierarchy, configuration, phasing, reporting, transaction recording, and interfaces based on the Open System C Initiative Transaction Level Modeling 2.0 standard.
Generics in Java allows the creation of generic classes and methods that can work with different data types. A generic class uses type parameters that appear within angle brackets, allowing the class to work uniformly with different types. Generic methods also use type parameters to specify the type of data upon which the method operates. Bounded type parameters allow restricting the types that can be passed to a type parameter.
This document provides an overview of key Java concepts including classes, objects, methods, fields, inheritance, interfaces, exceptions, and collections. Some key points:
- Java code is organized into classes which can contain fields to store data and methods to encapsulate behaviors. Objects are instantiated from classes.
- Fields can be declared with primitive types or as arrays/objects. Methods are declared with a return type and parameters.
- Inheritance allows subclasses to extend and override methods from parent classes. Interfaces define contracts that classes can implement.
- Exceptions provide error handling for exceptions that occur in code. Collections like ArrayList and LinkedList provide data structures to store and access multiple objects.
Applying Compiler Techniques to Iterate At Blazing SpeedPascal-Louis Perez
In this session, we will present real life applications of compiler techniques helping kaChing achieve ultra confidence and power its incredible 5 minutes commit-to-production cycle [1]. We'll talk about idempotency analysis [2], dependency detection, on the fly optimisations, automatic memoization [3], type unification [4] and more! This talk is not suitable for the faint-hearted... If you want to dive deep, learn about advanced JVM topics, devoure bytecode and see first hand applications of theoretical computer science, join us.
[1] http://eng.kaching.com/2010/05/deployment-infrastructure-for.html
[2] http://en.wikipedia.org/wiki/Idempotence
[3] http://en.wikipedia.org/wiki/Memoization
[4] http://eng.kaching.com/2009/10/unifying-type-parameters-in-java.html
Functional programming is getting a lot of attention because it eases many of the difficulties faced in object-oriented programming (OOP) such as testability, maintainability, scalability, and concurrency. Swift has a lot of functional programming features that can be easily used, but most of Objective-C and Swift programmers are not familiar with these concepts.
This talk aims to introduce some of the core concepts of functional programming with Swift such as:
• Importance of Immutability
• First-class, Higher-order and Pure functions
• Closures
• Generics and Associated Type Protocols
• Functors, Applicative Functors and Monads
• Enumerations and Pattern Matching
• Optionals
SQL is a standard language for accessing and manipulating databases. It allows users to query, insert, update, and delete data. The document discusses SQL statements like SELECT, INSERT, UPDATE, DELETE and functions like JOIN, aggregate functions, and scalar functions. It provides examples of creating tables and manipulating data using DDL, DML, and DCL statements. Joins allow combining data from multiple tables based on common fields.
An index is identified by its signature, while a property is identified by its name. An indexer is always an instance member, but a property can be static. An indexer is accessed through element access, while a property is accessed through member access. Extension methods allow custom functions to be added to existing types through static classes and a new syntax. Events allow classes to notify other classes when something happens by invoking event handler methods. Abstract classes can have both abstract and concrete members, while interfaces only contain implicitly abstract members that must be implemented in derived classes.
Boost.Dispatch is a generic tag-dispatching library that allows for specializing functions based on type constraints. It introduces a hierarchy system to categorize types and functions based on tags. This allows defining implementations of functions like "plus" for different argument types and architectures. The dispatch call uses the hierarchy information to select the best matching implementation at call sites in a generic way. This minimizes code duplication and increases the applicability of tag dispatching in C++.
This class is abstract but it does not provide implementation of abstract method print(). An abstract class must be subclassed and the abstract methods must be implemented in the subclass. We cannot create an object of an abstract class directly, it has to be through its concrete subclass.
The document provides an overview of lecture 03 on objects and classes in Java, including reviewing basic concepts, declaring and using classes, implementing inheritance, and discussing abstract classes and interfaces. It also includes examples of declaring classes, using constructors and methods, and implementing inheritance and polymorphism. The lecture aims to help students understand object-oriented concepts in Java like classes, objects, inheritance and polymorphism.
1) The document provides information on various SQL functions for string manipulation, date functions, aggregate functions, and selecting rows from tables based on conditions.
2) String functions include concatenation, conversion between ASCII and character values, indexing and pattern matching. Date functions include adding/subtracting dates and retrieving date parts. Aggregate functions include average, count, max, min and sum.
3) Row selection can be done using comparison, range, list, string and logical operators to specify conditions in the WHERE clause. Distinct, TOP and PERCENT clauses can also be used for result set filtering.
The document discusses SQL design patterns and relational division pattern in particular. It describes relational division as finding elements that belong to all sets in a collection of sets. It provides various implementations of relational division in SQL, including using minus, not exists, and grouping with a having clause to check for equality of counts.
This document discusses generics in Java. Generics provide type safety and avoid type casting. They allow for the creation of generic classes, interfaces, and methods that define type parameters. This allows collection classes to operate on objects of any type while still catching errors at compile time. The document covers bounded and unbounded generics, wildcard characters, and how generics work at compile time but are erased at runtime.
The document covers key concepts in Java expressions and flow control including:
- Distinguishing between instance and local variables and how instance variables are initialized
- Recognizing and correcting reference before assignment compiler errors
- Using operators and ensuring legal assignments of primitive types
- Applying boolean expressions in control constructs like if, switch, for, while, and do statements
- Leveraging the instanceof operator to test an object's class at runtime
- Understanding the differences between the basic for loop and enhanced for loop syntax
This document discusses Java data types, variables, and methods. It covers primitive data types like int, float, and boolean. It describes rules for identifiers and conventions for naming variables and classes. The document defines parameter types, implicit and explicit parameters, and how to call methods. It explains constructing objects with the new operator and accessor and mutator methods. The summary concludes with a discussion of static methods and how to call them without an object.
The document discusses templates in C++. It explains that templates allow functions and classes to be defined generically for multiple data types. It provides an example of a Pair class template that can represent a pair of values of any type. The document also discusses how to define template class members and prefixing the template declaration with template<class T> when defining members outside the class.
This document describes a model-driven approach to building augmented reality (AR) applications. Key points:
- AR applications are specified using models that describe the domain, AR representation, object anchoring using techniques like QR codes and beacons, and interaction with external APIs.
- An AR interpreter renders the virtual objects based on the models and allows interaction in the physical world.
- The approach was evaluated through case studies of AR apps for networking, museums, home design, inventory, and social media. A user study found the AR apps to have good usability.
- Future work includes adding physics, collaborative editing, migrating the designer to the web, and more user studies.
This document presents a modular approach to defining families of domain-specific languages (DSLs) using graph transformations. The approach uses language modules that define the abstract syntax and semantics of DSL variants. Module dependencies and extensions define how the variants relate and combine. Configurations select modules to derive a specific DSL meta-model and rules. The approach reduces specification effort compared to defining each variant separately while ensuring behavioral consistency. Tool support and experiments demonstrate the feasibility of the modular approach.
The document provides an overview of the Open Verification Methodology (OVM) framework. OVM is a SystemVerilog library that implements object-oriented design patterns to provide base classes for verification components. It includes features for component hierarchy, configuration, phasing, reporting, transaction recording, and interfaces based on the Open System C Initiative Transaction Level Modeling 2.0 standard.
Generics in Java allows the creation of generic classes and methods that can work with different data types. A generic class uses type parameters that appear within angle brackets, allowing the class to work uniformly with different types. Generic methods also use type parameters to specify the type of data upon which the method operates. Bounded type parameters allow restricting the types that can be passed to a type parameter.
This document provides an overview of key Java concepts including classes, objects, methods, fields, inheritance, interfaces, exceptions, and collections. Some key points:
- Java code is organized into classes which can contain fields to store data and methods to encapsulate behaviors. Objects are instantiated from classes.
- Fields can be declared with primitive types or as arrays/objects. Methods are declared with a return type and parameters.
- Inheritance allows subclasses to extend and override methods from parent classes. Interfaces define contracts that classes can implement.
- Exceptions provide error handling for exceptions that occur in code. Collections like ArrayList and LinkedList provide data structures to store and access multiple objects.
Applying Compiler Techniques to Iterate At Blazing SpeedPascal-Louis Perez
In this session, we will present real life applications of compiler techniques helping kaChing achieve ultra confidence and power its incredible 5 minutes commit-to-production cycle [1]. We'll talk about idempotency analysis [2], dependency detection, on the fly optimisations, automatic memoization [3], type unification [4] and more! This talk is not suitable for the faint-hearted... If you want to dive deep, learn about advanced JVM topics, devoure bytecode and see first hand applications of theoretical computer science, join us.
[1] http://eng.kaching.com/2010/05/deployment-infrastructure-for.html
[2] http://en.wikipedia.org/wiki/Idempotence
[3] http://en.wikipedia.org/wiki/Memoization
[4] http://eng.kaching.com/2009/10/unifying-type-parameters-in-java.html
Functional programming is getting a lot of attention because it eases many of the difficulties faced in object-oriented programming (OOP) such as testability, maintainability, scalability, and concurrency. Swift has a lot of functional programming features that can be easily used, but most of Objective-C and Swift programmers are not familiar with these concepts.
This talk aims to introduce some of the core concepts of functional programming with Swift such as:
• Importance of Immutability
• First-class, Higher-order and Pure functions
• Closures
• Generics and Associated Type Protocols
• Functors, Applicative Functors and Monads
• Enumerations and Pattern Matching
• Optionals
SQL is a standard language for accessing and manipulating databases. It allows users to query, insert, update, and delete data. The document discusses SQL statements like SELECT, INSERT, UPDATE, DELETE and functions like JOIN, aggregate functions, and scalar functions. It provides examples of creating tables and manipulating data using DDL, DML, and DCL statements. Joins allow combining data from multiple tables based on common fields.
An index is identified by its signature, while a property is identified by its name. An indexer is always an instance member, but a property can be static. An indexer is accessed through element access, while a property is accessed through member access. Extension methods allow custom functions to be added to existing types through static classes and a new syntax. Events allow classes to notify other classes when something happens by invoking event handler methods. Abstract classes can have both abstract and concrete members, while interfaces only contain implicitly abstract members that must be implemented in derived classes.
Boost.Dispatch is a generic tag-dispatching library that allows for specializing functions based on type constraints. It introduces a hierarchy system to categorize types and functions based on tags. This allows defining implementations of functions like "plus" for different argument types and architectures. The dispatch call uses the hierarchy information to select the best matching implementation at call sites in a generic way. This minimizes code duplication and increases the applicability of tag dispatching in C++.
This class is abstract but it does not provide implementation of abstract method print(). An abstract class must be subclassed and the abstract methods must be implemented in the subclass. We cannot create an object of an abstract class directly, it has to be through its concrete subclass.
The document provides an overview of lecture 03 on objects and classes in Java, including reviewing basic concepts, declaring and using classes, implementing inheritance, and discussing abstract classes and interfaces. It also includes examples of declaring classes, using constructors and methods, and implementing inheritance and polymorphism. The lecture aims to help students understand object-oriented concepts in Java like classes, objects, inheritance and polymorphism.
1) The document provides information on various SQL functions for string manipulation, date functions, aggregate functions, and selecting rows from tables based on conditions.
2) String functions include concatenation, conversion between ASCII and character values, indexing and pattern matching. Date functions include adding/subtracting dates and retrieving date parts. Aggregate functions include average, count, max, min and sum.
3) Row selection can be done using comparison, range, list, string and logical operators to specify conditions in the WHERE clause. Distinct, TOP and PERCENT clauses can also be used for result set filtering.
The document discusses SQL design patterns and relational division pattern in particular. It describes relational division as finding elements that belong to all sets in a collection of sets. It provides various implementations of relational division in SQL, including using minus, not exists, and grouping with a having clause to check for equality of counts.
This document discusses generics in Java. Generics provide type safety and avoid type casting. They allow for the creation of generic classes, interfaces, and methods that define type parameters. This allows collection classes to operate on objects of any type while still catching errors at compile time. The document covers bounded and unbounded generics, wildcard characters, and how generics work at compile time but are erased at runtime.
The document covers key concepts in Java expressions and flow control including:
- Distinguishing between instance and local variables and how instance variables are initialized
- Recognizing and correcting reference before assignment compiler errors
- Using operators and ensuring legal assignments of primitive types
- Applying boolean expressions in control constructs like if, switch, for, while, and do statements
- Leveraging the instanceof operator to test an object's class at runtime
- Understanding the differences between the basic for loop and enhanced for loop syntax
This document discusses Java data types, variables, and methods. It covers primitive data types like int, float, and boolean. It describes rules for identifiers and conventions for naming variables and classes. The document defines parameter types, implicit and explicit parameters, and how to call methods. It explains constructing objects with the new operator and accessor and mutator methods. The summary concludes with a discussion of static methods and how to call them without an object.
The document discusses templates in C++. It explains that templates allow functions and classes to be defined generically for multiple data types. It provides an example of a Pair class template that can represent a pair of values of any type. The document also discusses how to define template class members and prefixing the template declaration with template<class T> when defining members outside the class.
This document describes a model-driven approach to building augmented reality (AR) applications. Key points:
- AR applications are specified using models that describe the domain, AR representation, object anchoring using techniques like QR codes and beacons, and interaction with external APIs.
- An AR interpreter renders the virtual objects based on the models and allows interaction in the physical world.
- The approach was evaluated through case studies of AR apps for networking, museums, home design, inventory, and social media. A user study found the AR apps to have good usability.
- Future work includes adding physics, collaborative editing, migrating the designer to the web, and more user studies.
This document presents a modular approach to defining families of domain-specific languages (DSLs) using graph transformations. The approach uses language modules that define the abstract syntax and semantics of DSL variants. Module dependencies and extensions define how the variants relate and combine. Configurations select modules to derive a specific DSL meta-model and rules. The approach reduces specification effort compared to defining each variant separately while ensuring behavioral consistency. Tool support and experiments demonstrate the feasibility of the modular approach.
Multi-level modelling allows modelling at more than two meta-levels at once. The document discusses how multi-level modelling can be used for model-driven engineering. It presents the basics of multi-level modelling using concepts like clabjects, potency, levels and the orthogonal classification architecture. Examples are provided where multi-level modelling has advantages over two-level modelling, such as for modelling product types and instances, and domain-specific process modelling languages. Tool support for multi-level modelling is discussed, as well as how multi-level models can be managed through constraints, transformations and code generation.
The document proposes a novel approach called multi-level model product lines (MLM PLs) that combines multi-level modeling and product lines to create highly configurable families of modeling languages. MLM PLs support open variability through instantiation at different meta-levels and closed variability through feature configurations. A theory and tool implementation are presented, allowing exploratory modeling where variability can be resolved incrementally. The approach is demonstrated using the MetaDepth modeling environment.
This document provides an overview of scientific paper writing. It discusses why publishing research is important, different types of venues and their review processes. It also covers topics such as ethics in publishing, rankings of venues and authors, and types of papers. The document then describes how to structure a research paper, including sections such as the introduction, main body, related work, and conclusions. Finally, it provides tips for scientific writing and the publication process.
The document discusses flexible modeling based on facets. It introduces facets as objects that can be added to and removed from host objects, acquiring their slots, types, and constraints. This allows objects to become open and dynamically extendable. Facets provide a way to reuse operations on models, extend existing objects with new information, and view models through different "scenes". Facet laws and interfaces control facet acquisition and removal and which meta-models can be used for facets.
Máster en Métodos Formales en Ingeniería Informáticamiso_uam
Presentación del Máster en Métodos Formales en Ingeniería Informática en jornadas de posgrado en la facultad de ciencias de la Universidad Autónoma de Madrid
This document discusses analysing meta-model product lines (MMPLs) through lifted analysis techniques. It presents MMPLs as a compact representation of multiple meta-model variants defined through features. It aims to ensure the correctness of MMPLs by lifting existing meta-model analysis techniques to the product line level, including syntactic analysis of meta-models and checking meta-model properties. The key contributions are a declarative notion of MMPLs, lifted analyses to check well-formedness and properties more efficiently than enumerating each meta-model, and a classification of different property types that can be analysed on MMPLs. Tool support for specification and analysis of MMPLs is also discussed.
This document discusses facet-oriented modeling, which introduces the concept of facets to provide flexibility and dynamism to model-driven engineering. Facets allow objects to dynamically acquire and drop slots, types, and constraints. A facet is an object that becomes part of a host object, making its slots accessible. A DSL is presented for adding and removing facets. Facet interfaces and laws specify valid facet combinations and when hosts should acquire facets. The approach is evaluated in scenarios like integrating annotation models and reuse of transformations. It is implemented in the MetaDepth modeling tool.
This document discusses requirements for flexible modelling tools that can accommodate different modelling purposes and stages of development. It proposes a meta-modelling language and explicit modelling process to provide flexibility in modelling. The meta-modelling language supports multiple classification levels and types, as well as extensibility through untyped elements. An explicit modelling process defines phases, conformance rules, and transitions between phases to provide guidance for model development. Process-aware assistance filters model checks and fixes according to the current process intent.
The document discusses developing a transformation product line (TPL) approach to define model transformations over variants of a meta-model product line (MMPL) in a compact, reusable, extensible, and analyzable way by using transformation fragments with presence conditions and composing them through abstraction and overriding mechanisms. It aims to address the challenges of defining transformations over many variants of a meta-model in a scalable way while maintaining correctness through analysis at the TPL level.
The document provides an overview of the Model-Driven Engineering (MDE) research activities of the MISO group at the Universidad Autónoma de Madrid. The MISO group focuses on areas like (meta-)modelling, domain-specific languages, and model transformations. Some of their work includes multi-level modelling, a-posteriori typing, modelling through social networks, pattern-based development of DSLs, and analysis of model transformations for correctness.
The document summarizes model-driven engineering (MDE) and discusses approaches to reuse in MDE transformations. Specifically:
- MDE aims to increase abstraction in software development by modeling at a higher level of abstraction rather than coding directly. Models are used to describe problems, simulate/verify/test, and generate code.
- Reusing MDE artifacts like transformations is challenging as they are defined for specific meta-models. Current practice involves ad-hoc copying and adapting transformations, which is error-prone.
- The document presents three approaches to improve reuse: concepts, multi-level modeling, and a-posteriori typing. Concepts define transformations at a more abstract level and allow automated adaptation.
This document provides an overview of the Model-Driven Engineering (MDE) research activities at the MISO group at the Autonomous University of Madrid. The MISO group conducts research in (meta-)modeling, domain-specific languages, and model transformations. Their work includes multi-level modeling, a-posteriori typing, modeling through social networks, active DSLs, transformation analysis, and techniques for improving the reusability of model transformations.
The document discusses the need for and concepts around active domain-specific languages (DSLs) that can be used across devices and enable more advanced modeling scenarios. It presents a feature space for DSLs that includes characteristics like being geolocated, supporting external interactions and context-sensitivity. An active DSL is defined as combining these features. The initial realization of these ideas is demonstrated with DSL-Comet, which allows specifying DSLs for use on desktop and mobile and supports collaboration. Future work includes expanding DSL-Comet's capabilities and applying DSLs to large-scale collaborative modeling applications.
This document presents an approach for reusing model transformations through the extraction of typing requirements models (TRMs) from transformations. TRMs characterize the minimal requirements that source and target meta-models must satisfy for a transformation to be well-typed. The approach extracts TRMs from ATL transformations through an attribute grammar. Meta-models can then be checked for conformance to the TRMs to determine if a transformation can be reused. An evaluation of the approach on four transformations showed that it achieved high precision and recall in checking over 2,000 mutated meta-models for conformance.
This document summarizes some experiments conducted by researchers from the Universidad Autónoma de Madrid on model-driven engineering. It introduces the researchers and their work analyzing meta-models, model transformations, and evaluating modeling tools and notations with users. Specific experiments discussed include checking meta-models for refactoring opportunities, statically analyzing transformations to find errors, and evaluating domain-specific modeling tools and construction notations. The researchers find multi-level modeling patterns commonly occur in meta-models and show examples of refactoring modeling scenarios to a multi-level structure.
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
UI5con 2024 - Bring Your Own Design SystemPeter Muessig
How do you combine the OpenUI5/SAPUI5 programming model with a design system that makes its controls available as Web Components? Since OpenUI5/SAPUI5 1.120, the framework supports the integration of any Web Components. This makes it possible, for example, to natively embed own Web Components of your design system which are created with Stencil. The integration embeds the Web Components in a way that they can be used naturally in XMLViews, like with standard UI5 controls, and can be bound with data binding. Learn how you can also make use of the Web Components base class in OpenUI5/SAPUI5 to also integrate your Web Components and get inspired by the solution to generate a custom UI5 library providing the Web Components control wrappers for the native ones.
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
Transform Your Communication with Cloud-Based IVR SolutionsTheSMSPoint
Discover the power of Cloud-Based IVR Solutions to streamline communication processes. Embrace scalability and cost-efficiency while enhancing customer experiences with features like automated call routing and voice recognition. Accessible from anywhere, these solutions integrate seamlessly with existing systems, providing real-time analytics for continuous improvement. Revolutionize your communication strategy today with Cloud-Based IVR Solutions. Learn more at: https://thesmspoint.com/channel/cloud-telephony
Mobile app Development Services | Drona InfotechDrona Infotech
Drona Infotech is one of the Best Mobile App Development Company In Noida Maintenance and ongoing support. mobile app development Services can help you maintain and support your app after it has been launched. This includes fixing bugs, adding new features, and keeping your app up-to-date with the latest
Visit Us For :
When it is all about ERP solutions, companies typically meet their needs with common ERP solutions like SAP, Oracle, and Microsoft Dynamics. These big players have demonstrated that ERP systems can be either simple or highly comprehensive. This remains true today, but there are new factors to consider, including a promising new contender in the market that’s Odoo. This blog compares Odoo ERP with traditional ERP systems and explains why many companies now see Odoo ERP as the best choice.
What are ERP Systems?
An ERP, or Enterprise Resource Planning, system provides your company with valuable information to help you make better decisions and boost your ROI. You should choose an ERP system based on your company’s specific needs. For instance, if you run a manufacturing or retail business, you will need an ERP system that efficiently manages inventory. A consulting firm, on the other hand, would benefit from an ERP system that enhances daily operations. Similarly, eCommerce stores would select an ERP system tailored to their needs.
Because different businesses have different requirements, ERP system functionalities can vary. Among the various ERP systems available, Odoo ERP is considered one of the best in the ERp market with more than 12 million global users today.
Odoo is an open-source ERP system initially designed for small to medium-sized businesses but now suitable for a wide range of companies. Odoo offers a scalable and configurable point-of-sale management solution and allows you to create customised modules for specific industries. Odoo is gaining more popularity because it is built in a way that allows easy customisation, has a user-friendly interface, and is affordable. Here, you will cover the main differences and get to know why Odoo is gaining attention despite the many other ERP systems available in the market.
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
UI5con 2024 - Boost Your Development Experience with UI5 Tooling ExtensionsPeter Muessig
The UI5 tooling is the development and build tooling of UI5. It is built in a modular and extensible way so that it can be easily extended by your needs. This session will showcase various tooling extensions which can boost your development experience by far so that you can really work offline, transpile your code in your project to use even newer versions of EcmaScript (than 2022 which is supported right now by the UI5 tooling), consume any npm package of your choice in your project, using different kind of proxies, and even stitching UI5 projects during development together to mimic your target environment.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
J-Spring 2024 - Going serverless with Quarkus, GraalVM native images and AWS ...
mtATL
1. Towards effective mutation testing for ATL
Esther Guerra, Juan de Lara
Universidad Aut´onoma de Madrid (Spain)
Jes´us S´anchez Cuadrado
Universidad de Murcia (Spain)
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 1 / 30
miso.es
2. Introduction
Model transformations
Importance of correctness of model transformations
Testing of transformations helps in detecting errors
How do you know if you did enough tests?
Mutation testing to the rescue!
It permits quantifying the quality of a test suite
Based on injecting artificial faults in the program under test
If test suite detects the artificial faults, it will likely detect real errors
Our focus is on mutation testing for ATL
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 2 / 30
3. Introduction
Mutation testing
Input
ATL transformation to test
Test suite made of:
input models (manual vs automatic)
oracle function (partial vs total)
Challenge: Identify the best test input
model generation technique
good at finding errors
few models if possible
test cases
program
under test
INPUT
1
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 3 / 30
4. Introduction
Mutation testing
Mutation operators
Mimic errors of competent developers
Used to create mutants of the program
Operators for ATL exist, but do not
mimic real errors
Challenge: Design operators based on
errors made by ATL developers
mutant
programs
mutation
operators
test cases
2
program
under test
INPUT
2
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 4 / 30
5. Introduction
Mutation testing
Mutation score
For each mutant, execute test suite
against mutant and original program
Compare results
if different, the mutant is killed
otherwise, it is alive (undetected error)
Mutation score =
killed mutants / total mutants
The higher the score, the better the
quality of the test suite
mutant
programs
mutation
operators
live mutants killed mutants
mutation score
test cases
yes no
3
program
under test
INPUT
mutant test
==
original test
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 5 / 30
6. Introduction
Mutation testing
On effectiveness
Mutation testing is very expensive
(many potential mutants)
Careful selection of mutation operators
do not produce trivial mutants
produce hard-to-kill mutants
Challenge: Analyse the effectiveness of
operators for ATL, which is unknown
mutant
programs
mutation
operators
live mutants killed mutants
mutation score
test cases
yes no
3
program
under test
INPUT
mutant test
==
original test
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 6 / 30
7. Introduction
Mutation testing
Improving the test suite
Add input models that kill live mutants
Challenge: Devise a technique to
synthesize mutant-killer models for ATL
mutant
programs
mutation
operators
live mutants killed mutants
mutation score
additional
test cases
test cases
yes no
program
under test
INPUT
mutant test
==
original test
4
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 7 / 30
8. Contributions
Mutation operators for ATL
new operators that mimic frequent ATL developer errors
evaluation of efficacy of these and other operators
Test suite
evaluation of efficacy of three test model generation techniques:
random, meta-model coverage, transformation coverage
novel technique to generate input models that kill live mutants
Open-source tool for mutation testing of ATL
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 8 / 30
10. ATL
Atlas Transformation Language
Widely used model transformation language
Dynamic, testing is needed to avoid runtime errors
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 10 / 30
11. ATL by example
create OUT : Relational from IN : Class
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = −1 then true
else self.upperBound > 1 endif;
rule Class2Table {
from c : Class!Class ( not c.isAbstract )
to out : Relational!Table (
name <− c.name,
col <− Sequence{key}→union(c.att→select(e | not e.multiValued)),
key <− Set{key} ),
key : Relational!Column ( name <− ’objectId’ )
}
rule MultiValuedDataTypeAttribute2Column {
from a : Class!Attribute ( a.type.oclIsKindOf(Class!DataType) and a.multiValued )
to out : Relational!Table (
name <− a.owner.nameOrEmpty + ’ ’ + a.name,
col <− Sequence {thisModule.createIdColumn(a.owner), value} ),
value : Relational!Column ( name <− a.name )
}
lazy rule createIdColumn {
from ne : Class!NamedElt
to key : Relational!Column ( name <− ne.name )
}
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 11 / 30
12. ATL by example
create OUT : Relational from IN : Class // input and output meta−models
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = −1 then true
else self.upperBound > 1 endif;
rule Class2Table {
from c : Class!Class ( not c.isAbstract )
to out : Relational!Table (
name <− c.name,
col <− Sequence{key}→union(c.att→select(e | not e.multiValued)),
key <− Set{key} ),
key : Relational!Column ( name <− ’objectId’ )
}
rule MultiValuedDataTypeAttribute2Column {
from a : Class!Attribute ( a.type.oclIsKindOf(Class!DataType) and a.multiValued )
to out : Relational!Table (
name <− a.owner.nameOrEmpty + ’ ’ + a.name,
col <− Sequence {thisModule.createIdColumn(a.owner), value} ),
value : Relational!Column ( name <− a.name )
}
lazy rule createIdColumn {
from ne : Class!NamedElt
to key : Relational!Column ( name <− ne.name )
}
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 11 / 30
13. ATL by example
create OUT : Relational from IN : Class
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = −1 then true
else self.upperBound > 1 endif;
rule Class2Table { // matched rule
from c : Class!Class ( not c.isAbstract ) // input pattern with filter
to out : Relational!Table ( // output pattern
name <− c.name,
col <− Sequence{key}→union(c.att→select(e | not e.multiValued)),
key <− Set{key} ),
key : Relational!Column ( name <− ’objectId’ )
}
rule MultiValuedDataTypeAttribute2Column {
from a : Class!Attribute ( a.type.oclIsKindOf(Class!DataType) and a.multiValued )
to out : Relational!Table (
name <− a.owner.nameOrEmpty + ’ ’ + a.name,
col <− Sequence {thisModule.createIdColumn(a.owner), value} ),
value : Relational!Column ( name <− a.name )
}
lazy rule createIdColumn {
from ne : Class!NamedElt
to key : Relational!Column ( name <− ne.name )
}
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 11 / 30
14. ATL by example
create OUT : Relational from IN : Class
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = −1 then true
else self.upperBound > 1 endif;
rule Class2Table {
from c : Class!Class ( not c.isAbstract )
to out : Relational!Table (
name <− c.name, // binding
col <− Sequence{key}→union(c.att→select(e | not e.multiValued)), // binding
key <− Set{key} ),
key : Relational!Column ( name <− ’objectId’ )
}
rule MultiValuedDataTypeAttribute2Column {
from a : Class!Attribute ( a.type.oclIsKindOf(Class!DataType) and a.multiValued )
to out : Relational!Table (
name <− a.owner.nameOrEmpty + ’ ’ + a.name,
col <− Sequence {thisModule.createIdColumn(a.owner), value} ),
value : Relational!Column ( name <− a.name )
}
lazy rule createIdColumn {
from ne : Class!NamedElt
to key : Relational!Column ( name <− ne.name )
}
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 11 / 30
15. ATL by example
create OUT : Relational from IN : Class
helper context Class!Attribute def: multiValued : Boolean = // helper, similar to a function
if self.upperBound = −1 then true
else self.upperBound > 1 endif;
rule Class2Table {
from c : Class!Class ( not c.isAbstract )
to out : Relational!Table (
name <− c.name,
col <− Sequence{key}→union(c.att→select(e | not e.multiValued)), // helper invocation
key <− Set{key} ),
key : Relational!Column ( name <− ’objectId’ )
}
rule MultiValuedDataTypeAttribute2Column {
from a : Class!Attribute ( a.type.oclIsKindOf(Class!DataType) and a.multiValued )
to out : Relational!Table (
name <− a.owner.nameOrEmpty + ’ ’ + a.name,
col <− Sequence {thisModule.createIdColumn(a.owner), value} ),
value : Relational!Column ( name <− a.name )
}
lazy rule createIdColumn {
from ne : Class!NamedElt
to key : Relational!Column ( name <− ne.name )
}
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 11 / 30
16. Mutation testing for ATL
rule Class2Table {
from c : Class!Class (not c.isAbstract)
to out : Relational!Table … }
CFCP
:Class
isAbstract=true
name=‘Person’
original transformation mutant transformation
Min
Mout M’out
rule Class2Table {
from c : Class!Class (not c.isAbstract
and c.name=‘’)
to out : Relational!Table … }
:Class
isAbstract=false
name=‘Female’
:supers
:Table
name=‘Female’
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 12 / 30
18. Mutation operators for ATL
Syntactic operators
Create-update-delete operations on language elements
Troya et al. [1]: 18 operators for main elements of ATL meta-model
Concept Operator
Matched rule addition
deletion
name change
In and out pattern element addition
deletion
class change
name change
Filter addition
deletion
condition change
Binding addition
deletion
value change
feature change
1
Troya et al., Towards systematic mutations for and with ATL model transformations, ICST Workshops, 2015, pp. 1-10
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 14 / 30
19. Mutation operators for ATL
Semantic operators
Operations mimic faults a developer may incur, based on authors’
experience not on empirical evidence
Mottu et al. [1,2]: 10 operators which are language-independent
Navigation operators
Relation to the same class change (RSCC) Replaces navigation by another to the same class
Relation to another class change (ROCC) Replaces navigation by another to a different class
Relation sequence modification with deletion (RSMD) Removes last step of a navigation sequence
Relation sequence modification with addition (RSMA) Adds navigation step in a navigation sequence
Filter operators
Collection filtering change with perturbation (CFCP) Modifies filter, e.g., acting on property or type of class
Collection filtering change with deletion (CFCD) Deletes filter
Collection filtering change with addition (CFCA) Adds filter, e.g., returning an arbitrary element
Creation operators
Class compatible creation replacement (CCCR) Replaces type of created object by a compatible one
Classes association creation deletion (CACD) Deletes creation of association
Classes association creation addition (CACA) Adds relation between two target objects
1
Mottu et al., Mutation analysis testing for model transformations, ECMDA-FA, LNCS 4066, Springer, 2006, pp. 376-390
2
Aranega et al., Towards an automation of the mutation analysis dedicated to model transformations, STVR 25(5-7), 2014
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 15 / 30
20. Mutation operators for ATL
Typing operators
Operators introduce typing errors or force runtime errors
S´anchez et al. [1]: 27 operators
used to test a static analyzer for ATL
coverage of ATL mm + operators for programming languages
Type Targets
Creation binding
source/target pattern element
rule inheritance relation
Deletion rule, helper, binding
source/target pattern element
rule filter, rule inheritance relation ..............
Type modification type of source/target pattern element
helper context type, helper return type
type of variable, collection or parameter ..............
Feature name modification navigation expression, target of binding
Operation name modification predefined operator (e.g., and) or operation (e.g., size)
collection operation (e.g., includes), iterator (e.g., exists, collect)
operation/helper invocation
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 16 / 30
21. Mutation operators for ATL
Operators based on errors made in practice (zoo)
Operators emulate errors made by competent developers
Zoo set (new!!!): 7 operators emulating the 5 most frequent typing
errors in the ATL zoo [1]
Error Frequency Operator
No binding for compulsory target feature 48.8% Remove binding of compulsory feature (RBCF)
Invalid actual parameter type 11.9% Replace helper call parameter (RHCP)
Feature access over possibly undefined receptor 11.22% Remove enclosing conditional (REC)
Add navigation after optional feature (ANAOF)
Feature found in subtype 3.75% Replace feature access by subtype feature (RSF)
Binding possibly unresolved 3.7% Restrict rule filter (RRF)
Delete rule (DR)
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 17 / 30
22. Mutation operators for ATL
Operators based on errors made in practice (zoo)
Operators emulate errors made by competent developers
Zoo set (new!!!): 7 operators emulating the 5 most frequent typing
errors in the ATL zoo [1]
Error Frequency Operator
No binding for compulsory target feature 48.8% Remove binding of compulsory feature (RBCF)
Invalid actual parameter type 11.9% Replace helper call parameter (RHCP)
Feature access over possibly undefined receptor 11.22% Remove enclosing conditional (REC)
Add navigation after optional feature (ANAOF)
Feature found in subtype 3.75% Replace feature access by subtype feature (RSF)
Binding possibly unresolved 3.7% Restrict rule filter (RRF)
Delete rule (DR)
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 17 / 30
23. Mutation operators for ATL
Operators based on errors made in practice (zoo)
Operators emulate errors made by competent developers
Zoo set (new!!!): 7 operators emulating the 5 most frequent typing
errors in the ATL zoo [1]
Error Frequency Operator
No binding for compulsory target feature 48.8% Remove binding of compulsory feature (RBCF)
Invalid actual parameter type 11.9% Replace helper call parameter (RHCP)
Feature access over possibly undefined receptor 11.22% Remove enclosing conditional (REC)
Add navigation after optional feature (ANAOF)
Feature found in subtype 3.75% Replace feature access by subtype feature (RSF)
Binding possibly unresolved 3.7% Restrict rule filter (RRF)
Delete rule (DR)
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 17 / 30
24. Mutation operators for ATL
Operators based on errors made in practice (zoo)
Operators emulate errors made by competent developers
Zoo set (new!!!): 7 operators emulating the 5 most frequent typing
errors in the ATL zoo [1]
Error Frequency Operator
No binding for compulsory target feature 48.8% Remove binding of compulsory feature (RBCF)
Invalid actual parameter type 11.9% Replace helper call parameter (RHCP)
Feature access over possibly undefined receptor 11.22% Remove enclosing conditional (REC)
Add navigation after optional feature (ANAOF)
Feature found in subtype 3.75% Replace feature access by subtype feature (RSF)
Binding possibly unresolved 3.7% Restrict rule filter (RRF)
Delete rule (DR)
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 17 / 30
25. Mutation operators for ATL
Operators based on errors made in practice (zoo)
Operators emulate errors made by competent developers
Zoo set (new!!!): 7 operators emulating the 5 most frequent typing
errors in the ATL zoo [1]
Error Frequency Operator
No binding for compulsory target feature 48.8% Remove binding of compulsory feature (RBCF)
Invalid actual parameter type 11.9% Replace helper call parameter (RHCP)
Feature access over possibly undefined receptor 11.22% Remove enclosing conditional (REC)
Add navigation after optional feature (ANAOF)
Feature found in subtype 3.75% Replace feature access by subtype feature (RSF)
Binding possibly unresolved 3.7% Restrict rule filter (RRF)
Delete rule (DR)
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 17 / 30
26. Mutation operators for ATL
Operators based on errors made in practice (zoo)
Operators emulate errors made by competent developers
Zoo set (new!!!): 7 operators emulating the 5 most frequent typing
errors in the ATL zoo [1]
Error Frequency Operator
No binding for compulsory target feature 48.8% Remove binding of compulsory feature (RBCF)
Invalid actual parameter type 11.9% Replace helper call parameter (RHCP)
Feature access over possibly undefined receptor 11.22% Remove enclosing conditional (REC)
Add navigation after optional feature (ANAOF)
Feature found in subtype 3.75% Replace feature access by subtype feature (RSF)
Binding possibly unresolved 3.7% Restrict rule filter (RRF)
Delete rule (DR)
1
S´anchez et al., Static analysis of model transformations, IEEE TSE 43(9), 2017, pp. 868-897
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 17 / 30
28. Tool support
Java framework for mutation testing of ATL:
https://github.com/jdelara/MDETesting
Implementation of all presented mutation operators (extensible)
Operators can use transformation typing info (anATLyzer)
Generator of test models (random, mm coverage, path coverage)
Generator of mutant-killer models (explained later)
DifferentialTester
MutationRegistry Mutation
ModelGenerator
Path
Coverage
MM
Coverage Random
RSCC RSF
> 50 operators
…
mutations
*
SemanticTyping Syntactic Zoo
MutantGenerator
1
1
ATL Transformation
Mutant
KillerModel
Generator
1 mutant provider
original
1
TestDriver
0..1
1 executes
uses
Type
Information
has
EMF random
instantiator
USE Validator
model finder
AnATLyzer
static analyzer
1
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 19 / 30
29. Efficacy of
Operators and
Test Model Generation Techniques
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 20 / 30
30. Evaluation of mutation operators
Experiment design
6 syntactically correct transformations from the ATL zoo
For each transformation:
create test suite with models generated by our three techniques
(random, meta-model coverage, path coverage)
create transformation mutants
compute mutation score
Overall, >32 000 mutants, >1 million executions
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 21 / 30
31. Evaluation of mutation operators
Applicability of operators
61% operators were applicable to all transformations
4 operators with poor applicability (i.e., frequently useless):
[typ] deletion of parent rule (1 application)
[typ] modification of type of variable (1 application)
[zoo] deletion of enclosing conditional (1 application)
[syn] deletion of input pattern element (0 applications)
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 22 / 30
32. Evaluation of mutation operators
Resilience and stubbornness of mutants
overall, 88% mutants were killed
most operators produced stubborn mutants (killed by few models)
Id Type Operator Mutants %Killed mutants %Killer models
0 syn In pattern element deletion 0 - -
1 sem Classes association creation addition (CACA) 14 100.00 17.87
2 zoo Replace feature access by subtype feature 48 100.00 3.97
3 typ Parent rule deletion 21 100.00 3.72
4 typ Variable modification 48 100.00 2.08
5 sem Relation sequence modification with deletion (RSMD) 72 100.00 1.94
........
18 typ,syn In pattern element creation 3818 100.00 0.03
........
21 typ,syn Remove binding 724 99.45 0.13
........
24 zoo Remove binding of compulsory feature 260 99.23 0.36
........
52 typ Helper deletion 780 89.87 0.12
53 typ Parameter deletion 513 89.47 0.15
54 typ Parameter type modification 570 89.47 0.13
55 zoo Add navigation after optional feature 44 83.33 1.04
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 23 / 30
33. Evaluation of mutation operators
Resilience and stubbornness of mutants
operators 1 to 18 only produced trivial mutants (always killed)
Id Type Operator Mutants %Killed mutants %Killer models
0 syn In pattern element deletion 0 - -
1 sem Classes association creation addition (CACA) 14 100.00 17.87
2 zoo Replace feature access by subtype feature 48 100.00 3.97
3 typ Parent rule deletion 21 100.00 3.72
4 typ Variable modification 48 100.00 2.08
5 sem Relation sequence modification with deletion (RSMD) 72 100.00 1.94
........
18 typ,syn In pattern element creation 3818 100.00 0.03
........
21 typ,syn Remove binding 724 99.45 0.13
........
24 zoo Remove binding of compulsory feature 260 99.23 0.36
........
52 typ Helper deletion 780 89.87 0.12
53 typ Parameter deletion 513 89.47 0.15
54 typ Parameter type modification 570 89.47 0.13
55 zoo Add navigation after optional feature 44 83.33 1.04
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 23 / 30
34. Evaluation of mutation operators
Resilience and stubbornness of mutants
operators 52 to 55 produced the hardest-to-kill mutants
mutants of 52–54 were among the stubbornnest
mutants of 55 were crash-prone and not so sttuborn
Id Type Operator Mutants %Killed mutants %Killer models
0 syn In pattern element deletion 0 - -
1 sem Classes association creation addition (CACA) 14 100.00 17.87
2 zoo Replace feature access by subtype feature 48 100.00 3.97
3 typ Parent rule deletion 21 100.00 3.72
4 typ Variable modification 48 100.00 2.08
5 sem Relation sequence modification with deletion (RSMD) 72 100.00 1.94
........
18 typ,syn In pattern element creation 3818 100.00 0.03
........
21 typ,syn Remove binding 724 99.45 0.13
........
24 zoo Remove binding of compulsory feature 260 99.23 0.36
........
52 typ Helper deletion 780 89.87 0.12
53 typ Parameter deletion 513 89.47 0.15
54 typ Parameter type modification 570 89.47 0.13
55 zoo Add navigation after optional feature 44 83.33 1.04
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 23 / 30
35. Evaluation of mutation operators
Resilience and stubbornness of mutants
operators 21 & 24 had similar resilience, but 24 created fewer mutants
similarly, matched rule deletion preferrable to rule deletion
Id Type Operator Mutants %Killed mutants %Killer models
0 syn In pattern element deletion 0 - -
1 sem Classes association creation addition (CACA) 14 100.00 17.87
2 zoo Replace feature access by subtype feature 48 100.00 3.97
3 typ Parent rule deletion 21 100.00 3.72
4 typ Variable modification 48 100.00 2.08
5 sem Relation sequence modification with deletion (RSMD) 72 100.00 1.94
........
18 typ,syn In pattern element creation 3818 100.00 0.03
........
21 typ,syn Remove binding 724 99.45 0.13
........
24 zoo Remove binding of compulsory feature 260 99.23 0.36
........
52 typ Helper deletion 780 89.87 0.12
53 typ Parameter deletion 513 89.47 0.15
54 typ Parameter type modification 570 89.47 0.13
55 zoo Add navigation after optional feature 44 83.33 1.04
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 23 / 30
36. Evaluation of mutation operators
Resilience and stubbornness of mutants
no operator set was more efficient than the others
zoo operators: 1 hard-to-kill, 3 trivial, 3 intermediate
Id Type Operator Mutants %Killed mutants %Killer models
0 syn In pattern element deletion 0 - -
1 sem Classes association creation addition (CACA) 14 100.00 17.87
2 zoo Replace feature access by subtype feature 48 100.00 3.97
3 typ Parent rule deletion 21 100.00 3.72
4 typ Variable modification 48 100.00 2.08
5 sem Relation sequence modification with deletion (RSMD) 72 100.00 1.94
........
18 typ,syn In pattern element creation 3818 100.00 0.03
........
21 typ,syn Remove binding 724 99.45 0.13
........
24 zoo Remove binding of compulsory feature 260 99.23 0.36
........
52 typ Helper deletion 780 89.87 0.12
53 typ Parameter deletion 513 89.47 0.15
54 typ Parameter type modification 570 89.47 0.13
55 zoo Add navigation after optional feature 44 83.33 1.04
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 23 / 30
37. Evaluation of test model generation techniques
Mutation score of test suites generated by:
random instantiation (50 models with 100 objects)
coverage of input meta-model
coverage of transformation execution path
Meta-model Transformation path Random
#M. typ sem syn zoo #M. typ sem syn zoo #M. typ sem syn zoo
t1 62 69.98 80.73 100.00 97.14 27 77.53 75.23 100.00 97.14 50 67.15 58.33 59.86 97.14
t2 200 87.44 31.68 45.54 30.33 18 82.47 71.66 89.31 95.08 50 65.64 56.71 48.36 23.58
t3 50 81.21 81.44 84.50 97.04 1 84.85 87.37 90.56 99.26 50 64.18 81.05 69.01 95.56
t4 50 98.71 68.52 86.17 100.00 92 98.14 98.60 96.33 100.00 50 99.22 98.33 95.74 100.00
t5 710 73.48 82.05 73.37 92.16 24 76.83 84.62 81.41 92.16 50 15.67 65.81 22.22 78.00
t6 26 75.91 72.84 60.96 87.88 6 82.70 70.37 60.56 87.88 50 21.60 19.28 23.51 45.45
Transformation path is the best option
produced the highest-quality test suite more often
produced the smallest test suites (less testing time)
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 24 / 30
39. Synthesis of mutant-killer models
Method (intuition)
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = -1 then true
else self.upperBound > 1 endif;
false Mutation
live mutant
1) AST node of mutated code
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 26 / 30
40. Synthesis of mutant-killer models
Method (intuition)
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = -1 then true
else self.upperBound > 1 endif;
false Mutation
live mutant
MVDataType
Attribute2Column
Class2Table
multiValued
control flow graph
upperBound = -1 / then
true false
Helper call
IF
Matched rule
Mutation
Matched rule
2) execution paths from matched rules to mutation
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 26 / 30
41. Synthesis of mutant-killer models
Method (intuition)
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = -1 then true
else self.upperBound > 1 endif;
false Mutation
live mutant
Class.allInstances()-> -- rule input
select(c | not c.isAbstract)-> -- rule filter
exists(c | c.att->exists(e |
not e.upperBound = -1)) -- inlining of helper
or
Attribute.allInstances()->
exists(a | a.upperBound = -1)
OCL path condition
MVDataType
Attribute2Column
Class2Table
multiValued
control flow graph
upperBound = -1 / then
true false
Helper call
IF
Matched rule
Mutation
Matched rule
3) requirements for a test model to reach the mutated code
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 26 / 30
42. Synthesis of mutant-killer models
Method (intuition)
model finding
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = -1 then true
else self.upperBound > 1 endif;
false Mutation
live mutant
Class.allInstances()-> -- rule input
select(c | not c.isAbstract)-> -- rule filter
exists(c | c.att->exists(e |
not e.upperBound = -1)) -- inlining of helper
or
Attribute.allInstances()->
exists(a | a.upperBound = -1)
OCL path condition
: Class
isAbstract = false
: Attribute
upperBound = -1
att
input test model
MVDataType
Attribute2Column
Class2Table
multiValued
control flow graph
upperBound = -1 / then
true false
Helper call
IF
Matched rule
Mutation
Matched rule
4) synthesis of input test model by model finding
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 26 / 30
43. Synthesis of mutant-killer models
Method (intuition)
model finding
helper context Class!Attribute def: multiValued : Boolean =
if self.upperBound = -1 then true
else self.upperBound > 1 endif;
false Mutation
live mutant
Class.allInstances()-> -- rule input
select(c | not c.isAbstract)-> -- rule filter
exists(c | c.att->exists(e |
not e.upperBound = -1)) -- inlining of helper
or
Attribute.allInstances()->
exists(a | a.upperBound = -1)
OCL path condition
: Class
isAbstract = false
: Attribute
upperBound = -1
att
input test model
MVDataType
Attribute2Column
Class2Table
multiValued
control flow graph
upperBound = -1 / then
true false
Helper call
IF
Matched rule
Mutation
Matched rule
However, reachability is necessary but not sufficient...
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 26 / 30
44. Synthesis of mutant-killer models
Evaluation of efficacy
For each mutant:
generate a killer test model
execute mutant and original transformation with the test model
compare the results
typ sem syn zoo
Mutants %Killed Mutants %Killed Mutants %Killed Mutants %Killed
t1 266 93.94 58 96.55 187 87.57 15 100.00
t2 2200 97.14 550 83.82 4045 97.11 60 81.67
t3 151 93.10 32 100.00 175 94.08 21 95.24
t4 3161 82.76 649 71.19 5993 78.66 65 73.85
t5 382 92.25 75 94.67 363 86.76 41 92.68
t6 153 59.48 42 54.76 143 58.04 16 43.75
Overall, 85% mutants killed
By cases, killed mutants >90% in 12/24 (in green)
Altogether, reasonable good results
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 27 / 30
46. Wrap-up
Today’s presentation
Analyse some steps in mutation testing for ATL
mutation operators
test model generation techniques
synthesis of mutant-killer models
to make it more effective
(and ATL transformations less buggy)
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 29 / 30
47. Wrap-up
Today’s presentation
Analyse some steps in mutation testing for ATL
mutation operators
test model generation techniques
synthesis of mutant-killer models
to make it more effective
(and ATL transformations less buggy)
Future plans
Replica of evaluation with partial oracles
Method to detect equivalent mutants for ATL
Improve synthesis of mutant-killer models
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 29 / 30
48. Towards effective mutation testing for ATL
Esther Guerra, Juan de Lara
Universidad Aut´onoma de Madrid (Spain)
Jes´us S´anchez Cuadrado
Universidad de Murcia (Spain)
esther.guerra@uam.es
Questions?
Esther Guerra Towards effective mutation testing for ATL MoDELS 2019 30 / 30