Java Testing Patterns [Paperback]

Jon Thomas (Author), Matthew Young (Author), Kyle Brown (Author), Andrew Glover (Author)

Book Description

ISBN-10: 047144846X | ISBN-13: 978-0471448464 | Publication Date: October 1, 2004 | Edition: 1

* 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

Editorial Reviews

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.

About the Author

JON THOMAS is a senior software engineer for ScriptSave, where he creates and adopts a variety of patterns for building and testing Java applications. He was also a contributor to the bestselling book Java Tools for Extreme Programming (Wiley).

MATTHEW YOUNG is the senior Java architect at HealthTrio in Tucson, Arizona. He champions the causes of UML, the Agile process, and engineering process improvement.

KYLE BROWN is a senior technical staff member with IBM Software Services for WebSphere. He has published more than fifty papers and articles on software-engineering topics, including database patterns.

ANDREW GLOVER is CTO for Vanward Technologies and specializes in building automated testing frameworks for Java and a variety of other platforms.

Product Details

• Paperback: 424 pages
• Publisher: Wiley; 1 edition (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
• Average Customer Review: 3.8 out of 5 stars  See all reviews (4 customer reviews)
• Amazon Best Sellers Rank: #2,017,345 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

13 of 15 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

This review is from: Java Testing Patterns (Paperback)

"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

This review is from: Java Testing Patterns (Paperback)

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
(VINE VOICE)    (REAL NAME)   

This review is from: Java Testing Patterns (Paperback)

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.