Abstract: Combinatorial testing could detect the faults triggered by the interactions among factors in software. But in many cases, the pair-wise, N-way and even the variable strength combinatorial testing may lead test suite redundancy and fault detect ability decreasing, because these methods do not make sufficient consideration on the actual factors interaction. In this paper, a new interaction relationship based combinatorial testing model was proposed to cover the actual factor interactions in software by extending the conventional combinatorial testing model and IO relationship testing model. The new method may be more effectively than existed combinatorial testing methods without decrease of the fault detect ability. Furthermore, two test suite generation algorithms for interaction relationship based combinatorial testing were also presented. Finally, we compared our algorithms with some similar test generation algorithms in IO relationship testing model, and the experience result showed the advantage of our algorithms.

Abstract: One possibility to make testing strategies more effective is to incorporate knowledge about the typical geometric structure of failure-causing inputs within the input domain into the test data selection. For example Adaptive Random Testing is a testing strategy which is based on the idea of failure-causing inputs being clustered within the input domain. So far, there has been no empirical quantification about the location and the geometric shape of failure-causing inputs. Thus it is currently unknown whether the encouraging results gained by Adaptive Random Testing hold true in general. This work aims at introducing an approach which makes it possible to verify the assumption of clustered failure patterns. Possibly it furthermore enables the improvement of current Adaptive Random Testing methods and the development of further black box testing strategies incorporating knowledge about location and shape of failure patterns into test data selection. Therefore metrics for location and shape of failure patterns are specified. They are based on methods from image analysis.

Abstract: Size of a software application testing project is determined, and person/hours required for the testing project is estimated. The software application is sized by counting the number of different parameter types that occur within testing activities associated with the application. The parameter type numbers are then divided by a scaling weight to arrive at a Testing Unit number, which is then divided by a Testing Unit rate, e.g., person hours associated with each testing unit, to arrive at an estimated testing project effort. Some embodiments include an uncertainty calculation that potentially increases testing time based on clarity of the project requirements, the tester familiarity with the application area and the tester familiarity with the domain. Some embodiments calculate separate testing project times for different phases of the testing project.

Abstract: Test suite optimization aims at satisfying all testing objectives with the least number of test cases. According to the given testing objectives, the reduced testing requirement set can improve the effectiveness and efficiency of test suite optimization. This paper proposes a testing requirement reduction model that can describe the interrelations among the testing requirements in detail. Based on the model, this paper presents a testing requirement reduction method to generate the reduced testing requirement set, which is the basis of test suite generation, reduction and optimization. The experimental results show that the method is helpful to generate the smaller test suite and it contributes to the systematic, reasonable and effective testing.

Abstract: Component-based software technology is expected to be an effective and widely used method of constructing software system. However, some specialties of component bring a great challenge for testing the systems built by externally-provided components, especially for regression testing. Built-in test design is a fairly effective way to improve component's testability. In this paper, we present an improved regression testing method based on built-in test design for component-based systems. It needs the mutual collaboration between the component developers and users. Component developers are responsible for analyzing the affected methods and constructing the corresponding testing-interfaces in the new component version, and then component users can conveniently pick out the subset of test cases for regression testing with these testing-interfaces. Through employing preliminary experiments on some medium scale systems, our regression testing method based on built-in test design has been proven to be fairly feasible and cost-effective in practice.

Abstract: In simulation-based verification, we check the correctness of a given program by executing it on some input vectors. Even for medium-size programs, exhaustive testing is impossible. Thus, many errors are left undetected. The problem of increasing the exhaustiveness of testing and decreasing the number of undetected errors is the main problem of software testing. In this paper, we present a novel approach to software testing, which allows us to dramatically raise the probability of catching rare errors in large programs. Our approach is based on the cross-entropy method. We define a performance function, which is higher in the neighborhood of an error or a pattern we are looking for. Then, the program is executed many times, choosing input vectors from some random distribution. The starting distribution is usually uniform, and it is changed at each iteration based on the vectors with highest value of the performance function in the previous iteration. The crossentropy method was shown to be very efficient in estimating the probabilities of rare events and in searching for solutions for hard optimization problems. Our experiments show that the cross-entropy method is also very efficient in locating rare bugs and patterns in large programs.We show the experimental results of our cross-entropy based testing tool and compare them to the performance of ConTest and of Java scheduler.

