Generating a class integration test order (CITO) is essential to reduce the overhead of test stub construction (the primary cost in integration testing) and to ensure system reliability in complex software systems. Although reinforcement learning (RL) has shown promise in automating CITO generation, existing methods suffer from unstable policy learning and limited robustness against structural perturbations and defect injection. These challenges stem from insufficient reward shaping and the lack of reliable oracles for validation. To address these limitations, we propose LM-CITO, a stability-aware RL framework that integrates Lyapunov-guided reward shaping with semantic validation through metamorphic testing (MT). Specifically, we design a Lyapunov energy function over class dependency graphs to promote monotonic structural convergence during training, and define metamorphic relations (MRs) to verify behavioral consistency under controlled perturbations. Extensive experiments on six real-world systems demonstrate that LM-CITO consistently produces more effective policies, yielding CITOs with significantly reduced stubbing costs compared to baseline models. Furthermore, MT verifies the capability of our MRs to detect defects in 19 injected bug variants, confirming the robustness of LM-CITO under various fault-induced perturbations. These results highlight the synergy of stability guidance and MR-based validation, offering an effective, principled solution for oracle-free RL in software testing.

Class Integration Test Order (CITO) generation is essential to minimize testing cost in object-oriented software.Traditional methods based on static dependencies often producesuboptimal results, while recent approaches that incorporatedynamic dependencies typically neglect accurate stubbing costestimation and face scalability challenges. We propose DyCITO+,an extension of DyCITO, which originally modeled CITO generationas a Reinforcement Learning (RL) problem using Qlearning.However, DyCITO relies on tabular methods, and thislimits its scalability. DyCITO+ addresses this by introducingthree Deep Reinforcement Learning (DRL) algorithms: DeepQ-Network (DQN), Proximal Policy Optimization (PPO), andAdvantage Actor-Critic (A2C), to handle the complexity oflarge-scale systems more effectively. DyCITO+ builds on thedynamic dependency analysis mechanism from DyCITO, whichcaptures more accurate runtime relationships, including interfaceimplementation, abstract class inheritance, method overriding,and multilevel inheritance. We evaluated DyCITO+ on eightJava programs of varying sizes. The results show that DyCITO+significantly improves the scalability and effectiveness of CITOgeneration. Among the three DRL methods, A2C consistentlyproduces the lowest overall stubbing complexity, particularly inmedium- and large-scale systems.

The generation of class integration test orders (CITOs) is a pivotal element in integration testing, which focuses on determining the optimal order for integrating classes while testing an object-oriented system. Due to a high number of dependencies and their possible error proneness, some classes are more critical than others in a program. Existing methods for handling these classes only assess risk in terms of their dependencies; they do not consider historical bug information as an additional indicator and mainly work on small programs. To overcome these limitations, this paper introduces Criticality-Driven CITO (CD-CITO) generation, an innovative approach to optimize CITOs by focusing on class criticality. CD-CITO assesses both the importance of a class in terms of its dependencies and the likelihood of defects, based on historical bug data, to determine a criticality score. Then, it reformulates the CITO generation problem as a Reinforcement learning (RL) task and uses the Advantage Actor-Critic (A2C) algorithm to address it. We propose a novel reward calculation strategy to guide the learning agent, balancing stubbing costs with the criticality values of classes to optimize the test order. To extract fault proneness information and assess the approach, the paper uses Defects4J, a data set that contains real bugs and patches of Java programs. The results obtained show that CD-CITO effectively identifies and prioritizes highly critical classes and also minimizes stubbing costs while generating CITOs, which makes it a valuable tool for integration testing.

Several code comment generation approaches based on sequence-to-sequence (Seq2Seq) models have been proposed. Such approaches often extract structure information from abstract syntax trees (ASTs) using a certain serialization method. However, some structural information is inevitably lost while serializing ASTs. Furthermore, existing serialization methods only consider the “type” attribute of the nodes, neglecting the “value” attribute of the nodes. To further improve the performance of code comment generation, we propose a code comment generation approach, called SCATCom, which integrates a more comprehensive set of information from source code and ASTs, encompassing semantic, sequential, syntactic, and hierarchical structure information for code comment generation. Meanwhile, an AST traversal method, called V-POT, is presented, which considers both the “type” and the “value” attributes of the nodes. Experiments were designed and conducted on two commonly used datasets to validate the performance of our approach and the impact of five different serialization ways of ASTs on two code comment generation methods. The BLEU, METEOR, and ROUGE scores for our approach reach 52.6, 34.16, and 63.26 with an improvement of [Formula: see text], [Formula: see text], and [Formula: see text] compared to the baselines. It is evident that V-POT, which retains both the “type” and the “value” attributes, is superior to other methods that use only the “type” attribute.

QIM(quantization index modulation)-based VoIP steganography is an information-hiding technology that malicious users could misuse to engage in illegal activities. Its countermeasure, commonly known as the QIM-based VoIP steganalysis, has been one of the research hotspots over the past decades. VoIP speech data is sequential, so most previous studies have focused on the temporal features extracted from VoIP encoding codewords to improve detection accuracy. As a result, spatial features are often ignored or fully investigated. In practice, VoIP speech data has unique spatial characteristics. Spatial features could capture the properties of nearby codewords and frames. Inspired by the success of CLIP (contrastive language–image pre-training), we propose a novel model that could efficiently incorporate spatial and temporal features named CAST (contrastive analysis of spatial and temporal features). CLIP introduces the concept of contrastive language–image learning, which has demonstrated exceptional efficiency and effectiveness in aligning textual and visual representations. However, it is not directly applicable to the field of QIM-based VoIP steganalysis. In CAST, we introduce a way to align spatial and temporal features through contrastive analysis. Experimental results demonstrate that this alignment is resource-efficient and could enhance detection accuracy. Meanwhile, CAST outperforms other state-of-the-art models in most scenarios.

With the growing volume of VoIP traffic, many steganography algorithms exploit VoIP speech as a carrier, posing a threat to cybersecurity. Among them, quantization index modulation (QIM)-based VoIP steganography has demonstrated excellent stealth, making detection difficult. In recent years, more studies have focused on developing feasible QIM-based VoIP steganalysis methods for detecting QIM-based VoIP steganography. Previous studies have mostly focused on improving detection performance while neglecting efficiency, resulting in insufficient research on lightweight models. In online detection scenarios, detection efficiency is crucial. On the one hand, the long inference time of large models can delay warnings. On the other hand, the high computational requirements of these models make them difficult to deploy on remote devices, which reduces their practical value. In this letter, we propose a simple yet efficient model named EQVS (efficient QIM-based VoIP steganalysis network) for detecting QIM-based VoIP steganography. In EQVS, the fold and unfold operations are redesigned based on the characteristics of VoIP speech samples and the requirements of the QIM-based VoIP steganalysis task, to avoid disrupting correlation features. Then, multi-codeword priority attention mechanism, inspired by the multi-query attention and retention mechanisms, redefines the calculation procedure for the query, key, and value matrices, as well as the normalization and softmax operations, to further reduce computational resource consumption in a single attention head. Experimental results demonstrate that EQVS outperforms other state-of-the-art models in both detection performance and efficiency.

Machine learning (ML) classification techniques from various libraries have been widely introduced into software engineering (SE) to mine instructive insights, which help developers guarantee software quality. However, researchers would report instructive insights with no clear stability and consensus due to the indiscriminate use of various ML libraries. Such a lack of directive on using various ML libraries prevents developers from effectively applying instructive insights in practice. Therefore, through a case study of 23 popular software datasets across three task domains (i.e., software defect prediction, issue lifetime estimation, and code smell detection) in SE, in this article, we systematically study the impact of open-source ML libraries on performance consistency, performance stability, and model interpretation of six commonly used classifiers across two commonly used ML programming language (i.e., Python and R). We find that for a given classification technique: ML libraries with the tune setting cannot generate stable and consistent performance; ML libraries are sensitive in the interpretation of the model, even in case of the same parameter settings; and ML libraries from R would generate more stable and higher performance. Based on these findings, we suggest that future work in SE should indicate the specific ML libraries with the specific parameter settings that are used to discover the instructive insights for their tasks; try the ML libraries from R to build the models with high and stable performance for the software tasks; and use the same ML libraries that are used to select important features to construct the classification model.

