Software Testing Books

The book was all that i expecting, has been helpfully and interesting to buy this book.

I found this book most useful as a reference tool. It's not very useful in terms of studying for the NAPLEX. It is, however, detailed and I do occassionally refer back to it.

i think it's abest text book for pharmacy students and phamacists as a tertiary source for basic informations in pharmacy practice.

A MUST for all those who need to prepare for the FPGEE EXAM or NAPLEX. It covers all main arguments and it has also good drills. Highly recommended.

The term "drug of choice" is very popular in pharmacology and i don't think i'm wrong to say the book of choice for FPGEE is comprehensive pharmacy review. I Passed my FPGEE with score of 103 with the help of this book. It was quite helpful and contains precise and useful information on almost all the relevant topics you need to study for the FPGEE. All you need is 3 months of study and this book to pass the FPGEE.

Thsi book was recommended by two people working at Microsoft. One was a Test Lead in IIS team and another a Test Manager with the Games for Windows team. I thought that being the case it would be worth giving it a shot. Here are some of my observations:

1) This book is fast paced.

2) Every point is made succinctly and not blabbered on, so it keeps your interest througout.

3) Provides lots of examples to help relate. Many are errors in MS Word 2000, which also makes it interesting to read.

4) Covered many distinct types of approaches, so is very thorough and organized. Different types of testing, types of attack within each type of testing, how/what/when details of the attack is all listed. Nothing left out.

5) Aimed towards newbies to testing, but is a good quick refresher resource for those who have been into testing for a little bit.

This book, niche or specific in approach, is a nice add-on to Cem Kaner's foundation materials. The book is what is says .. a text discussing how to break software. Clearly, given its size, it discusses concepts and examples, but cannot be held accountable for all software types, applications, etc. given that being a ridiculous pursuit. Rather, this book focuses on particulars leading us to methods of thought. If you needed a leap of logic from this book to another .. this sets the stage nicely to interact with, learn from, or otherwise simply look at the recommended book lists of James Bach who seems to show a tendency towards understanding behavior driven development > which of course has immense weight and value in determining 'what' to test and 'when'.

amazon is not able to ship items anymore, I ordered this 2 weeks ago and they are not shipped. I decided to cancel the order and buy it from a decent seller

Great book covering orthodox and some unorthodox thoughts on testing methods and some specific guides. While the college trained tester or the person with many years of experience will probably find this too basic, it's still worth thumbing through for a new idea or two. The most common testing faults are missing common issues, such as testing for bad or negative input.

This is an awesome book for software testers with less than two years of experience. If that's you, then you'll definitely get a lot of value out of it. You should buy it without hesitation.

What it does well is provide a clear understanding of what it means to "think like a tester." I recommend also that QA managers give it to their greenest team members. They will undoubtedly become better testers as a result.

However, if you're someone who has been in QA for several years, all of these attacks are going to be obvious--and ones that you almost certainly will already consider a part of your regular testing repertoire.

Even still, it's fun reading about some of the extant bugs in shipping Microsoft products, with step-by-step instructions on how to make them happen. I also like the freeware that comes with it--it's limited in scope, but still quite useful for certain testing situations.

I am new to TDD. This book does a very good job for me to get first time insight into test driven development. I highly recommend this book for first timers in TDD. I bought this book after so much research in book stores and amazon. I am glad I bought this book. This book is descriptive and explained with simple examples. It does a good job for me to prepare myself in TDD.

For .NET developers new to test-driven-development who want a recipe for the process, an invaluable book. This is not a concept book, but rather a concrete example that gets a little loose towards the end. Those who have also adopted Model-View-Controller for their ASP.NET applications will be able to logically extend the first half of the book to test their web interfaces, something that is admittedly difficult using the "stock" ASP.NET design philosophy.

I would supplement this book with Pragmatic Unit Testing with nUnit and C#, which gives you a much higher-level view of how to utilize TDD on a daily basis.