Abstract: This paper combines two distinct areas of research, namely software reliability growth modeling, and efficacy studies on software testing methods. It begins by proposing two software reliability growth models with a new approach to modeling. These models make the basic assumption that the intensity of failure occurrence during the testing phase of a piece of software is proportional to the s-expected probability of selecting a failure-causing input. The first model represents random testing, and the second model represents partition testing. These models provide the s-expected number of failures over a period, which in turn is used in analyzing the failure detection abilities of testing strategies. The specific areas of investigation are *) conditions that enable partition testing yielding optimal results, and) comparison between partition testing and random testing in terms of efficacy

Abstract: Some specialties of component, such as high evolvability, implementation transparent, and limited access support, bring a great challenge for testing the systems built by externally-provided components, especially for regression testing. Built-in test design is a fairly effective way to improve component's testability. In this paper, we present a built-in regression testing method to validate the change and its impact of component-based software, which needs the mutual collaboration between the component developers and component users. Through employing preliminary experiments on some medium scale systems, our regression testing method based on built-in test design has been proven to be feasible and practical. Although our method indicates the same precision as Orso et al. 's method at statement level, it needs less exchanged information (i.e., meta-data) and test scripts, so it is more cost-effective.

Abstract: Composition of software elements into assemblies (systems) is a fundamental aspect of software development. It is an important strength of formal mathematical specification that the descriptions of elements can be precisely composed into the descriptions of assemblies. Testing, on the other hand, is usually thought to be ‘non-compositional.’ Testing provides information about any executable software element, but testing descriptions have not been combined to describe assemblies of elements. The underlying reason for the compositional deficiency of testing is that tests are samples. When two elements are composed, the input samples (test points) for the first lead to an output sample, but it does not match the input test points of the second, following element. The current interest in software components and component-based software development (CBSD) provides an ideal context for investigating elements and assemblies. In CBSD, the elements (components) are analysed without knowledge of the system(s) to be later assembled. A fundamental testing theory of component composition must use measured component properties (test results) to predict system properties. This paper proposes a testing-based theory of software component composition based on subdomains. It shows how to combine subdomain tests of components into testing predictions for arbitrarily complex assemblies formed by sequence, conditional, and iteration constructions. The basic construction of the theory applies to functional behaviour, but the theory can also predict the system's non-functional properties from component subdomain tests. Compared with the alternative of actually building and testing a system, theoretical predictions are computationally more efficient. The theory can also be described as an exercise in modelling. Components are replaced by abstractions derived from testing them, and these models are manipulated to model system behaviour. This article replaces a previously published version. DOI: 10.1002/stvr.368. Copyright © 2007 John Wiley & Sons, Ltd.

Abstract: Since scan testing is not based on the function of the circuit, but rather its structure, this method is considered to be a form of over testing or under testing. It is important to test VLSIs using the given function. Since the functional specifications are described explicitly in the FSMs, high test quality is expected by performing logical testing and timing testing. This paper proposes two test generation methods, a fault-independent test generation method and a fault-dependent test generation method, for state-observable FSMs. We give experimental results for MCNC'91 benchmark circuits. The quality and cost of the logic testing and timing testing for proposed test generation methods was evaluated.

Abstract: The increasing complexity and number of digital forensic tasks required in criminal investigations demand the development of an effective and efficient testing methodology, enabling tools of similar functionalities to be compared based on their performance. Assuming that the tool tester is familiar with the underlying testing platform and has the ability to use the tools correctly, we provide a numerical solution for the lower bound on the number of testing cases needed to determine comparative capabilities of any set of digital forensic tools. We also present a case study on the performance testing of password cracking tools, which allows us to confirm that the lower bound on the number of testing runs needed is closely related to the row size of certain orthogonal arrays. We show how to reduce the number of test runs by using knowledge of the underlying system

Abstract: A method of testing and modifying software by forming blocks of code and adding a unique identifier to each block, and associating first data with at least one of the blocks. A corresponding image is associated with at least one of the blocks. The conditioned software can be used in association with an Automated Functional Testing Tool or Automated Performance Testing Tool to test software applications. Modifications to the automated test scripts are required only when a new behavior of an object on the GUI is introduced.

