Java Testing Patterns (Paperback)

~ Jon Thomas (Author), Matthew Young (Author), Kyle Brown (Author), Andrew Glover (Author) "If you put together a puzzle, while it might not be apparent to you, you perform a process of testing and integration..." (more)
Key Phrases: exception inducement, user authentication component, protected void tearpown, Quasi-Modal Testing, Related Patterns, Data Access Objects (more...)

Editorial Reviews

Product Description

* Focuses on software testing, which is one of the most important-and often the most overlooked-aspects of software development
* First book that demonstrates how to apply both existing and new design patterns to the job of testing Java software
* Explains how applying proven patterns to the testing of software can help ensure that applications function correctly and more efficiently, and are easier to maintain
* Patterns will be extensively reviewed online to ensure community support and endorsement
* Covers detailed patterns for unit, functional, database, and application deployment testing
* Provides complete Java code that applies each pattern to a real-world sample application
* Companion Web site provides code for Java pattern implementations, plus code for the sample applications and test suites

From the Back Cover

Take your software development skills to the next level with this innovative approach to software testing

As an experienced Java developer, you’re probably well aware of how to use software design patterns for building better software. Now, these same lessons can be applied to software testing. With this comprehensive book, you’ll discover how to use testing patterns along with design patterns in order to make the overall development process a lot more efficient and ensure that your code is easier to maintain. Testing experts Thomas, Young, Brown, and Glover present a brief introduction to design patterns and then walk you through each of the essential types of tests that comprise a complete software test plan.

The authors then demonstrate how to use these patterns to build a real-world test suite. Each pattern contains complete Java code and detailed steps for using it to test an application. The authors also explore popular open source testing tools such as Ant and JUnit so you’ll have everything you need to implement a wide range of testing solutions.

With this book, you’ll quickly learn how to apply the patterns approach to software testing. The authors arm you with detailed patterns for each of the test types, including:

• Unit testing patterns
• Database testing patterns
• Integration testing patterns
• Use case testing patterns

The companion Web site contains code for Java pattern implementations as well as code for sample applications and test suites. This site also includes diagrams from the book and a bonus chapter.

See all Editorial Reviews

Product Details

• Paperback: 424 pages
• Publisher: Wiley (October 1, 2004)
• Language: English
• ISBN-10: 047144846X
• ISBN-13: 978-0471448464
• Product Dimensions: 9.2 x 7.2 x 0.9 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 3.8 out of 5 stars  See all reviews (4 customer reviews)
• Amazon.com Sales Rank: #1,028,136 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

12 of 14 people found the following review helpful:

2.0 out of 5 stars poor editing, not worth buying, October 7, 2004

By	Jeanne Boyarsky (New York, NY) - See all my reviews

"Java Testing Patterns" is one of those books where it appears nobody edited. Java class/method names and acronyms are used in lower/upper case interchangeably. Writing class names in all lowercase in a Java book doesn't inspire much confidence in the accuracy of the rest of the book. There are many typos and inconsistencies that make it hard to read.

The formatting is also very poor. The code looks good in Eclipse, but not in the book. Lines wrap without indentation. Similarly, UML diagrams are randomly split into pages. They are supposed to be on the web, but they aren't yet.

The intro states a target audience of "software engineers, engineering managers and software testers." This book is heavily reliant on reading code. After the first few chapters, I don't think managers or testers would benefit.

Speaking of code, I think the code is too verbose and complicated - especially for a book. A few times, a simple JavaBean's source takes up one to two pages. One DAO takes up 12 pages. There is a test method with 16 branches. These examples make understanding quite difficult.

Now as for what the book does well. There are five good chapters on patterns. However, two are in essence the Factory and State patterns. The appendices are very good too. I wouldn't buying a book for three chapters and some appendices. Other books cover the material better. I would not recommend this book in its current edition.

3 of 3 people found the following review helpful:

5.0 out of 5 stars Great practical patterns book, October 8, 2004

By	Chuck Larsen (NYC USA) - See all my reviews

I've only read a couple patterns books, including the classic GoF. The only thing I don't like about the GoF book is that the explanations are very academic and the examples are far from useful in my work.

What I like about this Java testing patterns book is that it is extremely practical and therefor useful. For me it bridged the gap from a highly theoretical treatment of patterns to a detailed understanding of how to really employ patterns while coding in Java. The examples are rich and detailed and reflect the kind of development work I do (ie the examples are not simple strawmen set up to demonstrate an isolated concept).

Also, this book does a very good job of presenting a selection of patterns that you are likely to use *in combination* and with popular development tools. For instance the book not only describes the Mock Object, MockDAO, and Test Database patterns but also explains best practices for using DbUnit, JUnit, and other tools when testing code written with these patterns. I'm extremely thankful for that advice which is the kind of thing I've not found anywhere else.

The code actually works (amazing!) and is very useful. The formatting is at times a little odd in the book but it is defintitely readable.

I also appreciate the size of the UML diagrams and their readability...thank you for not squeezing them all on one page!

The only downside to this book is that I wish it covered more patterns. Hopefully the authors will cover more in the next edition or release more material on the Web site.

1 of 1 people found the following review helpful:

4.0 out of 5 stars Patterns oriented approach to testing, November 20, 2004

By	Jack D. Herrington "engineer and author" (Silicon Valley, CA) - See all my reviews (TOP 500 REVIEWER)    (REAL NAME)

If you are a patterns buff you will probably love this book. It takes a Gang of Four Design Patterns approach to various types of testing, starting with unit testing in the abstract, but then covering use of mock objects, test database, exception testing and other areas. It's a wide coverage area but the patterns remain fairly abstract. For those of a more pragmatic mind you should look at Manning's JUnit Recipes.