Automated fault localization has been extensively studied to improve the effectiveness of software debugging. Existing automated fault localization methods neglect the guidance of the simple and easily available debugging information on fault localization. To bridge manual fault localization with automated fault localization, we propose a fault localization approach combining error guessing and logical reasoning via deep learning. The proposed approach simulates the actual debugging process. Specifically, developers’ debugging experience and context dependencies between methods are mapped into two different types of coverage matrices. The constructed matrices are fed to a convolutional neural network (CNN) to predict whether a method is buggy or not. To validate the effectiveness of the proposed approach, we designed and constructed the empirical study on the widely used Defect4J datasets. With respect to the top-n ([Formula: see text]) metric, our approach outperforms the state-of-the-art DeepFL and other five methods including Ochai, Muse, MULTRIC, TraPT and FLUCSS. Particularly, compared with the above methods, our approach has an improvement of 5–182% for top-1. In terms of MFR and MAR, the proposed approach is slightly lower than the best DeepFL but better than the other five methods. The approach we presented achieving the unification of manual and automatic debugging can aid in the improvement of fault localization accuracy.

Abstract Software fault localization is commonly recognized as arduous and time consuming. Spectrum‐based fault localization (SBFL) has been widely used due to its lightness. However, the effectiveness of SBFL is limited since it only considers simple statistics on the coverage information, ignoring the tie problem that the spectrum matrixes of some statements are the same. Most existing deep learning‐based fault localization (DLFL) techniques convert the coverage information into a vector, which utilizes the spectrum in a simplified manner and still has limitations in practice. To solve the above problem, we propose an approach via the weighted execution graph and graph attention network (WEGAT). We use a graph structure to represent the coverage information between test cases and program elements. Then, we generate a weighted execution graph by applying the predicate execution sequence. Furthermore, we combine the weighted execution graph with the AST as an integrated graph, which is the input of the GAT for fault localization. We evaluate WEGAT in within‐project and cross‐project prediction scenarios on the Defects4J benchmark. Experimental results show that our approach outperforms traditional SBFL (Ochiai, DStar and Tarantula) and DLFL (TraPT, CNN‐FL, Grace, and AGFL) methods, effectively improving the accuracy of fault localization.

Abstract Cross‐version defect prediction (CVDP) for evolutionary projects has attracted much attention from researchers in recent years. For multiple versions of an object‐oriented project, the degree of evolution (e.g., the degree of class change) between successive versions can reflect the differences between versions, which could affect the performance of CVDP. Therefore, how to measure the degree of evolution between successive versions and explore the correlations with the performance of CVDP are very important for software defect prediction. Based on the successive versions of evolutionary projects, this paper proposes six evolutionary measures from three aspects of class change, metric change, and label change, including the Ratio of New Classes (RNC), the Ratio of Deleted Classes (RDC), the Average Ratio of Metric Change (ARMC), the Ratio of Label Changed Classes (RLCC), the Ratio of Unchanged Classes (RUC), and the Ratio of Interference Classes (RIC). An empirical study was conducted on 40 versions of 11 object‐oriented projects from the PROMISE repository. Precision, Recall, F‐measure, and AUC were used as the performance indicators. Three correlation approaches (Pearson, Spearman, and Kendall) are applied to show the correlations between evolutionary measures and the performance of CVDP. The statistical results show that RNC, RDC, and RUC show no correlation with four performance indicators. ARMC shows weak or medium positive correlations with Recall and F‐measure. RLCC and RIC show very strong or strong negative correlations with Recall and F‐measure. The results indicate that the correlations between the proposed evolutionary measures and the performance of CVDP are different, which can guide the training set selection of CVDP.