Test-Driven Development in Microsoft.NET rises head and shoulders above the other books on the subject. While I know that is a very strong statement to make, the authors have made the focus of the book a very practical one. Don't get me wrong, there are several other great books on this subject, but they all seem to fall down when it comes to real-world situations.

The book is split into two parts; Part I is an overview of Test-Driven Development, and Part II covers using TDD to develop an example application.

Chapter 1 frames the entire discussion with an overview of Test-Driven Development concepts, including some straightforward guidelines for design. I thought it was laid out in very logical fashion.

Chapter 2 throws you right into the process it's a classic stack example, found in many other TDD books. What I liked most about it though, was that the chapter began with discussing HOW you start figuring out WHAT tests to write as you develop an application.

Chapter 3 covers another critical concept of TDD Refactoring. (What's Refactoring? You askread chapter 3 ;) ). Again, the authors walk you through a short yet concise primer using the Sieve of Eratosthenes implemented in C#. They introduce the algorithm and then discuss it in light of code refactoring techniques as implemented originally in Martin Fowler's Refactoring: Improving the Design of Existing Code.

Chapter 4 is the introduction of the example application that will be the focus of the remainder of the book. It lays out the scenario, project features and constraints of the fictitious project.

Chapter 5 covers an area that I've found generates a ton of interest when developers start thinking about TDD, namely data access. I really appreciated the practical approach that the authors took when writing the implementation chapters for the example application. I found the tests surrounding entities and relationships and the resulting explanations to be very good.

Chapter 6 covers how you create tests when implementing Web Services. In the process, the service interface pattern is discussed along with refactoring Web Services. The authors attempt to lead you through a "thought framework" for creating tests through each of the implementation chapters.

Chapters 7, 8, and 9 make a shift from programmer testing to customer testing and cover differing aspects of customer or acceptance testing. This group of chapters starts with an overview of acceptance testing and techniques. The middle chapter deals with driving development up through the implemented layers from a user or customer perspective. Chapter 9 rounds out the discussion by focusing on handling faults and how acceptance testing allows you to tighten things up.

Chapter 10 leads us back to the programmer testing side by dealing with transactions. Following this, Chapter 11 introduces the reader to Service-level refactoring, leading you through the thought process behind different techniques. The story winds down in Chapter 12 with applying the process of TDD to implementing a web client.

All in all, while I'd have like to have seen a both a simpler example and always more "real world" tips and tricks, I can tell you from my own experience that finding that balance is extremely difficult. I believe the authors have made a significant attempt at striking the "real world" / simplicity balance and that the resulting outcome is an excellent resource for learning TDD. When that is combined with the level of effort the authors are putting in to maintaining the code and forums at their GotDotNet workspace, this makes Test-Driven Development in Microsoft .NET an excellent choice for your library.

I attended a workshop on test driven development presented by James Newkirk. I was so intrigued with the concept that I had to go out and get his book to find out more. As a result our project now uses NUnit, TestDriven.net for test driven development and find that this has really boosted confidence in the developers and their code. The concept of test-driven development is a very useful agile method of writing code to the requirements based on tests (Red/Green/Refactor). This has certainly changed my perspective towards development and want to thank James Newkirk for purveying this concept.

This is a great book for experienced developers. It covers a wide range of realistic uses in .NET and has plenty of detailed examples. It gets you into the mindset of Test-Driven Development (TDD) in good increments. The NUnit discussed is a free download and is very easy to start using with your own software quickly, so you can come up to speed right away and begin using it on your projects. One of the better TDD books that I have read, possibly the best. It will certainly remain on my bookshelf for some time.

I found this book had alot of useful material and little filler. The book provides useful commands and common examples for using those commands without filling it with a bunch of man pages like some books. It also gives some key tips that will be helpful to any system administrator. I thought there should have been more information on system services like apache or mailsend, but maybe those won't be really covered much on the exam.

The questions at the end of the chapter, as mentioned by other users, aren't very useful, so you'll likely need to test yourself with other resources.

Don't be fooled by some reviewers who try to dispute the book with petty inconsistencies. They often are more interested in sounding like they have been diehard linux users all their life than actually giving any reliable feedback.

Pros: good coverage of cli commands, concise information without filler, useful tips that help you become a system administrator.

Cons: bad end of chapter questions, somewhat disorganized in the way the content is presented.

I took and passed the test in October 2006. I found that many of the questions on the 2005 Exam covered areas not in this book. As other reviewers have posted, I also used Michael Jang's RHCE Prep guide to flesh out the weak areas. The exam itself leans toward RedHat so it is not surprising the exam prep does too, and why Yang's prep guide was so helpful. So my advice is get this book but also get Jang's book also.

Read the book entirely, reviewed, and learned all the information. There was an abundance of questions on the Linux+ exam that were not mentioned in this book. All the questions that were covered in this book I got right in the exam and still didn't pass. One question that came up in the exam was " How do you finish off a while statement" and nowhere in this book gives an example of a while statement. I happen to know now that the answer is "done" thanks to another book. That is only one example of many. Other than that, I do believe this book is well written and has resourceful information.

In this book you can found a good start to the Linux+ Cert.
It dont have electronic material. It is a con.
Another good book and a great complement is Roderick Smith's Linux+ Study Guide from Sybex...
Best wishes in your cert!!
JRB

This is a good book to prepare the Linux+ certification.
There are chapters on hardware and software in which you can find also basic informations those could be useful also for technicians to recall knowledge. If you are a Linux expert you could find too easy, but it gives you all you need to understand the topics of the exam.
I'll use it also as reference in the future.

Very helpful book. Haven't tested yet but I will pass. Good analogies. Not such boring writing. Will be reading another source to be sure I am ready though. Excellent source of info. Will be good for future reference as well.

The book provides an excellent and, I feel, comprehensive, review of the meat needed to pass the Networking Essentials exam. It may not teach you enough about troubleshooting and logical thinking about networks, I didn't concentrate on that part of the book. But if you have a basic understanding of networking, this book will assist you in memorizing all of those specifications (cables, protocols, etc) you need to know inside and out for the exam. With 4 exams now down, I got my highest score yet on this exam.

I like all the Exam Cram books. But they all have the same weakness. They are crams and not comprehensive texts.

Still, I thought it was a good place to start. Most of the material is valid and a good foundation for the other exams.

I would supplement it with other more comprehensive books like the Microsoft Network Press book--those are the opposite and give you too much information that will bog you down and put you to sleep. Use both and pass.

The exam crams do what they claim. Give it as much as possible in the quickest way. I recommend this book for anyone studying for this exam.

Used this book, along with Testout demo as study guides. Very concise and to the point, although lacking in a few areas. This was my 5th test taken. Scored 933 yesterday. Make sure you take the other Core tests first.

Used this book as a last resource and it was worth it, very neat presentation of RAIDs and very clean illustrations. Lacking on a few items like troubleshooting tools how to read them. Read this a the last thing it will be worth it Passed yesterday with 966.

Whether you are a novoice or have been practicing TDD, this book is worth reading. It is really well organized, has great examples and explains how to use available TDD tools.
Great job, David!

Context: I've read a fair amount about TDD (including being a technical reviewer for Kent Beck's "By Example" book), but went a long time without getting a chance to use TDD. David Astels' book gave me a chance to get a little down and dirty with the technique and some of its associated frameworks.

