Main Page

Testing Extreme Programming
By Lisa Crispin, Tip House
Publisher : Addison Wesley
Pub Date : October 25, 2002
ISBN : 0-321-11355-1
Pages : 336

The rapid rise in popularity of Extreme Programming (XP) has put the practice of software testing squarely in the spotlight of application development. At one time, testing was a neglected practice, a highly specialized activity that came as an afterthought as complex, code-intensive projects were rushed to completion. But in today's world of escalating quality expectations, testing is a key component of the development process.

XP accelerates testing by demanding its complete integration with development. This in turn has pushed software professionals to rethink their traditional attitudes toward testing. XP asks the entire development team to embrace testing. In fact, testing is so critical to the XP methodology that programmers are required to write automated tests before they begin coding. Until now, however, there has been a distinct lack of instruction specific to testing and how it relates to XP.

Testing Extreme Programming is a practical tutorial that gives software builders a lucid understanding of this important aspect of development. This book demonstrates how testing is central to the XP project, clearly spelling out what testing should be done and when and how it should be performed. The authors teach by example, and readers will be able to improve their knowledge of the testing process by completing the book's exercises.

In addition, this book:

  • Provides a general overview of the XP methodology

  • Defines the roles of XP team members

  • Shows how to write effective tests before coding begins

  • Helps you avoid the traps and pitfalls that can derail software projects

  • Sheds light on the important practice of refactoring and how it relates to testing

  • Compares and contrasts manual and automated tests

Many software engineers have dismissed XP as a throw-out-the-rulebook, anything-goes technique. It isn't. As this book shows, XP is a deliberate and disciplined approach to software development. Many software engineers have reaped the benefits of this agile methodology because its emphasis on testing eliminates much of the risk inherent in software projects. XP helps developers produce software on time, under budget, and at a higher quality level. But you can't XP if you don't test. With this book as a guide, you will learn to embrace testing. A sound testing program is the engine that drives an XP project.

•  Table of Contents
Testing Extreme Programming
By Lisa Crispin, Tip House
Publisher : Addison Wesley
Pub Date : October 25, 2002
ISBN : 0-321-11355-1
Pages : 336
    Part I.  The XP Tester Role
      Chapter 1.  An Overview
      Overview of XP
      How XP Solves Testing and Quality Assurance Problems
      Wolves in Sheep's Clothing
      Chapter 2.  Why XP Teams Need Testers
      Definition of Tester
      The Tester's Contribution, Illustrated
      Shun the Dark Side
      Chapter 3.  How XP Teams Benefit from Having Testers
      Checks and Balances
      Acceptance Tests versus Unit Tests
      Navigating for XP Projects
      Chapter 4.  XP Testing Values
      Chapter 5.  Overview of the XP Tester Role
      XP Tester's Bill of Rights
      XP Tester Activities
      Chapter 6.  Quality and XP
      Defining Quality
      Setting Quality Criteria
      Who Is Responsible for Quality?
    Part II.  Test Drive through an XP Project
      Chapter 7.  User Stories and Release Planning
      The Tester's Role in Up-Front Activities
      Goals of Up-Front Tester Activities
      Exercise 1
      Chapter 8.  Identifying Hidden Assumptions
      A Process for Finding Hidden Assumptions
      Exercise 2
      Chapter 9.  Defining High-Level Acceptance Tests
      Basic Acceptance Test Definitions
      Exercise 3
      Chapter 10.  High-Level Acceptance Test Estimates
      Ways to Estimate Acceptance-Test Effort
      Exercise 4
      Chapter 11.  Enabling Accurate Estimates during Release Planning
      Why We Care about Estimates
      How You Can Improve Estimate Accuracy
      Exercise 5
      Chapter 12.  Planning the First Iteration
      Overview of Iteration Planning
      The Tester's Role in Iteration Planning
      Exercise 6
      Chapter 13.  Defining and Estimating Testing and Test Infrastructure Tasks
      Identifying and Estimating Test Infrastructure Tasks
      Identifying and Estimating Functional and Acceptance Testing Tasks
      A Note on Separate Test Teams
      Exercise 7
      Chapter 14.  Acceptance Tests and Quality
      Acceptance Test Details
      Internal and External Quality
      Exercise 8
      Chapter 15.  Nailing Down the Details
      Picking the Customer's Brain (and the Programmers'!)
      The Good, the Bad, and the Ugly
      Optional Tests
      Getting Creative
      Lights-Out Test Design
      Exercise 9
      Chapter 16.  Writing Acceptance Tests
      Executable Tests
      If You Have Trouble Getting Started
      Exercise 10
      Chapter 17.  Organizing Acceptance Tests
      Version Control of Acceptance Tests
      Executable Test Files
      Organizing Acceptance Tests in Spreadsheets
      Exercise 11
      Chapter 18.  Test Design and Refactoring
      Establishing the Initial System State
      Tests That Leave the System State Unchanged
      Coupling between Tests
      Exercise 12
      Chapter 19.  Manual Tests
      Exercise 13
      Chapter 20.  What!?!!
      Manual Tests Are Unreliable
      Manual Tests Undermine the XP Testing Practice
      Manual Tests Are Divisive
      The Wings-Fall-Off Button
      What If You Have Manual Tests?
      Exercise 14
      Chapter 21.  Test Automation
      Modular Tests
      Data-Independent Tests
      Self-Verifying Tests
      Exercise 15
      Chapter 22.  Making Executable Tests Run
      Linking the Executable Test to an Application Test Class
      Defining the Application Test Class
      Calling the Code to be Tested
      Running the Test
      Getting Additional Tests to Run
      Combining Multiple Tests into Test Suites
      Exercise 16
      Chapter 23.  Running Executable Tests through Other Interfaces
      Code Missed by Direct Calls
      Expanding Coverage of the Executable Tests
      Interfacing to a Test Tool
      Creating an Application Test-Interface Class
      Refactoring the Direct-Call Interface
      Refactoring the Application Test Class
      Creating a Tool-Specific Interface Class
      One Team's Experience with Direct-Call Test Automation
      Exercise 17
      Chapter 24.  Driving the System with a Test Tool
      WebART Overview
      Main WebART Script
      Login Module
      Validation Criteria
      Exercise 18
      Chapter 25.  Bugs on the Windshield: Running Acceptance Tests
      How Often Do You Run Acceptance Tests?
      Educating the Customer
      Acceptance Criteria
      Defect Management
      Road Food for Thought
      Exercise 19
      Chapter 26.  Looking Back for the Future
      Exercise 20
      Chapter 27.  Keep On Truckin': Completing the XP Road Trip
      Regression Testing
      Catching Up
      The Release
      When XP Projects End
      Exercise 21
    Part III.  Road Hazard Survival Kit
      Chapter 28.  Challenges in "Testability"
      Designing for Testability
      A Real-Life Example
      Exercise 22
      Chapter 29.  Selecting and Implementing Tools
      Evolving Tools
      Test Tools
      Other Tools Related to Quality
      Choosing an Off-the-Shelf Tool
      Implementing Tools
      Experimenting with Tools
      Chapter 30.  Project Tune-Ups
      Office Space
      Accessorizing for XP
      Test Environment
      Other Obvious Best Practices
      Additional Tester Duties
      Chapter 31.  Introducing XP to Your Organization: A Tester's Point of View
      Test Phases and Practices
      Introducing People to the XP Tester Role
      Helping XP Testers Succeed
      XP Testing with Blended Practices
      What If You Don't Have Enough Testers?
      Chapter 32.  XP for Projects of Unusual Size
      Adjusting XP
      Advance Planning Pays Off
      Working with Customers
      Satisfying Customer Test Documentation Requirements
      Iteration Planning and Execution for Large or Multilocation Projects
      Chapter 33.  Extreme Testing without Extreme Programming
      Gathering Requirements
      System Design
      Planning and Defining Tests
      Running Tests
      Let Worry Be Your Guide
      Chapter 34.  In Closing: May the Road Rise Up to Meet You
      Answers to Exercises
      Exercise 1 (Chapter 7)
      Exercise 2 (Chapter 8)
      Exercise 3 (Chapter 9)
      Exercise 4 (Chapter 10)
      Exercise 5 (Chapter 11)
      Exercise 6 (Chapter 12)
      Exercise 7 (Chapter 13)
      Exercise 8 (Chapter 14)
      Exercise 9 (Chapter 15)
      Exercise 10 (Chapter 16)
      Exercise 11 (Chapter 17)
      Exercise 12 (Chapter 18)
      Exercise 13 (Chapter 19)
      Exercise 14 (Chapter 20)
      Exercise 15 (Chapter 21)
      Exercise 16 (Chapter 22)
      Exercise 17 (Chapter 23)
      Exercise 18 (Chapter 24)
      Exercise 19 (Chapter 25)
      Exercise 20 (Chapter 26)
      Exercise 21 (Chapter 27)
      Exercise 22 (Chapter 28)