Search

As a result of late detection and resource limitations during any software evaluation, there have been several software-related breakdowns or malfunctions. Many people have begun focussing on the test cases or alternatively the priority of validation suites after identifying the difficulties in the regression testing process of any product. The test case prioritisation technique is presented as a solution to this problem. It increases the fault detection rate. Earlier research studies have been implemented many techniques, but the rate of fault detection is not up to the mark. To overcome this drawback, we proposed HOTCP (Hybrid Optimal Test Case Prioritisation with Multi-Objective Constraints) model, which includes two steps: first is test case generation and the next one is test case prioritisation. The test case is generated from the released software. Consequently, test case prioritisation will be done by the optimisation strategy, in which the multi-objective function will be defined based on the constraints like statement coverage, branch coverage, contribution index and fault exposing potential. For this optimisation process, a new algorithm is proposed termed as CCCOA (Customised Coot and Chimp Optimisation Algorithm). The COOT optimisation and Chimp optimisation algorithms are combined in this algorithm. The system produces prioritised test cases, and the performance of the proposed method is validated in comparison to the traditional methods in terms of several metrics. [ABSTRACT FROM AUTHOR]

Considering the testing process of the software system as a stochastic process is a primary approach to the software reliability modeling technique. Besides some popular distributions, the Poisson distribution has been considered the best based on its advantage when modeling the times at which arrivals enter a system. In the non-homogeneous Poisson process group of models, the S-shaped function is a value curve with many good results. This paper proposes a new imperfect debugging software reliability model based on (1) an Imperfect debugging assumption (the testing process could cause new faults); and (2) the Fault detection rate can be controlled more effectively by the appearance of a growth-rate-controller. The real data from industrial projects verify the application of this model based on good popular criteria values. [ABSTRACT FROM AUTHOR]

Due to the increasing reliance on technology in nearly every industry over the past three decades, it has become necessary to evaluate the performance of a software product prior to its formal release in the market. The properties of a software application, such as its complexity and lines of code, are subject to change over time as a result of factors namely the testing environment, allocation of resources, testing efficiency, and testing team's expertise. The assumption of constant Fault Detection Rate (FDR) may not accurately anticipate the  potential number of bugs correctly. Keeping all these considerations in mind, a framework is developed to incorporate change point in the development of a testing effort-based Software Reliability Growth Model (SRGM) that takes into account the effect of application characteristics under both perfect and imperfect debugging settings. In addition, these outcomes are compared to the model without a change point. The proposed model is validated on two real-life software fault datasets. The results demonstrate that the proposed model performs better than the model without a change point. [ABSTRACT FROM AUTHOR]

March algorithms are widely used in Memory Built-In Self-Test (MBIST) on-chip memory testing, providing linear test complexities that reduce the test time and cost. However, studies show that March algorithms with complexities lower than 18N have poor coverages of faults that have emerged with the advent of the nanometer process technologies and are more relevant to nowadays memories. New March AZ1 and March AZ2 algorithms, with 13N and 14N complexities, respectively, were introduced to provide optimum coverage of those faults and to produce a shorter test than an 18N-complexity test algorithm with a lesser area overhead, thus reducing chip manufacturing costs. This paper presents the implementation and validation of MBIST controllers that applied the March AZ1 and March AZ2 algorithms in a Field-Programmable Gate Array (FPGA) device. They were implemented in the Intel Max 10 DE10-Lite FPGA Development Board. A test generator was built in FPGA, as an alternative to the external tester, to provide test vectors required in initiating the test on the memory model using the implemented MBIST. The FPGA experimental tests demonstrated that they function correctly as the expected test sequences were observed. In addition, their fault detection abilities were also validated through tests on a fault-injected memory model, which shows that the implemented March AZ1 and March AZ2 provide 80.6% and 83.3% coverage of the intended faults, respectively, which outperform any other existing 14N-complexity March algorithms. [ABSTRACT FROM AUTHOR]

The efficiency and performance of a software application largely depend on the testing strategy adopted by the firm. Apart from the tools, techniques, and skills used for testing, the duration also plays an important influence in establishing software reliability. This defines the operational performance of the software. The testing duration decision is dependent on the failure behavior depicted by the software during the process of testing and the cost spent at various phases of development. In this paper, we study the multi-release model whose fault removal process is affected by random irregular fluctuations (white noise) and error generation phenomenon and determine the optimal time of testing for a multi-release-based software. The fault removal process is governed by the phenomenon of testing coverage which is affected by random fluctuations. The model shows encouraging results as it handles the stochastic property of the fault detection process. The optimal testing time is determined with the goal to minimize the expected development cost related to software while achieving the desired reliability levels of software for that release using a Genetic Algorithm. A real-life four-release fault dataset of tandem computers has been used to numerically demonstrate the methodology. It is observed through sensitivity analysis that the presence of white noise directly affects the cost and optimal testing duration. The potential to improve sensitivity, flexibility, early detection, discovering unsuspected patterns, and boost fault diagnosis is enhanced by collecting irregular fluctuations in the fault detection rate. This technology, by going beyond existing methodologies, has distinct advantages for detecting faults and can contribute to more dependable and efficient systems in a variety of domains. [ABSTRACT FROM AUTHOR]

Existing software product line (SPL) engineering testing approaches generally provide positive testing that validates the SPL's functionality. Negative testing is commonly neglected. This research aims to unify behavioral and feature models of an SPL, enable testing before and after variability binding for domain-centric and product-centric testing, and combine positive and negative testing for a holistic testing view. This study suggests behavioral modeling with event sequence graphs (ESGs). This heterogeneous modeling strategy supports bottom-up domain testing and top-down product testing with the feature model. This new feature-oriented ESG test creation method generates shorter test sequences than the original ESG optimum test sequences. Statechart and original ESG test-generating methods are compared. Positive testing findings are similar. The Statechart technique generated 12 test cases with 59 events, whereas the ESG technique created six test cases with 60 events. The ESG technique generated 205 negative test cases with 858 events with the Test Suite Designer tool. However, the Conformiq Designer tool for the Statechart technique does not have a negative test case generation capability. It is shown that the proposed ESG-based holistic approach confirms not only the desirable (positive) properties but also the undesirable (negative) ones. As an additional research, the traditional ESG test-generating approach is compared to the new feature-oriented method on six SPLs of different sizes and features. Our case study results show that the traditional ESG test generation approach demonstrated higher positive test generation scores compare to the proposed feature-oriented test generation approach. However, our proposed feature-oriented test generation approach is capable of generating shorter test sequences, which could be beneficial for reducing the execution time of test cases compared to traditional ESG approach. Finally, our case study has also shown that regardless of the test generation approach, there has been found no significant difference between the Bottom-up and Top-down test strategies with respect to their positive test generation scores. [ABSTRACT FROM AUTHOR]

