Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Introduction to software testing (2nd ed.)
Ammann P., Offutt J., Cambridge University Press, New York, NY, 2017. 364 pp. Type: Book (978-1-107172-01-2)
Date Reviewed: Jun 15 2018

Software testing is essential. It doesn’t much matter if you can do something quickly or in minimal memory or with a spiffy web interface if the results are incorrect, though incorrect might include “more or less correct” in many circumstances (this is often explicit in the statement of the problem). But at the same time, testing is often painful and can require more work than actually writing the code in the first place.

This book covers a basic view of software testing. Java is the primary language targeted, and JUnit is particularly covered as a unit test framework.

Fourteen chapters are organized into three main sections:

Part 1: “Foundations”
(1) “Why Do We Test Software?”
(2) “Model-Driven Test Design” covers the foundational approach that the text takes, the RIPR (reachability, infection, propagation, and revealability) model.
(3) “Test Automation” introduces the use of test automation at a high level.
(4) “Putting Testing First”: the importance of including testing in software projects.
(5) “Criteria-Based Test Design” covers testing criteria (including, for instance, coverage criteria, a common way to measure test effectiveness).
Part 2: “Coverage Criteria”
(6) “Input Space Partitioning”: breaking up the space of input parameters into groups that are equivalent for test purposes.
(7) “Graph Coverage”: using graphs to model the reachability of statements in the program.
(8) “Logic Coverage”: using the logical structure of the program to generate tests.
(9) “Syntax-Based Testing”: using syntactic criteria to generate tests; includes mutation testing and (roughly) fuzzing.
Part 3: “Testing in Practice”
(10) “Managing the Test Process” includes requirements analysis and basic test implementation.
(11) “Writing Test Plans”: documenting the test process as implemented.
(12) “Test Implementation” goes into more depth about how to actually implement tests based on the criteria found in Part 2.
(13) “Regression Testing for Evolving Software” is essential. Not only must most systems pass tests on new features, but the old features (for the most part) must still run; regression tests handle this aspect.
(14) “Writing Effective Test Oracles”: a test oracle is a way to specify the correct results in unit tests.

The book is dense in places (especially chapters 7 and 8, which amount to almost a third of the text). The graph criteria used are sometimes difficult, often only subtly different from each other, so these chapters require careful perusal.

Numerous exercises and answers are available on the book’s website, which also includes PowerPoint presentations for various topics and extra material. Some of the exercise solutions are for instructors only and require a password to view. Oddly, the book’s website doesn’t seem to be mentioned in the text itself--at least I couldn’t find it--but it is easily located with a web search.

There are also nice bibliographic notes in each chapter and a complete bibliography at the end.

Some of the material is clearly aimed more at a semester-long graduate course, although in the preface, parts of the book are identified as appropriate for undergraduates. Students without some reasonable familiarity with programming and graphs and without testing experience are likely to find things rather difficult.

A basic requirement for testing is that you need to know the intended behavior. Agile methods often manage to miss good requirement specifications, and testing in these cases can be difficult or impossible. If we don’t know what the result is supposed to be, we cannot really test for it. In practice, this can be more of a stumbling block than actually writing tests.

This is quite a nice book on a difficult topic. At its core, software testing requires mostly knowledge of the tools used for the language or system in question. Many software testers are likely to move forward without much of this knowledge, and by dint of working hard come to understand how best to test; however, a bit of theoretical knowledge is likely to make their tests more concise and more thorough.

More reviews about this item: Amazon, Goodreads

Reviewer:  Jeffrey Putnam Review #: CR146087 (1808-0409)
Bookmark and Share
  Featured Reviewer  
 
Testing And Debugging (D.2.5 )
 
 
Software Engineering (D.2 )
 
Would you recommend this review?
yes
no
Other reviews under "Testing And Debugging": Date
Software defect removal
Dunn R., McGraw-Hill, Inc., New York, NY, 1984. Type: Book (9789780070183131)
Mar 1 1985
On the optimum checkpoint selection problem
Toueg S., Babaoglu O. SIAM Journal on Computing 13(3): 630-649, 1984. Type: Article
Mar 1 1985
Software testing management
Royer T., Prentice-Hall, Inc., Upper Saddle River, NJ, 1993. Type: Book (9780135329870)
Mar 1 1994
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy