Introduction to Software Testing

(Edition 2)

Paul Ammann and Jeff Offutt

Chapter List
Part I: Overview
  1. Why Do We Test Software?
  2. Model-Driven Test Design
  3. Test Automation
  4. Putting Testing First
  5. Criteria-Based Test Design
Part II: Coverage Criteria
  6. Input Space Partitioning
  7. Graph Coverage
  8. Logic Coverage
  9. Syntax-based Testing
Part III: Testing in Practice
  10. Managing the Test Process
  11. Writing Test Plans
  12. Test Implementation
  13. Regression Testing for Evolving Software
  14. Writing Effective Test Oracles

Part I: Overview
    1. Why Do We Test Software?
       1.1 When Software Goes Bad
       1.2 Goals of Testing Software
       1.3 Bibliographic Notes
    2. Model-Driven Test Design
       2.1 Software Testing Foundations
       2.2 Software Testing Activities
       2.3 Testing Levels Based on Software Activity
       2.4 Coverage Criteria
       2.5 Model-Driven Test Design
          2.5.1 Test design
          2.5.2 Test automation
          2.5.3 Test execution
          2.5.4 Test evaluation
          2.5.5 Test personnel and abstraction
       2.6 Summary
       2.7 Bibliographic Notes
    3. Test Automation
       3.1 Software Testability
       3.2 Components of a Test Case
       3.3 A Test Automation Framework
          3.3.1 The JUnit Test Framework
          3.3.2 Data-Driven Tests
          3.3.3 Adding Parameters to Unit Tests
          3.3.4 JUnit From the Command Line
       3.4 Summary
       3.5 Bibliographic Notes
    4. Putting Testing First
       4.1 Taming the Cost-Of-Change Curve
          4.1.1 Is the Curve Really Tamed?
       4.2 The Test Harness as Guardian
          4.2.1 Continuous Integration
          4.2.2 System Tests in Agile Methods
          4.2.3 Adding Tests to Legacy Systems
          4.2.4 Weaknesses in Agile Methods for Testing
       4.3 Bibliographic Notes
    5. Criteria-Based Test Design
       5.1 Coverage Criteria Defined
       5.2 Infeasibility and Subsumption
       5.3 Advantages of Using Coverage Criteria
       5.4 Next Up
       5.5 Bibliographic Notes

Part II: Coverage Criteria
    6. Input Space Partitioning
       6.1 Input Domain Modeling
          6.1.1 Interface-based Input Domain Modeling
          6.1.2 Functionality-based Input Domain Modeling
          6.1.3 Designing Characteristics
          6.1.4 Choosing Blocks and Values
          6.1.5 Checking the Input Domain Model
       6.2 Combination Strategies Criteria
       6.3 Handling Constraints Among Characteristics
       6.4 Extended Example: Deriving an IDM from JavaDoc
          6.4.1 Tasks in Designing IDM-based Tests
          6.4.2 Designing IDM-based Tests for Iterator
       6.5 Bibliographic Notes
    7. Graph Coverage
       7.1 Overview
       7.2 Graph Coverage Criteria
          7.2.1 Structural Coverage Criteria
          7.2.2 Touring, Sidetrips, and Detours
          7.2.3 Data Flow Criteria
          7.2.4 Subsumption Relationships among Graph Coverage Criteria
       7.3 Graph Coverage for Source Code
          7.3.1 Structural Graph Coverage for Source Code
          7.3.2 Data Flow Graph Coverage for Source Code
       7.4 Graph Coverage for Design Elements
          7.4.1 Structural Graph Coverage for Design Elements
          7.4.2 Data Flow Graph Coverage for Design Elements
       7.5 Graph Coverage for Specifications
          7.5.1 Testing Sequencing Constraints
          7.5.2 Testing State Behavior of Software
       7.6 Graph Coverage for Use Cases
          7.6.1 Use Case Scenarios
       7.7 Bibliographic Notes
    8. Logic Coverage
       8.1 Semantic Logic Coverage Criteria (Active)
          8.1.1 Simple Logic Expression Coverage Criteria
          8.1.2 Active Clause Coverage
          8.1.3 Inactive Clause Coverage
          8.1.4 Infeasibility and Subsumption
          8.1.5 Making a Clause Determine a Predicate
          8.1.6 Finding Satisfying Values
       8.2 Syntactic Logic Coverage Criteria (DNF)
          8.2.1 Implicant Coverage
          8.2.2 Minimal DNF
          8.2.3 The MUMCUT Coverage Criterion
          8.2.4 Karnaugh Maps
       8.3 Structural Logic Coverage of Programs
          8.3.1 Satisfying Predicate Coverage
          8.3.2 Satisfying Clause Coverage
          8.3.3 Satisfying Active Clause Coverage
          8.3.4 Predicate Transformation Issues
          8.3.5 Side Effects in Predicates
       8.4 Specification-based Logic Coverage
       8.5 Logic Coverage of Finite State Machines
       8.6 Bibliographic Notes
    9. Syntax-based Testing
       9.1 Syntax-based Coverage Criteria
          9.1.1 Grammar-based Coverage Criteria
          9.1.2 Mutation Testing
       9.2 Program-based Grammars
          9.2.1 BNF Grammars for Compilers
          9.2.2 Program-based Mutation
       9.3 Integration and Object-Oriented Testing
          9.3.1 BNF Integration Testing
          9.3.2 Integration Mutation
       9.4 Specification-based Grammars
          9.4.1 BNF Grammars
          9.4.2 Specification-based Mutation
       9.5 Input Space Grammars
          9.5.1 BNF Grammars
          9.5.2 Mutating Input Grammars
       9.6 Bibliographic Notes

Part III: Testing in Practice
   10. Managing the Test Process
       10.1 Overview
       10.2 Requirements Analysis and Specification
       10.3 System and Software Design
       10.4 Intermediate Design
       10.5 Detailed Design
       10.6 Implementation
       10.7 Integration
       10.8 System Deployment
       10.9 Operation and Maintenance
       10.10 Implementing the Test Process
       10.11 Bibliographic Notes
   11. Writing Test Plans
       11.1 Level Test Plan Example Template
       11.2 Bibliographic Notes
   12. Test Implementation
       12.1 Integration Order
       12.2 Test Doubles
          12.2.1 Stubs and Mocks: Variations of Test Doubles
          12.2.2 Using Test Doubles to Replace Components
       12.3 Bibliographic Notes
   13. Regression Testing for Evolving Software
       13.1 Bibliographic Notes
   14. Writing Effective Test Oracles
       14.1 What Should be Checked?
       14.2 Determining Correct Values
          14.2.1 Specification-Based Direct Verification of Outputs
          14.2.2 Redundant Computations
          14.2.3 Consistency Checks
          14.2.4 Metamorphic Testing
       14.3 Bibliographic Notes