This paper proposes a novel algorithm that combines symbolic execution and data flow testing to generate test cases satisfying multiple coverage criteria of critical software applications. The coverage criteria considered are data flow coverage as the primary criterion, software safety requirements, and equivalence partitioning as sub-criteria. black The characteristics of the subjects used for the study include high-precision floating-point computation and iterative programs. The work proposes an algorithm that aids the tester in automated test data generation, satisfying multiple coverage criteria for critical software. The algorithm adapts itself and selects different heuristics based on program characteristics. The algorithm has an intelligent agent as its decision support system to accomplish this adaptability. Intelligent agent uses the knowledge base to select different low-level heuristics based on the current state of the problem instance during each generation of genetic algorithm execution. The knowledge base mimics the expert's decision in choosing the appropriate heuristics. black The algorithm outperforms by accomplishing 100% data flow coverage for all subjects. In contrast, the simple genetic algorithm, random testing and a hyper-heuristic algorithm could accomplish a maximum of 83%, 67% and 76.7%, respectively, for the subject program with high complexity. black The proposed algorithm covers other criteria, namely equivalence partition coverage and software safety requirements, with fewer iterations. black The results reveal that test cases generated by the proposed algorithm are also effective in fault detection, with 87.2% of mutants killed when compared to a maximum of 76.4% of mutants killed for the complex subject with test cases of other methods. [ABSTRACT FROM AUTHOR]

Most modern computer systems operate in distributed environments. To develop and test such applications, services, and systems, it is necessary to consider the physical devices, architectures, communication, security and deployment mechanisms involved. However, the requirements' specification process still replicates that of traditional applications: details remain implicit and are hidden in the description. As a result, specifications are difficult to identify and, ultimately, tests are designed in the traditional way: they overlook constraints and fail to achieve the desired effects. Our objective is to design a methodology for specifying requirements in both traditional software and applications deployed in distributed environments. We present an iterative and incremental requirements specification methodology. This methodology allows us to describe functional requirements and incorporate non-functional or quality constraints, which is the main contribution of this proposal. To ensure that quality requirements are specified during the design phase, the methodology proposes a series of phases, stages and artefacts that ensure the discovery and consideration of these requirements. In order to find out the strengths and weaknesses of our methodology, we have carried out a comparative study with other similar proposals in the literature. To this end, evaluation criteria were defined by considering standards and good practices in Requirements Engineering. The results of the comparative study show that our methodology constitutes a solid procedure for a detailed requirements specification from the beginning of the software development cycle. This represents an advance over the rest of the proposals studied. Our methodology contributes to the simplification of the design and execution phases of software testing, enabling traceability between the specified requirements and the designed test cases. [ABSTRACT FROM AUTHOR]

In the past 20 years, semiconductor manufacturing technology has advanced rapidly, but the advancement of integrated circuit (IC) testers has been slow. Using obsolete testers to inspect advanced wafers has become a significant challenge for test manufacturers. In this research, we used DITM (digital IC testing model) to discuss the impact of the test guardband (TGB) on quality and yield. Considering the interaction between semiconductor fabrication capability parameters and test capability parameters, we proposed an estimation method [deductive estimation method (DEM)] to analyze the electrical distribution changes of products after chip production and deduce the yield of future products. The deductive estimation method can correctly depict the future test yield (Y t) curve using the chip frequency data published by IRDS (International Roadmap for Devices and Systems) in 2017. Furthermore, test manufacturers can measure whether the current test capabilities can cope with future semiconductor chip manufacturing capabilities by predicting the trends. Next, test manufacturers can maintain high-quality and high-yield chip output by pre-adjusting the hardware testing capabilities of ATE (automated test equipment) or proposing more effective chip testing methods. [ABSTRACT FROM AUTHOR]

This paper presents a novel method for testing Boolean expressions. It is based on spectral, aka Fourier analysis of Boolean functions which is exploited to generate test inputs. The approach has three important contributions: (i) It generates a relatively small test suite with a high capability of fault detection, (ii) The test suite is prioritized such that expected fault detection time is shorter, (iii) It is entirely mathematical relying on a simple and straightforward formula. The proposed method is formulated and evaluations are performed on both synthetic and real expressions. It is also compared with two common test generation criteria, MC/DC and Minimal MUMCUT. Evaluations show that the test suite generated by the spectral approach is relatively small while expressing the capability of a better and quicker fault detection. The approach presented in this paper provides a useful insight into how spectral/Fourier analysis of Boolean functions can be exploited in software testing. [ABSTRACT FROM AUTHOR]

In software development, the software testing phase is an important process in determining the quality level of the software. Software testing is a process of executing a program aimed at finding errors in module access, units, and involves the execution of the system being tested on a number of test inputs, and determining whether the output produced is correct. In this study, a model-based testing (MBT) called integration-based model (I-BM) framework will be developed. This I-BM framework integrates testing variables from several software testing methods, namely black-box testing, white-box testing, unit testing, system testing, and acceptance testing. The integrated variables are function, interface, structure, performance, requirement, documentation, positives, and negatives. Then, this framework will document software errors to form a dataset, which will be measured for the level of accuracy of expected manual fault output using neural network algorithm and support vector machine. From the experiment results, it shows that the accuracy level of predicting fault output values from the I-BM framework using the neural network algorithm is on average 80%, and it produces a superior SVM architecture model in predicting I-BM framework output errors with an accuracy value of 0.99, precision of 0.99, recall of 0.99, and F 1 -score of 0.99. Compared to other MBT, the IBM framework has the advantage of being a more comprehensive software testing model because it starts from the identification of problems, analysis, design, documentation of software testing, and recommendations for each fault output found. Thus, software errors can be classified systematically in the form of a dataset, and not only focus on software testing for product lines and module mappings. [ABSTRACT FROM AUTHOR]

Testing is a vital part of achieving good-quality software. Deploying untested code can cause system crashes and unexpected behavior. To reduce these problems, testing should evolve with coding. In addition, test suites should not remain static throughout the software versions. Since whenever software gets updated, new functionalities are added, or existing functionalities are changed, test suites should be updated along with the software. Software repositories contain valuable information about the software systems. Access to older versions and differentiating adjacent versions' source code and acceptance test changes can provide information about the evolution process of the software. This research proposes a method and implementation to analyze 21 open-source real-world projects hosted on GitHub regarding the co-evolution of both software and its acceptance test suites. Related projects are retrieved from repositories, their versions are analyzed, graphs are created, and analysis related to the co-evolution process is performed. Observations show that the source code is getting updated more frequently than the acceptance tests. They indicate a pattern that source code and acceptance tests do not evolve together. Moreover, the analysis showed that a few acceptance tests test most of the functionalities that take a significant line of code. [ABSTRACT FROM AUTHOR]

