Test Case Reduction Research Articles

Clustering Analysis of Function Call Sequence for Regression Test Case Reduction

Regression test case reduction aims at selecting a representative subset from the original test pool, while retaining the largest possible fault detection capability. Cluster analysis has been proposed and applied for selecting an effective test case subset in regression testing. It groups test cases into clusters based on the similarity of historical execution profiles. In previous studies, historical execution profiles are represented as binary or numeric function coverage vectors. The vector-based similarity approaches only consider which functions or statements are covered and the number of times they are executed. However, the vector-based approaches do not take the relations and sequential information between function calls into account. In this paper, we propose cluster analysis of function call sequences to attempt to improve the fault detection effectiveness of regression testing even further. A test is represented as a function call sequence that includes the relations and sequential information between function calls. The distance between function call sequences is measured not only by the Levenshtein distance but also the Euclidean distance. To assess the effectiveness of our approaches, we designed and conducted experimental studies on five subject programs. The experimental results indicate that our approaches are statistically superior to the approaches based on the similarity of vectors (i.e. binary vectors and numeric vectors), random and greedy function-coverage-based maximization test case reduction techniques in terms of fault detection effectiveness. With respective to the cost-effectiveness, cluster analysis of sequences measured using the Euclidean distance is more effective than using the Levenshtein distance.

Maximal Frequent Sequence Based Test Suite Reduction through DU-pairs

The current paper illustrates the importance of clustering the frequent items of code coverage during test suite reduction. A modular Most maximal frequent sequence clustered algorithm has been used along with a Requirement residue based test case reduction process. DU-pairs form the basic code coverage requirement under consideration for test suite reduction. This algorithm farewell when compared with few other algorithms like Harrold Gupta and Soffa (HGS) and Bi-Objective Greedy (BOG) algorithms and Greedy algorithms in covering all the DU-Pairs. The coverage criteria achieved is 100% in many cases, except for few insufficient and incomplete test suites. DOI: http://dx.doi.org/10.15181/csat.v2i1.396

Regression Testing Prioritization, Selection and Reduction using Hybrid Criteria

Regression testing is a software testing technique. Testing and validating the part of code are the activity performed within different phases. Tasks of regression testing are: Test Case Prioritization, Test Suite Selection, Test case reduction which give the guarantee that no intended fault is produced while modifying the code. This paper hybrid all the criteria’s in different prospective with existing techniques. Selecting and choosing minimum number of test cases according to the result is our major goal. It will give solution to certain unnecessary results found after testing that further seem to be diminished in execution time. In our work we are formulizing the swarm algorithm for hybrid criteria. Hybrid criteria use Rank, Merge and Choice for building the test cases from test suite for minimizing the redundancy. Branch technique is used if one of test cases fails or does not show any result then next option can be used. Swarm algorithms give additional functions for having effective result with less time and effort. Initial seed value for hybrid criteria’s is taken randomly. This research will lead to give better efficiency in regression testing using hybrid criteria. Path Coverage deals with the test case selection as it gives all the details of test cases. General Terms Event Coverage, Statement Coverage, Execution Time, Fault Detected, Priority, ACO

A Survey of Automated Software Fault Localization Approach

Software testing run through the entire software development cycle, which consumes more than 50% of the development and maintenance effort. Fault localization is the most difficult and time-consuming task in software testing. Aimed at locating faults automatically in software, fault localization approach locates faults by running suitable test cases, so the quality of the test cases determines the effectiveness of fault localization. Therefore, the studies on test cases reduction approach for fault localization, automated fault-localization approach with high error-detection ability, and fault comprehension approach to help programmers understand the reason why a faulty statement cause failures have great significance for software testing and development. In this paper, the test cases reduction, fault localization, fault comprehension methods and their limitations are analyzed and summarized, and the future developing trend are discussed at last.

Test Exude: Approach for Test Case Reduction

Software development is a planned and structured process includes research, new development, modification, re-engineering results in software products. The structure of development of software is SDLC. It contains various process and activities to accomplish the task of the software product. In SDLC, testing is the most expensive phase. It is used to validate the software with all possible combinations. Exhaustive testing is impossible task in software testing, as, it is impractical with large software products. Now, automation is applied to generate the test cases for various applications, but the selection and reduction of test cases by automation is the main problem. This target only be achieved, when test cases is contained in large test suites. The technique we propose for test case reduction, called TestExude. It is a technique which gives test cases needed and discard other test cases from the Test Suite. It reduces the redundant test cases and its corresponding elements. This technique works on frequency of test cases in test suite and accepts largest frequency occurred in test suites and discard test cases on the base of frequency selected. Storage is well managed in this technique by reducing the test cases drastically in test suite. Test Suites size, user time, organization cost, storage cost are reduce efficiently. Ultimately, it improves and generate effective test case. This technique is more advantageous than any other techniques as it reduces the cost and time to its minimum extent.

