Buy Used
+ £2.80 UK delivery
Used: Good | Details
Condition: Used: Good
Comment: Ships from USA. Please allow 2 to 3 weeks for delivery. Light shelf wear and minimal interior marks. A tradition of quality and service.
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

Pragmatic Unit Testing in Java with Junit (Pragmatic Programmers) Paperback – 11 Sep 2003

3.3 out of 5 stars 3 customer reviews

See all formats and editions Hide other formats and editions
Amazon Price
New from Used from
"Please retry"
£44.45 £0.05
click to open popover

Special Offers and Product Promotions

Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.

  • Apple
  • Android
  • Windows Phone

To get the free app, enter your mobile phone number.

Product details

  • Paperback: 176 pages
  • Publisher: Pragmatic Bookshelf; 1 edition (11 Sept. 2003)
  • Language: English
  • ISBN-10: 0974514012
  • ISBN-13: 978-0974514017
  • Product Dimensions: 19 x 1.5 x 22.9 cm
  • Average Customer Review: 3.3 out of 5 stars  See all reviews (3 customer reviews)
  • Amazon Bestsellers Rank: 652,651 in Books (See Top 100 in Books)
  • See Complete Table of Contents

Product Description

From the Publisher

Improve your Java coding skills using unit testing: it's really all about coding, not testing. This book shows not just how to test, but what to test. Discover the tricky hiding places where bugs breed, and how to catch them using JUnit. You don't need to adopt Extreme Programming, or Test-Driven Development in order to reap the proven benefits of unit testing, the pragmatic way. Volume II of the Pragmatic Starter Kit.

About the Author

Andy Hunt and Dave Thomas have more than 50 years combined experience, developing software for clients around the world. For the last 10 years they've been working together as The Pragmatic Programmers, helping clients write software and improve their development processes. They are authors of the best-selling The Pragmatic Programmer, and have written several other books. They speak at conferences globally, and are editors of IEEE Software's "Construction" column.

See all Product Description

Customer Reviews

3.3 out of 5 stars
5 star
4 star
3 star
2 star
1 star
See all 3 customer reviews
Share your thoughts with other customers

Top Customer Reviews

Format: Paperback
but then it doesn't offer much beyond what you can glean from reading about the subject on the internet. It also misses out a great deal of stuff which would be useful such as how to test private methods of classes, using databases in testing using DbUnit or how to use Cactus or many of the other frameworks it mentions. It does cover a lot of ground on what to test and why you are testing, but I found it very brief and lacking information on how to test.
Comment 9 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback Verified Purchase
A slightly lengthy book but overall offered good advice. e.g. Right BICEP rule, CORRECT rule. Perhaps in need of a refresh though to take into account all the other testing techniques now available, e.g cucumber (BDD Testing), Mockito/PowerMock testing, Groovy/Spock (Specification) testing. (Source: I am a software developer)
Comment One person found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback Verified Purchase
This is not a bad book but I would only buy it if you have absolutely no experience of unit-testing.

It's well written and easy to understand but the subject matter is very basic and only suitable for beginners.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse

Most Helpful Customer Reviews on (beta) 4.1 out of 5 stars 16 reviews
34 of 38 people found the following review helpful
2.0 out of 5 stars a shallow introduction to a deep subject 18 Oct. 2005
By L. J. Levin - Published on
Format: Paperback
When I decided to learn about JUnit I picked up two books: this one and "JUnit Recipes" by Rainsberger. The differences were immediately obvious. "Pragmatic Unit Testing" is a reasonable choice if your goal is to simply learn something about JUnit (e.g., you are a high school or college student taking a couple of programming courses). On the other hand, if your goal is to actually make use of JUnit to help you produce code that actually does something, you will quickly drop this book and turn to some other source of information.

A quick look at the index or table of contents highlights the problem with this book. Think about some of the constructs in your code: interfaces, SQL databases, XML, J2EE apps, web servers, etc. None of these topics are listed because this book doesnt give you any input on how to construct JUnit tests for any of these situations. For example, what's the best way to test when multiple classes implement the same interface? No help here.

The books is best used as a quick intro to testing for novice Java programmers. For anyone doing serious programming I suggest the Rainsberger book. Thats the one I keep on my desk close at hand. "Pragmatic Unit Testing" now resides in a box down in my basement.
18 of 19 people found the following review helpful
3.0 out of 5 stars A good introduction but not Reference Shelf material 18 Aug. 2004
By Mr. V. J. O'Sullivan - Published on
Format: Paperback
Pragmatic Unit Testing is another outing for the "Pragmatic" brand. This time the authors apply their characteristic humour and collection of acronyms to unit testing, specifically as it applies to Java and using the JUnit software package.

The book gives a general introduction to the whys and wherefores of unit testing and then uses a good example to introduce JUnit as a mechanism for carrying out these tests. This is followed by various chapters that look into what you should test and when and where, etc. In this respect it covers much of the ground on unit testing and does it well but the truth is that there isn't all that much to cover; to the extent that the authors can even provide a one page at-a-glance summary of all their main points at the back of the book. This is fine and as an introductory text I would recommend the book.

On the other hand, there are a number of areas in unit testing that always present problems for developers. For instance:

How should private methods be tested? This is mentioned in passing but not really addressed.

Where should tests be stored? Some options are presented but their advantages and disadvantages barely mentioned.

How can systems such as databases or networks be simulated for test purposes? There is a short chapter on simple Mock Objects but after presenting a small example they conclude "and that's all there is to mock objects" and the rest of the chapter barely covers anything more.

In summary, the book is a good (if verbose) introduction for beginners but is of limited value for those who are already familiar with JUnit and are looking for a book that tackles the more difficult areas.
15 of 17 people found the following review helpful
5.0 out of 5 stars A cornucopia of wisdom 28 July 2004
By Jason - Published on
Format: Paperback
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 Java is to the Java programming language. That's certainly high praise indeed.
7 of 8 people found the following review helpful
5.0 out of 5 stars This should be required reading for new Java programmers 3 Mar. 2005
By akempo - Published on
Format: Paperback
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.
7 of 9 people found the following review helpful
5.0 out of 5 stars Great Description of Unit Testing 29 July 2004
By Bret Pettichord - Published on
Format: Paperback
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

<i>test.</i> 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.
Were these reviews helpful? Let us know