Boolean expressions are highly involved in control flows of programs and software specifications. Coverage criteria for Boolean expressions aim at producing minimal test suites to detect software faults. There exist various testing criteria, efficiency of which is usually evaluated through mutation analysis. This paper proposes an integer programming-based minimal test suite generation technique relying on mutation analysis. The proposed technique also takes into account the cost of fault detection. The technique is optimal such that the resulting test suite guarantees to detect all the mutants under given fault assumptions, while maximizing the average percentage of fault detection of a test suite. Therefore, the approach presented can also be considered as a reference method to check the efficiency of any common technique. The method is evaluated using four well-known real benchmark sets of Boolean expressions and is also exemplary compared with MCDC criterion. The results show that the test suites generated by the proposed method provide better fault coverage values and faster fault detection. [ABSTRACT FROM AUTHOR]

Programming Online Verification Exam (OE) system has been widely used in algorithm education and practice since it can automatically analyze program results (e.g., correct or incorrect) after executing the submitted programs with corresponding test cases. OE systems can provide both execution results and error information so that novice programmers can get feedback quickly. If the submitted program cannot pass all the test cases, the novice programmers will get wrong-answer feedback, and they have to find and fix the errors in the program. Automated program fault localization techniques, which can locate the errors in programs under test automatically, thus help novice programmers fix the errors quickly. However, the performance of current automated fault localization techniques is limited due to the high-density test cases in novice programs of OE system. In this paper, we analyze the impact of test case density (TCD) and execution variety on fault localization performance and propose a method to reduce TCD to improve fault localization precision for novice programs. To evaluate the performance of our method, we conduct a number of empirical studies on 1199 real fault diagnosis algorithm related novice programs, and the experimental results show that using improved test cases through our method for fault localization in OE system can enhance the precision of fault localization for novice programs. Specifically, after decreasing the test cases' density, the improvement of fault localization accuracy ranges from 0.6% to 17.34% in terms of the Expense metric, and from the Accuracy@N metrics, the number of faulty statements that can be found increases in most cases. [ABSTRACT FROM AUTHOR]

As a core component of the Space Telemetry, Track and Command (TT&C) system, the TT&C software's quality is the key factor to ensure the successful implementation of space TT&C missions. Due to the complexity of space TT&C missions, incremental development is adopted in which frequent testing is required. Many problems of the original manual testing are exposed, such as large consumption of human resources, low efficiency of testing and quality highly relying on human expertise. Automatic testing method is urgently required. However, the testing of the TT&C software highly depends on the domain knowledge of space TT&C missions, which is complex and professional. This hinders the direct application of existing software automatic testing methods to the TT&C software. Therefore, in this paper, we propose an automatic testing method of the TT&C software based on domain knowledge. The domain knowledge description of the space TT&C domain is defined and a set of guidance principles for eliciting domain knowledge elicitation is given. Testing cases are automatically generated and executed by combining the domain knowledge and the image recognition results. Evaluations show that our method can realize the automatic testing of space TT&C software increments with higher accuracy. Its time cost is reduced by more than 50% compared with the manual testing, and will not increase rapidly with growing software maintenance scale. The time cost in domain knowledge elicitation will not affect the testing efficiency. [ABSTRACT FROM AUTHOR]

The equivalent mutants problem is one of the crucial problems in mutation testing. In consequence of its existence, the effectiveness of mutation testing is underestimated. In addition, it will produce a certain amount of useless overhead. Equivalent mutants cannot be detected by any test input. The existing works mostly focus on static analysis to detect, or avoid generating, the equivalent mutants. The essence of these methods is to use prior knowledge to establish some rules of program equivalence. However, (1) it needs a lot of professional labor to sort out the equivalence rules, and (2) only a small part of the rules can be determined in advance, because of the diversity of mutation operators and mutation targets. Consequently, the best result reported so far is 50% of the equivalent mutants can be detected. Since it is generally believed that manual judgment of program equivalence is the most reliable, this paper proposes a novel method to automatically detect equivalent mutants by tracing program behavior like the professionals. The weighted software behavior graph is utilized in the detection of equivalent mutants for the first time. This method can not only figure out different execution paths, but also be sensitive to execution frequency. By comparing the weighted software behavior graphs of an alive mutant and its original program, we are able to examine more precisely whether the alive mutant is the same as the original program, in terms of the state of infection and/or the propagation. Evaluation results on an open dataset of manually evaluated equivalent mutants show that our approach can detect 77.5% of all the equivalent mutants, which is much higher than the existing static methods. [ABSTRACT FROM AUTHOR]

As more mobile applications become available to a broader user base, the need to localize applications to various languages and cultures grows. The need for localization demands localization testing. In this paper, the user interface localization problems are identified and categorized. The automated testing method containing automated localization defects detection algorithms using applications' screenshots analysis is presented. The proposed method was validated experimentally by comparing automated testing and manual review. The experiment contained an automated and manual review of 781 Android applications. The manual review results were compared with the proposed automated testing method results. The comparison shows that automated methods can save localization testing time and discover more defects. However, the proposed method does not fully substitute manual testing but can act as a helper. [ABSTRACT FROM AUTHOR]

Formal specifications can provide a solid foundation for software development and support for techniques of software quality assurance, such as specification-based inspection and testing. To ensure that these techniques can be applied effectively in practice, efficiently and accurately understanding specifications becomes extremely important. While this may be relatively easy for well-trained developers in formal methods, it can be rather difficult for computer since computer does not easily understand specifications. This difficulty poses a challenge for realizing automatic specification-based verification techniques that are in high demand for reducing development cost and improving software reliability. In this paper, we address this problem by discussing how the formal specification can be transformed into a knowledge graph to provide comprehensible, well-organized details of the specification for developers and computers. The transformation is done by extracting and storing information about attributes of each component and by establishing relationships between components in a formal specification. We elaborate on a top-down approach of constructing a knowledge graph from a specification, including creating an ontology, designing the Entity–Relationship (ER) diagram of the relational database based on the created ontology, extracting and storing attribute and relationship information in the relational database, mapping ontology to its instances and relational data to RDF triples, and displaying knowledge graph. Further, we present a case study to show how our approach works on the formal specification of an ATM system. Finally, we describe three experiments to evaluate its performance in improving specification readability, effectively guiding inspectors to establish traceability links between specifications and programs, and detecting defects through program inspection, respectively. [ABSTRACT FROM AUTHOR]