Improving Fault Detection Capability Using Coverage Based Analysis

A test suite for a system consists of several test cases and as the number of test cases is more, execution of all of these will take much time. If the number of test cases are reduced the execution time could be reduced. Moreover, if the execution of these is done in an ordered fashion ,it is observed to give an increased rate of fault detection. This can further be beneficial by providing feedback to system developers , improving fault fixing activity and thus ,software delivery. The reduction of test cases can be done in several ways. But the scenario is different when functional dependencies exists between some test cases, that is, one test case is needed to be executed before another. In this paper, two test case reduction techniques will be presented which will be followed by using the dependency information from a test suite. The first reduction technique considers all of the test cases while the second one is applied on the rejected suite obtained after implementing the first technique. This work is actually based on the hypothesis that lesser number of test cases will reduce the execution time, provided that the reduced test suite contains cases which collectively will cover the testing of every statement in the source code. Existing dependencies between different tests represent the interaction in the system under test, and hence, execution of complex instructions earlier is supposed to increase the fault detection rate, compared to arbitrary or untreated test orderings. Thus, the dependency information could further be used for prioritization of the test cases.

面向需求覆盖的航天软件测试用例优化方法

An approach to optimize the aerospace software test cases based on the requirement coverage is researched in this paper to improve the efficiency of the software testing and increase the effectiveness of aerospace software testing. It is composed of the reduction and design of test cases, and has been used in a test of aerospace project. Firstly, the characteristics, testing process, and optimization techniques of aerospace software are analyzed. Then, a method to reduce test requirements is improved to simplify the test requirements. Furthermore, a design of test cases based on the correlative keywords of requirements is given, and the requirement coverage is achieved. Finally, the optimizing approach is applied in the test of aerospace software. The results of application show that the method can not only satisfy the demand of requirement coverage, but also make the workload of designing test cases reduce by 39%. The method ensures testing adequacy, and improves the test efficiency greatly.

An Automated Sequence Model Testing (ASMT) for Reducing Test Suit Size

uality assertion of software is primarily done by means of testing an activity that faces constraints of both time & resources. Conventional testing strategies required the heavy resources & it can be done after the complete code is developed. So to apply some changes after the development requires lots of effort & cost. It also affects the time of deployment. So model based testing is a well accepted & dynamic approach for quality improvements because it provides affecting error detection at very low cost. It gives scalable & systematic solution to the test case reduction problem. To better understand the need of this early test case generation overall scenario of collaboration & development strategies is to be considered. The best way to get better knowledge of internal structure design models is the best option. Thus in this work we are focusing our research on path based testing by which internal structure of complete design can be verified & tested. Model based testing on path coverage is applied with standard coverage criteria for the large software's & generates larger test counts. Our aim is to reduce those test counts with maximum coverage of testing at the early phases of SDLC even before the actual development starts. This paper proposes a novel automated sequence model based testing (ASMT) approach selects the test criteria based on UML diagram like activity, sequence, class etc. It applies the criteria with generation modules to create novel test cases. The typical deployment of ASMT goes through five stages: setting up test criteria, test model designing, test suite creation, performing test & analyzing the result. Thus by combining all the above methods improved test strategies can be designed. At the initial level of our research the approach seems to be better that others & will proves its effectiveness in future implementation.

Regression Test Suite Reduction using an Hybrid Technique Based on BCO And Genetic Algorithm

Regression testing is a maintenance activity that is performed to ensure the validity of modified software. The activity takes a lot of time to run the entire test suite and is very expensive. Thus it becomes a necessity to choose the minimum set of test cases with the ability to cover all the faults in minimum time. The paper presents a new test case reduction hybrid technique based on Genetic algorithms(GA) and bee colony optimization (BCO) .GA is an evolutionary algorithms (EA), which generate solutions to optimization problems using techniques inspired by natural evolution, such as inheritance, mutation, selection, and crossover. BCO is a swarm intelligence algorithm. The proposed approach adopts the behavior of bees to solve the given problem. It proves to be optimistic approach which provides optimum results in minimum time.

