Lessons Learned in Software Testing: A Context-Driven Approach

Lessons Learned in Software Testing: A Context-Driven Approach

Released December 2001
Publisher(s): Wiley
ISBN: 9780471081128

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Decades of software testing experience condensed into the most important lessons learned.

The world's leading software testing experts lend you their wisdom and years of experience to help you avoid the most common mistakes in testing software. Each lesson is an assertion related to software testing, followed by an explanation or example that shows you the how, when, and why of the testing lesson. More than just tips, tricks, and pitfalls to avoid, Lessons Learned in Software Testing speeds you through the critical testing phase of the software development project without the extensive trial and error it normally takes to do so. The ultimate resource for software testers and developers at every level of expertise, this guidebook features:

  • Over 200 lessons gleaned from over 30 years of combined testing experience

  • Tips, tricks, and common pitfalls to avoid by simply reading the book rather than finding out the hard way

  • Lessons for all key topic areas, including test design, test management, testing strategies, and bug reporting

  • Explanations and examples of each testing trouble spot help illustrate each lesson's assertion

Table of contents

  1. Copyright
  2. FOREWORD
  3. PREFACE
    1. Welcome to Lessons Learned in Software Testing
    2. Who This Book Is For
    3. What This Book Is About
    4. What This Book Is Not
    5. How to Use This Book
    6. We Hope This Book Stimulates Conversations and Debates
    7. A Few Notes on Vocabulary
  4. ACKNOWLEDGMENTS
  5. 1. The Role of the Tester
    1. 1.1. Lesson 1: You are the headlights of the project.
    2. 1.2. Lesson 2: Your mission drives everything you do.
    3. 1.3. Lesson 3: You serve many clients.
    4. 1.4. Lesson 4: You discover things that will "bug" I someone whose opinion matters.
    5. 1.5. Lesson 5: Find important bugs fast.
    6. 1.6. Lesson 6: Run with the programmers.
    7. 1.7. Lesson 7: Question everything, but not necessarily out loud.
    8. 1.8. Lesson 8: You focus on failure, so your clients can focus on success.
    9. 1.9. Lesson 9: You will not find all the bugs.
    10. 1.10. Lesson 10: Beware of testing completely.
    11. 1.11. Lesson 11: You don't assure quality by testing.
    12. 1.12. Lesson 12: Never be the gatekeeper!
    13. 1.13. Lesson 13: Beware of the not-my-job theory of testing.
    14. 1.14. Lesson 14: Beware of becoming a process improvement group.
    15. 1.15. Lesson 15: Don't expect anyone to understand testing, or what you need to do it well.
  6. 2. Thinking Like a Tester
    1. 2.1. Lesson 16: Testing is applied epistemology.
    2. 2.2. Lesson 17: Studying epistemology helps you test better.
    3. 2.3. Lesson 18: Testing is grounded in cognitive psychology.
    4. 2.4. Lesson 19: Testing is in your head.
    5. 2.5. Lesson 20: Testing requires inference, not just comparison of output to expected results.
    6. 2.6. Lesson 21: Good testers think technically, creatively, critically, and practically.
    7. 2.7. Lesson 22: Black box testing is not ignorance-based testing.
    8. 2.8. Lesson 23: A tester is more than a tourist.
    9. 2.9. Lesson 24: All tests are an attempt to answer some question.
    10. 2.10. Lesson 25: All testing is based on models.
    11. 2.11. Lesson 26: Intuition is a fine beginning, but a lousy conclusion.
    12. 2.12. Lesson 27: To test, you must explore.
    13. 2.13. Lesson 28: Exploring involves a lot of thinking.
    14. 2.14. Lesson 29: Use the logic of abductive inference to discover conjectures.
    15. 2.15. Lesson 30: Use the logic of conjecture and refutation to evaluate a product.
    16. 2.16. Lesson 31: A requirement is a quality or condition that matters to someone who matters.
    17. 2.17. Lesson 32: You discover requirements by conference, inference, and reference.
    18. 2.18. Lesson 33: Use implicit as well as explicit specifications.
    19. 2.19. Lesson 34: "It works" really means it appears to meet some requirement to some degree.
    20. 2.20. Lesson 35: In the end, all you have is an impression of the product.
    21. 2.21. Lesson 36: Don't confuse the test with the testing.
    22. 2.22. Lesson 37: When testing a complex product: plunge in and quit.
    23. 2.23. Lesson 38: Use heuristics to quickly generate ideas for tests.
    24. 2.24. Lesson 39: You can't avoid bias, but you can manage it.
    25. 2.25. Lesson 40: You're harder to fool if you know you're a fool.
    26. 2.26. Lesson 41: When you miss a bug, check whether the miss is surprising or just the natural outcome of your strategy.
    27. 2.27. Lesson 42: Confusion is a test tool.
    28. 2.28. Lesson 43: Fresh eyes find failure.
    29. 2.29. Lesson 44: Avoid following procedures unless they followed you first.
    30. 2.30. Lesson 45: When you do create test procedures, avoid "1287."
    31. 2.31. Lesson 46: One important outcome of a test process is a better, smarter tester.
    32. 2.32. Lesson 47: You can't master testing unless you reinvent it.
  7. 3. Testing Techniques
    1. 3.1. Lesson 48: Testing combines techniques that focus on testers, coverage, potential problems, activities, and evaluation.
    2. 3.2. Lesson 49: People-based techniques focus on who does the testing.
    3. 3.3. Lesson 50: Coverage-based techniques focus on what gets tested.
    4. 3.4. Lesson 51: Problems-based techniques focus on why you're testing (the risks you're testing for).
    5. 3.5. Lesson 52: Activity-based techniques focus on how you test.
    6. 3.6. Lesson 53: Evaluation-based techniques focus on how to tell whether the test passed or failed.
    7. 3.7. Lesson 54: The classification of a technique depends on how you think about it.
      1. 3.7.1. Addendum to Techniques
      2. 3.7.2. How to Create a Test Matrix for an Input Field
      3. 3.7.3. How to Create a Test Matrix for Repeating Issues
      4. 3.7.4. How to Create a Traceability Matrix for Specification-Based Testing
      5. 3.7.5. How to Do Combination Testing Using the All-Pairs Technique
        1. 3.7.5.1. Start with Domain Partitioning
        2. 3.7.5.2. Achieving All Singles
        3. 3.7.5.3. Achieving All Pairs
        4. 3.7.5.4. A Step-By-Step Example
      6. 3.7.6. How to Analyze the Risks Associated with Some Item or Aspect of the Program
        1. 3.7.6.1. Quality Attributes
        2. 3.7.6.2. Problem Drivers
        3. 3.7.6.3. Use Error Catalogs
        4. 3.7.6.4. Use Up-to-Date Sources to Add to Your Error Catalogs
  8. 4. Bug Advocacy
    1. 4.1. Lesson 55: You are what you write.
    2. 4.2. Lesson 56: Your advocacy drives the repair of the bugs you report.
    3. 4.3. Lesson 57: Make your bug report an effective sales tool.
    4. 4.4. Lesson 58: Your bug report is your representative.
    5. 4.5. Lesson 59: Take the time to make your bug reports valuable.
    6. 4.6. Lesson 60: Any stakeholder should be able to report a bug.
    7. 4.7. Lesson 61: Be careful about rewording other people's bug reports.
    8. 4.8. Lesson 62: Report perceived quality gaps as bugs.
    9. 4.9. Lesson 63: Some stakeholders cannot report bugs-you're their proxy.
    10. 4.10. Lesson 64: Draw the affected stakeholder's attention to controversial bugs.
    11. 4.11. Lesson 65: Never use the bug-tracking system to monitor programmers' performance.
    12. 4.12. Lesson 66: Never use the bug-tracking system to monitor testers' performance.
    13. 4.13. Lesson 67: Report defects promptly.
    14. 4.14. Lesson 68: Never assume that an obvious bug has already been filed.
    15. 4.15. Lesson 69: Report design errors.
    16. 4.16. Lesson 70: Extreme-looking bugs are potential security flaws.
    17. 4.17. Lesson 71: Uncorner your corner cases.
    18. 4.18. Lesson 72: Minor bugs are worth reporting and fixing.
    19. 4.19. Lesson 73: Keep clear the difference between severity and priority.
    20. 4.20. Lesson 74: A failure is a symptom of an error, not the error itself.
    21. 4.21. Lesson 75: Do follow-up testing on seemingly minor coding errors.
    22. 4.22. Lesson 76: Always report nonreproducible errors; they may be time bombs.
    23. 4.23. Lesson 77: Nonreproducible bugs are reproducible.
    24. 4.24. Lesson 78: Be conscious of the processing cost of your bug reports.
    25. 4.25. Lesson 79: Give special handling to bugs related to the tools or environment.
    26. 4.26. Lesson 80: Ask before reporting bugs against prototypes or early private versions.
    27. 4.27. Lesson 81: Duplicate bug reports are a self-correcting problem.
    28. 4.28. Lesson 82: Every bug deserves its own report.
    29. 4.29. Lesson 83: The summary line is the most important line in the bug report.
    30. 4.30. Lesson 84: Never exaggerate your bugs.
    31. 4.31. Lesson 85: Report the problem clearly, but don't try to solve it.
    32. 4.32. Lesson 86: Be careful of your tone. Every person you criticize will see the report.
    33. 4.33. Lesson 87: Make your reports readable, even to people who are exhausted and cranky.
    34. 4.34. Lesson 88: Improve your reporting skills.
    35. 4.35. Lesson 89: Use market or support data when appropriate.
    36. 4.36. Lesson 90: Review each other's bug reports.
    37. 4.37. Lesson 91: Meet the programmers who will read your reports.
    38. 4.38. Lesson 92: The best approach may be to demonstrate your bugs to the programmers.
    39. 4.39. Lesson 93: When the programmer says it' s fixed, make sure it isn't still broken.
    40. 4.40. Lesson 94: Verify bug fixes promptly.
    41. 4.41. Lesson 95: When fixes fail, talk with the programmer.
    42. 4.42. Lesson 96: Bug reports should be closed by testers.
    43. 4.43. Lesson 97: Don't insist that every bug be fixed. Pick I your battles.
    44. 4.44. Lesson 98: Don't let deferred bugs disappear.
    45. 4.45. Lesson 99: Testing inertia should never be the cause of bug deferral.
    46. 4.46. Lesson 100: Appeal bug deferrals immediately.
    47. 4.47. Lesson 101: When you decide to fight, decide to win!
  9. 5. Automating Testing
    1. 5.1. Lesson 102: Speed the development process instead of trying to save a few dollars on testing.
    2. 5.2. Lesson 103: Expand your reach instead of trying to repeat the same tests over and over.
    3. 5.3. Lesson 104: Select your automation strategy based on your context.
    4. 5.4. Lesson 105: Don't mandate 100 percent automation.
    5. 5.5. Lesson 106: A test tool is not a strategy.
    6. 5.6. Lesson 107: Don't automate a mess.
    7. 5.7. Lesson 108: Don't equate manual testing to automated testing.
    8. 5.8. Lesson 109: Don't estimate the value of a test in terms of how often you run it.
    9. 5.9. Lesson 110: Automated regression tests find a minority of the bugs
    10. 5.10. Lesson 111: Consider what bugs you aren't finding while you automate tests.
    11. 5.11. Lesson 112: The problem with bad automation is that no one may notice.
    12. 5.12. Lesson 113: Capture replay fails.
    13. 5.13. Lesson 114: Test tools are buggy.
    14. 5.14. Lesson 115: User interfaces change.
    15. 5.15. Lesson 116: Select GUI test tools based on compatibility, familiarity, and service.
    16. 5.16. Lesson 117: Automated regression tests die.
    17. 5.17. Lesson 118: Test automation is a software development process.
    18. 5.18. Lesson 119: Test automation is a significant investment.
    19. 5.19. Lesson 120: Test automation projects require skills in programming, testing, and project management.
    20. 5.20. Lesson 121: Use pilot projects to prove feasibility.
    21. 5.21. Lesson 122: Have testers and programmers charter automation projects.
    22. 5.22. Lesson 123: Design automated tests to facilitate review.
    23. 5.23. Lesson 124: Don't skimp on automated test design.
    24. 5.24. Lesson 125: Avoid complex logic in your test scripts.
    25. 5.25. Lesson 126: Don't build test libraries simply to avoid repeating code.
    26. 5.26. Lesson 127: Data-driven test automation makes it easy to run lots of test variants.
    27. 5.27. Lesson 128: Keyword-driven test automation makes it easy for nonprogrammers to create tests.
    28. 5.28. Lesson 129: Use automated techniques to generate test inputs.
    29. 5.29. Lesson 130: Separate test generation from test execution.
    30. 5.30. Lesson 131: Use standard scripting languages.
    31. 5.31. Lesson 132: Automate tests using programming interfaces.
    32. 5.32. Lesson 133: Encourage the development of unit test suites.
    33. 5.33. Lesson 134: Beware of using automators who don't understand testing.
    34. 5.34. Lesson 135: Avoid automators who don't respect testing.
    35. 5.35. Lesson 136: Testability is often a better investment than automation.
    36. 5.36. Lesson 137: Testability is visibility and control.
    37. 5.37. Lesson 138: Start test automation early.
    38. 5.38. Lesson 139: Give centralized automation teams clear charters.
    39. 5.39. Lesson 140: Automate for immediate impact.
    40. 5.40. Lesson 141: You may have more test tools than you realize.
  10. 6. Documenting Testing
    1. 6.1. Lesson 142: To apply a solution effectively, you need to understand the problem clearly.
    2. 6.2. Lesson 143: Don't use test documentation templates: A template won't help unless you don't need it.
    3. 6.3. Lesson 144: Use test documentation templates: They foster consistent communication.
    4. 6.4. Lesson 145: Use the IEEE Standard 829 for test documentation.
    5. 6.5. Lesson 146: Don't use the IEEE Standard 829.
    6. 6.6. Lesson 147: Analyze your requirements before deciding what products to build; this applies as much to your documentation as to your software.
    7. 6.7. Lesson 148: To analyze your test documentation requirements, ask questions like the ones in this list.
    8. 6.8. Lesson 149: Summarize your core documentation requirements in one sentence with no more than three components.
  11. 7. Interacting with Programmers
    1. 7.1. Lesson 150: Understand how programmers think.
    2. 7.2. Lesson 151: Develop programmers' trust.
    3. 7.3. Lesson 152: Provide service.
    4. 7.4. Lesson 153: Your integrity and competence will demand respect.
    5. 7.5. Lesson 154: Focus on the work, not the person.
    6. 7.6. Lesson 155: Programmers like to talk about their work. Ask them questions.
    7. 7.7. Lesson 156: Programmers like to help with testability.
  12. 8. Managing the Testing Project
    1. 8.1. Lesson 157: Create a service culture.
    2. 8.2. Lesson 158: Don't try to create a control culture.
    3. 8.3. Lesson 159: Develop the power of the king's ear.
    4. 8.4. Lesson 160: You manage the subproject that provides testing services, not the development project.
    5. 8.5. Lesson 161: All projects evolve. Well-run projects evolve well.
    6. 8.6. Lesson 162: There are always late changes.
    7. 8.7. Lesson 163: Projects involve a tradeoff among features, reliability, time, and money.
    8. 8.8. Lesson 164: Let the project manager choose the project lifecycle.
    9. 8.9. Lesson 165: Waterfall lifecycles pit reliability against time.
    10. 8.10. Lesson 166: Evolutionary lifecycles pit features against time.
    11. 8.11. Lesson 167: Be willing to allocate resources to the project early in development.
    12. 8.12. Lesson 168: Contract-driven development is different from market-seeking development.
    13. 8.13. Lesson 169: Ask for testability features.
    14. 8.14. Lesson 170: Negotiate the schedules for builds.
    15. 8.15. Lesson 171: Understand what programmers do (and don't do) before delivering builds.
    16. 8.16. Lesson 172: Be prepared for the build.
    17. 8.17. Lesson 173: Sometimes you should refuse to test a build.
    18. 8.18. Lesson 174: Use smoke tests to qualify a build.
    19. 8.19. Lesson 175: Sometimes, the right decision is to stop the test and fix cycle and redesign the software.
    20. 8.20. Lesson 176: Adapt your processes to the development practices that are actually in use.
    21. 8.21. Lesson 177: "Project documents are interesting fictions: Useful, but never sufficient."
    22. 8.22. Lesson 178: Don't ask for items unless you will use them.
    23. 8.23. Lesson 179: Take advantage of other sources of information.
    24. 8.24. Lesson 180: Flag configuration management problems to the project manager.
    25. 8.25. Lesson 181: Programmers are like tornadoes.
    26. 8.26. Lesson 182: Great test planning makes late changes easy.
    27. 8.27. Lesson 183: Test opportunities arise whenever one person hands off an artifact to another.
    28. 8.28. Lesson 184: There is no universal formula for knowing how much testing is enough.
    29. 8.29. Lesson 185: "Enough testing" means "enough information for my clients to make good decisions."
    30. 8.30. Lesson 186: Never budget for just two testing cycles.
    31. 8.31. Lesson 187: To create a schedule for a set of tasks, estimate the amount of time needed for each task.
    32. 8.32. Lesson 188: The person who will do the work should tell you how long a task will take.
    33. 8.33. Lesson 189: There is no right ratio of testers to other developers.
    34. 8.34. Lesson 190: Trade tasks or transfer people from tasks that they are failing at.
    35. 8.35. Lesson 191: Rotate testers across features.
    36. 8.36. Lesson 192: Try testing in pairs.
    37. 8.37. Lesson 193: Assign a bug hunter to the project.
    38. 8.38. Lesson 194: Charter testing sessions, especially exploratory testing sessions.
    39. 8.39. Lesson 195: Test in sessions.
    40. 8.40. Lesson 196: Use activity logs to reveal the interruptions that plague testers' work.
    41. 8.41. Lesson 197: Regular status reports are powerful tools.
    42. 8.42. Lesson 198: There's nothing more dangerous than a vice president with statistics.
    43. 8.43. Lesson 199: Be cautious about measuring the project's progress in terms of bug counts.
    44. 8.44. Lesson 200: The more independent coverage measures you use, the more you know.
    45. 8.45. Lesson 201: Use a balanced scorecard to report status on multiple dimensions.
    46. 8.46. Lesson 202: Here's a suggested structure for a weekly status report.
    47. 8.47. Lesson 203: A project dashboard is another useful way for showing status.
    48. 8.48. Lesson 204: Milestone reports are useful when milestones are well defined.
    49. 8.49. Lesson 205: Don't sign-off to approve the release of a product.
    50. 8.50. Lesson 206: Do sign-off that you have tested a product to your satisfaction.
    51. 8.51. Lesson 207: If you write a release report, describe your testing work and results, not your opinion of the product.
    52. 8.52. Lesson 208: List unfixed bugs in the final release report.
    53. 8.53. Lesson 209: A useful release report lists the 10 worst things critics might say.
  13. 9. Managing the Testing Group
    1. 9.1. Lesson 210: Mediocrity is a self-fulfilling prophecy.
    2. 9.2. Lesson 211: Treat your staff as executives.
    3. 9.3. Lesson 212: Read your staffs bug reports.
    4. 9.4. Lesson 213: Evaluate your staff as executives.
    5. 9.5. Lesson 214: If you really want to know what' s going on, test with your staff.
    6. 9.6. Lesson 215: Don't expect people to handle multiple projects efficiently.
    7. 9.7. Lesson 216: Build your testing staffs domain expertise.
    8. 9.8. Lesson 217: Build your testing staffs expertise in the relevant technology.
    9. 9.9. Lesson 218: Work actively on skills improvement.
    10. 9.10. Lesson 219: Review technical support logs.
    11. 9.11. Lesson 220: Help new testers succeed.
    12. 9.12. Lesson 221: Have new testers check the documentation against the software.
    13. 9.13. Lesson 222: Familiarize new testers with the product through positive testing.
    14. 9.14. Lesson 223: Have novice testers edit old bug reports before writing new ones.
    15. 9.15. Lesson 224: Have new testers retest old bugs before testing for new bugs.
    16. 9.16. Lesson 225: Don't put novice testers on nearly finished projects.
    17. 9.17. Lesson 226: The morale of your staff is an important asset.
    18. 9.18. Lesson 227: Don't let yourself be abused.
    19. 9.19. Lesson 228: Don't abuse your staff with overtime.
    20. 9.20. Lesson 229: Don't let your staff be abused.
    21. 9.21. Lesson 230: Create training opportunities.
    22. 9.22. Lesson 231: Your hiring decisions are your most important decisions.
    23. 9.23. Lesson 232: Hire contractors to give you breathing room during recruiting.
    24. 9.24. Lesson 233: Rarely accept rejects from other groups into testing.
    25. 9.25. Lesson 234: Plan in terms of the tasks you need to do in your group and the skills needed to do them.
    26. 9.26. Lesson 235: Staff the testing team with diverse backgrounds.
    27. 9.27. Lesson 236: Hire opportunity candidates.
    28. 9.28. Lesson 237: Hire by consensus.
    29. 9.29. Lesson 238: Hire people who love their work.
    30. 9.30. Lesson 239: Hire integrity.
    31. 9.31. Lesson 240: During the interview, have the tester demonstrate the skills you're hiring him for.
    32. 9.32. Lesson 241: During the interview, have the tester demonstrate skills he'll actually use on the job over informal aptitude tests.
    33. 9.33. Lesson 242: When recruiting, ask for work samples.
    34. 9.34. Lesson 243: Hire quickly after you make up your mind.
    35. 9.35. Lesson 244: Put your hiring promises in writing and keep them.
  14. 10. Your Career in Software Testing
    1. 10.1. Lesson 245: Choose a career track and pursue it.
    2. 10.2. Lesson 246: Testers' incomes can be higher than programmers' incomes.
    3. 10.3. Lesson 247: Feel free to change your track and pursue something else.
    4. 10.4. Lesson 248: Whatever path you take, pursue it actively.
    5. 10.5. Lesson 249: Extend your career beyond software testing.
    6. 10.6. Lesson 250: Extend your career beyond your company.
    7. 10.7. Lesson 251: Conferences are for conferring.
    8. 10.8. Lesson 252: Lots of other companies are as screwed up as yours.
    9. 10.9. Lesson 253: If you don't like your company, look for a different job.
    10. 10.10. Lesson 254: Be prepared in case you have to bet your job (and lose).
    11. 10.11. Lesson 255: Build and maintain a list of companies where you'd like to work.
    12. 10.12. Lesson 256: Build a portfolio.
    13. 10.13. Lesson 257: Use your resume as a sales tool.
    14. 10.14. Lesson 258: Get an inside referral.
    15. 10.15. Lesson 259: Research salary data.
    16. 10.16. Lesson 260: If you're answering an advertisement, tailor your answer to the advertisement.
    17. 10.17. Lesson 261: Take advantage of opportunities to interview.
    18. 10.18. Lesson 262: Learn about companies when you apply for jobs with them.
    19. 10.19. Lesson 263: Ask questions during job interviews.
    20. 10.20. Lesson 264: Negotiate your position.
    21. 10.21. Lesson 265: Be cautious about Human Resources.
    22. 10.22. Lesson 266: Learn Perl.
    23. 10.23. Lesson 267: Learn Java or C++.
    24. 10.24. Lesson 268: Download demo copies of testing tools and try them out.
    25. 10.25. Lesson 269: Improve your writing skills.
    26. 10.26. Lesson 270: Improve your public speaking skills.
    27. 10.27. Lesson 271: Think about getting certified.
    28. 10.28. Lesson 272: If you can get a black belt in only two weeks, avoid fights.
    29. 10.29. Lesson 273: A warning about the efforts to license software engineers.
  15. 11. Planning the Testing Strategy
    1. 11.1. Lesson 274: Three basic questions to ask about test strategy are "why bother?", "who cares?", and "how much?"
    2. 11.2. Lesson 275: There are many possible test strategies.
    3. 11.3. Lesson 276: The real test plan is the set of ideas that guides your test process.
    4. 11.4. Lesson 277: Design your test plan to fit your context.
    5. 11.5. Lesson 278: Use the test plan to express choices about strategy, logistics, and work products.
    6. 11.6. Lesson 279: Don't let logistics and work products blind you to strategy.
    7. 11.7. Lesson 280: How to lie with test cases.
    8. 11.8. Lesson 281: Your test strategy is more than your tests.
    9. 11.9. Lesson 282: Your test strategy explains your testing.
    10. 11.10. Lesson 283: Apply diverse half-measures.
    11. 11.11. Lesson 284: Cultivate the raw materials of powerful test strategies.
    12. 11.12. Lesson 285: Your first strategy on a project is always wrong.
    13. 11.13. Lesson 286: At every phase of the project, ask yourself "what can I test now and how can I test it?"
    14. 11.14. Lesson 287: Test to the maturity of the product.
    15. 11.15. Lesson 288: Use test levels to simplify discussions of test complexity.
    16. 11.16. Lesson 289: Test the gray box.
    17. 11.17. Lesson 290: Beware of ancestor worship when reusing test materials.
    18. 11.18. Lesson 291: Two testers testing the same thing are probably not duplicating efforts.
    19. 11.19. Lesson 292: Design your test strategy in response to project factors as well as product risks.
    20. 11.20. Lesson 293: Treat test cycles as the heartbeat of the test process.
    21. 11.21. How To Evolve a Context-Driven Test Plan
      1. 11.21.1. 1. Monitor major test planning challenges.
      2. 11.21.2. 2. Clarify your mission.
        1. 11.21.2.1. MISSION ELEMENTS TO CONSIDER
        2. 11.21.2.2. POSSIBLE WORK PRODUCTS
      3. 11.21.3. 3. Analyze the product.
        1. 11.21.3.1. WHAT TO ANALYZE
        2. 11.21.3.2. WAYS TO ANALYZE
        3. 11.21.3.3. POSSIBLE WORK PRODUCTS
      4. 11.21.4. 4. Analyze product risk.
        1. 11.21.4.1. WHAT TO ANALYZE
        2. 11.21.4.2. WAYS TO ANALYZE
        3. 11.21.4.3. POSSIBLE WORK PRODUCTS
      5. 11.21.5. 5. Design the test strategy.
        1. 11.21.5.1. CONSIDER TECHNIQUES FROM FIVE PERSPECTIVES
        2. 11.21.5.2. WAYS TO PLAN
        3. 11.21.5.3. POSSIBLE WORK PRODUCTS
      6. 11.21.6. 6. Plan logistics.
        1. 11.21.6.1. LOGISTICAL AREAS
        2. 11.21.6.2. POSSIBLE WORK PRODUCTS
      7. 11.21.7. 7. Share the plan.
        1. 11.21.7.1. WAYS TO SHARE
        2. 11.21.7.2. GOALS
    22. 11.22. How Good Is This Test Plan?
      1. 11.22.1. Terms and Concepts
      2. 11.22.2. The Functions of a Test Plan
      3. 11.22.3. Test Plan Quality Criteria
      4. 11.22.4. Test Plan Heuristics
  16. A. The Context-Driven Approach to Software Testing
    1. A.1. The Seven Basic Principles of the Context-Driven School
    2. A.2. Illustrations of the Principles in Action:
    3. A.3. An Example
    4. A.4. Members of the Context-Driven School
  17. Bibliography
    1. -A-
    2. -B-
    4. -C-
    6. -D-
    7. -E-
    8. -F-
    10. -G-
    11. -H-
    13. -I-
    14. -J-
    15. -K-
    17. -L-
    19. -M-
    20. -N-
    21. -O-
    22. -P-
    23. -R-
    24. -S-
    25. -T-
    26. -W-
    28. -Y-
    29. -Z-

Product information

  • Title: Lessons Learned in Software Testing: A Context-Driven Approach
  • Author(s):
  • Release date: December 2001
  • Publisher(s): Wiley
  • ISBN: 9780471081128