Performance of a software is an important feature to determine the quality of the software developed. Performance testing of modular software is a time consuming and costly task. Several performance testing tools (PTTs) are available in the market which help software developers to test their software performance. In this paper, we propose an integrated multiobjective optimization model for evaluation and selection of best-fit PTT for modular software system. The total performance tool cost is minimized and the fitness evaluation score of the PTTs is maximized. The fitness evaluation of PTT is done based on various attributes by making use of the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS). The model allows the software developers to select the number of PTTs as per their requirement. The individual performance of the modules is considered based on some performance properties. The reusability constraints are considered, as a PTT can be used in the same module to test different properties and/or it can be used in different modules to test same or different performance properties. A real-world case study from the domain of enterprise resource planning (ERP) is used to show the working of the suggested optimization model. [ABSTRACT FROM AUTHOR]

Covering arrays are combinatorial objects that have been successfully applied in design of test suites for testing systems such as software, hardware, and networks where failures can be caused by the interaction between their parameters. Let n and k be positive integers with k ≥ 3. Two vectors x ∈ ℤ g 1 n and y ∈ ℤ g 2 n are qualitatively independent if for any ordered pair (a , b) ∈ ℤ g 1 × ℤ g 2 , there exists an index j ∈ { 0 , 1 , ... , n − 1 } such that (x (j) , y (j)) = (a , b). Let G be a graph with k vertices v 1 , v 2 , ... , v k with respective vertex weights g 1 , g 2 , ... , g k . A mixed covering array on G , denoted by CA (n , G , ∏ i = 1 k g i) , is a k × n array such that row i corresponds to vertex v i , entries in row i are from Z g i ; and if { v x , v y } is an edge in G , then the rows x , y are qualitatively independent. The parameter n is the size of the array. Given a weighted graph G , a mixed covering array on G with minimum size is optimal. In this paper, we introduce some basic graph operations to provide constructions for optimal mixed covering arrays on the family of graphs with treewidth at most three. [ABSTRACT FROM AUTHOR]

Automatic test oracle generation is a bottleneck in realizing full automation of the entire software testing process. This study proposes a new method for automatically generating a test oracle for a new test input on the basis of several historical test cases by using a backpropagation neural network (BPNN) model. The new method is different from existing test oracle techniques. Specifically, our method has two steps. First, the values of variables are collected as training data when several historical test inputs are used to execute the program at different breakpoints. The test oracles (pass or fail) of these test cases are utilized to classify and label the training data. Second, a new test input is used to execute the program at different breakpoints, where the trained BPNN prediction model automatically generates its test oracle on the basis of the collected values of the variables involved. We conduct an experiment to validate our method. In the experiment, 113 faulty versions of seven types of programs are used as experimental objects. Results show that the average prediction accuracy rate of 74,651 test oracles is 95.8%. Although the failed test cases in the training data account for less than 5%, the overall average recall rate (prediction accuracy of test case execution failure) of all programs is 78.9%. Furthermore, the trained BPNN can reveal not only the impact of the values of variables but also the impact of the logical correspondence between variables in test oracle generation. [ABSTRACT FROM AUTHOR]

Researchers have proposed several software reliability growth models, many of which possess complex parametric forms. In practice, software reliability growth models should exhibit a balance between predictive accuracy and other statistical measures of goodness of fit, yet past studies have not always performed such balanced assessment. This paper proposes a framework for software reliability growth models possessing a bathtub-shaped fault detection rate and derives stable and efficient expectation conditional maximization algorithms to enable the fitting of these models. The stages of the bathtub are interpreted in the context of the software testing process. The illustrations compare multiple bathtub-shaped and reduced model forms, including classical models with respect to predictive and information theoretic measures. The results indicate that software reliability growth models possessing a bathtub-shaped fault detection rate outperformed classical models on both types of measures. The proposed framework and models may therefore be a practical compromise between model complexity and predictive accuracy. [ABSTRACT FROM AUTHOR]

Software reliability growth models (SRGMs) are widely used to estimate software reliability by analyzing failure dataset throughout the testing process. A large number of SRGMs have been proposed on a regular basis by researchers since the 1970s. They are represented with a set of assumptions and a set of parameters. One major problem in SRGMs is that the uncertainties surrounding the assumptions and parameters are generally not taken into account by most of them. Therefore, sometimes, the predicted reliability on testing phase significantly varies in actual operational phase. This paper presents a logistic growth model that incorporates a special parameter to consider the effects of all possible uncertainties. A systematic analysis is carried out to identify the major uncertain factors and their impacts on the fault detection rate. The applicability of the model is shown by validating it on two different real datasets that are commonly used in various studies. The comparisons with nine established models in terms of mean square error (MSE), variance, predictive-ratio risk (PRR), R 2 and AIC have been presented. [ABSTRACT FROM AUTHOR]

The selection of variables in a given experiment is crucial, since it is the theoretical foundation that guides how data should be collected and analyzed. However, selecting variables is an intricate activity, especially considering areas such as Software Engineering and Education, whose studies should also consider human-related variables in the design. In this scenario, we aim to investigate how a support mechanism helps in the variables selection activity of the experiment process. To do so, we conducted a preliminary study on the use of an experimental framework composed of a catalog of variables. We explored the domain of the integration of software testing into programming education. Participants were divided into two groups (ad hoc and framework support) and asked to select variables for a given experiment goal. We analyzed the results by identifying threats to validity in their experimental design drafts. Results show a significant number of threats of type inadequate explication of constructs for both groups. Nonetheless, the framework helped to increase the clarity of concepts selected as variables. The cause of most raised threats, even with the framework support, was an inaccuracy in selecting the values of such variables (i.e. treatments and fixed values). [ABSTRACT FROM AUTHOR]