In the past decades, there have been many studies on VoIP steganalysis models for quantization index modulation (QIM) based steganography. However, most of the proposed models in these studies did not consider resource consumption, limiting the application scenarios of these models. Inspired by MobileViT, we proposed a lightweight VoIP steganalysis model in this letter named LStegT (Lightweight steganalysis transformer), which could combine the strengths of convolutional neural networks (CNN) and transformers. First, LStegT utilizes 1D deep-wise separable convolutions to capture the correlations among codewords (local correlations). Then, LStegT applies a transformer encoder to encode the correlations among frames (global correlations). The application of deep-wise separable convolutions could significantly reduce the computation resource consumption. Besides, the transformer encoder in LStegT requires fewer training parameters because it only needs to encode the correlation among frames. In this letter, we exhibit how we designed the architecture of LStegT based on the characteristics of VoIP streams and QIM-based steganography. Also, we explained why LStegT is lightweight from the MobileViT perspective. Finally, our experimental results show that LStegT performs superbly in detecting QIM-based steganography in VoIP streams.

For a new project, it is impossible to get a reliable prediction model because of the lack of sufficient training data. To solve the problem, researchers proposed cross-project defect prediction (CPDP). For CPDP, most researchers focus on how to reduce the distribution difference between training data and test data, and ignore the impact of class imbalance on prediction performance. This paper proposes a hybrid multiple models transfer approach (HMMTA) for cross-project software defect prediction. First, several instances that are most similar to each target project instance are selected from all source projects to form the training data. Second, the same number of instances as that of the defected class are randomly selected from all the non-defect class in each iteration. Next, instances selected from the non-defect classes and all defected class instances are combined to form the training data. Third, the transfer learning method called ETrAdaBoost is used to iteratively construct multiple prediction models. Finally, the prediction models obtained from multiple iterations are integrated by the ensemble learning method to obtain the final prediction model. We evaluate our approach on 53 projects from AEEEM, PROMISE, SOFTLAB and ReLink four defect repositories, and compare it with 10 baseline CPDP approaches. The experimental results show that the prediction performance of our approach significantly outperforms the state-of-the-art CPDP methods. Besides, we also find that our approach has the comparable prediction performance as within-project defect prediction (WPDP) approaches. These experimental results demonstrate the effectiveness of HMMTA approach for CPDP.

Software defect prediction can detect modules that may have defects in advance and optimize resource allocation to improve test efficiency and reduce development costs. Traditional features cannot capture deep semantic and grammatical information, which limits the further development of software defect prediction. Therefore, it has gradually become a trend to use deep learning technology to automatically learn valuable deep features from source code or relevant data. However, most software defect prediction methods based on deep learning extraction features from a single information source or only use a single deep learning model, which leads to the fact that the extracted features are not comprehensive enough to affect the final prediction performance. In view of this, this paper proposes a Hierarchical Feature Ensemble Deep Learning (HFEDL) Approach for software defect prediction. Firstly, the HFEDL approach needs to obtain three types of information sources: abstract syntax tree (AST), class dependency network (CDN) and traditional features. Then, the Convolutional Neural Network (CNN) and the Bidirectional Long Short-Term Memory based on Attention mechanism (BiLSTM+Attention) are used to extract different valuable features from the three information sources and multiple prediction sub-models are constructed. Next, all the extracted features are fused by a filter mechanism to obtain more comprehensive features and construct a fusion prediction sub-model. Finally, all the sub-models are integrated by an ensemble learning method to obtain the final prediction model. We use 11 projects in the PROMISE defect repository and evaluate our approach in both non-effort-aware and effort-aware scenarios. The experimental results show that the prediction performance of our approach is superior to state-of-the-art methods in both scenarios.

