Reusable Test Cases Research Articles

A safe regression testing approach for safety critical systems

Regression testing is important activity during the software maintenance to deal with adverse effects of changes. Our approach is important for safety critical system as usually formal methods are preferred and highly recommended for the safety critical systems but they are also applied for the systems development of other than critical system. Our approach is based on Regression testing using VDM++ which takes two VDM++ specifications, one baseline and other delta (Changed) along with test suite for the baseline version. It compares both versions by using comparator module, identifies the change. By analyzing the change we classify the test cases from original test suite into obsolete, re-testable, and reusable test cases. Our scope is at unit level i.e. at class level. Our approach gets two versions of VDM++ specification and returns regression test suite for the delta version. Our approach distinguishes test cases which are still effective for the delta version of VDM++ specification and it differs from re-test all strategy as it can distinguish the test cases and identifies test cases which are useful for delta version. Test cases reusability and test case reduction is the main objective of our approach. Our approach presents how to perform regression testing using VDM++ specification during the maintenance of systems.

Bottom-up reuse for multi-level testing

Lifecycle models divide the test process into consecutive test levels that are considered independently. This strict separation obstructs the view on the test process as a whole and fails to reflect the commonalities across test levels. Multi-level testing is an emerging approach that addresses the challenge of integrating test levels, putting particular emphasis on embedded systems. In this paper, we introduce a test level integration strategy based on reuse that is called bottom-up reuse. In addition, we present a test level instrument that seamlessly supports this strategy: multi-level test cases. We also provide a case study that reflects the positive results we have obtained in practice so far and demonstrates the feasibility of our test level integration approach. Bottom-up reuse and multi-level test cases lead to testing earlier on in the development process while reducing the effort required by test specification, test design, and test implementation.

J2ME 기반 모바일 응용 소프트웨어 GUI 자동화 테스트 지원기

Recently, the most mobile application software developers are being faced by short developing time (fast time-to-market), various requirements and requirement changes. In order to overcome the environment, developer should support user friendly GUI and assure the quality from the early developing process using GUI test method. This paper proposes a test method and tool for mobile software GUI, which reduces test time and supports comfortable test environment by user oriented UI design. We implemented a tool based on test scenarios based image flow for high testing accuracy and test case reusability. And the results show the characteristics of the method compared to the existing tools.

Patterns: from system design to software testing

Design patterns are used extensively in the design of software systems. Patterns codify effective solutions for recurring design problems and allow software engineers to reuse these solutions, tailoring them appropriately to their particular applications, rather than reinventing them from scratch. In this paper, we consider the following question: How can system designers and implementers test whether their systems, as implemented, are faithful to the requirements of the patterns used in their design? A key consideration underlying our work is that the testing approach should enable us, in testing whether a particular pattern P has been correctly implemented in different systems designed using P, to reuse the common parts of this effort rather than having to do it from scratch for each system. Thus in the approach we present, corresponding to each pattern P, there is a set of pattern test case templates (PTCTs). A PTCT codifies a reusable test case structure designed to identify defects associated with applications of P in all systems designed using P. Next we present a process using which, given a system designed using P, the system tester can generate a test suite from the PTCTs for P that can be used to test the particular system for bugs in the implementation of P in that system. This allows the tester to tailor the PTCTs for P to the needs of the particular system by specifying a set of specialization rules that are designed to reflect the scenarios in which the defects codified in this set of PTCTs are likely to manifest themselves in the particular system. We illustrate the approach using the Observer pattern.

Estimating the coverage of the framework application reusable cluster-based test cases

Object-oriented frameworks support both software code and design reusability. In addition, it is found that providing class-based tests with the framework reduces considerably the class-based testing time and effort of the applications developed using the frameworks. Similarly, reusable cluster-based test cases can be generated using the framework hooks, and they, too, can be provided with the framework to reduce the cluster testing time and effort of the framework applications. In this paper, we introduce a methodology to estimate the possible coverage of the cluster-based reusable test cases for framework applications prior to suggesting and applying a specific technique to produce the test cases. An experimental case study is conducted to demonstrate the practical issues in applying the introduced methodology and to give insights on the possible coverage of the framework reusable cluster-based test cases. The results of applying the methodology on five framework applications show that, on average, the reusable cluster-based test cases cover at least one-third of the cluster testing areas of the interface classes created during the framework application engineering stage.

블랙박스 테스트 케이스의 리엔지니어링