Software defect prediction is an effective approach to save testing resources and improve software quality, which is widely studied in the field of software engineering. The effort-aware just-in-time software defect prediction (JIT-SDP) aims to identify defective software changes in limited software testing resources. Although many methods have been proposed to solve the JIT-SDP, the effort-aware prediction performance of the existing models still needs to be further improved. To this end, we propose a differential evolution (DE) based supervised method DEJIT to build JIT-SDP models. Specifically, first we propose a metric called density-percentile-average (DPA), which is used as optimization objective on the training set. Then, we use logistic regression (LR) to build a prediction model. To make the LR obtain the maximum DPA on the training set, we use the DE algorithm to determine the coefficients of the LR. The experiment uses defect data sets from six open source projects. We compare the proposed method with state-of-the-art four supervised models and four unsupervised models in cross-validation, cross-project-validation and timewise-cross-validation scenarios. The empirical results demonstrate that the DEJIT method can significantly improve the effort-aware prediction performance in the three evaluation scenarios. Therefore, the DEJIT method is promising for the effort-aware JIT-SDP. [ABSTRACT FROM AUTHOR]

Mutation testing is well known as one of the most effective approaches to create test cases, which can detect software faults. However, its drawback is the low scalability — if no special attention is given to improve efficiency — that directly affects its application in practice. This paper shows a replication study focused on emphasizing evidence in which the use of distributed processing structures can improve mutation testing. For this purpose, an architecture that enables mutation testing concurrent execution was designed. Five load balancing algorithms responsible for controlling the distribution and execution of data while carrying out mutation testing were evaluated. Experiments were conducted in order to evaluate the scalability and performance of the architecture considering homogeneous and heterogeneous setups. A time reduction of 50% was observed when executing mutants in parallel in relation to the conventional sequential application of mutation testing. The performance gain was above 95% when there was a higher number of nodes in the distributed architecture. [ABSTRACT FROM AUTHOR]

Mobile and web applications must operate and be displayed correctly on many different devices and browsers. The visual testing of web or mobile applications is usually a manual process that requires a significant amount of testing time, meaning that applications are tested only on a few devices. It is then assumed that the applications will be displayed correctly on other compatible or similar devices. This paper presents an automated visual testing method for user interfaces. The main contributions of this paper are a classification scheme for visual defects of user interfaces and the definition of an automatic visual testing method that tests applications on many different devices with varying hardware and software parameters. The method is based on an automated search for defects using heuristic and expected state prediction algorithms, which involves analyzing the resources used by applications and screenshots. The testing method works by executing applications on a full set of devices, taking a screenshot at every execution step, and analyzing each of these screenshots. The manual as well as automated testing approaches were validated on 781 of Android applications. The experimental results show that the proposed method has advantages over manual testing. [ABSTRACT FROM AUTHOR]

Software testing is a continuous process during the software development stages to ensure quality software products. Researchers, experts and software engineers keep going on studying new techniques, methods and approaches of testing to accommodate changes in software development because of the flexible requirement along with the changing of technology. So, developers and testers need to have effective methods, tools and approaches to create a high-quality product at an efficient cost. This paper provides an effective approach for context-driven testing (CDT) in an agile software development process. CDT is a testing approach that supports the tester to choose their testing techniques and test objectives based on specific contexts. The aim of this paper is to propose an effective approach for implementing the CDT in practice, called CDTiP. Through an analysis of two case studies using an agile development process with different contexts, we validate the effectiveness of the approach in terms of test coverage, detect errors, test effort. The empirical results show that CDTiP is suitable for the agile development process that can help the tester to detect defects faster at minimum cost. The results of this method have been applied at Enclave, an ODC Software Engineering company, on real projects. [ABSTRACT FROM AUTHOR]

Fixed Sized Candidate Set (FSCS) is the first of a series of methods proposed to enhance the effectiveness of random testing (RT) referred to as Adaptive Random Testing methods or ARTs. Since its inception, test case generation overheads have been a major drawback to the success of ART. In FSCS, the bulk of this cost is embedded in distance computations between a set of randomly generated candidate test cases and previously executed but unsuccessful test cases. Consequently, FSCS is caught in a logical trap of probing the distances between every candidate and all executed test cases before the best candidate is determined. Using data mining, however, we discovered that about 50% of all valid test cases are encountered much earlier in the distance computations process but without any benefit of a hindsight, FSCS is unable to validate them; a wild goose chase. This paper then uses this information to propose a new strategy that predictively and proactively selects valid candidates anywhere during the distance computation process without vetting every candidate. Theoretical analysis, simulations and experimental studies conducted led to a similar conclusion: 25% of the distance computations are wasteful and can be discarded without any repercussion on effectiveness. [ABSTRACT FROM AUTHOR]

For the test case prioritization problems, the average percent of faults detected (APFD) and its variant versions are widely used as metrics to evaluate prioritized test suite's efficiency of fault detection. By a revisit of metrics for test case prioritization, we observe that APFD is only available for the scenarios where all test suites under evaluation contain the same number of test cases. Such a limitation is often overlooked, and lead to incorrect results when comparing fault detection efficiency of test suites with different sizes. Moreover, APFD cannot precisely illustrate the process of fault detection in the real world. Besides the APFD, most of its variants, including the NAPFD and the APFD C W , have similar problems. This paper points out these limitations in detail by analyzing the physical explanation of APFD series metrics formally. In order to eliminate these limitations, we propose a series of improved metrics, including the relative average percent of faults detected (RAPFD) and the relative cost-cognizant weighted average percent of faults detected (RAPFD C W ), to evaluate the efficiency of the test suite. Furthermore, for the scenario of parallel testing, a series of metrics including the relative average percent of faults detected in parallel testing (P -RAPFD) and the relative cost-cognizant weighted average percent of faults detected in parallel testing (P -RAPFD C W ) are proposed too. All the proposed metrics refer to both the speed of fault detection and the constraint of the testing resource. A formal analysis and some examples show that all the proposed metrics provide much more precise illustrations of the fault detection process. [ABSTRACT FROM AUTHOR]

Because of the sequence and number of calls of functions, software network cannot reflect the real execution of software. Thus, to detect crucial functions (DCF) based on software network is controversial. To address this issue, from the viewpoint of software dynamic execution, a novel approach to DCF is proposed in this paper. It firstly models, the dynamic execution process as an execution sequence by taking functions as nodes and tracing the stack changes occurring. Second, an algorithm for deleting repetitive patterns is designed to simplify execution sequence and construct software sequence pattern sets. Third, the crucial function detection algorithm is presented to identify the distribution law of the numbers of patterns at different levels and rank those functions so as to generate a decision-function-ranking-list (DFRL) by occurrence times. Finally, top-k discriminative functions in DFRL are chosen as crucial functions, and similarity the index of decision function sets is set up. Comparing with the results from Degree Centrality Ranking and Betweenness Centrality Ranking approaches, our approach can increase the node coverage to 80%, which is proven to be an effective and accurate one by combining advantages of the two classic algorithms in the experiments of different test cases on four open source software. The monitoring and protection on crucial functions can help increase the efficiency of software testing, strength software reliability and reduce software costs. [ABSTRACT FROM AUTHOR]

