Högskolan i Skövde

This work addresses problems associated with software testing in a Model Driven Development (MDD) environment. Today, it is possible to create platform independent models that can be executed and therefore, dynamically tested. However, when developing safety-critical software systems there is a requirement to show that the set of test cases covers the structure of the implementation. Since the structure of the implementation might vary depending on e.g., compiler and target language, this is normally done by transforming the design model to code, which is compiled and executed by tests until full coverage of the code structure is reached. The problem with such approach is that testing becomes platform dependent. Moving the system from one platform to another becomes time-consuming since the test activities to a large extent must start again for the new platform. To meet the goals of MDD, we need methods that allow us to perform structural coverage analysis on platform independent models in a way that covers as much as possible of the the structure of any implementation. Moreover, such method must enable us to trace specific test artifacts between the platform independent model and the generated code. Without such trace a complete analysis must be done at code level and much of the advantage of MDD is lost. 

We propose a framework for structural coverage analysis at a platform independent level. The framework includes: (i ) functionality for generation of test requirements, (ii ) creation of structural variants with respect to the translation to code, and (iii ) traceability between test artifacts at different design levels. The proposed framework uses a separate representation for structural constructs involved in coverage criteria for software in safety-critical systems. The representation makes it possible to create variants of structural constructs already at the top design level. These variants represent potential differences in the structure at lower design levels, e.g., target language or executable object code. Test requirements are then generated for all variants, thus covering the structure of different implementations. Test suites created to satisfy these test requirements are therefore, robust to different implementations.