Home > Store

Quality Code: Software Testing Principles, Practices, and Patterns

Register your product to gain access to bonus material or receive a coupon.

Quality Code: Software Testing Principles, Practices, and Patterns


  • Sorry, this book is no longer in print.
Not for Sale

eBook (Watermarked)

  • Your Price: $28.79
  • List Price: $35.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.


  • Copyright 2014
  • Dimensions: 7" x 9-1/8"
  • Edition: 1st
  • Book
  • ISBN-10: 0-321-83298-1
  • ISBN-13: 978-0-321-83298-6

Test-driven, test-first, and test-early development practices are helping thousands of software development organizations improve their software. Now, in Quality Code: Software Testing Principles, Practices, and Patterns, Stephen Vance builds on all that’s been learned about test-driven development, helping you achieve unprecedented levels of first-time quality. Using real-world code examples, this guide introduces patterns, principles, and more than two dozen detailed techniques for testing any software system more fully, effectively, and painlessly. Vance presents a conceptual framework to help you focus your efforts and design recommendations for improving testability across the software lifecycle, and also provides hands-on guidance to simplify testing of the full spectrum of code constructs. You’ll learn how to choose the best testing techniques for every situation, from the most common scenarios to threading. Two complete case studies put it all together, walking you through testing a brand-new Java application and an untested “legacy” JavaScript jQuery plugin. Whether you’re developing cutting-edge code for a new start-up, or maintaining an unruly old system, this guide will help you deliver exactly what you need: quality code.

• Simplify unit testing of all your code—and improve integration and system testing

• Delineate intent and implementation to promote more reliable and scalable testing

• Overcome confusion and misunderstandings about the mechanics of writing tests

• Test “side effects,” behavioral characteristics, and contextual constraints

• Understand subtle interactions between design and testability—and make them work for, not against, you

• Discover core principles that guide your key testing decisions

• Explore testing getters/setters, string handling, encapsulation, override variations, visibility, singleton patterns, error conditions, and more

• Reproduce and test complex race conditions deterministically

Sample Content

Online Sample Chapter

Quality Code through Software Testing: Where Do I Start?

Sample Pages

Download the sample pages (includes Chapter 1 and Index)

Table of Contents

Preface xiii

Acknowledgments xvii

About the Author xix

Part I: Principles and Practices of Testing 1

Chapter 1: Engineering, Craftsmanship, and First-Time Quality 3

Engineering and Craftsmanship 4

The Role of Craftsmanship in First-Time Quality 4

Practices Supporting Software Craftsmanship 6

Unit Testing under Code Checker Constraints 10

Unit Testing for Coverage 10

Chapter 2: Intent of Code 17

Where Did I Put That Intent? 18

Separating Intent from Implementation 18

A Simple Example That Makes You Think 19

Chapter 3: Where Do I Start? 23

An Approach to Testing 23

Chapter 4: Design and Testability 37

A Word on Design Paradigms 37

Encapsulation and Observability 38

Coupling and Testability 42

Chapter 5: Testing Principles 47

Craft Your Tests Well 47

Avoid Test Code in Production 51

Verify Intent over Implementation 52

Minimize Coupling 53

Prefer Minimal, Fresh, Transient Fixtures 54

Use Available Facilities 55

Prefer Complete over Partial Verification 55

Write Small Tests 55

Separate Your Concerns 56

Use Unique Values 57

Keep It Simple: Remove Code 58

Don’t Test the Framework 58

Sometimes Test the Framework 60

Part II: Testing and Testability Patterns 61

Chapter 6: The Basics 63

Bootstrapping Constructors 63

Testing Simple Getters and Setters 66

Share Constants 67

Locally Redefine 70

Temporarily Replace 71

Encapsulate and Override 72

Adjust Visibility 75

Verification by Injection 77

Chapter 7: String Handling 81

Verification by Containment 81

Verification by Pattern 83

Exact Verification by Value 85

Exact Verification with Formatted Results 88

Chapter 8: Encapsulation and Override Variations 91

Data Injection 91

Encapsulate Loop Conditions 94

Error Injection 96

Replace Collaborators 98

Use Existing No-Op Classes 101

Chapter 9: Adjusting Visibility 105

Packaging Tests with Code 105

Break It Down 108

Changing Access Levels 109

Test-Only Interfaces 111

Naming the Unnamed 112

Becoming friend-ly 113

Coerced Access via Reflection 114

Declarative Scope Changing 116

Chapter 10: Interlude: Revisiting Intent 119

Testing the Singleton Pattern 120

Singleton Intent 121

The Testing Strategy 121

Discerning Intent 127

Chapter 11: Error Condition Verification 129

Check the Return Value 129

Verify the Exception Type 130

Verify the Exception Message 132

Verify the Exception Payload 134

Verify the Exception Instance 137

Thoughts on Exception Design 140

Chapter 12: Use Existing Seams 145

Direct Calls 146

Dependency Injection 147

Callbacks, Observers, Listeners, and Notifiers 150

Registries 154

Factories 156

Logging and Other Facilities of Last Resort 159

Chapter 13: Parallelism 165

A Brief Introduction to Threads and Race Conditions 166

A Strategy for Race Condition Reproduction 170

Test the Thread Task Directly 173

Synchronize through Common Lock 176

Synchronize through Injection 181

Use Supervisory Control 184

Statistical Verification 187

Debugger APIs 189

Part III: Worked Examples 193

Chapter 14: Test-Driven Java 195

Bootstrapping 196

First Functionality 197

Cutting the Cord 198

Moving to Multiples 199

Ghost Protocol 200

Exercising Options 203

Moving Downstream 204

Retrospective 207

Chapter 15: Legacy JavaScript 209

Getting Started 210

DOMination 211

On Toothpaste and Testing 213

Scaling Up 215

Software Archeology 217

Retrospective 218

Bibliography 219

Index 221


Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership