Catálogo de publicaciones - libros

This chapter does not describe a component test method directly, but rather it describes an approach to specification of components and system architectures that is intended to facilitate component user testing. The approach is a synthesis of specification ideas that are known individually—such as Design by Contract, explicit dependencies, quality of service, cost of service—but are not being followed collectively in practice. The argument is that clearer specification content and structure by system architects and COTS component vendors enables more efficient and effective component search, selection, and testing in component-based systems. Further, the approach here includes component specification variations that facilitate both consideration of the maximum number of candidate components for a given system and the maximum market for a given component. These are achieved through generalizing specifications while retaining precision. A test structure is given that shows how the approach can be used for component testing and integration, and a simple example illustrates the approach.

Integration testing plays a crucial role in component-based software development. It is also very difficult due to the common problem of lack of information about the design of the components and the unavailability of source code of commercial off-the-shelf (COTS) components. Addressing this problem, we investigate how to observe system’s dynamic behavior in component integration testing. Based on a theory of behavioral observation developed in our previous work, this chapter proposes a formal model of component integration testing methods and a hierarchy of behavioral observation schemes suitable for component integration testing. Their properties and interrelations are studied. Incremental integration testing strategies are also investigated. The requirements for proper uses of test drivers and component stubs in incremental integration are analyzed.

The publish/subscribe component model is an emerging paradigm to support distributed systems composed of highly evolvable and dynamic federations of components. This paradigm eases the design of flexible architectures, but complicates their validation. It is easy to understand what each component does, but it is hard to foresee what the global federation achieves.

This chapter tackles the problem at the architectural level and describes an approach to ease the modeling and validation of such systems. The modeling phase specifies how components react to events. It distinguishes between the and the other components. The former oversees the communication and is supplied as a predefined parametric component. The latter are specified as UML statechart diagrams. The validation uses model checking (SPIN) to prove properties of the federation defined as (LSCs). We do not start from LTL () formulae, the property language of SPIN, but we render properties as automata. This solution allows us to represent more complex properties and conduct more thorough validation of the modeled systems. The approach is exemplified on a simple application that controls an .

Performance characteristics, such as response time, throughput, and scalability, are key quality attributes of distributed applications. Current practice, however, rarely applies systematic techniques to evaluate performance characteristics. We argue that evaluation of performance is particularly crucial in early development stages, when important architectural choices are made. At first glance, this contradicts the use of testing techniques, which are usually applied toward the end of a project. In this chapter, we assume that many distributed systems are built with middleware technologies, such as the Java 2 Enterprise Edition (J2EE) or the Common Object Request Broker Architecture (CORBA). These provide services and facilities whose implementations are available when architectures are defined. We also note that it is the middleware functionality, such as transaction and persistence services, remote communication primitives, and threading policy primitives, that dominates distributed system performance. Drawing on these observations, this chapter presents a novel approach to performance testing of distributed applications. We propose to derive application-specific test cases from architecture designs so that the performance of a distributed application can be tested based on the middleware software at early stages of a development process. We report empirical results that support the viability of the approach.

In this chapter, we first survey current component technologies and discuss the features they inherit. Quality assurance (QA) characteristics of component systems and the life cycle of component-based software development (CBSD) are also addressed. Based on the characteristics of the life cycle, we propose a QA model for CBSD. The model covers the eight main processes in component-based software systems (CBS) development. A Component-based Program Analysis and Reliability Evaluation (ComPARE) environment is established for evaluation and prediction of quality of components. ComPARE provides a systematic procedure for predicting the quality of software components and assessing the reliability of the final system developed using CBSD. Using different quality prediction techniques, ComPARE has been applied to a number of component-based programs. The prediction results and the effectiveness of the quality prediction models for CBSD were outlined in this chapter.

Detecting programming errors in component-based systems can be difficult and very expensive. Due to the trend in outsourcing the development of software, companies are deploying more third-party software for mission critical systems. Hence, there is an increased need to assess the robustness and security of software. The traditional way of supporting component-oriented programming is to provide components in the form of shared libraries. In this chapter we describe a tool called HEALERS that can detect programming errors and security vulnerabilities in third-party libraries without source code access. A major advantage of our approach is that it is highly automated and could be used by component users who have little knowledge about the internals of a library.

No matter which tools, techniques, and methodologies are used for software development, it remains an error-prone process. Nevertheless, changing such important constituents of the software process surely has an effect on the types of faults inherent in the developed software. For instance, some types of faults are typical for structured development, whereas others are typical for object-oriented development.

This chapter explores the question of whether component-based software requires new testing techniques, and proposes an integrated testing technique. This technique integrates various tasks during testing component-based software: white-and black-box testing of the main component (i.e., the top level component controlling the other components), black-box testing of components, black-box testing of the middleware and integration testing of the main component with other components.

Benefits of this technique are shown using a real-world example: the technique is automatable and applicable to existing component-based software.