A Novel Technique for Generation of Test Cases based on Bee Colony Optimization and Modified Genetic Algorithm (BCOmGA)

Software testing is the most important phase of software development life cycle which ensures the quality of software systems. This paper proposes a novel approach for generation of test cases from “Unified Modeling Language” (UML). The Test Case Selection and Reduction is done by using Stratified Sampling, Bee Colony Optimization and Genetic Algorithm. This aims to save cost, time and effort by efficiently minimizing the test suite to ensure maximum coverage. We have applied this technique to a module of a Card Administration System project taken from Software Company. The result shows that the proposed approach effectively detects all the flaws by covering all possible paths of the system. The proposed software testing technique (BCO-mGA) ensures maximum coverage in minimum possible timeframe by executing the final minimized test suite.

Identification and deletion of duplicate subtrees in classification tree for test case reduction

Among the many widely used specification-based testing techniques, classification tree method CTM is one of the most acclaimed methods, to generate test cases from the functional specification. While integrating applications, there may be a possibility for the occurrence of duplicates, which affects the performance improvement of integrated applications IAs. To test such applications, CTM can be used to generate test cases. A classification tree, thus generated for this application may have duplicate subtrees and test cases generated from this classification tree may also have redundant test cases. Thus, the existence of duplicate subtrees affects the quality and effectiveness of the classification tree. This paper concentrates on identifying duplicate subtrees through searching techniques and also proposed an enhanced duplicate terminal subtree deletion algorithm, which helps to reduce the number of redundant test cases. Finally, this paper compares the proposed algorithm with the existing one using case studies.

Test Cases Reduction and Selection Optimization in Testing Web Services

Software testing in web services environment faces different challenges in comparison with testing in traditional software environments. Regression testing activities are triggered based on software changes or evolutions. In web services, evolution is not a choice for service clients. They have always to use the current updated version of the software. In addition test execution or invocation is expensive in web services and hence providing algorithms to optimize test case generation and execution is vital. In this environment, we proposed several approach for test cases' selection in web services' regression testing. Testing in this new environment should evolve to be included part of the service contract. Service providers should provide data or usage sessions that can help service clients reduce testing expenses through optimizing the selected and executed test cases.

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.

Toward A Theory of Test Case Reduction in Specification Based Software Testing

During the software development, numbers of mistakes are committed by software developers consequential to the insertion of a number of faults in the program. The behavior of a faulty program may be different from expected one. Since testing to detect all imaginable faults is impossible because of large numbers of test cases are required. Fault based testing strategies detects only pre-defined types of faults. Kuhn's fault class hierarchies provide the focus of fault-based testing strategies on detecting particular faults. We have purposed supplementary fault detection strategies by considering Coupling Effect Hypothesis and the Competent Programmer Hypothesis to detect faults with small number of test cases. Our results extend Kuhn's fault class hierarchy combine with Black's fault detection strategies that provide a focus on testing strategies for detection of faults. The resulting tests are also effective for detecting faults in other classes with the sane test cases.

An Equivalent Division Method for Reducing Test Cases in State Transition Testing of MANET Protocols

A typical feature of MANETs is that network topology is dynamically changed by node movement. When we execute state transition testing for such protocols, first we draw the Finite State Machine (FSM) with respect to each number of neighbor nodes. Next, we create the state transition matrix from the FSMs. Then, we generate test cases from the state transition matrix. However, the state transition matrix is getting much large because the number of states and the number of transitions increase explosively with increase of the number of neighbor nodes. As a result, the number of test cases increases, too. In this paper, we propose a new method to reduce the number of test cases by using equivalent division method. In this method, we decide a representative input to each state, which is selected from equivalent inputs to the states. By using our proposed method, we can generate state transition matrix which is hard to affect increasing the number of neighbor nodes. As a consequence, the number of test cases can be reduced.

Analysis and representation of test cases generated from LOTOS

This paper presents a method to generate, analyse and represent test cases from protocol specification. The language of temporal ordering specification (LOTOS) is mapped into an extended finite state machine (EFSM). Test cases are generated from EFSM. The generated test cases are modelled as a dependence graph. Predicate slices are used to identify infeasible test cases that must be eliminated. Redundant assignments and predicates in all the feasible test cases are removed by reducing the test case dependence graph. The reduced test case dependence graph is adapted for a local single-layer (LS) architecture. The reduced test cases for the LS architecture are enhanced to represent the tester's behaviour. The dynamic behaviour of the test cases is represented in the form of control graphs by inverting the events, assigning verdicts to the events in the enhanced dependence graph.