Crowdsourced software testing (CST) is an emerging trend in software testing. Companies and developers assign testing tasks through CST platforms to thousands of online testers. Currently, CST platform managers are trying to find and resolve challenges in order to reach the best CST practice. Many features have been applied by CST platforms to improve CST activities, including notification emails, online chat rooms, forums and, most importantly, a CST platform dashboard to view all testing projects and tasks; these features have enabled CST to operate efficiently. Still, CST users find it difficult to stay abreast of test project updates, maintain their motivation, and avoid frustration. This aligns with the increasing studies in the literature that call for more efficient solutions to support CST process. This research aims to support CST by searching for potential process limitations and overcoming them. In order to do so, a five-stage approach is used: first, the current process of CST is investigated through reviewing 15 CST platforms. Second, the review has resulted in identifying eight possible activities to improve CST; among them six have been selected after a survey distributed to 30 domain experts in Stage 3. In Stage 4, we have designed and implemented five process models in a web-based system that can fulfill the requirements of the six activities identified earlier. In Stage 5, we have evaluated these process models through interviews with representatives of two CST platforms and an expert tester, and through making scenario-based evaluation with 20 domain experts who used the system and rated the value of the processes. The results show that the new improvements are sound and can strengthen the CST practice. [ABSTRACT FROM AUTHOR]

Hardware Trojan has become a major threat to the security and trustworthiness of integrated circuit (IC) employed in critical applications. Due to the presence of process variations and measurement noises, all existing side-channel Trojan detection approaches suffer from low detection sensitivity or even false negatives with increasing circuit size and decreasing Trojan size. In this paper, we propose a statistical test generation approach based on mutation analysis, which generates a set of test vectors aiming at activating the hardware Trojan inserted into the low activity nodes. Such approach not only enhances the controllability of low activity nodes through increasing the switching activity of it, but also improves the observability by propagating the artificial designed errors introduced by the mutant to the outputs. Simulation results of a set of ISCAS'85 and ISCAS'89 benchmark circuits show that the proposed approach improves the activity of low activity nodes 463% at most compared with the Multiple Excitation of Rare Occurrence (MERO) approach and increases the Trojan coverage with 84.08% reduction in test length. Moreover, the test vectors generated by the proposed approach and the MERO approach, respectively, are exerted to the circuit under test. Experimental results demonstrate that the Mahalanobis distance margin of the proposed approach is much greater than the MERO approach, and thus provide a comparable robustness with decreasing Trojan size. [ABSTRACT FROM AUTHOR]

To ensure the quality of current highly configurable software systems, intensive testing is needed to test all the configuration combinations and detect all the possible faults. This task becomes more challenging for most modern software systems when constraints are given for the configurations. Here, intensive testing is almost impossible, especially considering the additional computation required to resolve the constraints during the test generation process. In addition, this testing process is exhaustive and time-consuming. Combinatorial interaction strategies can systematically reduce the number of test cases to construct a minimal test suite without affecting the effectiveness of the tests. This paper presents a new efficient search-based strategy to generate constrained interaction test suites to cover all possible combinations. The paper also shows a new application of constrained interaction testing in software fault searches. The proposed strategy initially generates the set of all possible t - t u p l e combinations; then, it filters out the set by removing the forbidden t - t u p l e s using the Base Forbidden Tuple (BFT) approach. The strategy also utilizes a mixed neighborhood tabu search (TS) to construct optimal or near-optimal constrained test suites. The efficiency of the proposed method is evaluated through a comparison against two well-known state-of-the-art tools. The evaluation consists of three sets of experiments for 35 standard benchmarks. Additionally, the effectiveness and quality of the results are assessed using a real-world case study. Experimental results show that the proposed strategy outperforms one of the competitive strategies, ACTS, for approximately 83% of the benchmarks and achieves similar results to CASA for 65% of the benchmarks when the interaction strength is 2. For an interaction strength of 3, the proposed method outperforms other competitive strategies for approximately 60% and 42% of the benchmarks. The proposed strategy can also generate constrained interaction test suites for an interaction strength of 4, which is not possible for many strategies. The real-world case study shows that the generated test suites can effectively detect injected faults using mutation testing. [ABSTRACT FROM AUTHOR]

With the aggrandizement scale of software system, the number of test cases has grown explosively. Test case prioritization (TCP) has been widely used in software testing to effectively improve testing efficiency. However, traditional TCP methods are mostly based on software code and they are difficult to apply to model-based testing. Moreover, existing model-based TCP techniques often do not take the likely distribution of faults into consideration, yet software faults are not often equally distributed in the system, and test cases that cover more fault prone modules are more likely to reveal faults so that they should be run with a higher priority. Therefore, in this paper, we provide a TCP approach based on Hidden Markov Model (HMM), to detect faults as earlier as possible and reduce the cost of modification. This approach consists of the following main parts: (1) transforming the Unified Modeling Language (UML) sequence diagram to HMM; (2) estimating the fault urgency according to fault priority and probability; (3) estimating the fault severity by analyzing the weight of the state in the HMM; (4) generating test case priority from fault urgency and fault severity, then prioritizing test case. The proposed approach is implemented on unmanned aerial vehicles (UAV) flight control system to perform TCP. The experimental results show that our proposed TCP approach can effectively enhance the probability of earlier fault detection and improve the efficiency and stability as compared to other prioritization techniques, such as original prioritization, random prioritization, additional prioritization and EPS-UML. [ABSTRACT FROM AUTHOR]

For software testing, it is well known that the architecture of a software system can be utilized to enhance testability, fault detection and error locating. However, how much and what effects architecture-based software testing has on software testing have been rarely studied. Thus, this paper undertakes case study investigation of the effects of architecture-based software testing specifically with respect to fault detection and error locating. Through comparing the outcomes with the conventional testing approaches that are not based on test architectures, we confirm the effectiveness of architecture-based software testing with respect to fault detection and error locating. The case studies show that using test architecture can improve fault detection rate by 44.1%–88.5% and reduce error locating time by 3%–65.2%, compared to the conventional testing that does not rely on test architecture. With regard to error locating, the scope of relevant components or statements was narrowed by leveraging test architecture for approximately 77% of the detected faults. We also show that architecture-based testing could provide a means of defining an exact oracle or oracles with range values. This study shows by way of case studies the extent to which architecture-based software testing can facilitate detecting certain types of faults and locating the errors that cause such faults. In addition, we discuss the contributing factors of architecture-based software testing which enable such enhancement in fault detection and error locating. [ABSTRACT FROM AUTHOR]

