Home > Store > Business & Management > General Business > Six Sigma

Effective Software Testing: 50 Specific Ways to Improve Your Testing

Register your product to gain access to bonus material or receive a coupon.

Effective Software Testing: 50 Specific Ways to Improve Your Testing


  • Your Price: $47.99
  • List Price: $59.99
  • Usually ships in 24 hours.


  • Copyright 2003
  • Dimensions: 7-3/8x9-1/4
  • Pages: 304
  • Edition: 1st
  • Book
  • ISBN-10: 0-201-79429-2
  • ISBN-13: 978-0-201-79429-8

Effective Software Testing explores fifty critically important best practices, pitfalls, and solutions. Gleaned from the author's extensive practical experience, these concrete items will enable quality assurance professionals and test managers to immediately enhance their understanding and skills, avoid costly mistakes, and implement a state-of-the-art testing program.

This book places special emphasis on the integration of testing into all phases of the software development life cycle--from requirements definition to design and final coding. The fifty lessons provided here focus on the key aspects of software testing: test planning, design, documentation, execution, managing the testing team, unit testing, automated testing, nonfunctional testing, and more.

You will learn to:

  • Base testing efforts on a prioritized feature schedule
  • Estimate test preparation and execution
  • Define the testing team roles and responsibilities
  • Design test procedures as soon as requirements are available
  • Derive effective test cases from requirements
  • Avoid constraints and detailed data elements in test procedures
  • Make unit-test execution part of the build process
  • Use logging to increase system testability
  • Test automated test tools on an application prototype
  • Automate regression tests whenever possible
  • Avoid sole reliance on capture/playback
  • Conduct performance testing with production-sized databases
  • Tailor usability tests to the intended audience
  • Isolate the test environment from the development environment
  • Implement a defect tracking life cycle

Throughout the book, numerous real-world case studies and concrete examples illustrate the successful application of these important principles and techniques.

Effective Software Testing provides ready access to the expertise and advice of one of the world's foremost software quality and testing authorities.


Sample Content

Online Sample Chapter

Improving Your Software Testing: Focus on the Testing Team

Downloadable Sample Chapter

Click below for Sample Chapter(s) related to this title:
Sample Chapter 3

Table of Contents




 1. Involve Testers from the Beginning.
 2. Verify the Requirements.
 3. Design Test Procedures as Soon as Requirements Are Available.
 4. Ensure That Requirement Changes Are Communicated.
 5. Beware of Developing and Testing Based on an Existing System.


 6. Understand the Task at Hand and the Related Testing Goal.
 7. Consider the Risks.
 8. Base Testing Efforts on a Prioritized Feature Schedule.
 9. Keep Software Issues in Mind.
10. Acquire Effective Test Data.
11. Plan for the Test Environment.
12. Estimate Test Preparation and Execution.


13. Define the Roles and Responsibilities.
14. Require a Mixture of Testing Skills, Subject Matter Expertise, and Experience.
15. Evaluate the Testers' Effectiveness.


16. Understand the Architecture and Underlying Components.
17. Verify That the System Supports Testability.
18. Use Logging to Increase System Testability.
19. Verify That the System Supports Debug vs. Release Execution Modes.


20. Divide and Conquer.
21. Mandate the Use of a Test Procedure Template, and Other Test Design Standards.
22. Derive Effective Test Cases from Requirements.
23. Treat Test Procedures as "Living" Documents.
24. Use System Design and Prototypes.
25. Use Proven Testing Techniques When Designing Test Case Scenarios.
26. Avoid Constraints and Detailed Data Elements in Test Procedures.
27. Apply Exploratory Testing.


28. Structure the Development Approach to Support Effective Unit Testing.
29. Develop Unit Tests in Parallel or before the Implementation.
30. Make Unit Test Execution Part of the Build Process.


31. Be Aware of the Different Types of Testing Support Tools.
32. Consider Building a Tool Instead of Buying One.
33. Be Aware of the Impact of Automated Tools on the Testing Effort.
34. Focus on the Needs of Your Organization.
35. Test the Tools on an Application Prototype.


36. Do Not Rely Solely on Capture/Playback.
37. Develop a Test Harness When Necessary.
38. Use Proven Test Script Development Techniques.
39. Automate Regression Tests Whenever Possible.
40. Implement Automated Builds and Smoke-Tests.


41. Do Not Make Nonfunctional Testing an Afterthought.
42. Conduct Performance Testing with Production Sized Databases.
43. Tailor Usability Tests to the Intended Audience.
44. Consider All Aspects of Security, for Specific Requirements and System-Wide.
45. Investigate the System's Implementation to Plan for Concurrency Tests.
46. Setup an Efficient Environment for Compatibility Testing.


47. Clearly Define the Beginning and the End of the Test Execution Cycle.
48. Isolate the Test Environment from the Development Environment.
49. Implement a Defect Tracking Life-Cycle.
50. Track the Execution of the Test Program.
Index. 0201794292T08272002


In most software-development organizations, the testing program functions as the final "quality gate" for an application, allowing or preventing the move from the comfort of the software-engineering environment into the real world. With this role comes a large responsibility: The success of an application, and possibly of the organization, can rest on the quality of the software product.