Cross-version defect prediction (CVDP) has attracted more attention of researchers in recent years. For an evolutionary project, multiple versions will be produced during the process of software evolution. However, for multiple versions of an object-oriented project, the evolution degree (e.g. class change degree) between neighboring versions could affect the performance of CVDP. Therefore, how to measure the evolution degree of neighboring versions and explore the impact on the performance of CVDP are very important. Based on the neighboring versions of evolutionary projects, this paper proposed six evolutionary measures from three aspects of class change, metric change, and label change, including ratio of new classes (RNC), ratio of deleted classes (RDC), average ratio of metric change (ARMC), ratio of label changed classes (RLCC), ratio of unchanged classes (RUC), and ratio of interference classes (RIC). Spearman's rank correlation coefficient was applied to show the correlations between evolutionary measures and the performance of CVDP. An empirical study was conducted on 40 versions of 11 projects from the PROMISE repository. The performance of CVDP was evaluated with F-measure and AUC. The statistical results show that RNC, RDC, and RUC show no correlation with F-measure and AUC. ARMC shows a medium positive correlation with F-measure. RLCC and RIC show very strong or strong negative correlations with F-measure. The results indicate that the correlations between the proposed evolutionary measures and the performance of CVDP are different, which can guide the training set selection of CVDP.

Software fault localization is notoriously tedious and time-consuming. Developed rapidly, machine learning techniques have been adopted for fault localization by researchers. Most existing approaches use the test coverage information as feature input to the learning model, ignoring the limited ability of the single-dimensional features. The effectiveness of fault localization is not greatly improved. To overcome the limitation, we propose a fault localization approach based on Bidirectional Recurrent Neural Networks (BiRNNs) and multi-dimensional features. Our approach collects suspiciousness-based, text similarity-based and fault-proneness-based features from the traditional fault localization areas and software metrics. To evaluate our approach, the experiments have been studied on the real-fault benchmark Defects4J and seeded fault program NanoXML. The experimental results show that our approach effectively improves fault localization accuracy.

In recent years, many intelligent optimization algorithms have been applied to the class integration and test order (CITO) problem. These algorithms also have been proved to be able to efficiently solve the problem. Here, the design of fitness function is a key task to generate the optimal solution. To better solve the class integration and test order problem, we propose a new fitness function to generate the optimal solution that achieves a balanced compromise between the different measures (objectives) such as the total number of stubs and the total stubbing complexity in this paper. We used some programs to compare and evaluate the different approaches. The experimental results show that our proposed approach is encouraging to some extent in solving the class integration and test order problem.

Software dependency network metrics extracted from the dependency graph of the software modules by the application of Social Network Analysis (SNA metrics) have been shown to improve the performance of the Software Defect prediction (SDP) models. However, the relative effectiveness of these SNA metrics over code metrics in improving the performance of the SDP models has been widely debated with no clear consensus. Furthermore, some of the common SDP scenarios like predicting the number of defects in a module (Defect-count) in Cross-version and Cross-project SDP contexts remain unexplored. Such lack of clear directive on the effectiveness of SNA metrics when compared to the widely used code metrics prevents us from potentially building better performing SDP models. Therefore, through a case study of 9 open source software projects across 30 versions, we study the relative effectiveness of SNA metrics when compared to code metrics across 3 commonly used SDP contexts (Within-project, Cross-version and Cross-project) and scenarios (Defect-count, Defect-classification (classifying if a module is defective) and Effort-aware (ranking the defective modules w.r.t to the involved effort)). We find the SNA metrics by themselves or along with code metrics improve the performance of SDP models over just using code metrics on 5 out of the 9 studied SDP scenarios (three SDP scenarios across three SDP contexts). However, we note that in some cases the improvements afforded by considering SNA metrics over or alongside code metrics might only be marginal, whereas in other cases the improvements could be potentially large. Based on these findings we suggest that the future work should: consider SNA metrics alongside code metrics in their SDP models; as well as consider Ego metrics and Global metrics, the two different types of the SNA metrics separately when training SDP models as they behave differently.

Integration testing is a very important step in software testing. Existing methods evaluate the stubbing cost for class integration test orders by considering only the interclass direct relationships such as inheritance, aggregation, and association, but they omit the interclass indirect relationship caused by control coupling, which can also affect the test orders and the stubbing cost. In this paper, we introduce an integration test order strategy to consider control coupling. We advance the concept of transitive relationship to describe this kind of interclass dependency and propose a new measurement method to estimate the complexity of control coupling, which is the complexity of stubs created for a transitive relationship. We evaluate our integration test order strategy on 10 programs on various scales. The results show that considering the transitive relationship when generating class integration test orders can significantly reduce the stubbing cost for most programs and that our integration test order strategy obtains satisfactory results more quickly than other methods.

