Andrea Baldini

A Comparative Evaluation of Tests Generated from Different UML Diagrams

This paper presents a single project experiment on the fault revealing capabilities of model-based test sets. The tests are generated from UML statecharts and UML sequence diagrams. This experiment found that the statechart test sets did better at revealing unit level faults than the sequence diagram test sets, and the sequence diagram test sets did better at revealing integration level faults than the statechart test sets. The statecharts also resulted in more test cases than the sequence diagrams. The results show that model-based testing can be used to systematically generate test data and indicates that different UML models can play different roles in testing.

BOND: An interposition agents based fault injector for Windows NT

The goal of this paper is to present BOND, a Software Fault Injection tool able to simulate abnormal behavior of a computer system running Windows NT 4.0 Operating System. The Fault Injector is based on interposition techniques, which guarantees a low impact on the execution of the target program, and allows the injection of Commercial off-the-Shelf software programs. BOND allows performing both statistical and deterministic fault injection experiments, trading-off between overhead and precision of the obtained results. Moreover, the tool is capable of injecting faults into different locations, at any level of the application context (code and data sections, stack, heap, processors registers, system calls, ...). A complete set of experimental results on different application programs demonstrates the effectiveness and the flexibility of the tool.

A Dependable Autonomic Computing Environment for Self-Testing of Complex Heterogeneous Systems

This paper is part of a R&D project aiming at the definition and implementation of an environment for dependable autonomic computing. The primary goal of the study is the increase of dependability of digital systems using self-healing techniques. Mobile agents implement self-testing policies for complex and heterogeneous systems. The aim of this paper is to present the general ideas of the project, describe the design decisions and a detailed view of the current architecture. The research includes design and development of a working prototype.

Towards a unified test process: from UML to end-of-line functional test

In this paper, we propose the use of a UML methodology to go from user requirements and specifications to end of production testing of complex embedded systems. We consider behavioral, structural and physical levels building a comprehensive and modular model. The process contains the definition of a set of properties being created and then updated in each phase, and heavily relies on message passing and elaborating facilities to increase both abstraction and descriptive power. Result of the process is test pattern generation using custom ATE commands. We also present and discuss an underdevelopment case study of a significantly complex automotive application.

System-level functional testing from UML specifications in end-of-production industrial environments

The goal of this research is the study of a methodology to convert design-level specifications of complex embedded systems to system-level functional tests for direct instrumentation; the general context is industrial end-of-production environment (EOP) and the approach uses official and de facto industrial standards (e.g., Unified Modeling Language, UML) and advanced techniques from academic research. The research suggests process guidelines, exploring the generation of the timed test sequences from a UML model, the translation phases, and addressing the problem of timing and environment creation. A case study of a significantly complex application is provided directly from the industrial world thanks to an agreement between Politecnico’s Testgroup and Magneti Marelli Electronic Systems, research and development site of Venaria Reale, an international leader in automotive applications.

Efficient design of system test: a layered architecture

Starting from the idea of a general methodology to transform design specifications into system level functional test patterns for complex embedded systems, we propose a layered architecture as basis of such process. The architecture aims at strongly simplifying the test design, allowing the test engineer to concentrate on the high level parts of the system and wrapping all the complexity of the test environment. The results are then verified on a complex case study of automotive applications.

“Bond”: An Agents-Based Fault Injector for Windows NT

The goal of this chapter is to present BOND, a Software Fault Injection tool able to simulate abnormal behavior of a computer system running Windows NT 4.0/2000 Operating System. The Fault Injector is based on interposition techniques, which guarantees a low impact on the execution of the target program, and allows the injection of Commercial off-the-Shelf software programs. BOND allows performing both statistical and deterministic Fault Injection experiments, trading-off between overhead and precision of the obtained results. Moreover, the tool is capable of injecting faults into different locations, at any level of the application context (code and data sections, stack, heap, processor’s registers, system calls...). A complete set of experimental results on different application programs demonstrates the effectiveness and the flexibility of the tool.

QUACK: A Platform for the Quality of New Generation Integrated Embedded Systems

Over the last two years, the QUACK project investigated a new methodology for assessing the quality of heterogeneous, modular and configurable embedded systems, i.e., systems made out of a number of hardware and software components, usually embedded in devices with real-time requirements, and produced in families of different versions and configurations. The main aim of the project was to overcome the limitations of traditional techniques in dealing with the many new aspects and issues that arise, when the addressed class of systems is under concern. This paper surveys the final results of the QUACK project: that is, a new methodology for quality assessment of heterogeneous, modular and configurable embedded systems, throughout the whole software process.

Design for Testability for Highly Reconfigurable Component-Based Systems

Abstract Highly-reconfigurable component-based systems, i.e., systems that are built form existing components and are distributed in many versions and configurations, are becoming increasingly popular. The design and verification of such systems presents new challenges. In this paper we propose a design approach that facilitates analysis and testing of different configurations by identifying and tracking relations among requirements, logic components and resources. The approach proposed in the paper allows for easily identifying different dependencies among resources, components and requirements and thus spotting the tests that must be re-executed to assure the desired level of quality.

Beyond UML to an End-of-Line Functional Test Engine

In this paper, we analyze the use of UML as a starting point to go from design issues to end of production testing of complex embedded systems. The first point is the analysis of the big gap between system signals and UML messages; then the paper focuses on the additional information necessary to fill such gap; different test types are considered, focusing on the application software test; finally the actuation and observation are both analyzed inside the test environment, with particular care to the black-box requirement for behavioral testing. The emphasis of the work is on the resulting test engine definition, verified on a complex case study of a top-of-the-line automotive application; this application is a modern car console, grouping many controls of car-related devices, such as phone, navigation, radio, CD. The testing of GSM capabilities of such device is studied in particular.