Common Test Patterns and Reuse of Test Designs
Mark Folkerts, Tim Lamey, and John Evans
Summary: The traditional test-design process is very repetitive, yet many testing problems have generic elements that easily could be reused in the creation of subsequent test designs. This article suggests that you capture these patterns, and use them to simplify the creation of subsequent test designs. (7 printed pages)
Enumeration of Things to "Cover"
Generic Test-Design Templates
Convergence of Concepts
Test-Design Reuse Summary
The usual test-design process is very repetitive, yet many testing problems have generic elements that you can reuse easily in the creation of later test designs. You can capture these patterns, and use them to simplify the creation of later test designs.
One problem that still limits effectiveness and efficiency in the testing of applications is that a usual development-and-test cycle involves a lot of creation of test-design details from scratch, and in a somewhat ad-hoc manner, whenever a new set of application features is defined. The primary tool often is an empty test-design template, which includes categories of test issues to address, and enumeration of test specifications or test-case details that are based on feature functional specifications.
If viewed across a series of project cycles, test-design activities are one area in which there is a lot of repetition: Test engineers start with a blank page in a test-design specification and fill it in detail by detail, when many of these issues are generic and common to nearly every application-testing scenario.
A goal of the test-design process should be to reduce ad-hoc reinvention of test designs by capturing and reusing common test patterns.
The recognition of test patterns is loosely similar to design patterns that are used in software development. (There are also some classic object-oriented design patterns that might be suitable for test-automation design, but we do not address those patterns here directly.) Creating test designs by reusing patterns can cover repetitive, common core verification of many aspects of an application. This frees the test engineer to focus more time and thought on truly unique aspects that are particular to an application, without having to waste effort on definition of the more generic portions of the test design.
Just as developers who are writing software strive to minimize the code that they reinvent or create from scratch by using existing functionality for common, generic, or repeated operations, so too should test engineers strive to minimize the amount of time that they spend on defining test cases and verification steps for functionality that is common to every application with which they are presented. Test engineers should be able to reuse the full and rich set of tests that previously have been identified for similar situations.
Experienced, expert testers often approach these issues by applying their knowledge and past experience as heuristics to recognize what test situations align with techniques, test issues, and test approaches. When they see a given test situation, they immediately identify a method of testing that is appropriate and applicable. Novices, on the other hand, are likely to be unaware of all of the issues or pitfalls that are associated with the situation or the test conditions that should be applied.
In addition, expert knowledge is not captured explicitly into a highly transferrable format for the novice to be able to take advantage of it, and it often can be lost to the team when the expert has moved on.
An underused tool that provides the first step in capturing product-testing experience is the checklist. Checklists make the thought process and accumulated ideas explicit for reuse at a later time by the same or another test engineer. Often, they are lists of heuristics and pneumonic devices that should be applied to the testing and verification process, to avoid forgetting any obvious tests. Effective checklists in this context are abstracted so that they are applicable to multiple projects or applications. The appropriate level of abstraction is to:
- Check each entry field that has maximum-length string data.
- Check each required field that has null data.
- Challenge type-checking validation of each field that has data of a different type from what is allowed.
- Test for all data values that are simultaneously maximized or most stressful.
- Verify that the nominal value of data is accepted, stored, retrieved, and displayed.
Unfortunately, generic and feature-specific test objectives often are jumbled together, without thought being given to reuse; the generic aspects of the design are buried in the specifics, and the value for reuse is reduced.
Successful tests are ones that find problems; the problems that are found often are due to timeless mistakes and common failure modes. Some problem areas have classic errors in implementation; some conceptual designs have classic mistakes that are associated with them; some technologies have inherent flaws or limitations; some failures are critical or important, and must be validated; and some error-handling consistently is neglected.
The test-design processes of expert testers often rely, in part, on experience about things that have gone wrong in the past. However, this past experience is not included in any functional specification for a product, and therefore is not called out explicitly to verify. The experience of an expert tester can be captured and turned into valuable test-design heuristics.
Testing is organized often around failure modes, so that enumeration of failure modes is a valuable portion of test design. Lack of anticipation of new, novel, or infrequent failure modes is the prime source of test-escapement problems, where bugs are not detected during testing phases, but affect customers who use the application. Often, these bugs are the result of failure modes that could have been anticipated—based upon past product-testing experience—but the experience was not captured, shared, or known to a novice tester. An easy way to avoid this problem is to write generic specifications for common failure modes, convert them into test conditions to verify or validate, and concatenate this to any test-design template.
Enumeration of Things to "Cover"
A useful approach to the multidimensional, orthogonal nature of test planning is to identify categories of tests that have strong conceptual relationships, and then use those subsets to ensure that testing completeness is achieved in each category. One concept that is helpful is to break the problem into distinct manageable categories, based on the idea of "coverage." In this case, the concept of coverage can be applied in a more generic, broadly applicable form than the specific techniques that are used to identify untested areas of the code (such as the metrics that are collected with code-coverage toolsets).
The key part of this analysis process is to create as many separate categories of things that can be "covered" as possible. Iterate in each category, to build lists of test items that should be covered. Common categories to use as a starting point for the process are user-scenario coverage, specification-requirement coverage, feature coverage, UI control coverage, field coverage, form coverage, output/report coverage, error coverage, code coverage, condition coverage, and event coverage.
The concept can be extended to many other areas. Identification of a number of test categories aids the analysis and design process that often is applied to requirements review for test identification. Having a formalized set of categories allows the test engineer to decompose requirements into testable form, by dividing the problem into testable fragments or test matrices across a number of dimensions.
Generic Test-Design Templates
Test-design specification templates should be expanded beyond the typical empty-document sections to fill in, to include generic validation rules, test-case checklists, common failure modes, and libraries of generic tests. The templates should include many of the usual tests for application features, so that they do not have to be added or reinvented. Part of this generic design should implement "boilerplate" tests that will be the first ones that every testing effort should include, even before considering more sophisticated and instance-specific tests. In this way, the generic test-design specifications allow any tester—for example, a new contingent staff member—to perform a range of generic tests, even before any customized, application-specific test planning.
Test automation—especially, when it is applied (as usual default) as regression test automation—suffers from static test data. Without variation in the data or execution path, bugs are located with decreasing frequency. The paradox is that the reduction in bugs that are found per test pass is not representative of the total number of bugs that remain in the system. Bugs are only less common on the well-exercised code paths that are represented by the static data. Bugs that remain in untested areas of the application are resistant to the testing methods (the automation pesticide paradox).
The lack of variation sometimes can improve the stability of the test code somewhat, but at the detriment of good test coverage. Effectiveness of testing—as measured in the detection of new bugs—is improved significantly by the addition of variation, each test pass using different values of data within the same equivalence class. Automation should be designed so that a test-case writer can provide a common equivalence class or data type as a parameter, and the automation framework will vary the data randomly within that class and apply it for each test run. (The automation framework should record the seed values or actual data that was used, to allow reruns and retesting with the same data for debugging purposes.)
In some cases, working with dynamically selected input data can be problematic because determining the expected outcome might be difficult (the Oracle problem). However, in many cases, there are tests that can be selected and verified automatically, even without requiring sophisticated approaches to determine the correct test output for a particular input.
Test-automation strategies too often are based solely on the automation of regression tests, putting all of the eggs in that basket alone. This is analogous to buying insurance to protect against failures that are due to regression: It is expensive, and it mitigates failures in the areas that the insurance (automation) covers, but it does not reduce or prevent the problem in uninsured (unautomated) portions of the application. Wise insurance-purchasing strategies usually are based on the selection of the optimum amount, and not on the spending of all available resources on a gold-plated, zero-deductible insurance policy. In testing terms, some teams spend too much time on automation—at the expense of lost mindshare that could be dedicated to other types of testing, and putting their projects at increased risk of detecting only a small portion of the real problems.
The cost/benefit ratio of test automation can be tilted in a positive direction by concentrating on adding stability to development processes, identifying sources of regression failures, and fixing them systematically. When pursued with vigor, it soon becomes inappropriate to over-invest in a regression test-automation strategy, and much more important to invest in other more leveraged forms of test automation. Otherwise, the dominant problem changes quickly from creating tests to find bugs to trying to manage and maintain myriad redundant, overlapping, obsolete, or incorrect regression test cases.
A regression-focused approach can result in automated tests that are too static. The cost/benefit ratio is marginal for these tests, when all of the maintenance and management costs are taken into account; they do not find many bugs. If test systems are designed to challenge dynamically the full range of data-dependent failures, alternate invocation modes, and number iterations, they can accomplish much more than regression testing.
By increasing the abstraction of test automation to "find all strings on the form and test them with all generic tests (apply random data variations until an error occurs or 100,000 conditions are tried)" and running the tests continually, testing is elevated from a marginally valuable static regression suite to a generic tool that has a much higher probability of adding value to the project. (This has the added benefit of providing technical opportunities for extending Software Test Engineers, instead of just chaining them to a desk to maintain legacy automation.)
The other benefit of higher-level abstraction and making tests more generic is efficiency; adding test cases should be simple and quick, and not require hours of custom test-case coding of minutiae. Having test automation designed at the level of "test this control()"—instead of 50 lines of "click here, type this, wait for this window"—empowers a broad range of testers to automate tests and focus efforts on planning meaningful tests, instead of having to slog through the implementation details of simplistic scenarios that are coded against poorly abstracted test frameworks.
Convergence of Concepts
There are many useful approaches that are being applied to well-designed tests and can contribute to the reuse of test design:
- Equivalence-Class Partitioning
- Boundary-Value Conditions
- Strong Data Typing
- Design Patterns
- Model-Based Testing
- Test Oracles
- Test-Data Generators
One of the benefits of reusable test design is that you can take advantage of the convergence of these concepts and apply the results, so that they improve the cost/benefit ratio of test efforts on future projects. All of these techniques have elements to contribute to raising test-design abstraction—improving reuse, reducing reinvention, elevating the sophistication of tests, and extending the reach of Software Test Engineers.
Test-Design Reuse Summary
- Reduce ad-hoc reinvention of test designs by capturing and reusing common test patterns.
- Recognize and abstract test issues, and capture them in a form that can be reapplied as a higher level chunk of activity, instead of always dropping down to the detailed instance level.
- Treat past test designs essentially as individual instantiations of a generic test-design "class."
- Institutionalize, "package," or "productize" the results and experience of past test-design work into a reusable deliverable that can be applied to similar test efforts.
- Create checklists of generalized "things to test" that will be a resource for reuse on future versions or applications. These generalized tests augment the separate list of feature details (most often, business rules) and associated tests that truly are unique to a specific project.
- Enumerate common and generic failure modes as items to verify, and make them part of test-design templates.
- Enumerate and document explicit test "coverage" categories, so that they can be incorporated into analysis and test design.
- Ensure that each category contains as complete a set of tests as possible to ensure coverage of the category. Divide the results into generic and unique subsets of tests. Reuse the generic portions of these lists for future efforts.
- Test-design specification templates should be expanded beyond empty-document sections to fill in, to include generic validation rules, test-case checklists, common failure modes, and libraries of generic tests.
- Avoid the pesticide paradox by using a test infrastructure that provides for flexible data-oriented testing at the equivalence-class or data-type level, instead of supporting only specific, handcrafted test cases. Varying the test data and the paths of execution will increase the probability of detecting new bugs.
The following are a few frequently occurring test-design patterns that are suitable for reuse.
- Identify a record or field upon which to operate (based on input name and parameter info).
- Generate randomized item from equivalence classes.
- Verify nonexistence.
- Add item.
- Read and verify existence of identical unchanged data.
- Modify and verify matching modified data.
- Delete and verify removal of item.
Data-Type Validation Pattern
- Identify item with type characteristics (for example, a data field) at an abstract level; this should not be limited to simple data types, but should include common business data types (for example, telephone number, address, ZIP code, customer, Social Security number, calendar date, and so on).
- Enumerate the generic business rules that are associated with the type.
- Define equivalence partitions and boundaries for the values for each business rule.
- Select test-case values from each equivalence class.
Input Boundary Partition Pattern
- Enumerate and select an input item.
- Select a "valid" equivalence partition.
- Apply a lookup or random generation of a value within that partition, and use it for test.
- Identify a system response to verify.
- Identify a stress axis (for example, number of items, size of items, frequency of request, concurrency of requests, complexity of data structures, and dimensionality of input).
- Identify a starting level of stress.
- Verify and measure system response.
- Increase stress, and repeat cycle until system response fails.
- Switch to another stress axis.
- Increase the level of that axis until failure.
- Additionally, add concurrent stress axes.
- Increase the number of concurrent axes until failure.
Heuristic of Error-Mode Detection Pattern
- Enumerate past human-error modes.
- Select a mode that has observed recurrence.
- Identify a scope in which the failure mode might apply, and routinely test for that failure until you are convinced that it is not manifested.
File Test Pattern
- Identify and define files and file semantics to be evaluated.
- Enumerate failure modes for files.
- Identify system response for each failure mode to verify (create an Oracle, list).
- Select each failure mode, and apply it in turn to the designated file.
- Verify response.
Generic Window UI Operations
- Validate modality.
- Validate proper display and behavior when on top or behind.
Testers should build test designs around reusable test patterns that are common to a large number of application-testing problems. The inclusion of these patterns as a standard part of the test-design template reduces the time that is spent on test design, by eliminating the need to start with a blank test-design specification. Reuse of these patterns has the added benefit of codifying expert-tester knowledge, so as to increase the likelihood of catching common failures.