Introduction to Software Testing and over 2 million other books are available for Amazon Kindle . Learn more
FREE Delivery in the UK.
Only 1 left in stock.
Dispatched from and sold by Amazon.
Gift-wrap available.
Introduction to Software ... has been added to your Basket
Condition: Used: Good
Trade in your item
Get a £11.38
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Introduction to Software Testing Hardcover – 28 Jan 2008

See all 2 formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
"Please retry"
£33.85 £24.95
£59.99 FREE Delivery in the UK. Only 1 left in stock. Dispatched from and sold by Amazon. Gift-wrap available.

Trade In this Item for up to £11.38
Trade in Introduction to Software Testing for an Amazon Gift Card of up to £11.38, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

More About the Author

Discover books, learn about writers, and more.

Product Description


'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

'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 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

'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

'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

Book Description

This extensively class-tested textbook teaches students an innovative and successful approach to software testing. Lots of examples are used to give students a better understanding of the material. Exercises, with solutions for instructors, are included for the same reason. PowerPoint slides are available to help instructors prepare their own courses.

Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) 7 reviews
2 of 2 people found the following review helpful
This is a good introduction to testing for graduate CS students or senior undergrads 10 Jan. 2014
By Cem Kaner, J.D, Ph.D. - Published on
Format: Hardcover
I've taught from this book. I used it as a textbook in Florida Tech's software testing 2 course, which is focused on teaching programmers how to test their own code and how to design and write (including test) test tools. Students in that course have taken a course in black box testing already. That is, they understand a lot about testing a software system from an external point of view. The goal in this course is to help them understand how to test code well when they know the code.

I agree with the comment that this book doesn't try to train readers/students how to do unit tests. We use a different book to teach students the mechanics of unit testing. Those books teach a lot about the toolset, a lot about "best practices" for organizing tests, creating mock objects, etc. Students learn a lot about "how" but none of those books give students much insight about "what".

Ammann & Offutt help me teach students to think about what questions they want their tests to answer. Once students know what information they're looking for, the mechanics are very important, but without knowing what they're looking for, the mechanics are irrelevant.

My main criticism of the book is that it is rough sledding for several of our students. Some of the material in this book is beyond what I expect a 4th year undergraduate to learn in our course, or at least, explained in a way that is beyond them. Then again, you can make the same criticism of almost any advanced technical book.

I have a fair bit of non-academic experience in the field and, now as a professor, I work extensively with practitioners. People do things differently at different companies. The approach to testing that I primarily advocate and teach (system-level, context-driven testing) is seen as highly practical at some companies, as too sloppy at some, and as too academically pure at others. Similarly, intense unit-test-focused testing (e.g. TDD) is popular at some companies and barely attempted at others (barely done even in companies where the programmers call themselves "agile" and say they do Scrum). So it is not surprising to see some people say that what Ammann & Offutt are teaching is, in the experience of those people, impractical and unlike what they see in the real world. But the real world is a big place, and in many parts of it, this book rocks.
It would probably be a great resource if you were writing a paper on software ... 10 Feb. 2015
By Jo - Published on
Format: Hardcover
This "book" is a farce. Its not really a book so much as a sequence of obscure mathematical topics.

I can't believe that this is used on the university level. It would probably be a great resource if you were writing a paper on software testing in 1972. There is NOTHING in this book that helps you test software in 2014. Its all abstractions. Nothing concrete. Nothing helpful. Most of it is bizarre theories and definitions on types of test coverage that are extremely tedious and completely without context. You have been warned.
Raise your test thinking to the next level 24 Jun. 2014
By Eric "Siggy" Scott - Published on
Format: Hardcover
The take home: Line and branch coverage are sucky measures of test quality, and one can benefit by thinking beyond them.

This book is a thorough and understandable introduction to the theory of how to design good tests for software.

It does not introduce you to JUnit, mocking, theories or other well-known implementation details, nor agile, TDD or other practical philosophies de jure. Those are meant to be covered by a supplementary text -- Lord knows plenty are available.

Instead, this book summarizes the research community's solid, language-independent answers to questions such as "how many tests do I need to write?", "what test inputs do I choose?", and "how can I measure the quality of a test suite?"

Line and branch coverage metrics are used widely in industry, familiar to most JUnit programmers. Ammann and Offut show how these are just the rudimentary beginnings of a vast, well-studied family of measures of test quality. They also argue that the same measures and design strategies apply to integration testing, system testing, and unit testing. This leads to an apparently odd organization of the book that changes your world view when you realize its brilliance.

The thesis is that metrics of this sort give managers control over setting testing goals -- such as when to stop testing. Instead of the traditional "write tests until it feels right," or "test until the budget runs out," with good coverage metrics you can set a target that balances testing effort with the risk posed by bugs. Developers of flight control systems, for instance, are required by FAA policy to use certain logic-based coverage criteria that a team writing a Wiki framework would probably forego.

The book is organized in a pedagogical way, easy to understand but occasionally loosing the forest for the trees. Examples are in Java, but the focus is on models of software represented as graphs, logic expressions, etc. Specific technologies are rarely mentioned, because the authors wanted to book to have shelf value. The book will still be relevant a decade from now.

It is not true, as some reviewers claim, that this book has no real-world significance. The book is actually very light on theory, introducing only what is necessary to understand how to test software well.

Readers who are already practiced in unit testing and who are ready to take their understanding to the next level will be opened up to a wealth of new practices and development tools.
2 of 8 people found the following review helpful
Worthless 8 Oct. 2013
By dgcoffman - Published on
Format: Hardcover
Absolutely no relevence to actually writing test code whatsoever. As another review says, has no mention of unit testing. In fact, I could find almost no mention of any real-world testing idioms at all. Mocking is mentioned in passing a single time.
This is a book of theory written for PhDs by PhDs. Practitioners and students will find nothing of value here.
3 of 10 people found the following review helpful
Very good book 17 Sept. 2008
By WP - Published on
Format: Hardcover
This is a very good book. It gives good no-nonsense but nicely readable technical grounding to software testing. Highly recommended as textbook for courses in testing.
Were these reviews helpful? Let us know