A multitude of small tasks must be performed and managed by the testing team--so many, in fact, that it is tempting to focus purely on the mechanics of testing a software application and pay little attention to the surrounding tasks required of a testing program. Issues such as the acquisition of proper test data, testability of the application's requirements and architecture, appropriate test-procedure standards and documentation, and hardware and facilities are often addressed very late, if at all, in a project's life cycle. For projects of any significant size, test scripts and tools alone will not suffice--a fact to which most experienced software testers will attest.

Knowledge of what constitutes a successful end-to-end testing effort is typically gained through experience. The realization that a testing program could have been much more effective had certain tasks been performed earlier in the project life cycle is a valuable lesson. Of course, at that point, it's usually too late for the current project to benefit from the experience.

Effective Software Testing provides experience-based practices and key concepts that can be used by an organization to implement a successful and efficient testing program. The goal is to provide a distilled collection of techniques and discussions that can be directly applied by software personnel to improve their products and avoid costly mistakes and oversights. This book details 50 specific software testing best practices, contained in ten parts that roughly follow the software life cycle. This structure itself illustrates a key concept in software testing: To be most effective, the testing effort must be integrated into the software-development process as a whole. Isolating the testing effort into one box in the "work flow" (at the end of the software life cycle) is a common mistake that must be avoided.

The material in the book ranges from process- and management-related topics, such as managing changing requirements and the makeup of the testing team, to technical aspects such as ways to improve the testability of the system and the integration of unit testing into the development process. Although some pseudocode is given where necessary, the content is not tied to any particular technology or application platform.

It is important to note that there are factors outside the scope of the testing program that bear heavily on the success or failure of a project. Although a complete software-development process with its attendant testing program will ensure a successful engineering effort, any project must also deal with issues relating to the business case, budgets, schedules, and the culture of the organization. In some cases, these issues will be at odds with the needs of an effective engineering environment. The recommendations in this book assume that the organization is capable of adapting, and providing the support to the testing program necessary for its success.


This book is organized into 50 separate items covering ten important areas. The selected best practices are organized in a sequence that parallels the phases of the system development life cycle.

The reader can approach the material sequentially, item-by-item and part-by-part, or simply refer to specific items when necessary to gain information about and understanding of a particular problem. For the most part, each chapter stands on its own, although there are references to other chapters, and other books, where helpful to provide the reader with additional information.

Chapter 1 describes requirements-phase considerations for the testing effort. It is important in the requirements phase for all stakeholders, including a representative of the testing team, to be involved in and informed of all requirements and changes. In addition, basing test cases on requirements is an essential concept for any large project. The importance of having the testing team represented during this phase cannot be overstated; it is in this phase that a thorough understanding of the system and its requirements can be obtained.

Chapter 2 covers test-planning activities, including ways to gain understanding of the goals of the testing effort, approaches to determining the test strategy, and considerations related to data, environments, and the software itself. Planning must take place as early as possible in the software life cycle, as lead times must be considered for implementing the test program successfully. Early planning allows for testing schedules and budgets to be estimated, approved, and incorporated into the overall software development plan. Estimates must be continually monitored and compared to actuals, so they can be revised and expectations can be managed as required.

Chapter 3 focuses on the makeup of the testing team. At the core of any successful testing program are its people. A successful testing team has a mixture of technical and domain knowledge, as well as a structured and concise division of roles and responsibilities. Continually evaluating the effectiveness of each test-team member throughout the testing process is important to ensuring success.

Chapter 4 discusses architectural considerations for the system under test. Often overlooked, these factors must be taken into account to ensure that the system itself is testable, and to enable gray-box testing and effective defect diagnosis.

Chapter 5 details the effective design and development of test procedures, including considerations for the creation and documentation of tests, and discusses the most effective testing techniques. As requirements and system design are refined over time and through system-development iterations, so must the test procedures be refined to incorporate the new or modified requirements and system functions.

Chapter 6 examines the role of developer unit testing in the overall testing strategy. Unit testing in the implementation phase can result in significant gains in software quality. If unit testing is done properly, later testing phases will be more successful. There is a difference, however, between casual, ad-hoc unit testing based on knowledge of the problem, and structured, repeatable unit testing based on the requirements of the system.

Chapter 7 explains automated testing tool issues, including the proper types of tools to use on a project, the build-versus-buy decision, and factors to consider in selecting the right tool for the organization. The numerous types of testing tools available for use throughout the phases in the development life cycle are described here. In addition, custom tool development is also covered.

Chapter 8 discusses selected best practices for automated testing. The proper use of capture/playback tools, test harnesses, and regression testing are described.

Chapter 9 provides information on testing nonfunctional aspects of a software application. Ensuring that nonfunctional requirements are met, including performance, security, usability, compatibility, and concurrency testing, adds to the overall quality of the application.

Chapter 10 provides a strategy for managing the execution of tests, including appropriate methods of tracking test-procedure execution and the defect life cycle, and gathering metrics to assess the testing process.


The target audience of this book includes Quality Assurance professionals, software testers, and test leads and managers. Much of the information presented can also be of value to project managers and software developers looking to improve the quality of a software project



Click below to download the Index file related to this title:


Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership