Software Fault Localization Based on Weighted Association Rule Mining and Complex Networks

Discovery of association rules has been found useful in many applications. With large database, the process of mining association rules is time consuming. The efficiency becomes crucial factor. Weighted association is more meaningful in some application. This paper implements a fast and stable algorithm to mining weighted association rules base on the open source library Lucene. The methods to create index in Lucene and utilization of the index to find weighted frequent itemsets are introduced. Based on apriori algorithm, a weighted association rule mining algorithm is implemented. All the rules can be recommended to customer by searching Lucene Index. Experiment shows that this method is more efficient than general apriori algorithm.

With the advent of mobile and internet technology, social media has experienced a tremendous growth over the past few years. Social networking site such as Twitter provides the platform for content generation, information dissemination and communications. Summarizing the textual contents or extracting the influential words is a challenging task. Therefore an unsupervised graph based approach is proposed for automatic Keyword Extraction from the collection of Tweets using Node and Edge Weight (KETNEW). The node weight and edge weight depends on various parameters such as tweet frequency, position of node, clustering coefficient, co-occurrence frequency and shared neighbors. The important aspect of our approach is that it is a hybrid approach i.e. a graph based approach (structural approach) which depends upon statistical as well as linguistic features. Apart from this, it also depends on the position of the word in the text. These numerous features made it perform better than existing techniques.

“Why does my program crash?”—This ever recurring question drives the developer both when trying to reconstruct a failure that happened in the field and during the analysis and debugging of the test case that captures the failure. This is the question this thesis attempts to answer. For that I will present two approaches which, when combined, start off with only a dump of the memory at the moment of the crash (a core dump) and eventually give a full explanation of the failure in terms of the important runtime features of the program such as critical branches, state predicates or any other execution aspect that is deemed helpful for understanding the underlying problem. The first approach (called RECORE) takes a core dump of a crash and by means of search-based test case generation comes up with a small, self-contained and easy to understand unit test that is similar to the test as it is attached to a bug report and reproduces the failure. This test case can server as a starting point for analysis and manual debugging. Our evaluation shows that in five out of seven real cases, the resulting test captures the essence of the failure. But this failing test case can also serve as the starting point for the second approach (called BUGEX). BUGEX is a universal debugging framework that applies the scientific method and can be implemented for arbitrary runtime features (called facts). First it observes those facts during the execution of the failing test case. Using state-of-the-art statistical debugging, these facts are then correlated to the failure, forming a hypothesis. Then it performs experiments: it generates additional executions to challenge these facts and from these additional observations refines the hypothesis. The result is a correlation of critical execution aspects to the failure with unprecedented accuracy and instantaneously point the developer to the problem. This general debugging framework can be implemented for any runtime aspects; for evaluation purposes I implemented it for branches and state predicates. The evaluation shows that in six out of seven real cases, the resulting facts pinpoint the failure. Both approaches are independent form one another and each automates a tedious and error prone task. When being combined, they automate a large part of the debugging process, where the remaining manual task—fixing the defect—can never be fully automated.

In many domains it is necessary to generate surrogate networks, e.g., for hypothesis testing of different properties of a network. Generating surrogate networks typically requires that different properties of the network are preserved, e.g., edges may not be added or deleted and edge weights may be restricted to certain intervals. In this paper we present an efficient property-preserving Markov chain Monte Carlo method termed CycleSampler for generating surrogate networks in which (1) edge weights are constrained to intervals and vertex strengths are preserved exactly, and (2) edge and vertex strengths are both constrained to intervals. These two types of constraints cover a wide variety of practical use cases. The method is applicable to both undirected and directed graphs. We empirically demonstrate the efficiency of the CycleSampler method on real-world data sets. We provide an implementation of CycleSampler in R, with parts implemented in C.

Software security is crucial in every aspect of information technology. As today's software has become larger and more complex than ever before, software fault localization has become more time consuming and labor intensive accordingly. Consequently, a broad spectrum of software fault localization techniques are proposed and implemented. However, most of these techniques assume the existence of a test suite to enable their execution traces and results to be used in locating program bugs. However, this is not always true in practice. After the release of software, programmers begin debugging immediately after one failure is detected. Only the test case that results in the failure is available for programmers. In such a situation, fault localization techniques, which require multiple failed and successful test cases, cannot be applied. Hence, in this paper, we propose an innovative fault localization framework, CRAXfault, based on single-path concolic execution, which exploits the execution path of one failed test case to automatically generate numerous test cases that are then used in a fault localization technique (e.g., Tarantula, Ochiai, Crosstab, and DStar). CRAXfault is evaluated across 15 real-life programs. The results demonstrate a remarkable effectiveness of CRAXfault in the number of statements that must be examined before the first faulty statement for a given bug is identified and acceptable efficiency in the time cost for generating test cases.

In the software multi-fault scenario, the failed test cases of different fault sources are classified by clustering, and then the program statements in each cluster are ranked with suspicion by the fault location technology based on program spectrum. Software multi-fault location technology decouples failed test cases by clustering their code coverage information. At present, there are many clustering strategies for software failed test cases. However, due to the characteristics of high dimension, complex structure and variable shape of the execution information of failed test cases, it is difficult for a single clustering algorithm to accurately identify the cluster structure, so that it cannot be decoupled accurately. In this paper, a variety of clustering algorithms and different parameters are selected to obtain multiple cluster members, according to the clustering members to get the similarity matrix, and then hierarchical clustering is used to obtain the final clustering results, to achieve the integration between different clustering algorithms, so that the algorithm can identify the complex cluster structure, and then improve the efficiency of fault location.

In risk-driven testing, test cases are generated and/or prioritized based on different risk measures. For example, the most basic risk measure would analyze the history of the software and assigns higher risk to the test cases that used to detect bugs in the past. However, in practice, a test case may not be exactly the same as a previously failed test, but quite similar. In this study, we define a new risk measure that assigns a risk factor to a test case, if it is similar to a failing test case from history. The similarity is defined based on the execution traces of the test cases, where we define each test case as a sequence of method calls. We have evaluated our new risk measure by comparing it to a traditional risk measure (where the risk measure would be increased only if the very same test case, not a similar one, failed in the past). The results of our study, in the context of test case prioritization, on two open source projects show that our new risk measure is by far more effective in identifying failing test cases compared to the traditional risk measure.

Adaptive Random Testing (ART) has been proposed as an enhancement to random testing, based on assumptions on how failing test cases are distributed in the input domain. The main assumption is that failing test cases are usually grouped into contiguous regions. Many papers have been published in which ART has been described as an effective alternative to random testing when using the average number of test case executions needed to find a failure (F-measure). But all the work in the literature is based either on simulations or case studies with unreasonably high failure rates. In this paper, we report on the largest empirical analysis of ART in the literature, in which 3727 mutated programs and nearly ten trillion test cases were used. Results show that ART is highly inefficient even on trivial problems when accounting for distance calculations among test cases, to an extent that probably prevents its practical use in most situations. For example, on the infamous Triangle Classification program, random testing finds failures in few milliseconds whereas ART execution time is prohibitive. Even when assuming a small, fixed size test set and looking at the probability of failure (P-measure), ART only fares slightly better than random testing, which is not sufficient to make it applicable in realistic conditions. We provide precise explanations of this phenomenon based on rigorous empirical analyses. For the simpler case of single-dimension input domains, we also perform formal analyses to support our claim that ART is of little use in most situations, unless drastic enhancements are developed. Such analyses help us explain some of the empirical results and identify the components of ART that need to be improved to make it a viable option in practice.

A Methodology to Identify Multiple Equipment Coordinated Control with Power Metering System

