Review By: Lee Copeland
12/15/2003

The author begins with this situation: “Here you are with a big testing job ahead of you and no idea where to start.” This introductory book on software testing delivers exactly what it promises—where to start. The book’s opening chapter describes exploratory testing as a way to get started. Its steps are: explore the application to gain familiarity; define a simple, baseline set of tests and create the environment required for their execution; as you test, analyze trends in the results; build inventories of testworthy requirements and construct tests for each of them; combine data from the inventories; push the boundaries of the application; create devious tests; and finally, stress the system. Subsequent chapters describe this process in detail. Chapter 2 explains how to extract application requirements and create categories of tests. Chapter 3 describes how to move from these categories to specific test cases. Both of these chapters contain excellent, detailed examples of this process. Chapter 4 explains the use of tables and spreadsheets to minimize the documentation required to define the tests while maintaining the level of detail necessary. Again, excellent examples are presented. Chapter 5 introduces the reader to state diagrams and decision tables, both excellent schemes for documenting system design and an excellent basis for creating test cases. This chapter ends with a discussion of testing coverage.

The first half of this book is marvelous. Then, it seems, the author just runs out of steam. Beginning in Chapter 6, the excellent explanations and the detailed examples of the previous chapters evaporate. This chapter, “Testing Object-Oriented Software,” is very weak. Only section 6.4.2 discusses testing issues unique to OO (testing inheritance) and some of its information is simply incorrect. While I was pleased to see a section on the use of orthogonal arrays in testing (6.4.1), the author presents them only in the context of OO testing—a real disservice to this testing approach. By Chapter 7, “Testing Web Applications,” she has completely abandoned the detailed process and examples of the early chapters for statements such as “Many users have a low tolerance for anything … that does not work” (p.164). Very little of this chapter is specifically Web related, and little practical guidance is given to testers concerning either the technical testing issues they will face or practical testing approaches they could use.

In Chapter 8, “Reducing the Number of Test Cases,” the author gets back on track with useful information on choosing a reasonable subset of the many tests that could be run. Prioritization and risk analysis are the main topics here. Chapter 9, “Creating Quality Software,” presents to the novice tester other processes that surround or interact with testing: requirements gathering, project management, configuration management, quality assurance, reviews and inspections, levels of software testing, and the need for a testing environment. Chapter 10 is a useful introduction to standards: ISO 9000, IEEE 829, and the CMM.

Even with its shortcomings, I recommend this book for those new to software testing. The author’s writing style is not only crisp but fun to read. The detailed examples in the first five chapters and in the appendix lead the reader to an understanding of the level of work that needs to be performed to implement good software testing.