Architecture-based testing allows test engineers to focus on the structure of complicated software and the interactions between software components that constitute the architecture of a software product. By observing and controlling the connections and interactions between components of complex or large systems during software testing, architecture-based testing can detect and localize such faults at those locations. The complexity of software product line testing is high because an implementation under test contains variability given the different binding times and is used by multiple products. This paper introduces how architecture-based testing is applied to test generation for a software product line and examines the strengths of the proposed method against existing software product line testing methods. The paper also illustrates the use of product line architecture and architectural artifacts to generate product line interaction tests. It was found that architecture-based testing can be applied to software product line test generation by tailoring it to deal with variability and product-line specific processes. The results of a comparison with existing methods show that architecture-based software product line test generation provides better capabilities in terms of variability in the testing stage, the explicit formation and application of binding, test coverage, and architectural awareness. [ABSTRACT FROM AUTHOR]

This paper establishes a finite axiomatization of possibly non-halting computer programs and tests, with the if-then-else operation. The model is a two-sorted algebra, with one sort being the programs and the other being the tests. The main operation on programs is composition, and 1 and 0 represent the programs skip and loop (i.e. never halts) respectively. Programs are modeled as partial functions on some state space X , with tests modeled as partial predicates on X. The operations on the tests are the usual logical connectives ∧, ∨, ¬ , T and F. In addition, there is the hybrid operation of if-then-else, and the test-valued operation H on programs which is true when a program halts, and undefined otherwise. The halting operation H implies that operations of domain D and domain join ∨ may also be expressed. When tests are assumed to be possibly non-halting, the evaluation strategy of the logical connectives affects the result. Here we model parallel evaluation, as opposed to the common sequential (or short-circuit) evaluation strategy. For example, we view α ∧ β as false if either α or β is false, even if the other does not halt. [ABSTRACT FROM AUTHOR]

Finding an effective method for testing object-oriented software (OOS) has proven elusive in the software community due to the rapid development of object-oriented programming (OOP) technology. Although significant progress has been made by previous studies, challenges still exist in relation to the object distance measurement of OOS using Adaptive Random Testing (ART). This is partly due to the unique features of OOS such as encapsulation, inheritance and polymorphism. In a previous work, we proposed a new similarity metric called the Object and Method Invocation Sequence Similarity (OMISS) metric to facilitate multi-class level testing using ART. In this paper, we broaden the set of models in the metric (OMISS) by considering the method parameter and adding the weight in the metric to develop a new distance metric to improve unit testing of OOS. We used the new distance metric to calculate the distance between the set of objects and the distance between the method sequences of the test cases. Additionally, we integrate the new metric in unit testing with ART and applied it to six open source subject programs. The experimental result shows that the proposed method with method parameter considered in this study is better than previous methods without the method parameter in the case of the single method. Our finding further shows that the proposed unit testing approach is a promising direction for assisting software engineers who seek to improve the failure-detection effectiveness of OOS testing. [ABSTRACT FROM AUTHOR]

At present, bug tracking systems are used to collect and manage bug reports in many software projects. As participants, the testers not only submit bug reports to the system, but also comment on bug reports in the system. The tester's behaviors of submitting and commenting reflect his/her influence in bug tracking systems. However, with the rapid increase of the bug reports in software projects, evaluating the testers' influence in the projects accurately becomes more and more difficult. Aiming at solving this problem, the submission and comment on bug report can be regarded as social behaviors of the testers, and thus the method of Influence Ranking for Testers (IRfT) in bug tracking systems is presented and used for measuring the influence of the testers in this paper. The case study of the Eclipse project in Bugzilla shows that the result produced by IRfT is consistent with the actual performance of the testers in this project. The ranking results can keep stable in the cases of link adding or removing and tester removing in tester networks, and the results are also proved to be valid in the future. The further investigation on the speed of network break-down by node removal demonstrates that the top-ranking testers are important in the organization of tester networks. Additionally, the results also show that the ranking of the testers is related to the existence time in bug tracking system. Therefore, IRfT is proved to be an effective measurement for evaluating the influence of the testers in bug tracking system, and it can further demonstrate the testers' contributions in software testing, such as bug validations, bug fixes, etc. [ABSTRACT FROM AUTHOR]

As part of a software testing process, output verification poses a challenge when the output is not numeric or textual, such as graphical. The industry practice of using human oracles (testers) to observe and verify the correctness of the actual results is both expensive and error-prone. In particular, this practice is usually unsustainable when developing web applications — the most popular software of our era. This is because web applications change frequently due to the fast-evolving requirements amid popular demand. To improve the cost effectiveness of browser output verification, in this study we design failure-based testing techniques and evaluate the effectiveness and efficiency thereof in the context of web testing. With a novel application of the concept of adaptive random sequence (ARS), our approach leverages peculiar characteristics of failure patterns found in browser layout rendering. An empirical study shows that the use of failure patterns and inclination to guide the testing flow leads to more cost-effective results than other classic methods. This study extends the application of ARSs from the input space of programs to their output space, and also shows that adaptive random testing (ART) can outperform random testing (RT) in both failure detection effectiveness (in terms of F-measure) and failure detection efficiency (in terms of execution time). [ABSTRACT FROM AUTHOR]

Software testing is an essential activity to ensure the quality of software systems. Combinatorial testing is a method that facilitates the software testing process; it is based on an empirical evidence where almost all faults in a software component are due to the interaction of very few parameters. The test generation problem for combinatorial testing can be represented as the construction of a matrix that has certain properties; typically this matrix is a covering array. Covering arrays have a small number of tests, in comparison with an exhaustive approach, and provide a level of interaction coverage among the parameters involved. This paper presents a repository that contains binary covering arrays involving many levels of interaction. Also, it discusses the importance of covering array repositories in the construction of better covering arrays. In most of the cases, the size of the covering arrays included in the repository reported here are the best upper bounds known, moreover, the files containing the matrices of these covering arrays are available to be downloaded. The final purpose of our Binary Covering Arrays Repository (BCAR) is to provide software testing practitioners the best-known binary test-suites. [ABSTRACT FROM AUTHOR]

