Introducing Software Testing is a step-by-step approach for getting started with testing tasks. It gives an brief overview of testing, then in a practical way show how to develop test cases.
Software testing is an important stage in the software development process, as is illustrated by the growing market for testing tools. Independent testing and verification before the implementation of the system can help improve its quality and reliability and cut the overall costs of the project.
Often a user of a new system is disappointed to find that all is not well with their new set up, and one of the most common reasons is that there has been insufficient testing to prove that a particular system will do precisely what was intended.
Managers are becoming aware of the need to test new products, though often the task of software testing is assigned to a programmer who, although he may have extensive programming experience, has not been trained to test software, and is suddenly expected to do so with a strict project deadline approaching. This book is intended to come to the rescue of such an IT professional. It covers aspects such as:
Best practice documentation strategies, methods and standards; and,
Tips on handling the various requirements facing the tester, including fitness for use models and presenting the case for testing to your manager.
A number of real-life case studies are introduced in the early chapters and then used throughout as examples of how to put the methods presented into practice and proceed successfully with them. These include an Object-Oriented and a Web testing example. The book will also be structured to provide extensive references out to other books in the testing area, to which the reader will be pointed to further develop his testing skills.
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.