OSD: A Source Level Bug Localization Technique Incorporating Control Flow and State Information in Object Oriented Program (original) (raw)

A Statement Level Bug Localization Technique using Statement Dependency Graph

Proceedings of the 12th International Conference on Evaluation of Novel Approaches to Software Engineering, 2017

Existing bug localization techniques suggest source code methods or classes as buggy which require manual investigations to find the buggy statements. Considering that issue, this paper proposes Statement level Bug Localization (SBL), which can effectively identify buggy statements from the source code. In SBL, relevant buggy methods are ranked using dynamic analysis followed by static analysis of the source code. For each ranked buggy method, a Method Statement Dependency Graph (MSDG) is constructed where each statement acts as a node of the graph. Since each of the statements contains few information, it is maximized by combining the contents of each node and its predecessor nodes in MSDG, resulting a Node Predecessor-node Dependency Graph (NPDG). To identify relevant statements for a bug, similarity is measured between the bug report and each node of the NPDG using Vector Space Model (VSM). Finally, the buggy statements are ranked based on the similarity scores. Rigorous experiments on three open source projects named as Eclipse, SWT and PasswordProtector show that SBL localizes the buggy statements with reasonable accuracies.

Fault Localization using Probabilistic Program Dependence Graph

Fault localization is an expensive technique in software debugging. Program dependence graphs are used for testing, debugging and maintenance applications in software engineering. Program dependence graphs (PDG) are used to build a probabilistic graphical model of program behavior. In this paper we proposed a model based fault localization technique using probabilistic program dependence (PPDG).This work presents algorithm for constructing PPDGs and PPDGs based fault localization. Our experimental result shows that proposed PPDG based fault localization method performs better than existing testing based fault localization (TBFL) method for DotNet programs. Our results also indicate that the probabilistic approach is efficient for fault localization.

Modeling Programs with Unstructured Control Flow for Debugging

Lecture Notes in Computer Science, 2002

Even with modern software development methodologies, the actual debugging of source code, i.e., location and identification of errors in the program when errant behavior is encountered during testing, remains a crucial part of software development. To apply model-based diagnosis techniques, which have long been state of the art in hardware diagnosis, for automatic debugging, a model of a given program must be automatically created from the source code. This work describes a model that reflects the execution semantics of the Java language, including exceptions and unstructured control flow, thereby providing unprecedented scope in the application of model-based diagnosis to programs. Besides the structural model building process, a behavioral description of some of the model components is given. Finally, impacts of the modeling decisions on the diagnostic process are considered.

Fault localization models in debugging

2017 International Conference on Infocom Technologies and Unmanned Systems (Trends and Future Directions) (ICTUS), 2017

Debugging is considered as a rigorous but important feature of software engineering process. Since more than a decade, the software engineering research community is exploring different techniques for removal of faults from programs but it is quite difficult to overcome all the faults of software programs. Thus, it is still remains as a real challenge for software debugging and maintenance community. In this paper, we briefly introduced software anomalies and faults classification and then explained different fault localization models using theory of diagnosis. Furthermore, we compared and contrasted between value based and dependencies based models in accordance with different real misbehaviours and presented some insight information for the debugging process. Moreover, we discussed the results of both models and manifested the shortcomings as well as advantages of these models in terms of debugging and maintenance..

Path Optimization in Programs and Its Application to Debugging

Lecture Notes in Computer Science, 2006

We present and solve a path optimization problem on programs. Given a set of program nodes, called critical nodes, we find a shortest path through the program's control flow graph that touches the maximum number of these nodes. Control flow graphs over-approximate real program behavior; by adding dataflow analysis to the control flow graph, we narrow down on the program's actual behavior and discard paths deemed infeasible by the dataflow analysis. We derive an efficient algorithm for path optimization based on weighted pushdown systems. We present an application for path optimization by integrating it with the Cooperative Bug Isolation Project (CBI), a dynamic debugging system. CBI mines instrumentation feedback data to find suspect program behaviors, called bug predictors, that are strongly associated with program failure. Instantiating critical nodes as the nodes containing bug predictors, we solve for a shortest program path that touches these predictors. This path can be used by a programmer to debug his software. We present some early experience on using this hybrid static/dynamic system for debugging.

Critical Slicing for Software Fault Localization

ACM Sigsoft Software Engineering Notes, 1996

Developing effective debugging strategies to guarantee the reliability of software is important. By analyzing the debugging process used by experienced programmers, we have found that four distinct tasks are consistently performed:

Fault localization for data-centric programs

Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering, 2011

In this paper we present an automated technique for localizing faults in data-centric programs. Data-centric programs primarily interact with databases to get collections of content, process each entry in the collection(s), and output another collection or write it back to the database. One or more entries in the output may be faulty. In our approach, we gather the execution trace of a faulty program. We use a novel, precise slicing algorithm to break the trace into multiple slices, such that each slice maps to an entry in the output collection. We then compute the semantic difference between the slices that correspond to correct entries and those that correspond to incorrect ones. The "diff" helps to identify potentially faulty statements. We have implemented our approach for ABAP programs. ABAP is the language used to write custom code in SAP systems. It interacts heavily with databases using embedded SQL-like commands that work on collections of data. On a suite of 13 faulty ABAP programs, our technique was able to identify the precise fault location in 12 cases.

Lightweight Fault Localization with Abstract Dependences

2006

Locating faults is one of the most time consuming tasks in today's fast paced economy. Testing and formal verification techniques like model-checking are usually used for detecting faults but do not attempt to locate the root-cause for the detected faulty behavior. This article makes use of abstract dependences between program variables for locating faults in programs. We discuss the basic ideas, the underlying theory, and first experimental results, as well our model's limitations. Our fault localization model is based on a previous work that uses the abstract dependences for fault detection. First case studies indicate our model's practical applicability

Statistical Debugging Effectiveness as a Fault Localization Approach: Comparative Study

Journal of Software Engineering and Applications, 2016

Fault localization is an important topic in software testing, as it enables the developer to specify fault location in their code. One of the dynamic fault localization techniques is statistical debugging. In this study, two statistical debugging algorithms are implemented, SOBER and Cause Isolation, and then the experimental works are conducted on five programs coded using Python as an example of well-known dynamic programming language. Results showed that in programs that contain only single bug, the two studied statistical debugging algorithms are very effective to localize a bug. In programs that have more than one bug, SOBER algorithm has limitations related to nested predicates, rarely observed predicates and complement predicates. The Cause Isolation has limitations related to sorting predicates based on importance and detecting bugs in predicate condition. The accuracy of both SOBER and Cause Isolation is affected by the program size. Quality comparison showed that SOBER algorithm requires more code examination than Cause Isolation to discover the bugs.