Stephen Vance - Quality Code: Software Testing Principles, Practices, and Patterns [2014, PDF, ENG]

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
Testing 8
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
Understand Your Scope 24
A Conceptual Framework for Testing 25
State and Behavioral Testing 26
To Test or Not to Test 27
The Recipe 28
Test the “Happy Path” 29
Test the Alternate Paths 29
Test the Error Paths 30
Test the Data Permutations 30
Test the Defects 35
Chapter 4: Design and Testability 37
A Word on Design Paradigms 37
Encapsulation and Observability 38
Representational Encapsulation 38
Behavioral Encapsulation 39
Shades of Testing 40
Encapsulation, Observability and Testability 42
Coupling and Testability 42
Chapter 5: Testing Principles 47
Craft Your Tests Well 47
Couple Inputs to Outputs 48
Use a Naming Convention 49
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
Don’t Test Generated Code 59
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
Testing the Singleton Nature 122
Testing the Class Purpose 123
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
Interfaces 146
Implementations 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
Some History 166
Race Conditions 167
Deadlocks 169
A Strategy for Race Condition Reproduction 170
Test the Thread Task Directly 173
Synchronize through Common Lock 176
Synchronize through Injection 181
Example: Injecting Synchronization through Logging 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
Dead End 200
Spy Craft 201
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