Behavioral models are important assets that must be thoroughly verified early in the design process. This can be achieved with manually-written test cases that embed carefully hand-picked domain-specific input data. However, such test cases may not always reach the desired level of quality, such as high coverage or being able to localize faults efficiently. Test amplification is an interesting emergent approach to improve a test suite by automatically generating new test cases out of existing manually-written ones. Yet, while ad-hoc test amplification solutions have been proposed for a few programming languages, no solution currently exists for amplifying the test cases of behavioral models.

To test a system efficiently, we need to know how good are the defined test cases and to localize detected faults in the system. Measuring test coverage can address both concerns as it is a popular metric for test quality evaluation and, at the same time, is the foundation of advanced fault localization techniques. However, for Domain-Specific Languages (DSLs), coverage metrics and associated tools are usually manually defined for each DSL representing costly, error-prone, and non-reusable work.

The Internet of Things (IoT) aims for connecting. This assumption brings about several software engineering challenges that constitute a serious obstacle to its wider adoption. The main feature of the IoT is genericity w.r.t the variability of software and hardware technologies. Model-driven engineering (MDE) is a paradigm that advocates using models to address software engineering problems. It can help to meet the genericity of the IoT from a software engineering perspective. Existing MDE approaches for the IoT focus only on modeling the internal behavior of things but lack a comprehensive approach dedicated to network modeling. In the present article, we introduce a network-oriented methodology based on MDE to unify the IoT’s heterogeneous concepts. Fundamentally, we avoid the intrinsic heterogeneity of the IoT by separating the network’s specification (i.e., the things, the communication scheme, and its constraints) from its concrete implementation (i.e., the low-level artifacts, such as source code and documentation). Technically, the methodology relies on a model-based domain-specific language (DSL) and a code generator. The former enables the modeling of the network’s specification, and the latter provides a procedure to generate the low-level artifacts from this specification. Our results show that this methodology makes iot’s software engineering more rigorous, helps prevent bugs earlier, and saves time.

Cyber-Physical Systems (CPSs) encompass both Information Infrastructures and networks of physical devices. Applications for monitoring them are usually implemented after the physical systems that they have to monitor: the CPS has to be running in order to monitor it. Monitoring applications define communications between the elements of those systems, and are compliant with their designs. Such applications can be complicated to develop, maintain and evolve, especially if the physical system changes. This paper brings an approach for engineering CPS monitoring applications, relying on model-driven techniques for generating a platform using the MQTT communication protocol for monitoring the CPS. First, it provides a meta-model for modeling sensors and actuators networks. Second, it introduces EMIT a monitoring platform for sensors and actuators networks. Third, it presents a transformation from models of sensors and actuators networks to automatically generate Emit monitoring configuration. We illustrate our approach on a case study and discuss its limitations and improvement points.

Reducing the energy consumption of a complex, especially cyber-physical, system is a cross-cutting concern through the system layers, and typically requires long feedback loops between experts in several engineering disciplines. Having an immediate automatic estimation of the global system consumption at design-time would significantly accelerate this process, but cross-layer tools are missing in several domains.

Elasticity is one of the main features of cloud-based systems (CBSs), where elastic adaptations, such as those to deal with scaling in or scaling out of computational resources, help meet performance requirements under varying workload. There is an industrial need to find configurations of elastic adaptations and workload that could lead to degradation of performance in a CBS, serving possibly millions of users. However, the potentially great number of such configurations poses a challenge: executing and verifying all of them on the cloud can be prohibitively expensive in both, time and cost. We present an approach to model elasticity adaptation due to workload changes as a classification tree model and consequently generate short test sequences of configurations that cover all T-wise interactions between parameters in the model. These test sequences, when executed, help us assess the performance of elastic CBS. Using MongoDB as a case study, test sequences generated by our approach reveal several significant performance degradations.

International audience

