Fault localization and repair for Java runtime exceptions

Abstract

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.

Unveiling Exception Handling Bug Hazards in Android Based on GitHub and Google Code Issues

“…Several papers have investigated the use of stack trace information to support: bug classification and clustering [48], [31], [21], fault prediction models [32], automated bug fixing tools [45] and also the analysis of Android APIs [30]. Kim et al [31] use an aggregated form of multiple stack traces available in crash reports to detect duplicate crash reports and to predict if a given crash will be fixed.…”

“…In a similar study, Bettenburg et al [12] identify stack traces as the second most stack trace feature for developers. Sinha et al [45] proposed an approach that uses stack traces to guide a dataflow analysis for locating and repairing faults that are caused by the implicitly signaled exceptions. Kim at al.…”

DLint: dynamically checking bad coding practices in JavaScript

“…analyses static code and runtime behaviour to find bugs. Other approaches combine both approaches to find security vulnerabilities in web sites [26] and to debug and repair faults in Java programs [51].…”

Finding Bugs in Web Applications Using Dynamic Test Generation and Explicit-State Model Checking

“…Clause and Orso [8] present a technique, based on dynamic tainting, to find the minimal subset of input responsible for the fault. Given a program that fails with a runtime exception caused by an incorrect value, Sinha et al's technique [40] identifies the source statement at which the incorrect assignment was made, which helps to locate the fault.…”