Review By: Nancy Michniewicz
07/08/2010This book reviews various mathematical principles and explains how they apply to software testing. Three examples are used throughout the book to show how to apply the various techniques. The three examples are the Triangle program, the Next Date function, and the Commission problem. The book is divided into four parts: a mathematical context, functional testing, structural testing, and systems testing.

Part 1
Chapter 1 begins with defining some basic testing definitions. Chapter 2 details the three examples used throughout the book. The remaining chapters of part 1 discuss some basic math principles: set theory, functions, relations, propositional logic, probability theory, and graph theory.

Part 2 discusses functional testing, which includes chapters discussing Boundary Value Testing, Equivalence Class Testing, and Decision Table Based Testing. Boundary Value Testing is mainly used for verifying inputs. It can be extended to cover robustness by looking at extremes (larger than the max/smaller than the min). Other extensions of boundary value testing are worst-case testing and special-value testing. Equivalence Class Testing is used to reduce the amount of redundancy as well as provide more completeness. Equivalence class testing is broken into three types: weak, where one variable of each equivalence class is used; strong, where we use all equivalence classes; and traditional, where equivalence classes are divided into valid and invalid classes and one value of each is used. Decision-based testing is used to show combinations of inputs and outputs for specific actions. Chapter 8 wraps up part 2 by using the examples to show how effective and efficient boundary value, equivalence class, and decision-based testing can be. It also provides recommendations on when to use each type.

Part 3 covers structural testing. Structural-testing methods are used to validate actual source code. Chapter 9 focuses on path testing, test coverage metrics, and basis path testing. Chapter 10 discusses data-flow testing where the focus is on checking various points in a program where variables are assigned and used. Chapter 11 reviews the various structural techniques discussed, reviews the examples and looks at how the structural techniques would be used for each and how appropriate they are.

Part 4 focuses on integration and system testing. Chapter 12 introduces the common lifecycle methods: waterfall, waterfall-like, specification based, and object oriented. The Simple Automatic Teller Machine System (SATM) example is then detailed for discussion in the remaining chapters of the book. Chapter 13 looks at the SATM example to explain several approaches to integration testing: decomposition-based integration (which can be top down, bottom up, or sandwich, which is a combination of the first two), call-graph-based integration, and path-based integration. Chapter 14 discusses system testing. System testing is used to validate the system works as expected. This chapter then discusses threads, providing several definitions, and again uses the SATM example. Chapter 15 focuses on object-oriented testing and compares it to testing of more traditionally developed systems. Again the SATM example is used to show how to apply this method. Chapter 16, the final chapter, discusses interaction testing with a final short blurb on client-server testing.

As an experienced tester I didn’t gain much from this book except that it reviewed mathematics I already use in my testing techniques. I would not actually sit down and think through each of these techniques as I plan my testing. Not enough time is allocated in a “real” project go through many of these techniques. Many are very time consuming. But I do believe many of the techniques are used by testers in test-case development without thinking about it.

Overall, I felt the book read much like a classroom book. Exercises are even included at the end of each chapter. For those who are new to the field, take a look. It is beneficial but it is not light reading. For those who are experienced, you most likely already use these techniques and won’t gain much.

I would recommend this book only to those testers new to the field or those with a minimal mathematical background. This book may also be of interest to software developers new to the field.