Summary Concurrent programs are notoriously difficult to debug due to shared memory and the non‐determined nature of thread scheduling. Frequent context switches add a huge burden on developers in reasoning about concurrency bugs. To alleviate this problem, we present a bidirectional trace simplification approach based on a context switch linked list. First, we calculate the dependence relations, including local dependences, synchronization dependences, and remote read/write dependences. Second, we construct a context switch linked list according to the original buggy trace. Then, we backward refactor the context switch linked list in sequence to extend thread execution intervals. Finally, we forward check the context switch linked list in sequence to ensure that no nodes can be further merged. We have conducted experiments on eight Java multi‐threaded programs to evaluate our approach. The results show that our approach performs better than or is comparable to the compared static approaches in effectiveness and efficiency.

Software evolution is an important activity in the life cycle of a modern software system. In the process of software evolution, the repair of historical defects and the increasing demands may introduce new defects. Therefore, evolution‐oriented defect prediction has attracted much attention of researchers in recent years. At present, some researchers have proposed the process metrics to describe the characteristics of software evolution. However, compared with the traditional software defect prediction methods, the research on evolution‐oriented defect prediction is still inadequate. Based on the evolution data of object‐oriented programs, this study presented two new process metrics from the defect rates of historical packages and the change degree of classes. To show the effectiveness of the proposed process metrics, the authors made comparisons with the code metrics and other process metrics. An empirical study was conducted on 33 versions of nine open‐source projects. The results showed that adding the proposed process metrics could improve the performance of evolution‐oriented defect prediction effectively.

Regression testing is a very time-consuming and expensive testing activity. Many test case prioritization techniques have been proposed to speed up regression testing. Previous studies show that no one technique is always best. Random strategy, as the simplest strategy, is not always so bad. Particularly, when a test suite has higher fault detection capability, the strategy can generate a better result. Nevertheless, due to the randomness, the strategy is not always as satisfactory as expected. In this context, we present a test case prioritization approach using fixed size candidate set adaptive random testing algorithm to reduce the effect of randomness and improve fault detection effectiveness. The distance between pair-wise test cases is assessed by exclusive OR. We designed and conducted empirical studies on eight C programs to validate the effectiveness of the proposed approach. The experimental results, confirmed by a statistical analysis, indicate that the approach we proposed is more effective than random and the total greedy prioritization techniques in terms of fault detection effectiveness. Although the presented approach has comparable fault detection effectiveness to ART-based and the additional greedy techniques, the time cost is much lower. Consequently, the proposed approach is much more cost-effective.

Software defect prediction (SDP) is an available way to enhance test efficiency and guarantee software reliability. However, there are more clean instances than defective instances in real software projects, and this results in severe class distribution skews and gets the poor performance of classifiers. So solving the class-imbalance problem in SDP has attracted growing attention from industry and academia in software engineering. In this paper, we propose a novel class-imbalance learning approach for both within-project and cross-project class-imbalance problem. We utilize the thought of stratification embedded in nearest neighbor (STr-NN) to produce evolving training datasets with balanced data. For within-project, we directly employ the STr-NN approach for defect prediction. For cross-project, we first introduce transfer component analysis to mitigate the distribution differences between source and target dataset, and then employ the STr-NN approach on the transferred data. We conduct experiments on PROMISE and NASA datasets using ensemble learning based on weight vote. Experimental results indicate that our approach has higher area under curve (AUC), Recall and comparable probability of a false alarm (pf), and F-measure than some existing methods for the class-imbalance problem.

