Customer Reviews

A Practitioner's Guide to Software Test Design

5 star:		(8)
4 star:		(3)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

The top two software testing books that I recommend are Systematic Software Testing (ISBN 1580535089), and this gem. Whereas the first book gives a complete process and accompanying practices, this one focuses on a collection of highly effective techniques that every test professional should have in his or her toolbox.

Copeland starts off with an overview of testing as a process, followed by case studies. These lay the foundation for the techniques for which a chapter is devoted to each technique. The chapters on the techniques are divided into collections of techniques that are most effective for blackbox (seven) and whitebox (two) testing. The next chapters are devoted to scripted testing with an emphasis on IEEE 829, exploratory testing, and test planning. The book wraps up with an outstanding chapter on software defect taxonomies, advice on when to stop testing, and case studies.

So why did I state this book is a page turner? Copeland has masterfully used humor, statements that catch you off guard, and a warm conversational style to hold your attention. Among the priceless gems of humor are the off-the-wall quotes that he uses in front of each chapter. One of many examples of how he holds your attention by catching you off guard is in Chapter 6 on pairwise testing: 'Why does pairwise testing work so well? I don't know', which he then follows up with one of the most cogent explanations of the technique I've had the pleasure of reading. As an aside, his treatment of pairwise testing - and the power of that technique - is reason enough to read this book.

Another aspect of this book I like is the thoroughness with which he presents techniques. This includes citing the work of other well known practitioners, using case studies, summaries, practice scenarios, and additional references for each chapter. Copeland also has a talent for clearly articulating and conveying complex topics and concepts, adding to this book's value as both courseware and a working reference.

If you are a software testing professional, or you are responsible for teaching this discipline this is one of the top books in my opinion. It is not as wide in scope as Software Testing: A Craftsman's Approach (ISBN: 0849308097), but it makes up for that by covering the essentials in the clearest possible manner.

Lee Copeland's book, "A Practitioner's Guide to Software Test Design" provides an easily read introduction into a critical but often ignored subject. As those familiar with the IEEE Standard for Software Test Documentation (IEEE-Std-829) know, Test Design is the first step in turning the "What" of the Test Plan into the "How" of test execution. The IEEE Test Documentation lifecycle is Test Plan - Test Design - Test Case Development - Test Procedure Development - (Test Execution) - Test Summary Report creation. Many test engineers proceed directly from Test Planning into Test Procedure creation, and do Test Design implicitly as opposed to explicitly. This can have a negative impact on an effective test program. This book clearly shows how to implement the test design process described in Drabick's book "Best Practices for the Formal Software Testing Process".

Lee's book provides a concise description based on excellent Case Studies of Black-Box (Requirements Focused) test techniques, moving from the simple (Equivalence Class and Boundary Value testing) to the more complex (Domain Analysis and Use Case testing). He provides the best description I've seen of test case development using orthogonal arrays. Lee then addresses White-Box (Structural Focused) testing, showing how to approach Control Flow and Data Flow testing. Again, he has the best description with illustrative examples of Data Flow testing that I've ever seen.

Lee then describes two Test Paradigms: Scripted Testing and Exploratory Testing that appear to be significantly different, and shows how the two can be used together for even more effective testing. That's the way I've always done testing, by the way.

His Defect Taxonomies chapter provides valuable insight on how to use such information in test design (I never thought of that), and he concludes with a short chapter that addresses the critical question When to Stop Testing.

The Case Studies on "Brown & Donaldson" and "Stateless University Registration" are effectively used to provide valuable insight into the techniques.

This book would be a good read in combination with the book from Rick Craig and Stefan Jaskiel, "Systematic Software Testing".

In summary, this book is well done, is an easy read, and should be read by every test engineer.

I agree with everything that Johanna wrote in her review, but I'd like to add one more point.

Orthogonal arrays and domain testing are two very challenging topics. They are also essential test design techniques.

As important as these topics are, few books or articles present the concepts in an understandable way. Up until now, the tester had to struggle through some arcane, mystifying ideas before coming to the essence: How to use them for testing.

