Rapid Pattern-Oriented Scenario-Based Testing for Embedded Systems

Systems change often, and each change requires reverification and revalidation. Modern software development processes such as agile process even welcome and accommodate frequent software changes. Traditionally, software reverification and revalidation are handled by regression testing. This chapter presents a pattern-oriented scenario-based approach to rapidly reverify and revalidate frequently changed software. Key features of this approach are (1) classifying system scenarios into reusable patterns; (2) application of a formal completeness analysis to identify missing scenarios; (3) identifying scenario patterns (SPs) and corresponding verification patterns (VPs) and robustness patterns (RBPs); (4) rapid test script generation by reusing test script templates. This approach is also compatible with formal approaches such as model checking. This approach has been used at industrial sites to test safety-critical medical devices with significant savings in cost and effort. The chapter presents several examples to illustrate the effectiveness and efficiency of this approach.

Towards the Integration of a Formal Object-Oriented Method and Relational Unified Process

In this chapter, we study the use of a formal object-oriented method within Relational Unified Process (RUP). Our purposes are (a) to unify different views of UML models; (b) to enhance RUP and UML with a formal method to improve the quality of software; (c) to scale up the use of the formal method with the use-case driven, iterative and incremental aspects of RUP. Our overall aim is to establish a sound foundation of RUP and UML and scale up the use of formal methods in software-intensive system development.

A Unified Software Reengineering Approach towards Model Driven Architecture Environment

When developing a software system, there are a number of principles, paradigms, and tools available to choose from. For a specific platform or programming language, a standard way can usually be found to archive the ultimate system; for example, a combination of an incremental development process, object-oriented analysis and design, and a well supported CASE (Computer-Aided Software Engineering) tool. Regardless of the technology to be adopted, the final outcome of the software development is always a working software system. However, when it comes to software reengineering, there is rather less consensus on either approaches or outcomes. Shall we use black-box or white-box reverse engineering for program understanding? Shall we produce data and control flow graphs, or some kind of formal specifications as the output of analysis? Each of these techniques has its pros and cons of tackling various software reengineering problems, and none of them on its own suffices to a whole reengineering project. A proper integration of various techniques capable of solving a specific issue could be an effective way to unravel a complicated software system. This kind of integration has to be done from an architectural point of view. One of the most exciting outcomes of recent efforts on software architecture is the Object Management Group’s (OMG) Model-Driven Architecture (MDA). MDA provides a unified framework for developing middleware-based modern distributed systems, and also a definite goal for software reengineering. This chapter presents a unified software reengineering methodology based on Model-Driven Architecture, which consists of a framework, a process, and related techniques.

Deriving Safety-Related Scenarios to Support Architecture Evaluation

This chapter introduces an analysis process that combines the different perspectives of system decomposition with hazard analysis methods to identify the safety-related use cases and scenarios. It argues that the derived safety-related use cases and scenarios, which are the detailed instantiations of system safety requirements, serve as input to future software architectural evaluation. Furthermore, by modeling the derived safety-related use cases and scenarios into UML (Unified Modeling Language) diagrams, the authors hope that visualization of system safety requirements will not only help to enrich the knowledge of system behaviors but also provide a reusable asset to support system development and evolution.

A Framework for Managing Consistency of Evolving UML Models

As the standard for object-oriented analysis and design, the UML (Unified Modeling Language) metamodel, as well as contemporary CASE (Computer-Aided Software Engineering) tools, must provide adequate and integrated support for all essential aspects of software evolution. This includes version control, traceability, impact analysis, change propagation, inconsistency management, and model refactorings. This chapter focuses on the latter two aspects, and shows how tool support for these aspects can be provided. First, we extend the UML metamodel with support for versioning. Second, we make a classification of the possible inconsistencies of UML design models. Finally, we use the formalism of description logics, a decidable fragment of first-order predicate logic, to express logic rules that can detect and resolve these inconsistencies. We also show how the logic rules are used to propose model refactorings. As a proof of concept, we report on the results of initial experiments with a prototype tool we developed for this approach.

Developing Software Testing Ontology in UML for a Software Growth Environment of Web-Based Applications

This chapter introduces the concept of software growth environments to support sustainable long-term evolution of Web-based application systems. A multiagent prototype system is designed and implemented with emphasis on software testing. In this environment, software tools are agents that cooperate effectively with each other and human testers through communications at a high level of abstraction. New tools can be integrated into the system with maximal flexibility. These are achieved through the design and utilisation of an ontology of software testing that represents the knowledge of software engineering and codifies the knowledge for computer processing as the contents of an agent communication language. The ontology is represented in UML (Unified Modeling Language) at a high level of abstraction so that it can be validated by human experts. It is also codified in XML (Extensible Markup Language) for computer processing to achieve the required flexibility and extendibility.

Describing and Extending Classes with XMI

This chapter reports on an industrial experience about the management and the evolution of classes in an automated way. Today’s software industries rely on software components that can be reused in different situations, in order to save time and reuse verified software. The object-oriented programming paradigm significantly supports component-oriented programming, by providing the class construct. Nevertheless, already-implemented components are often required to evolve toward new architectural paradigms. Our approach enables the description of classes via XML (eXtensible Markup Language) documents, and allows the evolution of such classes via automated tools, which manipulate the XML documents in an appropriate way. To grant standard descriptions compliant with the UML (Unified Modeling Language) model, we exploit the XMI (XML Metadata Interchange) interchange format, which is a standard, defined by OMG (Object Management Group), that puts together XML, UML and MOF (Meta Object Facility).

Abstracting UML Behavior Diagrams for Verification

UML (Unified Modeling Language) and XML (Extensible Markup Language) related technologies have matured, and at present many novel applications of both languages are frequently appearing. This chapter discusses the combined use of both UML and XML in the exciting application domain of software abstraction for verification. In particular, software development environments that use UML notations are now including verification capabilities based on state exploration. This method is effective for many realistic problems, although it is well known that it is affected by the state explosion problem for many complex systems and that some kind of abstraction is needed. This is the point where XML can be used as a powerful technology, due to its features for program transformation. We describe how to use XML-related standards like dom or xmi in order to extend UML verification tools with automatic abstraction.

Support for Architectural Design and Re-Design of Embedded Systems

The market pushes the continuous evolution of embedded appliances (cellular phones, hand-held games, medical machinery, automotive systems, etc.). The assistance of appropriate methodologies and tools for supporting system-level design of embedded systems has become necessary for the development of appliances with tight constraints on performance, cost, and safety. Moreover, it is crucial to be able to rapidly and effectively modify appliances in order to meet new possible requirements. This chapter addresses the architectural design and redesign of embedded systems from a methodological viewpoint, taking into account both the hardware and software aspects; the final goal is to figure out the most convenient structure for the investigated system. In this context, the employment of both UML and XML can be regarded as an important step to substantially improve the overall design process.

UML- and XML-Based Change Process and Data Model Definition for Product Evolution

This chapter presents a software architecture and implementation to support in-service product configuration management applicable to both the automotive and aerospace industries. In both these industry sectors it is now feasible, with emerging technologies such as telematic systems and OSGi, to implement a distributed and integrated information system to support product evolution over its entire life cycle. For this area we demonstrate the definition of an exchangeable multidomain enterprise data model defined as an XML DTD. We also present a UML process model for configuration change management defined using a familiar industry-standard tool and develop a framework to show how exported XMI definitions can be translated into WfMC XPDL, whilst preserving the process model’s semantics. The chapter goes on to describe an evolution process for in-service embedded software using the OSGi Framework.