Empirical studies show that coverage-based fault localizations are very effective in testing and debugging software applications. It is also a commonly held belief that no software testing techniques would perform best for all programs with various data structures and complexity. An important research question posed in this paper is whether the type and complexity of faults in a given program has any influence on the performance of these fault localization techniques. This paper investigates the performance of coverage-based fault localizations for different types of faults. We explore and compare the accuracy of these techniques for two large groups of faults often observed in object-oriented programs. First, we explore different types of traditional method-level faults grouped into six categories including those related to arithmetic, relational, conditional, logical, assignment, and shift. We then focus on class-level faults related to object-oriented features and group them into four categories including inheritance, overriding, Java-specific features, and common programming mistakes. The results show that coverage-based fault localizations are less effective for class-level faults associated with object-oriented features of programs. We therefore advocate the needs for designing more effective fault localizations for debugging object-oriented and class-level defects. [ABSTRACT FROM AUTHOR]

Pair-wise testing is a widely used strategy of software testing. It requires testing every pair of parameter values at least once. This paper focuses weighting of parameter values for this testing strategy. Weighting is an added feature which allows the tester to prioritize different parameter values by specifying their desired frequency of occurrence in a test suite. This feature is desirable as it allows the tester to have more control over the resulting test suite. However, there has been not much research on weighting: to our knowledge, all existing weighting methods treat weights as a second class requirement and cannot generate a test suite that sufficiently respects the given weights. Aiming to overcome this problem, this paper proposes a weighting method which can be used in combination of any one-test-at-a-time greedy test case generation algorithm. By comparing the parameter value distribution in the current test suite and the ideal one specified by the given weights, the method generates each test case so that the resulting test suite can reflect the weights as accurately as possible. The usefulness of the method is demonstrated through empirical results. [ABSTRACT FROM AUTHOR]

This study analyzes relevant contemporary software testing process models. In addition to contemporary theoretical models, the study also analyzes business software testing process models in a considerable number of software organizations. The dual (i.e. theoretical and empirical) analysis of the testing process aims to provide a basis for a testing process model design which is specific to testing business software in small and medium software organizations. The empirical study was conducted by a survey research strategy in 24 software organizations. In order to gather detailed information on the testing process, an interview was conducted on a purpose-selected sample of four organizations. The gathered data were processed by quantitative and qualitative data analysis. The results of theoretical and empirical research were used as a basis for attaining the study's desired outcome: the business software testing process-based model which was graphically presented in BPMN 2.0 notation and described according to the ISO/IEC TR 24774 standard for process description in systems and software engineering. The combination of the graphic representation of the model and its description in compliance with the process description is a proven method in process management, which should enable easier understanding, and thus the implementation of the model in small and medium software organizations. [ABSTRACT FROM AUTHOR]

It has been recognized by many researchers that the notion of test architecture should be utilized for software testing to cope with the task of testing complicated software, as it can support test architecture design and test case generation based on test architecture as well as efficient fault detection and error locating. However, in the current software testing theory and practice, the notion of test architecture and how it can be utilized for software testing are not well understood. To redress this situation, this paper provides foundational concepts and principles of architecture-based software testing to help utilize test architecture for software testing. Case study experiments are conducted to show how the concepts and principles of architecture-based software testing work and the effects that can be obtained by using architecture-based software testing. [ABSTRACT FROM AUTHOR]

Automated GUI testing based on behavioral model is one of the most efficient testing approaches. By mining user usage, test scenarios can be generated based on statistical models such as Markov chain. However, these works require static analysis before starting the exploration which requires too much prerequisites and time. To address these challenges, we propose a behavioral-based GUI testing approach for mobile applications that achieves faster and higher coverage. The proposed approach does not conduct static analysis. It creates a behavioral model from usage logs by applying a statistical model. The events within the behavioral model are mapped to GUI components in a GUI tree. Finally, it updates the model dynamically to increase the probability of an event that rarely or never occurs when users use the application. The proposed approach was evaluated on four open-source Android applications, and compared with the state-of-the-art tools and manual testing. The main evaluation criteria are code coverage and ability to find errors. The proposed approach performed better than the current state-of-the-art automated testing tools in most aspects. [ABSTRACT FROM AUTHOR]

Demand for highly reliable software is increasing day by day which in turn has increased the pressure on the software firms to provide reliable software in no time. Ensuring high reliability of the software can only be done by prolonged testing which in result consumes more resources which is not feasible in the existing market situation. To overcome this, software firms are providing patches after software release so as to fix the remaining number of bugs and to give better product experience to users. An update/fix is a minor portion of software to repair the bugs. With such patches, organizations enhance the performance of the software. Delivering patches after release demands extra effort and resources which are costly and hence not economical for the firms. Also, early patch release might cause improper fixation of bugs, on the other hand, delayed release may increase the chances of more failure during the operational phase. Therefore, determining optimal patch release time is imperative. To overcome the above issues we have formulated a two-dimensional time and effort-based cost model to regulate the optimum release and patch time of software, so that the total cost is minimized. Proposed model is validated on a real life data set. [ABSTRACT FROM AUTHOR]

Software testing plays a crucial role in software development process to achieve high quality software. Increased demand for new features, market competition, time and resource limitation has shortened the software lifecycle. To be in the market, software companies have to release new versions of software with new functionalities. Many ideologies and cost models have been formulated in the past decades with the idea of when to release the software for single and multi-versions. In the existing literature, the total debugging cost for the first version and next versions includes the cost of debugging in the operational phase along with the testing cost. It is assumed that the software is supported until the operational phase is over. Also, it is considered that some of the remaining faults of the previous release are reported and removed during the testing period of the new versions, which shows the repetition of cost for debugging the remaining number of faults of the previous release and results as increased cost of the software for the next release. In the present paper, we provide a new perspective on the release cost. To overcome the above problem in this paper, we describe a generalized cost model in which the remaining faults of the current version are removed during the operational phase of the current version and partly in the testing period of the next version. Application of the proposed cost model is shown on a real fault counting data for multi-versions of a software. [ABSTRACT FROM AUTHOR]

Object-oriented software systems contain large number of modules which make unit testing, integration testing, and system testing very difficult and challenging. While the aim of unit testing is to show that individual modules are working properly and the aim of the system testing is to determine whether the whole system meets its specifications, the aim of integration testing is to uncover errors in the interactions between system modules. However, it is generally impossible to test all connections between modules because of time and budget constraints. Thus, it is important to focus the testing on the connections presumed to be more error-prone. The goal of this work is to guide software testers where in a software system to focus when performing integration testing to save time and resources. This paper proposes a new approach to predict and rank error-prone connections. We use method level metrics that capture both dependencies and internal complexity of methods. We performed experiments on several Java applications and used error seeding techniques for evaluation. The experimental results showed that our approach is effective for selecting the test focus in integration testing. [ABSTRACT FROM AUTHOR]