Register your product to gain access to bonus material or receive a coupon.
Quality Code: Software Testing Principles, Practices, and Patterns
- By Stephen Vance
- Published Dec 4, 2013 by Addison-Wesley Professional.
Book
- Sorry, this book is no longer in print.
Description
- 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
Extras
Related Articles
Reproducing Race Conditions in Tests
That One Thing: Reduce Coupling for More Scalable and Sustainable Software
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