Maybe too dirty? As others have said, the source code in Part III of the book doesn't do what the book describes; you need to go to Mr. Astels' web site and get updated source code.

I found the coverage of Java frameworks (in part II) to be very helpful; it expanded my understanding of what TDD techniques can be used.

(Disclaimer: I worked with the author on one large project).
Dave Astels' book is a comprehensive work covering TDD from the ground up to advanced topics. While most of the book examples use Java and JUnit, it does cover unit testing frameworks in several other languages as well. I've read two books on the topic (the other one is Kent Beck's "TDD By Example") and I liked Dave's book better. The basics of TDD can be explained in 10 minutes however when it is applied on practice it gets complicated in at least 3 areas: 1) testing UI 2) testing with database - data setup, isolation, etc. and 3) mocks. Kent's book is more about a philosophy of TDD but it only goes through a very simple "toy" example. Dave's book really helped me to understand mocks and it does cover UI testing in great length. Mocks are an advanced topic, so it does require a good knowledge of Java and OOP. The rest of the book seems to be on intermediate technical level.

The only thing this book is missing, I think, is a discussion about data setup and database-related testing, dbUnit, etc., other than an advice to avoid it altogether (p. 83). While you can indeed use mocks to avoid it, on the large real projects some kind of integration testing (including testing with the database) will be necessary. I hope the second edition will come out at some point!

