Hanno Eichelberger

The nautilus analyzer: understanding and debugging data transformations

When developing data transformations - a task omnipresent in applications like data integration, data migration, data cleaning, or scientific data processing -developers quickly face the need to verify the semantic correctness of the transformation. Declarative specifications of data transformations, e.g., SQL or ETL tools, increase developer productivity but usually provide limited or no means for inspection or debugging. In this situation, developers today have no choice but to manually analyze the transformation and, in case of an error, to (repeatedly) fix and test the transformation. The goal of the Nautilus project is to semi-automatically support this analysis-fix-test cycle. This demonstration focuses on one main component of Nautilus, namely the Nautilus Analyzer that helps developers in understanding and debugging their data transformations. The demonstration will show the capabilities of this component for data transformations specified in SQL on scenarios from different domains that are based on real-world data. We provide an overview the Nautilus Analyzer, discuss components and implementation techniques, and outline our demonstration plan. The Nautilus website (http://nautilus-system.org) features a video, screenshots, and further details.

Accelerated model-based robustness testing of state machine implementations

In this paper, we present an approach for accelerating model-based robustness testing of state-based software components. We use the Z3 SAT solver to derive executable test cases fully automatically from a state model based on a UML Statechart. The test cases are paths along the Statechart comprising states and transitions. The main advantage of our approach is an accelerated execution of the test cases by refining already reached states as starting points for further test cases using reverse execution. Furthermore, the presented approach is able to check whether a correct target state has been reached or not when executing the path-based test cases using runtime verification and therefore increases the test significance. The runtime verification is done without instrumenting the source code of the component under test.

Debugger-Based Record Replay and Dynamic Analysis for In-Vehicle Infotainment

In the first operation tests of In-Vehicle Infotainment systems remaining failures which were not detected by other testing techniques can often be observed. These failures have to be reconstructed in the laboratory in order to be able to debug them. Record and replay concepts enable the automatic reconstruction of execution sequences, but often they disturb the normal execution, require comprehensive instrumentation or can not be implemented for every platform. Our approach considers these criteria by implementing record and replay with a symbolic debugger. Manually locating the root causes of failures during replay is time-consuming. Therefore, we apply dynamic analyses; they can detect anomalies and state changes during a run. The paper presents a collection of analyses which can not be smoothly executed online during operation, but do not cause drawbacks at replay.

Efficient Testing of Different Loop Paths

Loops can represent an infinite number of possible execution paths and therefore purse a major challenge for current static analysis frameworks and test input generators. In this paper, we introduce a new loop exploration algorithm to examine different iteration orders (i.e. loop paths) in order to test distinct loop behaviour. To reduce the complexity of testing all possible combinations of iterations, we introduce a criterion to group different paths into equivalence classes and show how to specifically generate test cases that cover the different equivalence classes. We demonstrate how this approach helps to achieve higher coverage rates and helps to find software failures that are not discovered by current test case generation frameworks.

Efficient Fault Localization During Replay of Embedded Software

When testing embedded software in real world operation, remaining failures which have not been detected during unit or system testing can often be observed. The execution of these failures is traced during operation tests of the integrated embedded system to replay it for offline debugging in the laboratory. It is time-consuming to detect the root-causes of noncrashing failures in the replay manually. Dynamic analyses during replay assist the developers in fixing these failures. The implementation of dynamic analyses using standard debugging tools improves the portability to different embedded platforms. Unfortunately, fine-grained dynamic analyses with debugger tools are often not applicable in practice because they require too much runtime effort for monitoring. Our approach accelerates the analyses by monitoring in detail only the locations which are relevant for the failure. It starts with fast monitoring of method calls to detect the approximate location of the failure in the replayed execution. Afterwards, in additional replays, it detects the root-causes by monitoring in detail only the relevant executions of methods. This paper shows how our multi-level concept makes fault localization for embedded software using debugger tools applicable in practice.

More Flexible Object Invariants with Less Specification Overhead

Object invariants are used to specify valid object states. They play a central role for reasoning about the correctness of object-oriented software. Current verification methodologies require additional specifications to support the flexibility of modern object oriented programming concepts. This increases the specification effort and represents a new source of error. The presented methodology reduces the currently required specification overhead. It is based on an automatic control flow analysis between code positions violating invariants and code positions requiring their validity. This analysis helps to prevent specification errors, possible in other approaches. Furthermore, the presented methodology distinguishes between valid and invalid invariants within one object. This allows a (more) flexible definition of invariants.

Ansatz für eine kollaborative Umgebung in der Fabrik- und Prozessplanung

Kurzfassung Dieser Beitrag stellt kurz die aktuellen Forschungsaktivitäten des Fraunhofer IPA in Stuttgart im Bereich „Digitale Fabrik“ vor. Theoretische Konzepte für eine durchgängige und kollaborative Fabrik- und Prozessplanung wurden im Rahmen des europäischen Projekt DiFac umgesetzt. Die Beschreibung der konzipierten und entwickelten Architektur der Hauptkomponente Factory Constructor der VR-basier-ten Produktionsumgebung DiFac bildet den Schwerpunkt dieses Artikels.

Automated Reproduction and Analysis of Bugs in Embedded Software

Embedded systems are used everywhere in our daily lives. About 90% of the produced microprocessors are used in embedded systems. Embedded systems get more and more dominated by software. Bugs remain in the software and can often be observed for the first time only in late development phases. It is difficult to reproduce bugs in embedded systems based on test reports. Our proposed automated bug reproduction concept is capable of handling sensor inputs as well as thread schedules. It reduces the manual effort while debugging a reproduced bug by applying dynamic verification during replay . This chapter shows the implementation of assertions and presents anomaly detection techniques to locate the root-causes of bugs. Anomalies can be detected by comparing executions which cause the bug with executions which do not cause the bug. Interferences between two executions which can be compared have to be detected. Using partitioning techniques, we explain coverage-based analysis and metrics as well as invariant-based analysis. The monitoring of the software for these analyses may cause a high overhead and thus may result in long monitoring times. Therefore, we show how monitoring can be accelerated by hierarchical refinement. Most of the available automated bug reproduction and dynamic verification tools are only applicable on specific platforms. Debugging tools, like the GDB, are usually the first tools which are available for new embedded platforms. Therefore, our tool is implemented based on the GDB . We present a tool for automated bug reproduction and efficient dynamic verification implemented with a debugger tool.