Early testing reduces the cost of detecting faults and improves the system reliability. In particular, testing component or service based systems during modeling frees the tests from implementation details, especially those related to the middleware. COSTOTest is a tool that helps the tester during the process of designing tests at the model level. It suggests the possibilities and the lacks when (s)he builds test cases. Building executable tests is achieved thanks to model transformations.

One of the main features of cloud computing is elasticity, where resource is (de-)allocated on demand and at system's runtime. Since elasticity is not trivial, testing cloud-based systems (CBS) is laborious. Among others, testers must set up elasticity parameters on cloud computing infrastructure, specify a sequence of resource variations, and drive CBS through this sequence. In this paper, we propose a Domain-Specific Language (DSL) aiming at reducing the tester's effort in writing and executing CBS elasticity testing. Our DSL abstracts test case specification from different cloud provider's libraries, making it portable. Experiments with two different case studies, a MongoDB replica set and a distributed web application, shows that our approach reduces the effort (in number of words) to write test cases, compared to dedicated libraries. We also see a reduced effort when running the same test case on multiple cloud providers.

Specifying a model transformation is challenging as it must be able to give a meaningful output for any input model in a possibly infinite modeling domain. Transformation pre-conditions constrain the input domain by rejecting input models that are not meant to be transformed by a model transformation. This paper presents a systematic approach to discover such pre-conditions when it is hard for a human developer to foresee complex graphs of objects that are not meant to be transformed. The approach is based on systematically generating a finite number of test models using our tool, PRAMANA to first cover the input domain based on input domain partitioning. Tracing a transformation's execution reveals why some pre-conditions are missing. Using a benchmark transformation from simplified UML class diagram models to RDBMS models we discover new pre-conditions that were not initially specified.

Summary A benefit of model‐driven engineering relies on the automatic generation of artefacts from high‐level models through intermediary levels using model transformations. In such a process, the input must be well designed, and the model transformations should be trustworthy. Because of the specificities of models and transformations, classical software test techniques have to be adapted. Among these techniques, mutation analysis has been ported, and a set of mutation operators has been defined. However, it currently requires considerable manual work and suffers from the test data set improvement activity. This activity is a difficult and time‐consuming job and reduces the benefits of the mutation analysis. This paper addresses the test data set improvement activity. Model transformation traceability in conjunction with a model of mutation operators and a dedicated algorithm allow to automatically or semi‐automatically produce improved test models. The approach is validated and illustrated in two case studies written in Kermeta.Copyright © 2014 John Wiley & Sons, Ltd.

Model transformations are an integral part of several computing systems that manipulate interconnected graphs of objects called models in an input domain specified by a metamodel and a set of invariants. Test models are used to look for faults in a transformation. A test model contains a specific set of objects, their interconnections and values for their attributes. Can we automatically generate an effective set of test models using knowledge from the transformation? We present a white-box testing approach that uses static analysis to guide the automatic generation of test inputs for transformations. Our static analysis uncovers knowledge about how the input model elements are accessed by transformation operations. This information is called the input metamodel footprint due to the transformation. We transform footprint, input metamodel, its invariants, and transformation pre-conditions to a constraint satisfaction problem in Alloy. We solve the problem to generate sets of test models containing traces of the footprint. Are these test models effective? With the help of a case study transformation we evaluate the effectiveness of these test inputs. We use mutation analysis to show that the test models generated from footprints are more effective (97.62% avg. mutation score) in detecting faults than previously developed approaches based on input domain coverage criteria (89.9% avg.) and unguided generation (70.1% avg.).

Testing remains a major challenge for model transformation development. Test models that are used as test data for model transformations, are constrained by various sources of knowledge that is expressed in different formalisms. Thus, in order to automatically generate test models it is necessary to interpret these different sources of knowledge and combine them into a consistent set of information that can be used for model synthesis. In this paper, we identify sources of testing knowledge and present our tool Cartier that uses Alloy as the first-order relational logic language to represent combined knowledge in the form of constraints. The constraints are solved leading to a selection of qualified test models from the input domain of a model transformation. We illustrate our approach using the Unified Modeling Language class diagram to relational database management systems transformation as a running example.