Lee's presentation skips the arcane and the mystical. He takes you straight to the core of the idea. After a few short pages, you will understand both of these concepts, even if you've read other authors' presentations and come away confused. More importantly, you'll understand how to use these techniques to design effective and efficient tests.

Bravo, Lee, and thank you for demystifying these concepts for the rest of us.

Most texts on software testing have a chapter or two which describe test design techniques. This is the first text that is devoted exclusively to this subject. There is little in the way of theory. The text is practical and provides the software test professional with clear explanations and examples of test techniques that have been proven to be effective.

Although Copeland covers both black box (behavioral) and white box (developer oriented) test techniques, the majority of the test design techniques described are black box. Each technique is explained along with its applicability, advantages/disadvantages, along with references for more information.

For what can be a dry subject, Copeland effectively used humor to make this book very readable.

I also appreciated the chapter summaries, key points in the margins, and a thorough works cited -- including several web articles. Highly recommended.

This is a great read on an important topic. Lee Copeland has done a super job in bringing together a diverse set of test techniques in a way that will make sense to testers of all experience levels. This book also brings many of the techniques we have used over the years, such as boundary value testing and equivalence classes, up to date with newer techniques such as pairwise testing and use cases for testing.

It was interesting to read some of the quotes from Boris Beizer and other early testing authors. Some of those nuggets, such as the example of "Kiddie Pool vs. Real Pool" had a big impact on me years ago as I developed my understanding of what testing is about. Copeland achieves a nice level of coverage in this book, as he addresses black box and white box testing, as well as testing paradigms that shape the way someone may look at testing. The trade-offs between exploratory and scripted approaches are examined in particular.

I really like the readability of this book, due in large part to the humor that Copeland sprinkles through the book just when you need a smile.

Copeland also does an excellent job of thoroughly explaining by example how the various testing techniques are applied. He takes each technique step-by-step and breaks it down so that even a beginner can understand.

I found the chapter devoted to bug taxonomies very helpful by providing the lists by Beizer, Caner, Binder, Whittaker and others in a single location. I often tell my students to "start a bug collection" to understand the defects most common in the software they test. This is a natural and effective starting point for process improvement. The bug taxonomy can give you a head start on your own bug collection.

I can highly recommend this book to any tester. If you are looking for a self-study book in test planning, this is a great place to start!

I have been a manager in my company's testing organization for about four months after having worked in software development for the past 13 years. While I do not directly write or execute test cases, I thought this was an important topic for me to understand better. As a result I bought Lee Copeland's A Practitioner's Guide to Software Test Design, and I am very happy with this book.

Like most managers I don't have hours on end to dedicate to reading. However, this book is a very easy read. I actually thought I had gotten something too basic because the chapters on equivalence class partitioning and boundary values were extremely simple. Yet Copeland called out that testers and developers have probably used these techniques intuitively without formally knowing the official techniques. Things got much more interesting in chapters 5-11 as Copeland covered techniques such as pairwise testing, domain analysis testing, and control flow testing. My favorite chapter was on pairwise testing because he listed different online resources for orthogonal arrays and pairwise testing. I was able to download and run James Bach's tool generate test cases using a pairwise algorithm. I was also interested in his reference to the AT&T research site dedicated to orthogonal arrays. These techniques have complex mathematical principles at their foundation, but Copeland does a good job of focusing on how to use them rather than getting into the motivation and theory behind them.

Sections III and IV are more process focused than specifically related to test case design, but these are useful for helping testers put the techniques in context to their daily work. There are two case studies included in the appendices, but I didn't find it necessary to refer to them in order to get what I needed out of this book. The chapters and summaries contain sufficient information for working through the vast majority of the exercises without referring to the case studies.

Overall, this is a very good book on the fundamentals of test case design. Copeland has done a great job of balancing substance with accessibility. For fun each chapter begins with a selection of a "bad writing" contest. While these have nothing to do with the material, it keeps his book from being a dry, boring, and ponderous work to read. I recommend this to anyone who wants to build their knowledge of test case design.

