Browse Books

Reviewer: Fernando Berzal

Testing computer software involves making sure that software does what it was designed to do, and that it does not do anything that is unintended. The self-assessment test at the beginning of this book will probably make you aware of how far you are from properly testing software. Even if you excel at this test, which is unlikely, given the poor state of the practice in software testing, this book will force you to develop a broader perspective on the issue of software testing. In fact, testing spans a wide range of often-neglected topics in the computer science curricula. This extended edition of a classic book [1] keeps its focus on practical tactics and techniques for software testing. Some people may object to this book, arguing that its examples are dated. You will find code snippets in FORTRAN and even in PL/I, but every example illustrates key concepts that go beyond the syntactic details of the programming language of the hour. You will also find some Java examples, which will probably be as obsolete in 25 years as PL/I examples are today. Other people may say that the book is just full of generalities. They are partly right, although they fail to acknowledge the importance of clear and concise prose in technical writing. After the previously mentioned self-assessment test, the book focuses on the psychological and economical aspects of software testing. From a psychological perspective, programmers are not always good testers, because testing requires a different frame of mind. Testing is no more than executing a program with the intent of finding errors. This simple fact makes programmers bad candidates for testing software, especially for testing their own software. From an economical point of view, testing is a sticky issue, because it is impractical, and usually impossible, to find all of the errors in a software program. A discussion of general principles and vital testing guidelines precedes an overview of non-computer-based testing. Human testing, in its various forms (that is, inspections, walkthroughs, reviews, and desk checking), is quite effective in practice. A handy common error types checklist will improve your effectiveness. The book includes a sample one, for you to update and expand according to your programming environment. Even though complete testing is economically unfeasible, test case design methods exist to help you in your testing efforts. A complete chapter, of more than 45 pages, is devoted to the use of different logic coverage criteria, equivalence partitioning, boundary values, cause-effect graphs, and plain error guessing, all of which are useful in software testing. Although there is certainly room for improvement in the presentation of cause-effect graphing, this chapter is the best survey on test case design techniques I have ever read. After covering the basic tools of the trade, the book delves into the organization of the testing process. For unit testing, the authors advocate preparing the smallest set of test cases that cover the boundary conditions, and satisfy the multicondition coverage criterion (namely, the finer-grained coverage criterion). For integration testing, they recommend a bottom-up incremental strategy. Finally, they elaborate on 15 categories of system tests, to apply distinct testing processes to distinct development processes. In other words, they urge a multi-strategy approach, because each testing technique is oriented to detect distinct classes of errors, and the different techniques are complementary. The book also addresses key questions, such as when to stop testing, or what to do after a successful test case. A successful test case is a test case that yields an error, which you have to locate and fix, where locating the error takes the lion's share of the effort. Using common language, you have to debug your code. Two new chapters on trendy topics complete this updated edition of the book. "Extreme Testing" provides a primer on test-driven development, and discusses acceptance tests taken from user stories, two of the key practices of extreme programming. "Testing Internet Applications" includes a basic description of the many failure points of Internet-based applications. Both chapters are interesting, but fall short of the quality standard set by the original book. In short, this updated edition of an all-time software testing classic will make the book relevant for another couple of decades. Its key points are as important today as they were when it was originally published. Some bibliographic references were missed, and a more thorough glossary is needed to round out this excellent book on practical software testing. Time will tell if this landmark book survives another generation, or if the fiercer publishing environment of today relegates it to the shelf of past glories. Online Computing Reviews Service