Community Research and Development Information Service - CORDIS

Framework for testing software systems on component level

The COACH test framework can test software systems on component level. This means that the framework can be used to identify components that do not behave according to their specifications. Once a component containing a fault has been identified, further localization of the fault within the component can be done using the test and debug facilities that are usually part of the implementation language specific development environment.

Tests on CCM components and the observation of interactions between components are expressed using IDL data types and are independent of the data types of the implementation language of the component. The ability to test components may be severely restricted when the components under test depend on interactions between other components that are not yet implemented. To reduce this restriction, the dependent components can be substituted by, so-called, Reactor components for the purpose of testing only.

Reactor components provide the same set of facets, operations and events as their real counterparts. Reactor component implementations can be generated automatically from the IDL specification. The Reactor components do not necessarily need to be implemented in the same language as the components they are substituting. For practical purposes we have chosen to generate Reactor components in Java. The implementation of the Reactor component is configurable to allow different kind of responses: The response may be interactive allowing the tester to examine the parameter values and construct a reply using an interactive IDL type editor, or the response is automated. The Reactor can be hard-coded to give an automated response, or by executing a script that can be loaded and interpreted at runtime. When an invocation arrives on a Reactor component facet it can reply (within limits) as if the real component is in place.

The range of possible test scenarios is now extended for the components under test and can reduce the probability of errors when the final components replace the Reactor components when they are available. The presence of Reactor components can demonstrate correct behaviour of the components under test for various interaction scenarios. In particular, error conditions occurring in the Reactor components can usually be simulated more easily using Reactors then real implementations. Even when real implementations become available, Reactor components are still useful for regression testing.

Another part of the test framework is the Actor component that acts as a general purpose CCM client component that can invoke operations on other components. The Actor can also load and execute test scripts or can be run in interactive mode. In interactive mode the tester can interactively fill in parameter values for a selected operation, invoke the operation and examine the result. References to other components may be passed as return values of operations. References to component facets can be obtained by using the navigation operations provided by the component interface.

In addition to providing the tester with a means of testing components using an actor and reactor, the CCM test framework allows the tester to trace and visualize the propagation of invocations between CCM components. Invocation tracing is useful for comparing the runtime behaviour of a planned system with its design specifications.

The Tracer framework consists of two parts:
- The TraceServer, which is a CCM component containing a collection of events that occurred within the system under test. At each interaction point a trace event must be send to the TraceServer component with timing and identity information about the interaction. This requires that the invocation flow at the interactions points is intercepted to allow for the additional actions to collect and sent the trace information. The CORBA Portable Interceptor is used to intercept the invocation flow of an operation on a CORBA object. Since CCM Component facets are implemented as normal CORBA objects, this mechanism is also suitable for the implementation of invocation tracing for CCM component interactions. The PI mechanism also allows additional service data to be propagated transparently between CORBA invocations.

- The TraceServer responds to queries by returning the requested event data formatted in XML, including complex parameter data types. The TraceViewer is a combination of a web server and a web client. The web server translates HTTP requests from the web client into TraceServer queries using CORBA invocations and returns the result as plain text XML. The web client visualizes the data received from the web server in a user-friendly manner.

With the combination of Actor, Reactor, and Invocation tracing viewer the implementers of CCM components have a powerful set of tools available to test their CCM components at an early stage.

Related information

Reported by

See on map
Follow us on: RSS Facebook Twitter YouTube Managed by the EU Publications Office Top