Pragmatic Unit Testing in Java with JUnit

by Andrew Hunt, Dave Thomas, Andy Hunt

Book Overview

Learn how to improve your Java coding skills using unit testing. Despite it's name, unit testing is really a coding technique, not a testing technique. Unit testing is done by programmers, for... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0974514012
• ISBN13: 9780974514017
• Release Date: September 2003
• Publisher: Pragmatic Bookshelf
• Length: 159 Pages
• Weight: 0.85 lbs.
• Dimensions: 0.6" x 7.5" x 8.9"

Customer Reviews

This should be required reading for new Java programmers

Pragmatic Unit Testing is one of those books that you only find once in a great while: concise, readable, practical, and applicable to everyday work tasks. There are a number of test frameworks for Java, a number of them based on JUnit. This is both good and bad: good, because JUnit is an effective, easy to use framework, and bad, because the documentation that comes with JUnit is horrible. This book is the documentation that JUnit SHOULD come with. Although quite simple in nature, this book provides guidelines not only for using JUnit, but concepts for planning effective Unit tests as well. I particularly like the examples and exercises the authors included with the book, as I learn better by doing them and seeing the results myself. If you're not familiar with Unit testing or skeptical of the results, read this book and give it a fair try. You'll never program the same way again.

bridging the gap

Unit Testing is one of those widely accepted good practices that is not always well applied. This book helps to bridge the gap between what should be done and what is done. While JUnit and Mock Objects are introduced in the text, the main focus is on developing insight into the philosophy of pragmatic unit testing. Most developers have a vague understanding of the why and how, but what do their results really mean? Are they sufficient to determine that the code is correct? How does the developer know? With anecdotes and clear examples, the authors help to clear the fog. Just as important, they dispel many of the testing myths and explode the excuses that are offered for not unit testing. Resistance will frequently come developers, but also from management thinking that developing test code will add time to the project instead of saving it. A side-effect of developing unit tests is that they add another layer of code that must be managed. Do you need tests for your test? Where does it end? Again the pragmatic programmers provide poignant pointers to managing the tests themselves. One of the pragmatic programmer commandments must be "Be brief". In less than 160 pages, this slim volume covers a lot of ground. For a project technical lead, several copies for your team to read may be a solid investment. Be sure to make a poster-sized version of the "Pragmatic Unit Testing: Summary" page from the book for the wall behind your desk.

an excellent introduction

(The following is an excerpt of a review of "The Pragmatic Starter Kit" I posted at JavaRanch.) "Pragmatic Unit Testing - In Java with JUnit" - the second volume in the three part "The Pragmatic Starter Kit" series" - from authors, Andrew Hunt and David Thomas, is an excellent introduction to the practice of unit testing - proving that a piece of code does what the developer intended it to do. If you're a new developer, hopefully you've asked yourself and others questions about how to establish that your code really works, how to feel confident that it keeps working after scores of changes have been made, what types of common problems and bugs should you be looking for, where are these problems likely to be, and what makes a good test. While answering those questions, this book also introduces the practice of testing with Mock Objects, how to organize the test code in a project, how to better design code for testability, and how to make use of JUnit for running all these tests. I'd recommend this book as a strong introduction to any developer new to or uncertain about the art of unit testing.

Great Description of Unit Testing

There has been a resurgent interest amongst developers in unit testing, mostly spurred on by Extreme Programming, test-driven development and the JUnit testing harness. But most of the discussion has been on how tests can shape design, rather than on how tests can test. This book does the best job of describing how JUnit-style unit tests can actually be used for testing. The book is available in two flavors: one in Java for JUnit and one in C# for NUnit.

A cornucopia of wisdom

Refusing to rest on their laurels from their 1999 success The Pragmatic Programmer, Andrew Hunt and David Thomas are back with a vengeance. They've taken a step back from their previous title to write The Pragmatic Starter Kit, billed as a prequel to The Pragmatic Programmer. The Pragmatic Starter Kit, meant to lay the foundation for a pragmatic programmer, consists of three titles: Pragmatic Version Control, Pragmatic Unit Testing, and Pragmatic Automation. Together, these titles show how to set up a sound development infrastructure, and educate as to fundamental practices, tools, and philosophies which may be used to enhance productivity within this infrastructure. Pragmatic Unit Testing, the second volume of The Pragmatic Starter Kit, teaches the developer to code smartly by practicing a regime of disciplined unit testing. Hunt and Thomas begin by convincing the reader just why it is we must write unit tests, and then quickly debunk the most common excuses developers use for not testing. Now that we are suitably convinced, the authors go on to explain how to plan and write unit tests, how to work with the JUnit framework, and how to use mock objects. Most books on this subject don't really go too far beyond how to write unit tests. Where this book stands head and shoulders above the rest though, is the great depth the book goes into showing us exactly what tests need to be written. Through a series of helpful mnemonics, the reader is taught exactly what to test, how to correctly test boundary conditions, and what the properties of good tests are. We are also given general testing principles to keep in mind, as well as questions to ask ourselves about our code while testing. The concepts given herein are invaluable, and if the book ended with just this, it would be well worth the money. The book doesn't stop there however. The authors offer excellent advice for integrating unit testing within the scope of a project in a team environment, and we are given a look at how unit testing can influence design. Exercises are presented to help the reader practice key concepts throughout the book. There are a couple of things that this book isn't. This book is not a treatise on how to unit test specific components in an application. As stated previously, this book is less about how to test specific components, and more about what tests should be written in the first place. This book also does not overtly espouse any particular process. Extreme programming and test-driven development are certainly mentioned, but they are not championed above other processes. This book is concise, weighing in at around 159 pages. The book is a very quick and pleasant read. It is appropriate for the novice as well as the developer who's been around the block a couple of times. If you write unit tests, and particularly if you are new to the game, this book is a cornucopia of wisdom. Pragmatic Unit Testing is to the practice of unit testing, what Joshua Bloch's Effective