Overall, it's a great book for both newcomers and developers with unit testing experience. BTW, it won SD West 2004 Jolt Award.

This book is about Test-Driven Development (TDD). Its purpose is to help you write better code (by having more tests) and give you a head start with existing tools to achieve this.

The book falls short of these goals: The explanations about writing tests are short on advice and are sometimes misleading. The presentation of the tools is long, with little useful facts.

The book is organized into four parts: Background on TDD, refactoring and programming by intention; A look at JUnit and related tools used to write and run tests; A lengthy example of TDD; An overview of other tools in the xUnit family. The book is targeted at a Java audience but programmers using other languages should have little difficulties understanding the code.

I have a major problem with the background section. The author repeatedly claims that TDD provides exhaustive test coverage and ensures that you can refactor your code with confidence. Any error will be caught by the tests. This is foolish. First, tests rarely reach 100% code coverage. Even the sample that the author provides in the book ends up with less than 90% coverage. This leaves many gaps where tests will fail to detect errors. Even if tests cover 100% branches in the code tests are not exhaustive. Depending on the data used, the same branch may exhibit different behavior. (Not to speak about race conditions and other sources of hard to find bugs.) I fully agree with the author that writing unit tests will improve the quality of the code and help find bugs. But claiming that this is a silver bullet is not wise. I would recommend reading books about tests (e.g., Myers' The Art of Software Testing and McConnell's Code Complete chapter on unit testing) in addition to this book. The section on refactoring is a summary of Martin Fowler's Refactoring book which I recommend.

The second part presents JUnit. JUnit is a framework used to write and run tests. It is a good presentation. However I would have liked to get pieces of advices on what tests to write in addition to how to write them. The author briefly mentions boundary testing but does not have much to say about the tests themselves. Again a test book is invaluable for this. The author recommends using a test coverage tool as well as Jester to measure the tests coverage. This is a great idea.

The third section is an (overly) extended example: the author walks us through writing TDD code. This could have been a great part, giving meaning to the `practical' adjective in the book title. Unfortunately it is a long rambling, showing lots of code but short on insights. The actual `meat' of this part could be summarized in less than five pages.

The last section presents variations on the JUnit tool. Many languages (C++, C#, VB, Python, etc) are discussed. This part would have been better put on a website rather than printed in the book. Given the changes in some of these frameworks the information is obsolete.

The books ends with several appendices dealing with extreme programming and agile modeling.

Unit tests are a great tool to improve code quality. Whether or not you actively practice TDD, a good book on it can provide insights into improving your code. This book contains some interesting bits of wisdom. However much of it is buried by the rest of the material.

Dave's book does one thing that most other books in this field do not do: it avoids the web application. Hallelujah!

This book provides a good foundation for understanding TDD: the programming cycle, refactoring, tools, mock objects... it is possible to begin applying TDD for yourself after reading the first 1/3 or so of this book.

Writing effectively about programming sessions is not easy. Only a few authors can do it well, and Dave does an admirable job in this. My only beef with the case study (which makes up the bulk of the book) is that, after a while, it becomes somewhat repetitive. This isn't Dave's fault: it's the nature of programming. Sometimes we just need to add another button or another text field. We don't necessarily learn anything new doing it, but if we want a finished product, we have to do it. I understand Dave's desire to present a complete (if small) project, and so applaud his willingness to risk some duplication in the name of finishing what he started.

The experience of learning from this book is similar to learning from real project experience: not every page contains something new and exciting, but if you follow along and ask questions (of yourself), then you will have learned a great deal by the end.

I read about a dozen of books about testing, and I put this one into a reference for my workers. This is short and very robust. My highest rank.

This book is very interesting to learn or to progress (I have 10 years of experience in software developpement) in Art of Testing. The only tedious point is that the author are not really integrate the new principales of Test Driven Development in its book. So, I advise to read a book on this subject before or after.

Benoit, a French Programmer ;-)

