Testing OO systems, is a guide to designing test-suites and test automation for object-oriented software. Components like classes, class clusters, frameworks, subsystems, and application systems are considered.

This book gives guidelines for the following design questions :

• How to design responsibility-based tests for classes and small clusters using behavior models, state-space coverage and interface data flow analysis ?

• How to use coverage analysis to assess test completeness ?

• How to design responsibility-based tests for large clusters and subsystems using dependency analysis and hierarchic state models ?

• How to design responsibility-based tests for application systems using object-oriented analysis/design models ?

• How to automate test execution with object-oriented test drivers, stubs, test frameworks, and built-in test ?

WHAT IS THE BOOK ABOUT ?

This book is about Software Engineering and Systems Engineering as much as it is about testing object-oriented software.

Models are necessary for test design. This book shows how to develop testable models focused on preventing and removing bugs.

Patterns are used throughout to express best practices for designing test suites.

Tools implement test designs. This book shows how to design effective test automation frameworks.

This book answers many questions which include the following :

• What are the differences between testing procedural and object-oriented software ?

• Is it essential to retest inherited super class features if a new subclass is written?

• What kind of testing is needed to be sure that a class behaves correctly for all the possible message sequences ?

• What is a good integration test strategy for rapid incremental development ?

• How can models represented in UML be used to design tests ?

• What can I do to make it easier to test my classes ad applications ?

• How can I use testing to achieve greater reuse ?

• How should I design test drivers and stubs ?

• How can I make my test cases reusable ?

• How can I design a good system test plan for an object-oriented application?

• How much testing is enough ?

CHAPTER WISE DETAILS :

The book is sub-divided into 4 parts :

• Preliminaries
• Models
• Patterns
• Tools

These 2 chapters cover what is the book about and a brief introduction about the topics in the book.

PRELIMINARIES

Chapter 3 :

This chapter (Testing : A brief introduction) includes a brief introduction to testing.

Chapter 4 :

This chapter (Testing and Object oriented software) includes the different kinds of bugs that object-oriented testing must target and what they imply for testing strategies .

MODELS

Chapter  5 :

This chapter (Test models) is about the model-based testing.

Chapter 6 :

This chapter (Combinational models) shows how to  model and test logical relationships.

Chapter 7 :

This chapter (State Machines) is about the state machines, how to develop highly effective, state-based test suites.

Chapter 8 :

This chapter  (Tester's guide to UML) covers the basics of UML, summarizes each UML diagram and relates testing strategies.

PATTERNS

Chapter 9 :

This chapter (Results-oriented Test Strategy) outlines a strategy for effective and efficient testing and test design patterns.

Chapter 10,11,12,13,14 :

These chapters cover how these patterns are organized by scope : methods and components, reusable components, clusters, subsystems and application systems.

Chapter 15 :

This chapter (Regression Testing ) is about the patterns for integration testing, regression testing

TOOLS

Chapter 16 :

This chapter (Test Automation) explains why object-oriented software should be developed to test object-oriented software.

Chapter 17 :

This chapter (Assertions) shows how some testing can be accomplished by code embedded in application.

Chapter 18 :

This chapter (Oracles) presents strategies to generate expected test results and evaluate actual test-results.

Chapter 19 :

This chapter (Test harness design) presents design patterns for automated test frameworks and components.

CASE STUDY

This book consists of a case-study called "Big Foot's Tootsie" which is about integrating a COTS tool suite for large scale object-oriented development.