2,334 research outputs found
PRF: A Framework for Building Automatic Program Repair Prototypes for JVM-Based Languages
PRF is a Java-based framework that allows researchers to build prototypes of
test-based generate-and-validate automatic program repair techniques for JVM
languages by simply extending it with their patch generation plugins. The
framework also provides other useful components for constructing automatic
program repair tools, e.g., a fault localization component that provides
spectrum-based fault localization information at different levels of
granularity, a configurable and safe patch validation component that is 11+X
faster than vanilla testing, and a customizable post-processing component to
generate fix reports. A demo video of PRF is available at
https://bit.ly/3ehduSS.Comment: Proceedings of the 28th ACM Joint European Software Engineering
Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE
'20
Automatic Repair of Real Bugs: An Experience Report on the Defects4J Dataset
Defects4J is a large, peer-reviewed, structured dataset of real-world Java
bugs. Each bug in Defects4J is provided with a test suite and at least one
failing test case that triggers the bug. In this paper, we report on an
experiment to explore the effectiveness of automatic repair on Defects4J. The
result of our experiment shows that 47 bugs of the Defects4J dataset can be
automatically repaired by state-of- the-art repair. This sets a baseline for
future research on automatic repair for Java. We have manually analyzed 84
different patches to assess their real correctness. In total, 9 real Java bugs
can be correctly fixed with test-suite based repair. This analysis shows that
test-suite based repair suffers from under-specified bugs, for which trivial
and incorrect patches still pass the test suite. With respect to practical
applicability, it takes in average 14.8 minutes to find a patch. The experiment
was done on a scientific grid, totaling 17.6 days of computation time. All
their systems and experimental results are publicly available on Github in
order to facilitate future research on automatic repair
Automatic Software Repair: a Bibliography
This article presents a survey on automatic software repair. Automatic
software repair consists of automatically finding a solution to software bugs
without human intervention. This article considers all kinds of repairs. First,
it discusses behavioral repair where test suites, contracts, models, and
crashing inputs are taken as oracle. Second, it discusses state repair, also
known as runtime repair or runtime recovery, with techniques such as checkpoint
and restart, reconfiguration, and invariant restoration. The uniqueness of this
article is that it spans the research communities that contribute to this body
of knowledge: software engineering, dependability, operating systems,
programming languages, and security. It provides a novel and structured
overview of the diversity of bug oracles and repair operators used in the
literature
FixMiner: Mining Relevant Fix Patterns for Automated Program Repair
Patching is a common activity in software development. It is generally
performed on a source code base to address bugs or add new functionalities. In
this context, given the recurrence of bugs across projects, the associated
similar patches can be leveraged to extract generic fix actions. While the
literature includes various approaches leveraging similarity among patches to
guide program repair, these approaches often do not yield fix patterns that are
tractable and reusable as actionable input to APR systems. In this paper, we
propose a systematic and automated approach to mining relevant and actionable
fix patterns based on an iterative clustering strategy applied to atomic
changes within patches. The goal of FixMiner is thus to infer separate and
reusable fix patterns that can be leveraged in other patch generation systems.
Our technique, FixMiner, leverages Rich Edit Script which is a specialized tree
structure of the edit scripts that captures the AST-level context of the code
changes. FixMiner uses different tree representations of Rich Edit Scripts for
each round of clustering to identify similar changes. These are abstract syntax
trees, edit actions trees, and code context trees. We have evaluated FixMiner
on thousands of software patches collected from open source projects.
Preliminary results show that we are able to mine accurate patterns,
efficiently exploiting change information in Rich Edit Scripts. We further
integrated the mined patterns to an automated program repair prototype,
PARFixMiner, with which we are able to correctly fix 26 bugs of the Defects4J
benchmark. Beyond this quantitative performance, we show that the mined fix
patterns are sufficiently relevant to produce patches with a high probability
of correctness: 81% of PARFixMiner's generated plausible patches are correct.Comment: 31 pages, 11 figure
An Investigation into the Use of Mutation Analysis for Automated Program Repair
Research in Search-Based Automated Program Repair has demonstrated promising results, but has nevertheless been largely confined to small, single-edit patches using a limited set of mutation operators. Tackling a broader spectrum of bugs will require multiple edits and a larger set of operators, leading to a combinatorial explosion of the search space. This motivates the need for more efficient search techniques. We propose to use the test case results of candidate patches to localise suitable fix locations. We analysed the test suite results of single-edit patches, generated from a random walk across 28 bugs in 6 programs. Based on the findings of this analysis, we propose a number of mutation-based fault localisation techniques, which we subsequently evaluate by measuring how accurately they locate the statements at which the search was able to generate a solution. After demonstrating that these techniques fail to result in a significant improvement, we discuss why this may be the case, despite the successes of mutation-based fault localisation in previous studies
Test case prioritization using test case diversification and fault-proneness estimations
Context: Regression testing activities greatly reduce the risk of faulty
software release. However, the size of the test suites grows throughout the
development process, resulting in time-consuming execution of the test suite
and delayed feedback to the software development team. This has urged the need
for approaches such as test case prioritization (TCP) and test-suite reduction
to reach better results in case of limited resources. In this regard, proposing
approaches that use auxiliary sources of data such as bug history can be
interesting.
Objective: Our aim is to propose an approach for TCP that takes into account
test case coverage data, bug history, and test case diversification. To
evaluate this approach we study its performance on real-world open-source
projects.
Method: The bug history is used to estimate the fault-proneness of source
code areas. The diversification of test cases is preserved by incorporating
fault-proneness on a clustering-based approach scheme.
Results: The proposed methods are evaluated on datasets collected from the
development history of five real-world projects including 357 versions in
total. The experiments show that the proposed methods are superior to
coverage-based TCP methods.
Conclusion: The proposed approach shows that improvement of coverage-based
and fault-proneness based methods is possible by using a combination of
diversification and fault-proneness incorporation
Mining Fix Patterns for FindBugs Violations
In this paper, we first collect and track a large number of fixed and unfixed
violations across revisions of software.
The empirical analyses reveal that there are discrepancies in the
distributions of violations that are detected and those that are fixed, in
terms of occurrences, spread and categories, which can provide insights into
prioritizing violations.
To automatically identify patterns in violations and their fixes, we propose
an approach that utilizes convolutional neural networks to learn features and
clustering to regroup similar instances. We then evaluate the usefulness of the
identified fix patterns by applying them to unfixed violations.
The results show that developers will accept and merge a majority (69/116) of
fixes generated from the inferred fix patterns. It is also noteworthy that the
yielded patterns are applicable to four real bugs in the Defects4J major
benchmark for software testing and automated repair.Comment: Accepted for IEEE Transactions on Software Engineerin
Variable-Based Fault Localization via Enhanced Decision Tree
Fault localization, aiming at localizing the root cause of the bug under
repair, has been a longstanding research topic. Although many approaches have
been proposed in the last decades, most of the existing studies work at
coarse-grained statement or method levels with very limited insights about how
to repair the bug (granularity problem), but few studies target the
finer-grained fault localization. In this paper, we target the granularity
problem and propose a novel finer-grained variable-level fault localization
technique. Specifically, we design a program-dependency-enhanced decision tree
model to boost the identification of fault-relevant variables via
discriminating failed and passed test cases based on the variable values. To
evaluate the effectiveness of our approach, we have implemented it in a tool
called VARDT and conducted an extensive study over the Defects4J benchmark. The
results show that VARDT outperforms the state-of-the-art fault localization
approaches with at least 247.8% improvements in terms of bugs located at Top-1,
and the average improvements are 330.5%.
Besides, to investigate whether our finer-grained fault localization result
can further improve the effectiveness of downstream APR techniques, we have
adapted VARDT to the application of patch filtering, where VARDT outperforms
the state-of-the-art PATCH-SIM by filtering 26.0% more incorrect patches. The
results demonstrate the effectiveness of our approach and it also provides a
new way of thinking for improving automatic program repair techniques
- …