Software testing is the key to ensuring software quality. Test case generation and software fault localization are two important research objects of testing. Spectrum-based fault localization (SBFL) method is a mainstream dynamic fault localization method, which inputs test cases into the program for execution and collects statement coverage information and execution results. By analysing this information, a fault report can be generated. The performance of SBFL is affected by test case quality. Therefore, this paper proposes a test case generation method based on improved genetic algorithm to assist SBFL. This method uses a small number of initial test cases to execute the program, then uses the XGBoost model to pre-process the spectrum information and generates a list of potential fault statements to guide the iterative process of the genetic algorithm. The experimental results show that the test cases generated using the improved genetic algorithm have certain advantages over the test cases generated by general genetic algorithm and the baseline test cases.

Given a large network, local community detection aims at finding the community that contains a set of query nodes and also maximizes (minimizes) a goodness metric. This problem has recently drawn intense research interest. Various goodness metrics have been proposed. However, most existing metrics tend to include irrelevant subgraphs in the detected local community. We refer to such irrelevant subgraphs as free riders. We systematically study the existing goodness metrics and provide theoretical explanations on why they may cause the free rider effect. We further develop a query biased node weighting scheme to reduce the free rider effect. In particular, each node is weighted by its proximity to the query node. We define a query biased density metric to integrate the edge and node weights. The query biased densest subgraph, which has the largest query biased density, will shift to the neighborhood of the query nodes after node weighting. We then formulate the query biased densest connected subgraph (QDC) problem, study its complexity, and provide efficient algorithms to solve it. We perform extensive experiments on a variety of real and synthetic networks to evaluate the effectiveness and efficiency of the proposed methods.

Asymmetry between odd and even node weight in complex networks

Fuzzers, or random testing tools, are powerful tools for finding bugs. A major problem with using fuzzersis that they often trigger many bugs that are already known. The fuzzer taming problem addresses this issue by ordering bug-triggering random test cases generated by a fuzzer such that test cases exposing diverse bugs are found early in the ranking. Previous work on fuzzer taming first reduces each test case into a minimal failure-inducing test case using delta debugging, then finds the ordering by applying the Furthest Point First algorithm over the reduced test cases. During the delta debugging process, a sequence of failing test cases is generated (the "delta debugging trail"). We hypothesize that these additional failing test cases also contain relevant information about the bug and could be useful for fuzzertaming. In this paper, we propose to use these additional failing test cases generated during delta debugging to help tame fuzzers. Our experiments show that this allows for more diverse bugs to be found early in the furthest point first ranking.

We consider the practical NP-complete problem of finding a minimum weight spanning tree with both edge weights and inner nodes weights. We present two polynomial time algorithms with approximation factors of 2.35 · ln n and 2Hn, respectively, where n is the number of nodes in the graph and Hn is the n-th Harmonic number. This nearly matches the lower bound of (l-\in )Hn, for any \in \ge 0. We also give an approximation algorithm with approximation factor \Delta - 1, where \Delta is the maximum degree of the graph. For metric spaces, we give a 3.105-approximation algorithm and show that an approximation factor of 1.463 is impossible unless {NP \subseteq DTIME[n^{O(\log longn)} ]}.

Graph-based semantic measures have been used to solve problems in several domains. They tend to compare semantic entities in order to estimate their similarity or relatedness. While semantic similarity is applicable to hierarchies or taxonomies, semantic relatedness is adapted to ontologies. In this work, we propose a novel semantic relatedness measure, named Rel Topic , within topic ontologies for topic labeling purposes. In contrast to traditional measures, which are dependent on textual resources, Rel Topic considers semantic properties of entities in ontologies. Thus, correlations of nodes and weights of nodes and edges are assessed. The pertinence of Rel Topic is evaluated for topic labeling of old press articles. For this purpose, a topic ontology representing the articles, named Topic-OPA, is derived from open knowledge graphs by applying a SPARQL-based automatic approach. A use-case is presented in the context of the old French newspaper Le Matin. The generated topics are evaluated using a dual evaluation approach with the help of human annotators. Our approach shows an agreement quite close to that shown by humans. The entire approach’s reuse is demonstrated for labeling a different context of articles, recent (modern) newspapers.