Black-box testing needs to prepare fitting test data, execute software, and examine the result. If we test software effectively, not only selecting test cases but also representing test cases are important. In static testing effectiveness of testing activities also depends on how to represent test cases and checklist to validate. This paper suggests a method for finding ineffective critical test cases and reengineering them. An experiment of reengineering digital set-top box software shows the process and results of checking effectiveness and conformance of current test cases and patching test cases. The result shows how much save the test time and improve test coverage by reengineering test cases. Methods of reuse and restructuring test cases are also studied to fit into embedded product-line software.

Reusing class-based test cases for testing object-oriented framework interface classes

An application framework provides a reusable design and implementation for a family of software systems. Frameworks are introduced to reduce the cost of a product line (i.e., family of products that share the common features) and to increase the maintainability of software products through the deployment of reliable large-scale reusable components. A key challenge with frameworks is the development, evolution and maintenance of test cases to ensure the framework operates appropriately in a given application or product. Reusable test cases increase the maintainability of the software products because an entirely new set of test cases does not have to be generated each time the framework is deployed. At the framework deployment stage, the application developers (i.e., framework users) may need the flexibility to ignore or modify part of the specification used to generate the reusable class-based test cases. This paper addresses how to deal effectively with the different modification forms such that the use of the test cases becomes easy and straightforward in testing the framework interface classes (FICs) developed at the application development stage. Finally, the paper discusses the fault coverage and experimentally examines the specification coverage of the reusable test cases. Copyright © 2005 John Wiley & Sons, Ltd.

Empirical studies of test‐suite reduction

AbstractTest‐suite reduction techniques attempt to reduce the costs of saving and reusing test cases during software maintenance by eliminating redundant test cases from test suites. A potential drawback of these techniques is that reducing the size of a test suite might reduce its ability to reveal faults in the software. Previous studies have suggested that test‐suite reduction techniques can reduce test‐suite size without significantly reducing the fault‐detection capabilities of test suites. These studies, however, involved particular programs and types of test suites, and to begin to generalize their results, further work is needed. This paper reports on the design and execution of additional studies, examining the costs and benefits of test‐suite reduction, and the factors that influence these costs and benefits. In contrast to previous studies, results of these studies reveal that the fault‐detection capabilities of test suites can be severely compromised by test‐suite reduction. Copyright © 2002 John Wiley & Sons, Ltd.

Intelligent Test Plan Metrics on Adaptive Use Case Approach

This paper describes a design driven approach to drive intelligent test plan generation based on adaptive use case (3,5). Its foundation is an object-oriented software design approach which partitions design schema into design architecture of functional components called “design component”. A use case software development methodology of adaptive use case approach developed in I.I .T is employed which preserves this unit architecture on through to the actual code structure. Based on the partition design schema produced during the design phase of this methodology, a test plan is generated which includes a set of component and scenario based test. A software metric is introduced which produces an ordering of this set to enhance productivity and both promote and capitalize on test case reusability, This paper contains an application that illustrates the proposed approach.

Testing z/OS: The premier operating system for IBM's zSeries server

The “z” in zSeries™ stands for zero down time. As businesses have come to rely more and more on the continuous availability of their largest systems, the verification techniques used by IBM in developing those systems have had to evolve. Methodologies, techniques, and tools need continuous enhancements to develop the necessary verification processes that support development for a “zero down time” system. This paper describes the verification methodologies used in z/OS™ development, as well as test technologies and techniques. Special attention is paid to tool and test case reuse, and to techniques for testing for data integrity and system recovery. We also explain how these methodologies can be used for both traditional on-line transaction processing and newer Web-based or distributed applications.

An empirical study of regression test selection techniques

Regression testing is the process of validating modified software to detect whether new errors have been introduced into previously tested code and to provide confidence that modifications are correct. Since regression testing is an expensive process, researchers have proposed regression test selection techniques as a way to reduce some of this expense. These techniques attempt to reduce costs by selecting and running only a subset of the test cases in a program's existing test suite. Although there have been some analytical and empirical evaluations of individual techniques, to our knowledge only one comparative study, focusing on one aspect of two of these techniques, has been reported in the literature. We conducted an experiment to examine the relative costs and benefits of several regression test selection techniques. The experiment examined five techniques for reusing test cases, focusing on their relative ablilities to reduce regression testing effort and uncover faults in modified programs. Our results highlight several differences between the techiques, and expose essential trade-offs that should be considered when choosing a technique for practical application.