The Art of Software Testing provides the novice with the essentials for developing and implementing a comprehensive testing approach. It's also a valuable resource for those with experience. I dive into this book constantly.

The premise is simple enough: How can you write effective test cases that adequately exercise your system requirements? Myers suggests that good software testing depends on the answer. Testing what the program is supposed to do is only part of the battle. However, in my experience, this is usually where we plant our flag. This can be difficult enough, depending on the quality of the criteria. Bad or vague requirements necessarily lead to insufficient and flawed testing.

As a result negative testing, boundary testing, testing for unexpected conditions, and so forth will often go by the wayside.

In addition, testing is often presented as a gateway to production, and can be cursory as a result. The creativity and time that adequate test cases demand are simply not within project scope. This is often exacerbated by intent to pass systems without finding errors.

Myers addresses these issues as he explores test planning and creation. Hence this book really belongs on the shelves, not only of software testers, but project management as well. The methodology of requirements-based testing is not new. However the profession is growing and more sectors are discovering the need for testing their systems. Art of Software Testing is still relevant and should be promulgated.

This book is expensive, however it is well worth its price. A top 10 book for IT professionnals.

It's hard to give the appropriate number of stars to this edition. On the one hand, this is one of the classics of the field, and deservedly so. In it's first edition, this may have been the first great book on testing, and there is something about the "first great book" on any topic that makes it a lasting value decades later: DeMarco on Structured Analysis, Brooks on the wicked complexity of software project management, Booch on object-oriented design, K&R on C. And so I think it goes with The Art of Software Testing. It's a short book, and full of good ideas that will stay with you.

But.

This revised edition is simply a terrible value. At the full list price, you'd be paying something like fifty cents a page...and, let me tell you, a book had better revolutionize my life for that kind of money. I'm a dedicated capitalist sell-out software developer, but this kind of pricing arouses even _my_ hacker sensibilities. Also, the value of the revision is questionable: there may be a chapter on Extreme Programming, but it seems to me that the best material in this book is still the classic text that survives from the 1st ed. So, my recommendation is that you simply _buy_ the first edition, new or used, at a fraction of the price. Then, you get nearly all of the benefit, plus the cachet of having the "classic" on your shelf. You can put it right next to "The C Programming Language" and "The Mythical Man-Month." Then, your visitors will know you're a serious software developer...and, you know what? They'll probably be right.

I also like and recommend Kaner, Falk and Nguyen, "Testing Computer Software," for a more in-depth and up-to-date treatment of testing issues.

Buyer beware. This book does not reflect the many changes to JUnit implemented in version 4. I found it to be a very good book when it came out four years ago however.

pragmatic Unit testing in java save a lot of time to debug java code.

JUnit Testing can really save you a lot of time debugging. This book provides a various way to work with JUnit.

This is another fine book from the "Pragmatic Programmer" series. If you are doing Java development, but haven't gotten into unit testing yet, this is a great place to start. The book is a quick read - I made it through in two days. The book gives background on why unit testing is important and then tells you how to go about doing it with JUnit. The book has practical advice for the kinds of things to include in unit tests while it finishes with design considerations for make code easier to test. To get the most out of the book, you need to download the code from the author's web site and work through the exercises. It is great how they have taken a critical topic and made it extremely accessible. I highly recommend it.

This book is very good for a beginner to unit testing. I like the simple explanation of the different types of unit testing that must be done. This really helps a beginner to make sure that the tests are comprehensive.