Abstract: Empirical studies report unsatisfactory fault detection of state-based methods in class testing and advocate the use of functional methods to complement state-based testing. In this paper, we take the view that the modest fault detection of state-based class testing reported in the literature is actually due to the inappropriate state diagram used. We show that functional testing of a class can be reduced to state-based testing, provided that the right state model is produced. We present a strategy for constructing a state diagram for a class method, based on a domain partition derived through functional techniques. We also describe a method for deriving test sequences from the resulting state diagrams, essentially a variant of the W-method. The paper also reports results from an experimental evaluation of the proposed approach, based on mutants generated by Mu- Java.

Abstract: By introducing the conceptions and principles of orthogonal experiment approach and describing its basic steps,this paper discusses how to choose an orthogonal table and the main steps of testing use case design.And a practical project is discussed to exemplify application of orthogonal experiment in project testing.

Abstract: In the industrial production, it is frequently needed to test the area of the irregular shape plane object. In this paper optical method is used to perform non-contact area measurement of random shape plane object testing and matrix CCD-computer system is combined to realize real time automatic measurement. In this paper principle and method for area measurement of arbitrary shape plane object using matrix CCD-microlens-compute system is present. Testing device is designed from the hardware and the software. At last the factors affecting on the accuracy are analyzed. By experiment, it is proved that this method processes fast speed, high accuracy and strong adaptability. The system makes on-line testing possible and may be applied in the modern industrial testing conveniently.

Abstract: Interaction testing is widely used to detect faults in software systems.In many applications where interaction testing is needed,the whole test set can not be run completely due to time or budget constraints.Under such situations,it is essential to prioritize the tests.In this paper,a greedy algorithm is adopted to prioritize generated pair-wise coverage test set with driven weights,so that whenever the testing is corrupted,interactions deemed most important are tested.

Abstract: Software compatibility testing is an important quality assurance task aimed at ensuring that component-based software systems build and/or execute properly across a broad range of user system configurations. Because each configuration can involve multiple components with different versions, and because there are complex and changing interdependencies between components and their versions, it is generally infeasible to test all potential configurations. Therefore, compatibility testing usually means examining only a handful of default or popular configurations to detect problems, and as a result costly errors can and do escape to the field This paper presents an improved approach to compatibility testing called RACHET. We formally model the configuration space for component-based systems and use the model to generate test plans covering user-specified portion of the space - the example in this paper is covering all it direct dependencies between components. The test plan is executed efficiently in parallel, by distributing work so as to best utilize test resources. We conducted experimentsand simulation studies applying our approach to a large-scale data management middleware system. The results showed that for this system RACHET discovered incompatibilities between components at a small fraction of the cost for exhaustive testing without compromising test quality

Abstract: Test case prioritization is an effective and practical technique that helps to increase the rate of regression fault detection when software evolves. Numerous techniques have been reported in the literature on prioritizing test cases for regression testing. However, existing prioritization techniques implicitly assume that source or binary code is available when regression testing is performed, and therefore cannot be implemented when there is no program source or binary code to be analyzed. In this paper, we presented a new technique for black box regression testing, and we performed an experiment to measure our technique. Our results show that the new technique is helpful to improve the effectiveness of fault detection when performing regression test in black box environment.

Abstract: One approach to testing concurrent programs is called reachability testing, which derives test sequences automatically and on-the-fly, without constructing a static model. Existing reachability testing algorithms are exhaustive in that they are intended to exercise all possible synchronization sequences of a concurrent program with a given input. In this paper, we present a new testing strategy, called t-way reachability testing, that adopts the dynamic framework of reachability testing but selectively exercises a subset of synchronization sequences. The selection of the synchronization sequences is based on a combinatorial testing strategy called t-way testing. We present an algorithm that implements t-way reachability testing, and report the results of several case studies that were conducted to evaluate its effectiveness. The results indicate that t-way reachability testing can substantially reduce the number of synchronization sequences exercised during reachability testing while still effectively detecting faults. Copyright © 2007 John Wiley & Sons, Ltd.