Overall: A

Lee Copeland has written a very clear exposition of software test design techniques, this being a text book that reads like a story. It is very readable, with examples of the techniques described. The examples are not text book examples, but are the kind of problems that exponents face in the real world of software testing. He leads the reader, making you feel like you have been on a journey. Unlike some of its kind, it is not speaking down to you. What is more, the book is suitable for many levels of testing, including people not directly involved in the testing activity itself.

At the end of test techniques themselves (of which more later), the author has some remarks about other testing matters. He describes scripted tested and exploratory testing in detail. These are well described, and the book states that the descriptions given are the two extremes - with very few instances occurring in the wild at these extremes. What Copelend is almost saying (but does not quite say it) is that the two are at the opposite extremes of the same continuum, and that most testing situations have elements of both - the extremes are textbook only.

In the description of techniques is thorough and systematic, giving the advantages and disadvantages of each technique. There is no account of the Classification Tree Method (CTM), which would have been a good introduction into pairwise testing (which is covered). There is also no account of some other techniques (syntax testing, Linear Code sequence and Jump), but that said, it would be a mammoth task to cover everything.

The book gives the best account that I have found of pairwise testing, with or without using orthogonal arrays. It is very detailed, and has examples of where significant testing advantage has been gained by using this technique. The test coverage that can be achieved with well chosen pairwise test cases seems too good to be true. Copeland states that there also needs to be an element of tester prudence used, to augment the technique if necessary with some commonly occurring combinations that were not selected by the two tools that support the technique.

One very useful thread within the book is a set of web-based set of web applications that illustrate techniques used within the book. The examples were not explicitly created for use within the book, but were from testing courses and workshops from STQE, who Copeland works for. The applications aid understanding and are a real bonus for the reader.

Add this to your bookshelf if you are involved in any way in the software development process. However, if in testing, make sure that you have some other both technical and managerial testing books available

Peter Morgan (morganp@supanet.com)

The first 2/3 of the book (chapters 1-11) are great. A superb overview of many testing techniques helpful to a software tester. A superb "tool collection" for a software tester's tool box.

The last 1/3 of the book (chapters 12-16), it seems to lose focus a bit. Concepts started being tainted with business paradigms and tedious coverage of items that could have easily just been referenced only.

Overall, though, I do love the book and see it as a valuable resource to keep around. :-)

This is a great reference, giving a good overview of most common test methods. Good bases for in-depth study or to structure a class around.

As I've read Lee's articles through the years, I'm always struck by his sense of humor and his practical approach to his work. This book reflects both.

For fun, he's included a winning entry from the worst fiction writing contest (Bulwer-Lytton) - which help me create a great frame of mind for reading the chapters. For practicality, Lee added Insights, Key Points, Notes, and Where to go for more information in the margins.

The chapter I liked the best was the pairwise testing chapter. Pairwise testing is an underutilized technique, and this chapter helps people understand which conditions should prompt a tester to consider pairwise testing and how to perform pairwise testing. Quoting from the book (p. 89), Lee says, "The exciting hope of pairwise testing is tha by creating and running between 1 percent to 20 percent of the tets you will find between 70 percent and 85 percent of the total defects." In my experience, pairwise testing provide me a technique when no other techniques were possible.

If you haven't thought about how to organize defects, then chapter 15, "Defect Taxonomies" will be helpful. He reviews some well-known taxonomies and concludes with the wise advice (p. 232) "The taxonomy that is most useful is your taxonomy, the one you create from your experience within your organization." Throughout the book, Lee helps the tester learn how to apply techniques to the product under test.

If you're not sure which test techniques you could apply to your product to improve your testing, this book will help you choose. If you're trying to teach a new test technique to a less seasoned tester, this book will help. If you're managing a test group and you don't know as much as you'd like about testing, you should definitely buy this book so you can talk to your testers. Lee has written an engaging, easy to understand book about ways to think about testing.