Marcio S. Dias

Software architecture-based regression testing

Abstract Software architectures are becoming centric to the development of quality software systems, being the first concrete model of the software system and the base to guide the implementation of software systems. When architecting dependable systems, in addition to improving system dependability by means of construction (fault-tolerant and redundant mechanisms, for instance), it is also important to evaluate, and thereby confirm, system dependability. There are many different approaches for evaluating system dependability, and testing has been always an important one, being fault removal one of the means to achieve dependable systems. Previous work on software architecture-based testing has shown it is possible to apply conformance testing techniques to yield some confidence on the implemented system conformance to expected, architecture-level, behaviors. This work explores how regression testing can be systematically applied at the software architecture level in order to reduce the cost of retesting modified systems, and also to assess the regression testability of the evolved system. We consider assessing both “low-level” and “high-level” evolution, i.e., whether a slightly modified implementation conforms to the initial architecture, and whether the implementation continues to conform to an evolved architecture. A better understanding on how regression testing can be applied at the software architecture level will help us to assess and identify architecture with higher dependability.

Software Architecture Analysis Based on Statechart Semantics

High assurance architecture-based and component-based software development relies fundamentally on the quality of the components of which a system is composed and their configuration. Analysis over those components and their integration as a system plays a key role in the software development process. This paper describes an approach to develop and assess architecture and component-based systems based on specifying software architecture augmented by statecharts representing component behavioral specifications. The approach is applied for the C2 style and associated ADL and is supported within a quality-focussed environment, called Argus-I, which assists specification-based analysis and testing at both the component and architecture levels.

Analyzing software architectures with Argus-I

This formal research demonstration presents an approach to develop and assess architecture and component-based systems based on specifying software architecture augmented by statecharts representing component behavioral specifications (Dias et al., 2000). The approach is applied for the C2 style (Medvidovic et al., 1999) and associated ADL and is supported within a quality-focused environment, called Argus-I, which assists specification-based analysis and testing at both the component and architecture levels.

Systematic Testing of Software Architectures in the C2 Style

The topic of software architecture (SA) based testing has recently raised some interest. Recent work on the topic has used the SA as a reference model for code conformance testing, to check if an implementation fulfills (conforms to) its specification at the SA level. In this context, on previous papers, we have analyzed: i) how suitable test cases can be ”selected” from the SA specification and ii) how they may be ”refined” into concrete tests executable at the code level. While the selection stage has been done systematically, the refinement step has been left to be done manually, based on the software engineer knowl- edge on how to map ”abstract values of the specification to the concrete values of the implementation”. In this paper, we extend previous approaches, by pro- viding a systematic way to perform the refinement step. We show how choos- ing a specific architectural style, which supports implementation and facilitates the mapping among SA-based and code-based test cases, a completely system- atic SA-based testing approach can be delivered.

Reasoning about software architecture-based regression testing through a case study

Two main issues need to be covered when dealing with the dependability of component-based systems: quality assurance of reusable software components and quality assurance of the assembled component-based system. By focussing on the assembly, a software architecture specification of a component-based system allows to explicitly model the structure and required system behavior by specifying how components and connectors are intended to interact. Software architecture-based conformance testing techniques can yield confidence on the implementation conformance to expected structural and behavioral properties as specified in the architectural models. In this paper we explore software architecture-based regression testing methods that enable reuse of earlier saved results to test if a different assembly of components conforms to the evolved software architecture. The approach is presented through a running example.

The role of event description in architecting dependable systems

Software monitoring is a technique that is well-suited to supporting the development of dependable system. It has been widely applied not only for this purpose but also for other purposes such as debugging, security, performance evaluation and enhancement, etc. However, there is an inherent gap between the levels of abstraction of the information that is collected during software monitoring (the implementation level) and that of the software architecture level where many design decisions are made. Unless an immediate structural one-to-one architecture-to-implementation mapping takes place, we need a specification language to describe how low-level events are related to higher-level ones. Although some specification languages for monitoring have been proposed in the literature, they do not provide support up to the software architecture level. In addition, these languages make it harder to link to (and reuse) information from other event-based models often employed for reliability analysis. In this paper, we discuss the importance of event description as an integration element for architecting dependable systems.

Identifying cause and effect relations between events in concurrent event-based components

Concurrent event-based components present characteristics that impose difficulties in understanding their dynamic behavior, mainly for interpreting the cause and effect relations between input and output events in component interactions. In this paper, we propose a technique to help in the process of understanding the dynamic behavior of concurrent event-based components. It checks the event trace (generated by monitoring the component execution) against a specification of the component communication protocol (even with a possibly incomplete or incorrect specification). The technique identifies and presents the more probable cause and effect relations between the component events, providing also a measurement related to this probability.

Adaptable analysis of dependable system architectures through monitoring

Every day, our society becomes more dependent on complex software systems with high availability requirements, such as those present in telecommunications, air traffic control, power plants and distribution lines, among others. In order to facilitate the task of maintaining and evolving such systems, dynamic software architecture infrastructures have recently been in the research agenda. However, complexity and dynamic evolution of dependable systems bring some challenges for verification. Some of these challenges are associated to modifications in the set of properties being verified and also in the types of analysis being performed during system operation. In this work, we present a multiple specification and architectural-based approach for software monitoring that allows the adaptation of analysis tasks in order to properly handle the challenges mentioned above.