Software defect prediction (SDP) utilizes the learning models to detect the defective modules in project, and their performance depends on the quality of training data. The previous researches mainly focus on the quality problems of class imbalance and feature redundancy. However, training data often contains some instances that belong to different class but have similar values on features, and this leads to class overlap to affect the quality of training data. Our goal is to investigate the impact of class overlap on software defect prediction. At the same time, we propose an improved K-Means clustering cleaning approach (IKMCCA) to solve both the class overlap and class imbalance problems. Specifically, we check whether K-Means clustering cleaning approach (KMCCA) or neighborhood cleaning learning (NCL) or IKMCCA is feasible to improve defect detection performance for two cases (i) within-project defect prediction (WPDP) (ii) cross-project defect prediction (CPDP). To have an objective estimate of class overlap, we carry out our investigations on 28 open source projects, and compare the performance of state-of-the-art learning models for the above-mentioned cases by using IKMCCA or KMCCA or NCL VS. without cleaning data. The experimental results make clear that learning models obtain significantly better performance in terms of balance, Recall and AUC for both WPDP and CPDP when the overlapping instances are removed. Moreover, it is better to consider both class overlap and class imbalance.

Abstract Software defect prediction (SDP) has been a very important research topic in software engineering, since it can provide high‐quality results when given sufficient historical data of the project. Unfortunately, there are not abundant data to bulid the defect prediction model at the beginning of a project. For this scenario, one possible solution is to use data from other projects in the same company. However, using these data practically would get poor performance because of different distributional characteristics among projects. Also, software has more non‐defective instances than defective instances that may cause a significant bias towards defective instances. Considering these two problems, we propose an improved transfer adaptive boosting (ITrAdaBoost) approach for being given a small number of labeled data in the testing project. In our approach, ITrAdaBoost can not only employ the Matthews correlation coefficient (MCC) as the measure instead of accuracy rate but also use the asymmetric misclassification costs for non‐defective and defective instances. Extensive experiments on 18 public projects from four datasets indicate that: (a) our approach significantly outperforms state‐of‐the‐art cross‐project defect prediction (CPDP) approaches, and (b) our approach can obtain comparable prediction performances in contrast with within project prediction results. Consequently, the proposed approach can build an effective prediction model with a small number of labeled instances for mixed‐project defect prediction (MPDP).

Software testing consumes a significant portion of software effort. Program entities such as branch or definition–use pairs (DUPs) are used in diverse software development tasks. In this study, the authors present a novel evolution‐based approach to generating test data for all definition–use coverage. First, the subset of DUPs, which can ensure the coverage adequacy, is computed by a reduction algorithm for the whole DUPs. Then they apply a genetic algorithm to generate test data for the subset of DUPs. Furthermore, the fitness of an individual depends on the matching degree between the traversed path and the definition‐clear path of each target DUP. They also investigate the coverage and the size of test cases of test data generation by applying the authors’ approach on 15 widely used subject programs. The experimental results show that their approach can reduce the size of test cases that generated without affecting the coverage rate.

The advent of cloud computation and big data applications has enabled data access concurrency to be prevalent in the distributed cloud environment. In the meantime, security issue becomes a critical problem for researchers to consider. Concurrency bug diagnosis service is to analyze concurrent software and then reason about concurrency bugs in them. However, frequent context switches in concurrent program execution traces will inevitably impact the service performance. To optimize the service performance, this paper presents a static constraint-aware method to simplify concurrent program buggy traces. First, taking the original buggy trace as the operation object, we calculate the maximal sound dependence relations based on the constraint models. Then, we iteratively check the dependent constraints and move forward current event to extend thread execution intervals. Finally, we obtain the simplified trace that is equivalent to the original buggy trace. To evaluate our approach, we conduct a set of experiments on 12 widely used Java projects. Experimental results show that our approach outperforms other state-of-the-art approaches in terms of execution time.

