Developer Testing: Building Quality Into Software

Paperback | September 6, 2016

byAlexander Tarlinder

not yet rated|write a review

How do successful agile teams deliver bug-free, maintainable software—iteration after iteration? The answer is: By seamlessly combining development and testing. On such teams, the developers write testable code that enables them to verify it using various types of automated tests. This approach keeps regressions at bay and prevents “testing crunches”—which otherwise may occur near the end of an iteration—from ever happening. Writing testable code, however, is often difficult, because it requires knowledge and skills that cut across multiple disciplines.


In Developer Testing, leading test expert and mentor Alexander Tarlinder presents concise, focused guidance for making new and legacy code far more testable. Tarlinder helps you answer questions like: When have I tested this enough? How many tests do I need to write? What should my tests verify? You’ll learn how to design for testability and utilize techniques like refactoring, dependency breaking, unit testing, data-driven testing, and test-driven development to achieve the highest possible confidence in your software. Through practical examples in Java, C#, Groovy, and Ruby, you’ll discover what works—and what doesn’t.


You can quickly begin using Tarlinder’s technology-agnostic insights with most languages and toolsets while not getting buried in specialist details. The author helps you adapt your current programming style for testability, make a testing mindset “second nature,” improve your code, and enrich your day-to-day experience as a software professional. With this guide, you will

  • Understand the discipline and vocabulary of testing from the developer’s standpoint
  • Base developer tests on well-established testing techniques and best practices
  • Recognize code constructs that impact testability
  • Effectively name, organize, and execute unit tests
  • Master the essentials of classic and “mockist-style” TDD
  • Leverage test doubles with or without mocking frameworks
  • Capture the benefits of programming by contract, even without runtime support for contracts
  • Take control of dependencies between classes, components, layers, and tiers
  • Handle combinatorial explosions of test cases, or scenarios requiring many similar tests
  • Manage code duplication when it can’t be eliminated
  • Actively maintain and improve your test suites
  • Perform more advanced tests at the integration, system, and end-to-end levels
  • Develop an understanding for how the organizational context influences quality assurance
  • Establish well-balanced and effective testing strategies suitable for agile teams

Pricing and Purchase Info

$49.98 online
$49.99 list price
In stock online
Ships free on orders over $25

From the Publisher

How do successful agile teams deliver bug-free, maintainable software—iteration after iteration? The answer is: By seamlessly combining development and testing. On such teams, the developers write testable code that enables them to verify it using various types of automated tests. This approach keeps regressions at bay and prevents “t...

Alexander Tarlinder wrote his first computer program around the age of ten, sometime in the early nineties. It was a simple, text-based role playing game for the Commodore 64. It had lots of GOTO statements and an abundance of duplicated code. Still, to him, this was the most fantastic piece of software ever conceived, and an entry p...
Format:PaperbackDimensions:352 pages, 9 × 7 × 1 inPublished:September 6, 2016Publisher:Pearson EducationLanguage:English

The following ISBNs are associated with this title:

ISBN - 10:0134291069

ISBN - 13:9780134291062


Extra Content

Table of Contents

Foreword by Jeff Langr xiii

Foreword by Lisa Crispin xv

Preface xvii

Acknowledgments xxiii

About the Author xxv


Chapter 1: Developer Testing 1

Developers Test 1

Developer Testing Activities 2

What Developers Usually Don’t Do 5

Defining Developer Testing 6

Developer Testing and the Development Process 7

Summary 8

Chapter 2: Testing Objectives, Styles, and Roles 9

Testing and Checking 9

Testing Objectives 10

Testing Styles 11

Your Quality Assurance and Developer Testing 18

Summary 19


Chapter 3: The Testing Vocabulary 21

Errors, Defects, Failures 22

White Box and Black Box Testing 22

Classifying Tests 23

The Agile Testing Quadrants 32

Some Other Types of Testing 33

Summary 36


Chapter 4: Testability from a Developer’s Perspective 37

Testable Software 37

Benefits of Testability 39

Testability Defined 43

Summary 55


Chapter 5: Programming by Contract 57

Contracts Formalize Constraints 57

Implementing Programming by Contract 60

Enforcing Contracts 62

Summary 65


Chapter 6: Drivers of Testability 67

Direct Input and Output 68

Indirect Input and Output 68

State 70

Temporal Coupling 71

Data Types and Testability 72

Domain-to-Range Ratio 77

Summary 78


Chapter 7: Unit Testing 79

Why Do It? 79

What Is a Unit Test? 81

The Life Cycle of a Unit Testing Framework 83

Naming Tests 85

Structuring Tests 88

Assertion Methods 89

Testing Exceptions 99

Behavior-driven Development–Style Frameworks 102

Summary 105


Chapter 8: Specification-based Testing Techniques 107

Equivalence Partitioning 107

Boundary Value Analysis 110

Edge Cases and Gotchas for Some Data Types 111

State Transition Testing 113

Decision Tables 115

Summary 116


Chapter 9: Dependencies 119

Relations between Objects 119

System Resource Dependencies 125

Dependencies between Layers 129

Dependencies across Tiers 132

Summary 133


Chapter 10: Data-driven and Combinatorial Testing 135

Parameterized Tests 138

Theories 139

Generative Testing 141

Combinatorial Testing 145

Summary 149


Chapter 11: Almost Unit Tests 151

Examples 152

Impact 156

Summary 157


Chapter 12: Test Doubles 159

Stubs 159

Fakes 162

Mock Objects 164

Spies 170

Dummies 171

Verify State or Behavior? 173

Summary 176


Chapter 13: Mocking Frameworks 177

Constructing Test Doubles 177

Setting Expectations 179

Verifying Interactions 183

Misuse, Overuse, and Other Pitfalls 185

Summary 189


Chapter 14: Test-driven Development—Classic Style 191

Test-driving a Simple Search Engine 192

Order of Tests 204

Red- to Green-bar Strategies 205

Challenges 206

Test First or Test Last? 209

Summary 210


Chapter 15: Test-driven Development—Mockist Style 213

A Different Approach 213

Double-loop TDD 220

Summary 223


Chapter 16: Duplication 225

Why Duplication Is Bad 225

Taking Advantage of Duplication 227

Mechanical Duplication 228

Knowledge Duplication 232

Summary 235


Chapter 17: Working with Test Code 237

Commenting Tests 237

Deleting Tests 241

Summary 243


Chapter 18: Beyond Unit Testing 245

Tests that Aren’t Unit Tests 245

Characteristics of Tests that Aren’t Unit Tests 257

Pointers and Practices 263

Deciding on a Developer Testing Strategy 267

Summary 269


Chapter 19: Test Ideas and Heuristics 271

High-level Considerations 271

Low-level Considerations 274

Summary 276


Appendix A: Tools and Libraries 277


Appendix B: Source Code 279

Test Doubles 279

Data-driven and Combinatorial Testing 279

Test-driven Development 282

Beyond Unit Testing 287


Bibliography 289

Index 295