Matthias Riebisch

UML-Based Statistical Test Case Generation

For incremental iterative software development processes, automated testing is necessary to enable evolution not only in terms of functionality, but in terms of software quality as well. Automation requires models to provide the necessary information. Scenarios and use cases do not only feed requirements engineering, they may also be the basis for testing. They have to be enriched by detailed behavioral information in order to be used for statistical test case generation. This paper introduces an approach for generating system-level test cases based on use case models and refined by state diagrams. These models are transformed into usage models to describe both system behavior and usage. The method is intended for integration into an iterative software development process model. The resulting test cases are suited to be carried out in conventional ways, i.e., either manually or using test tools. The method is supported by an XML-based tool for model transformation.

Feature-Oriented Development of Software Product Lines: Mapping Feature Models to the Architecture

Software product lines (PLs) present a solid approach in large scale reuse. Due to the PLs’ inherit complexity, many PL methods use the notion of “features” to support requirements analysis and domain modelling (e.g. FODA, FORM, FeatuRSEB). Nevertheless, the link between features and architecture remains weak in all methodologies, with a large impact on the traceability of high-level concerns in respect to lower-lever architectural structures. This paper provides an analysis on the state of the art of feature-oriented PL methodologies from the point of view of the linkage between feature models and architecture. Based on the identified shortcomings it introduces an approach to allow a strong mapping between features and architecture. The approach makes use of extensions in the feature modelling techniques and adopts plug-in architectures as a means of mapping feature structures and at the same time satisfying the demanded PL variability and flexibility.

Details of formalized relations in feature models using OCL

System families are a form of high level reuse of development assets in a specific problem domain, by making use of commonalities and variabilities. To represent assets belonging to the core of the family and assets belonging to variable parts, feature modeling is a widely used concept. Consistency checking in feature models is not yet addressed appropriately by current methods. The paper gives a brief overview of feature modeling and elaborates the problems of current approaches. Based on the applications of these approaches within an ongoing research project, the paper proposes a formalized definition for feature modeling using the Object Constraint Language (OCL) and a set of associations and constraints to be used in the feature model. The relations between features in the feature model and features to external assets are examined and a way to formally handle these relations is presented as a result of a research project.

An approach for reverse engineering of design patterns

For the maintenance of software systems, developers have to completely understand the existing system. The usage of design patterns leads to benefits for new and young developers by enabling them to reuse the knowledge of their experienced colleagues. Design patterns can support a faster and better understanding of software systems. There are different approaches for supporting pattern recognition in existing systems by tools. They are evaluated by the Information Retrieval criteria precision and recall. An automated search based on structures has a highly positive influence on the manual validation of the results by developers. This validation of graphical structures is the most intuitive technique. In this paper a new approach for automated pattern search based on minimal key structures is presented. It is able to detect all patterns described by the GOF [15]. This approach is based on positive and negative search criteria for structures and is prototypically implemented using Rational Rose and Together.

The feature-architecture mapping (FArM) method for feature-oriented development of software product lines

Software product lines (PLs) are large, complex systems, demanding high maintainability and enhanced flexibility. Nonetheless, in the state of the art PL methods, features are scattered and tangled throughout the system components, leading to poor maintainability. Additionally, the majority of PL methods support manual product composition, while the implementation of feature-level variability in PL products influences the systems conceptual integrity. Generative programming techniques do enhance flexibility, but on the cost of maintainability. The feature-architecture mapping (FArM) method provides a stronger mapping between features and the architecture. It is based on a series of transformations on the initial PL feature model. During these transformations, architectural components are derived, encapsulating the business logic of each transformed feature and having interfaces reflecting the feature interactions. The flexibility of FArM architectures is supported through the explicit integration of plug-in mechanisms. The methodology is evaluated in the context of a wireless handheld device PL

Supporting evolutionary development by feature models and traceability links

During their usage, software systems have to be changed constantly. If such changes are implemented in an incomplete or inconsistent way a loss of architectural quality will occur, i.e. in terms of maintainability and understandability. The lack of traceability of the impact of changed requirements in the software enhances this effect. Traceability links have been proposed as a link between the requirements and the different parts of a solution. In practical use, these links are difficult to establish and maintain. Currently, tools cannot effectively support these links due to human-required decisions. This paper introduces feature models as an intermediate element for linking requirements to design models. They enable a more appropriate bridging of the different levels of abstraction. Feature models group sets of requirements to a feature and enable a modeling of the variability of requirements. The feature models structure traceability links between requirements, design elements and implementation parts. This leads to lower efforts of establishing and maintaining the links. Furthermore, descriptions of design decisions can be attached to the links. Industrial experience with this approach shows its support for the evolutionary development of large software systems, especially in the improved comprehension of the changes by the developers.

Using feature modeling for program comprehension and software architecture recovery

The available evidence in a legacy software system, which can help in its understanding and recovery of its architecture are not always sufficient. Very often the systems documentation is poor and outdated. One may argue that the most reliable resource of information is the systems source code. Nevertheless a significant knowledge about the problem domain is required in order to facilitate the extraction of the systems useful architectural information. In this approach feature modeling is introduced as an additional step in a systems architectural recovery process. Feature modeling structures the systems functionality and supports reverse engineering by detecting the relations between source code elements and requirements. Tracing these relations may lead to a better understanding of the programs behavior and the recovery of various architectural elements. In this way, by providing a mapping between source code and features, the systems feature model supports program comprehension and architectural recovery. The approach is developed as first part of a migration methodology towards a component-based architecture of legacy systems. Recovered information about features and architecture is collected in a repository to enable a refactoring as next step. The approach is currently applied in a large project for reengineering of an industrial image processing system.

Modeling Variability for Object-Oriented Product Lines

The concept of a software product line is a promising approach for increasing planned reusability in industry. For planning future requirements, the integration of domain analysis activities with software development for reusability turned out to be necessary, both from a process and from an economic point of view. In this context, variability of requirements in a domain is expressed by feature models. Feature models enable planning and strategic decisions both for architectural and for component development. By expressing feature dependencies, feature models are used to partition the architecture and the implementation. For industrial use, appropriate methods for modeling variability in requirements, design and implementation as well as tools for supporting feature models and for integrating them with other models are needed. The ECOOP workshop explored the possibilities and limitations of feature models and supporting methods. Its fully reviewed contributions aim at improving the feature model usage as well as the integration into the software development process. Improving industrial applicability of feature modeling and methods is an important goal. This paper provides a summary of the discussion and presents the major results as well as important questions and issues identified for future research.

A Model-Based Regression Testing Approach for Evolving Software Systems with Flexible Tool Support

Model-based selective regression testing promises reduction in cost and labour by selecting a subset of the test suite corresponding to the modifications after system evolution. However, identification of modifications in the systems and selection of corresponding test cases is challenging due to interdependencies among models. State-based testing is an important approach to test the system behaviour. Unfortunately the existing state-based regression testing approaches do not care for dependencies of the state machines with other system models. This paper presents the tool support and evaluation of our state-based selective regression testing methodology for evolving state-based systems. START is an Eclipse-based tool for state-based regression testing compliant with UML 2.1 semantics. START deals with dependencies of state machines with class diagrams to cater for the change propagation. We applied the START on a case study and our results show significant reduction in the test cases resulting in reduction in testing time and cost.

Evolution support by homogeneously documenting patterns, aspects and traces

The evolution of complex software systems is promoted by software engineering principles and techniques like separation of concerns, encapsulation, stepwise refinement, and reusability of design solutions. Design patterns capture the expertise for reusable design solutions. Aspect-oriented programming is a methodology that enables the modularization of cross-cutting concerns. Traceability links designate dependencies between requirements, design, and source code. In order to support maintenance, documentation has to enable understandability by describing these issues. Descriptions have to facilitate tool support for automating documentation activities. In this paper, we use the notion of patterns, aspects and traces for a homogeneous documentation approach. We integrate various types of documentation, keep track of traces from requirements to the source code, keep design information in the source code, and generate additional design views on software systems. We have implemented these ideas as an extension to javadoc, the documentation approach used by Java. This extension can be used to automatically generate views on the design and on aspects as well as on traceability links as part of the standard javadoc system documentation.