The Art of Unit Testing, 2nd Ed, video edition

Table of contents

1. PART 1 GETTING STARTED
   1. Chapter 1 - The basics of unit testing
   2. Chapter 1 - Properties of a good unit test
   3. Chapter 1 - Drawbacks of nonautomated integration tests compared to automated unit tests
   4. Chapter 1 - What makes unit tests good
   5. Chapter 1 - Test-driven development
   6. Chapter 1 - The three core skills of successful TDD
   7. Chapter 2 - A first unit test
   8. Chapter 2 - Introducing the LogAn project
   9. Chapter 2 - Loading up the solution
   10. Chapter 2 - Writing your first test
   11. Chapter 2 - Refactoring to parameterized tests
   12. Chapter 2 - More NUnit attributes
   13. Chapter 2 - Checking for expected exceptions
   14. Chapter 2 - Testing results that are system state changes instead of return values
2. PART 2 CORE TECHNIQUES
   1. Chapter 3 - Using stubs to break dependencies
   2. Chapter 3 - Determining how to easily test LogAnalyzer
   3. Chapter 3 - Refactoring your design to be more testable
   4. Chapter 3 - Dependency injection: inject a fake implementation into a unit under test
   5. Chapter 3 - Simulating exceptions from fakes
   6. Chapter 3 - Variations on refactoring techniques
   7. Chapter 3 - Overcoming the encapsulation problem
   8. Chapter 4 - Interaction testing using mock objects
   9. Chapter 4 - The difference between mocks and stubs
   10. Chapter 4 - A simple handwritten mock example
   11. Chapter 4 - One mock per test
   12. Chapter 4 - The problems with handwritten mocks and stubs
   13. Chapter 5 - Isolation (mocking) frameworks
   14. Chapter 5 - Dynamically creating a fake object
   15. Chapter 5 - Simulating fake values
   16. Chapter 5 - Testing for event-related activities
   17. Chapter 5 - Advantages and traps of isolation frameworks
   18. Chapter 6 - Digging deeper into isolation frameworks
   19. Chapter 6 - How profiler-based unconstrained frameworks work
   20. Chapter 6 - Values of good isolation frameworks
   21. Chapter 6 - Ignored arguments by default
   22. Chapter 6 - Isolation framework design antipatterns
3. PART 3 THE TEST CODE
   1. Chapter 7 - Test hierarchies and organization
   2. Chapter 7 - Anatomy of a build script
   3. Chapter 7 - Triggering builds and integration
   4. Chapter 7 - Mapping out tests based on speed and type
   5. Chapter 7 - Ensuring tests are part of source control
   6. Chapter 7 - Cross-cutting concerns injection
   7. Chapter 7 - Using test class inheritance patterns
   8. Chapter 7 - Creating test utility classes and methods
   9. Chapter 8 - The pillars of good unit tests
   10. Chapter 8 - Writing trustworthy tests
   11. Chapter 8 - Avoiding logic in tests
   12. Chapter 8 - Testing only one concern
   13. Chapter 8 - Assuring code review with code coverage
   14. Chapter 8 - Writing maintainable tests
   15. Chapter 8 - Removing duplication
   16. Chapter 8 - Enforcing test isolation
   17. Chapter 8 - Avoiding multiple asserts on different concerns
   18. Chapter 8 - Comparing objects
   19. Chapter 8 - Writing readable tests
   20. Chapter 8 - Asserting yourself with meaning
4. PART 4 DESIGN AND PROCESS
   1. Chapter 9 - Integrating unit testing into the organization
   2. Chapter 9 - Identify possible entry points
   3. Chapter 9 - Ways to succeed
   4. Chapter 9 - Aiming for specific goals
   5. Chapter 9 - Realizing that there will be hurdles
   6. Chapter 9 - Tough questions and answers
   7. Chapter 9 - Why is the QA department still finding bugs?
   8. Chapter 10 - Working with legacy code
   9. Chapter 10 - Writing integration tests before refactoring
   10. Chapter 10 - Important tools for legacy code unit testing
   11. Chapter 10 - Read Michael Feathers’s book on legacy code
   12. Chapter 11 - Design and testability
   13. Chapter 11 - Make classes nonsealed by default
   14. Chapter 11 - Pros and cons of designing for testability
   15. Chapter 11 - Alternatives to designing for testability
   16. Chapter 11 - Example of a hard-to-test design
   17. Chapter 11 - Summary