Introduction to Software Testing
Announcement: The second edition has been published. This is now an archival website and will no longer be updated.
The authors donate all royalties from book sales to a scholarship fund for software engineering students at George Mason University.
Published February 2008. Paul Ammann and Jeff Offutt, Introduction to Software Testing, Cambridge University Press, Cambridge, UK, ISBN 0-52188-038-6, 2008.
I think this is a great testing book, both from academic and industrial perspectives. I believe Ammann and Offutt’s book will become the testing textbook of choice.
There are a lot of testing books out there, some better than others. Most are narrow in the topics they cover and the level of detail they present. In stark contrast, Ammann and Offutt's book has the advantage of presenting concepts and techniques that cover the broad range of languages and platforms used in practice by industry and academia. Theirs is one of the most thorough and practical testing books ever published. Roger Alexander, Associate Professor, Washington State University
The book (is) well written, logically organized, and provides excellent examples as well as useful course materials (such as homework assignments and quizzes). The book greatly facilitates the teaching and learning process. I plan to offer the course again and use the Ammann and Offutt text... The students also complimented the book in their student evaluations (a very rare occurrence).
The book provides an excellent high level as well as detailed presentation of topics that are often difficult for students to master, such as: control flow graph coverage, data flow graph coverage (including all-defs, all-uses, all-du-paths criteria), graph coverage for use cases, logic coverage (predicate coverage, clause coverage), syntax-based testing, etc. In particular, the logic coverage Chapter took very complex concepts and made them understandable for the students. Also, the examples that appear in the book are very useful and are highly representative of what our students run into after they graduate and land jobs as developers and/or testers. Jane Hayes, Associate Professor, University of Kentucky
I read it, used the material in it, and found it very useful, insightful, and precise. Now that it is a “real” book, I hope to use it as a textbook in the future. Lionel Briand, Simula Research Laboratory, Oslo, Norway
This is a great book for learning software testing. The clear terminology definitions and comprehensive examples provide an easy way to master the software testing techniques. After reading this book I get the image: instead of experimental techniques, which you can only get through experience, the term software testing means a set of general scientific methods and criteria that can be applied to individual cases. I think, for people who work in or prepare to enter the software testing field, this book is definitely what you need in your hand. Ling Liu, Research Professor, ETH Zurich (Text was used at Shanghai University, Shanghai China)
“....Where has this book been all these years? Your book reminds me why I wanted to study software testing in graduate school: testing touches on all the interesting theoretical/engineering models/representations for software.” Arthur Reyes, Associate Professor, University of Texas at Arlington
These two leading researchers provide an excellent exposition of the recent advancement of software testing in a manner that is suitable for classroom use. Theoretical concepts are covered rigorously and in practical contexts allowing students to build a solid foundation while being well-connected to the real applications. The abundant examples and exercises make both teaching and learning a more tangible task. In addition to classroom use, the balanced coverage of theory and application also makes the book a valuable addition to the practitioners' bookshelf. Jeff Lei, Assistant Professor, University of Texas at Arlington
This software testing textbook creatively uses only four models to capture current software testing techniques helping students, researchers, and practitioners to deeply grasp these techniques from an abstract, systematic perspective. The textbook provides excellent balance between theory and practice! Tao Xie, Assistant Professor, North Carolina State University
After a five-year effort,
Paul and Jeff are pleased to announce completion of their textbook,
“Introduction to Software Testing.”
The book introduces a novel perspective on software testing by defining generic
models and coverage criteria suitable for all software life-cycle artifacts.
This book is based on our collective experience of over 40 years
teaching software testing to hundreds of students,
and features accurate theory,
and numerous exercises.
Producing a book is just part of our overall goal – we are distributing complete courses with enough materials so that someone with general knowledge in software engineering or computer science can teach testing without first being an expert in software testing. This package includes syllabi for undergraduate and graduate courses, high quality powerpoint slides, over 200 worked homework exercises, dozens of fully working example programs, sample exams, and working software test tools. The materials can be used in courses at the undergraduate, master's and PhD level. The book has already been classroom tested by instructors at several universities.
Following Beizer’s lead in his landmark book
Software Testing Techniques,
we present testing
as a mental discipline that helps all IT
professionals develop higher quality software.
Software testing is a fast growing discipline.
Industry increases IT hiring each year,
and recent years have seen a marked increase
in emphasis on quality of software engineering in general,
and testing in particular.
Bill Gates recently said of Microsoft
“We have as many testers as we have developers.
And developers spend half their time testing.
We're more of a testing organization than we're a software organization.”
Thus the book
fits a growing industry need,
testing is considered to be critical knowledge in new IT and SE curricula,
and it offers material to help modernize existing CS curriculums.
The most novel innovation of the book is the overall structure. Instead of the traditional lifecycle-based approach of unit testing, module testing, integration testing, system testing, etc., our book is based on the principle that testing is based on finding models that describe the software, then designing tests that cover the models. As the following figure shows, we were able to define four models that represent the known software testing techniques. For example, a graph is pretty much the same, no matter whether it comes from source code, design documents, specifications, or requirements models.
|After an overview in the first chapter, the book discusses each model in separate chapters. Generic test criteria are defined for each model, then the book shows how generate the model from different software artifacts and how to apply the criteria.||The following figure shows the test coverage criteria that are defined on each of the four models; software testing experts and researchers will recognize most of the criteria from the literature.|
|The cover is an original piece of art by Peter Hoey commissioned specifically for the book. Paul and Jeff supplied some creative suggestions, including the concepts of a tester using the four major concepts in the book, graphs, logic, partitions and syntax, to bring order out of the chaos of testing||the myriads of technologies that software developers use. We asked the artist to make the tester as gender-neutral and race-neutral as possible, to emphasize the universal need for adequate software testing.|
In the summer of 2002,
Paul walked into Jeff's office and said “we have a problem.”
The problem was that the book we had been using in our MS-level course on software testing,
Software Testing Techniques by Boris Beizer,
was out of print.
Since Paul was teaching the course in the coming semester,
Jeff's response was “no, you have a problem.”
Well, Paul's problem became our problem,
and ultimately, we realized nobody else was going to write the book we needed.
So we started our own.
Five years later, we submitted our 362 page, 9 chapter book, Introduction to Software Testing, to Cambridge University Press. Paul and Jeff met several times per week in the first summer and laid out the overall structure of the book. The most important insight was an innovative structure for how to present testing; instead of a lifecycle-based approach where unit testing, module testing, integration testing, and system testing are very different activities; we had a fundamental realization. Testing is really a process of identifying one of a very few structures to represent the software, and then applying test coverage criteria to that structure. This insight was based on Beizer's adage that “testers find a graph and cover it.” The book's central observation is there are few truly different coverage criteria, and they can be applied to four structures: graphs, logical expressions, input spaces, and syntax structures. This not only simplifies the teaching of testing, but also allows for a convenient and direct theoretical treatment of each structure.
In the intervening five years, the title went from “Paul and Jeff’s Test Book” to “Coverage Criteria for Software Testing” and finally to Introduction to Software Testing. We used draft chapters and finally the entire book in graduate classes at George Mason University every semester since Fall 2002. Colleagues have used drafts of the book in various universities, including Carleton University, Colorado Technical University, North Carolina State University, Shanghai University, Texas Tech University, University of Illinois at Urbana-Champagne, University of Kentucky, University of Nevada at Las Vegas, University of Texas at Arlington, and Washington State University.
This extensive class testing
has allowed us to incorporate incredible amounts of feedback.
Along the way,
we realized the material is suitable for many kinds of classes:
an undergraduate course on software testing;
an MS-level course on software testing;
a PhD-level research course on software testing;
and modules in data structures and general software engineering courses.
We call this the “stream approach.”
Initially, we just wanted a book to teach our course. Eventually, we realized that we are not simply providing a book to the community, we are providing complete courses to the community based our almost 20 years of experience teaching testing. In addition to the book, we provide numerous carefully worked examples, high quality powerpoint slides, presentation hints, solutions to exercises, and working software. Samples of these materials are provided on this website. In 2002, you would have to already be an expert in testing to put together a course. This book allows non-experts to teach a testing course using our book and materials.
This is a preliminary website. Over the coming months, we will add more materials for instructors and students, and at some point most of the material will move to Cambridge University Press's website. GMU will continue to host some materials such as the web application programs. Paul and Jeff will also continue to maintain the book website for the foreseeable future.
|A brief timeline of the book|
|June 2002||Paul and Jeff start designing the book|
|Organization of structures and criteria established|
|Fall 2002||First draft chapters are used in SWE 637 at GMU|
|Fall 2004||Main chapters on the four structures completed and used in class|
|Spring 2005||Jeff's “book sabbatical”|
|November 2006||Signed with Cambridge University Press|
|Fall 2006||Paul's “book sabbatical”|
|June 2007||Complete manuscript sent to Cambridge|
|July 2007||Original cover art commissioned|
|August 2007||Original cover art completed|
|January 2008||Publication date|