Software defect prediction is aimed to find potential defects based on historical data and software features. Software features can reflect the characteristics of software modules. However, some of these features may be more relevant to the class (defective or non-defective), but others may be redundant or irrelevant. To fully measure the correlation between different features and the class, we present a feature selection approach based on a similarity measure (SM) for software defect prediction. First, the feature weights are updated according to the similarity of samples in different classes. Second, a feature ranking list is generated by sorting the feature weights in descending order, and all feature subsets are selected from the feature ranking list in sequence. Finally, all feature subsets are evaluated on a k-nearest neighbor (KNN) model and measured by an area under curve (AUC) metric for classification performance. The experiments are conducted on 11 National Aeronautics and Space Administration (NASA) datasets, and the results show that our approach performs better than or is comparable to the compared feature selection approaches in terms of classification performance.

The recent studies indicate that predicate-based statistical fault localization suffered from the control dependence confounding effect and the failure flow confounding effect, which decrease the measurement accuracy of fault localization. However, the extent of the potentially confounding effect of data dependence is uncertain. This paper presents a novel approach that accounts for the effects of program dependences to mitigate the confounding effect during statistical predicate-based fault localization. First, we present a variable type-based predicate designation technique to improve the ability of fault-relevant predicate identification. Then, we conduct dependence analysis to examine the extent of the potentially confounding effect of data dependence in fault localization. Finally, we propose a linear regression-based method to mitigate both the data dependence confounding effect and the control dependence confounding effect. Using the open-source software systems, we find that the fault-relevant predicate can be identified effectively by the proposed predicate design technique, and the effectiveness of fault localization can be significantly improved after mitigating the dependence confounding effect.

With the continuous evolution of software systems, test suites often grow very large.Rerunning all test cases may be impractical in regression testing under limited resources.Coverage-based test case prioritization techniques have been proposed to improve the effectiveness of regression testing.The original test suite often contains some test cases which are designed for exercising production features or exceptional behaviors, rather than for code coverage.Therefore, coverage-based prioritization techniques do not always generate satisfactory results.In this context, we propose a global similarity-based regression test case prioritization approach.The approach reschedules the execution order of test cases based on the distances between pair-wise test cases.We designed and conducted empirical studies on four C programs to validate the effectiveness of our proposed approach.Moreover, we also empirically compared the effects of six similarity measures on the global similarity-based test case prioritization approach.Experimental results illustrate that the global similarity-based regression test case prioritization approach using Euclidean distance is the most effective.This study aims at providing practical guidelines for picking the appropriate similarity measures.

In recent years, many approaches have been developed to determine the order of tested classes in interclass integration test. However, existing approaches are inaccurate, as they ignore the influence of abstract classes and polymorphism. In this paper, we propose a test-level-based approach to deal with class-integration-test order, in which both abstract classes and polymorphism are taken into account. First, based on interclass dependence analysis, we develop an edge-removing algorithm to eliminate cycles caused by static and dynamic dependencies, taking abstract classes and polymorphism into account. Then, after eliminating cycles, we propose a class-integration-test order algorithm based on test levels, including static and dynamic test levels. In this algorithm, we take into account the fact of some test levels infeasible caused by the characteristic of abstract classes that they cannot be instantiated and offer corresponding adjustment strategy. Finally, we design and implement a test level order generator. The experimental results show that the proposed strategy needs less test stubs than the most typically graph-based approaches. Copyright © 2014 John Wiley & Sons, Ltd.

This paper presents a new approach for locating and repairing faults that cause runtime exceptions in Java programs. The approach handles runtime exceptions that involve a flow of an incorrect value that finally leads to the exception. This important class of exceptions includes exceptions related to dereferences of null pointers, arithmetic faults (e.g., ArithmeticException), and type faults (e.g., ArrayStoreException). Given a statement at which such an exception occurred, the technique combines dynamic analysis (using stack-trace information) with static backward data-flow analysis (beginning at the point where the runtime exception occurred) to identify the source statement at which an incorrect assignment was made; this information is required to locate the fault. The approach also identifies the source statements that may cause this same exception on other executions, along with the reference statements that may raise an exception in other executions because of this incorrect assignment; this information is required to repair the fault. The paper also presents an application of our technique to null pointer exceptions. Finally, the paper describes an implementation of the null-pointer-exception analysis and a set of studies that demonstrate the advantages of our approach for locating and repairing faults in the program.