Also it clarifies the intention behind use of mock objects. I would use the concepts in this book as a checklist to make sure the tests are written to cover all types of problems.

I gave 4 star only because it contains toy examples and does not go into too much detail on this very important topic. JUnit Recipes contains more realistic examples.

I used this book to help a foreign student study for the SAT. I had successfully used the GRE for Dummies book myself and found it to be far superior to the other dry, boring, overlong test books. This book is structured similarly. What I like about it is its straight-forward talk. It gets right to the point in easy-to-understand language and even some humor -- something that's sorely missing from other test-prep books. Particularly helpful are the vocabulary words sprinkled throughout the book. Reading the words in context is far more useful than a long list of words to memorize.

What was disappointing were the errors in some of the examples and sample test questions. This book needs to be edited thoroughly and reissued, and then it would be worthy of a higher rating.

I would still recommend the book with caution. The information in the book is definitely useful for verbal and math refreshers. However, I'd recommend taking sample tests from another source.

My son and a friend are in the other room right now, taking the practice test. I'm dreading grading them because you can't trust that the answers in the book are right! Too bad it's too late for me to go out and get 2 different books. Just fyi, here are the mistakes we found (2002 edition)

1. Pg. 288, #11 (Answer should be A)
2. Pg. 125, top problem (She wrote + then multiplied.)
3. Pg. 188, the problem has many typos (Should be (1/(1/x))+1=11

Unless you have never seen an SAT before in your entire life, this book is completely worthless. I bought it mainly for the practical advice I hoped it would contain; I was, however, sorely disappointed. The book is juvenile, uninformative, and riddled with mistakes, especially in the practice tests. The "tips" Vlk hands out are dubious at best. I've taken the SAT officially 4 times, and I've taken numerous practice tests over the years, and nothing Vlk says is at all innovative or interesting. Stick with 10 Real SATs

This is a good book for preparation, but the practice tests are completely unlike the real ones. I took one one here, got a 1025. Compare that to a 1200 I took, with no extra preparation on a real test!

I have 3 different SAT books, and have flipped through several in the bookstores. This is by far the best.

It has the best lay-out & breaks down everything in the simplest way. I haven't been in high school for 8years and this book totally refreshed (& probably even taught) me on 95% of what appeared on the SAT.

Get this book if you need to know HOW to do the problems. Get another book or look online if you want to know about the extremely debated "techniques" for improving your scores based on not what you know, but on how you alocate your time during the test.

[reviewed by XPSD member Paul Hamill]

Unit testing and test-driven development (TDD) is a skill that has been desperately lacking on many of the projects I have been involved with over the last few years. I have tried reading books by Kent Beck and others on this subject, but I have always had trouble getting to the next level of applying the skills to "real" problems. This book does not take the approach of claiming to teach you how to be a great test-driven developer, instead it is a survey of the unit test tools available for many environments today and along the way explains the fundamentals of unit testing and TDD.

If you have read other books on TDD, you may find much of this book a review, however there are many explanations of how some of these tools would be used in actual projects which I found valuable. The discussion of mock objects is a good one which explained some details about how to use mock objects in practice that I didn't understand in reading other sources on the subject. In addition, several tools I was unaware of were discussed that I am interested in looking into for making TDD easier to do. For example, XMLUnit and NUnitForms are 2 tools that would seem to make testing a data-driven GUI application much more manageable.

I would recommend this book for anyone who has an interest in unit testing or test driven development and wants to know what tools are available to do this. Also, this book would be invaluable if you intend to write your own xUnit framework for a language.

I have put off writing a review of this book because I had very mixed feelings. On the plus side, it is a very clear concise guide to unit testing - a great introduction.

On the negative side, I figured that any decent programmer already knows what's covered here. Even those who don't write unit tests (bad programmer, bad) knows what they are and how to do it.

Then I was stuck on how to unit test in a particular case and the author email me - look on page 37. And there it was.

So, if you are learning to program - GET THIS BOOK. No one will hire you unless you know this. If you're an experienced programmer, it can still teach you a thing or two.

- dave thielen

ps - the author is a friend of mine and that did cause me to round up my 4.5 rating.

I had used JUnit for several years before picking up this book and I like to think that I know the tool pretty well. So why did I decide to read this book? I read this book because I thought that might help me venture a bit outside my familiar JUnit turf and into doing test-first programming with languages other than Java. The short version? A very nice introduction to all the included xUnit ports. The long version? Read on.

The first four chapters are general introduction to the topic of unit testing (and to some degree, test-driven development). I was prepared to do a quick scan through them all but ended up reading chapters 3 (xUnit architecture) and 4 (writing unit tests) almost word to word-the topic was mostly familiar but the authors solid writing kind of kept me going.

The first two chapters didn't pique my interest that much, perhaps because I had already seen people develop a unit test framework from scratch as an introduction to the domain.

The real meat of the book that I was looking forward to was in chapters 7 through 9, the introductions to CppUnit, NUnit, PyUnit-which were mostly new to me although I had done very little fooling around with them before. I wasn't disappointed. The author managed to put together a pretty good set of tutorials for these frameworks. Obviously the same information is available online but I still prefer reading a treekiller rather than a printout of a web page.

The not so bright spots in the book, in my opinion, were the chapters on unit testing a Swing GUI and on XMLUnit. Not that they were in anyway badly written. I just felt like they didn't belong. I would've personally swapped in a couple of additional xUnit ports instead (Ruby and PHP, for example).

This is definitely not a book you'll carry with you from project to project. There's approximately 100 pages of substance split among half a dozen topics so none of them gets covered in detail. The rest, almost 100 pages of the book is what I'd classify as "nice to have"-I don't mind having that material in the book but I also wouldn't have minded if they'd left them out.

To summarize, if you'd like to get an idea of how the unit testing frameworks on different platforms/languages differ and what they have in common, this is as good an introduction to them as any and well written in all dimensions. However, you might be disappointed if you're looking for a more long-lasting companion.

I have been using JUnit for unit testing on Java for quite a while and I have also been exposed to other testing frameworks, but had never looked under the hood is such detail as Paul does in this book.

He starts with a good overview of what a unit test framework and then takes us to a very nice tutorial on building your own unit test framework from scratch. This exercise is very well documented and you learn the basic principles behind a unit test framework while building a simple application and the unit tests required to test it.

After laying out the foundation, he goes on to explain in more detail how to write unit tests, how to use assertions, how to deal and test exceptions and expected errors, how to test protected behavior, how to organize your project for testing and using more advanced techniques like mock objects and performance testing.

He also includes a chapter that deals with testing GUIs (Graphical User Interfaces) which is a challenging task, but he offers good ideas for doing test driven development for a GUI to the application that we have been building during the previous chapters.

After all the basic concepts have been covered, the next chapters are dedicated to the most important (or more popular) unit test frameworks which are JUnit for Java, CppUnit for C++, NUnit for C# on .NET, PyUnit for Python and XMLUnit for XML documents. It is interesting to note that throughout the book the author uses the same application for the example code, so that we can compare the actual implementation of the tests using the different frameworks.

In the appendices, there is a C++ version of the simple Java framework that was built on chapter 2 and there are also summaries of the class reference documentation for JUnit and CppUnit.

Overall I think it is a very solid book with good examples and very concise content. Even though it doesn't cover all the unit test frameworks that exist today, I think it covers the most important ones, but the real gem is on the in-depth analysis of what makes a unit test framework.

If you are already familiar with one or more unit test frameworks, this book will give you a deeper understanding of them, and if you are still programming without writing unit tests... shame on you ;-)... buy this book and learn how simple it is to have a very good unit testing framework, no matter what language you use.

This is a very solid, no-nonsense introduction to unit test framework.

For a 200 page book, this one is packed with carefully chosen information, detailed enough for new comers to start unit testing, useful enough for a frequently-visited reference, and at the same time concise enough for anyone to get an overview of the unit test landscape.