Home > Articles > Programming

Preface to Best Practices for the Formal Software Testing Process: A Menu of Testing Tasks

  • Print
  • + Share This
Roger Drabick introduces his book, Best Practices for the Formal Software Testing Process: A Menu of Testing Tasks, which provides a soup-to-nuts list of tasks and processes for a program of formal software or system testing.
This chapter is from the book

What is “the formal software testing process”?

One of the definitions the Institute of Electrical and Electronics Engineers (IEEE) Software Standards collection provides for process is “a course of action to be taken to perform a given task” or “a written description of a course of actions, for example, a documented test procedure.” Various editions of Webster’s Dictionary offer a series of definitions for process, including “a particular method of doing something, generally involving a number of steps or operations.”

A simpler definition of a process is “the way we do things.”

Thus, we could say that the “testing process” is “a course of action to be taken to perform formal testing,” or “the way we do testing here.”

But, how does “the way we do testing here” stack up against industry standards for best testing practices, and why did I go to all the effort to define a Formal Testing Process Model? Let me share a short personal retrospective.

I have spent twenty-eight years of a mostly exciting technical career testing and managing testing programs. These programs started out as hardware programs, and evolved into hardware and software systems programs in the mid-1970’s. I was lucky in some respects to work for a large company in the Department of Defense (DoD) area; thus, we were always in an environment that forced us to be rigorous and methodical, both in test execution and in test documentation. Note that being methodical didn’t always lead to delivering successful systems.

When I first began working in programs that were primarily software, I was looking for sources of material on “best practices” relative to the software testing process. Being in the DoD environment, our customers supplied Contract Deliverable Requirements Lists (CDRLs) that identified the documents we had to write. Thus, we had a framework for our programs. Later, I discovered a number of military standards (for example, DoD-Standards 2167A and 2168), and the IEEE Software Engineering Standards, which I continue to use to this day. Following the series of documentation contained in IEEE-Standard-829, the Standard for Software Test Documentation, suggested a standard process to utilize for software and systems test documentation.

In 1992, while working in the Commercial and Government Systems Division of the Eastman Kodak Company, my job was to develop a testing estimate for a program we were bidding for the Internal Revenue Service. Having built estimates previously for large, complex, testing programs, I knew that I needed a logical, structured list of tasks to form the basis of my estimate. I could then convert this task list into a work breakdown structure (WBS), and estimate the time to perform each task.

About this same time, I was reading Watts Humphrey’s fascinating book Managing the Software Process (Humphrey, 1989). Watts showed how to use Input-Process-Output (IPO) diagrams to document a process; I applied that technique to the testing process. That was the first formal documentation of the top levels of the model you will see described in this book. I published an article describing how aspects of this model could be used in estimating, in 1993 in the June issue of Ed Yourdon’s American Programmer newsletter (Yourdon, 1993).1 That’s one use of such a model. Over the years, I continued to refine the model until it became the fairly detailed model presented in this book.

Incidentally, our prime contractor accepted my estimate, and both it and the Internal Revenue Service accepted the overall estimate.

The first light bulb that lit as I began to learn about software testing is that testing has a life cycle that is closely linked to the software development life cycle. What seems like a logical truth in 2003 was a real revelation to many in the mid-1970’s. I still think that the “V-diagram” is a thing of beauty. The V-diagram is a means of illustrating the relationship between the concurrent software development and testing life cycles (see Figure 1-2 for one example of the V-diagram). Unfortunately, there are still a large number of people and corporations developing software who haven’t recognized this basic truth. We write a test plan while requirements are being developed. We then do test design and write test cases as the software design is being developed, and write test procedures during the coding phase.2 Execution of formal testing occurs following unit testing and integration testing.

The second light bulb that lit pertained to the critical importance of test planning, and the consequent need for “testable requirements.” Many good books have been written on these subjects (Gause and Weinberg, 1989; Wiegers, 1999), so I will not belabor the point here.

The third light bulb that was turned on was realizing that to properly estimate testing programs, we need a structured, internally consistent list of tasks that test engineers will perform on a specific program. Once such a list of tasks is in hand, we can then estimate each task individually to get a bottoms-up estimate for a testing program. And if we perform the same set of tasks (or a very similar set) on each program, we can begin to establish accurate metrics for how much our testing costs, and how long it can be expected to take.

In brief, what I am providing in this book is a soup-to-nuts list of tasks and processes for a program of formal software or system testing. If you are just starting to implement a testing process, you will not want to try to implement all parts of this model in one fell swoop; it would be too overwhelming and too costly. In later chapters, I suggest ways to implement this process in a prioritized, piecewise fashion.


There is no “one true way” to test software, so the goal of this book is to provide you with information that you can use to develop a formal testing process that fits the needs of you, your customers, and your organization.

Glenford Myers woke up the testing community in 1979 with his book The Art of Software Testing; he stated that the purpose of testing is to find errors, rather than to prove that a system works. Regardless of what your opinion of his thesis is, we test to see if we can find any problems with developed systems. A best-practices test process is performed throughout the duration of the development process. The test process puts appropriate emphasis on requirements testability, documentation prior to test execution, review of the documentation, systematic interface with the development community, and test execution according to the approved documentation. A series of tasks to accomplish this testing process is presented in this book.

In addition to defining the sequence of tasks in the testing process, I address interfaces between the formal testing group and the other organizations involved in the software development life cycle, including development engineers, managers, software quality engineers, and software configuration management personnel. All of these people have significant roles that must be performed in a quality manner to make the software development process and the software testing process work. One of the primary purposes of test documentation is communication with the other groups on the program, so we as test engineers must be sure to make these intergroup interfaces work. All of us should be aware that there’s a Level 3 key process area (KPA) in the Software Engineering Institute’s Capability Maturity Model (SEI-CMM) for Intergroup Coordination. Early in the development life cycle, test engineers and managers review program-level plans, including the Program Management Plan (PMP), the Configuration Management Plan (CMP), the Software Quality Assurance Plan (SQAP), and the Software Development Plan (SDP), or whatever you call these documents in your environment. During the requirements phase of the software development life cycle, test engineers review the requirements. Later in the life cycle, the groups that authored these plans and the requirements get to return the favor by reviewing the test plan. Test engineers review software design (and sometimes code) for input to their test designs, test cases, and test procedures. Once again, development engineers, QA staff members, and CM personnel should review the test designs, test cases, and test procedures. As has been shown in other reference materials (Wiegers, 2002), peer reviews minimize defects and cost-of-quality by finding defects as early as possible in the life cycle.

  • + Share This
  • 🔖 Save To Your Account