An Approach and Benchmark to Detect Behavioral Changes of Commits in Continuous Integration

TL;DR

This paper introduces DCI, an automated approach that detects behavioral changes in code commits by generating test methods, and provides a new benchmark dataset of real-world behavioral changes in open source Java projects.

Contribution

The paper presents DCI, a novel automated method for detecting behavioral changes in commits using assertion amplification and input space exploration, along with a curated dataset of real-world changes.

Findings

DCI successfully detects behavioral changes in 15.29% of commits in the benchmark.

The approach can be integrated into existing development workflows.

It works effectively on commits with existing unit tests that cover the modified code.

Abstract

When a developer pushes a change to an application's codebase, a good practice is to have a test case specifying this behavioral change. Thanks to continuous integration (CI), the test is run on subsequent commits to check that they do no introduce a regression for that behavior. In this paper, we propose an approach that detects behavioral changes in commits. As input, it takes a program, its test suite, and a commit. Its output is a set of test methods that capture the behavioral difference between the pre-commit and post-commit versions of the program. We call our approach DCI (Detecting behavioral changes in CI). It works by generating variations of the existing test cases through (i) assertion amplification and (ii) a search-based exploration of the input space. We evaluate our approach on a curated set of 60 commits from 6 open source Java projects. To our knowledge, this is the first ever curated dataset of real-world behavioral changes. Our evaluation shows that DCI is able to generate test methods that detect behavioral changes. Our approach is fully automated and can be integrated into current development processes. The main limitations are that it targets unit tests and works on a relatively small fraction of commits. More specifically, DCI works on commits that have a unit test that already executes the modified code. In practice, from our benchmark projects, we found 15.29% of commits to meet the conditions required by DCI.

Full text

In this paper, we propose an approach that detects behavioral changes in commits. As input, it takes a program, its test suite, and a commit. Its output is a set of test methods that capture the behavioral difference between the pre-commit and post-commit versions of the program. We call our approach DCI (Detecting behavioral changes in CI). It works by generating variations of the existing test cases through (i) assertion amplification and (ii) a search-based exploration of the input space.

We evaluate our approach on a curated set of 60 commits from 6 open source Java projects. To our knowledge, this is the first ever curated dataset of real-world behavioral changes. Our evaluation shows that DCI is able to generate test methods that detect behavioral changes. Our approach is fully automated and can be integrated into current development processes. The main limitations are that it targets unit tests and works on a relatively small fraction of commits. More specifically, DCI works on commits that have a unit test that already executes the modified code. In practice, from our benchmark projects, we found 15.29% of commits to meet the conditions required by DCI.

1 Introduction

In collaborative software projects, developers work in parallel on the same code base. Every time a developer integrates her changes, she submits them in the form of a commit to a version control system. The Continuous Integration (CI) server fowler2006continuous merges the commit with the master branch, compiles and automatically runs the test suite to check that the commit behaves as expected. Its ability to detect bugs early makes CI an essential contribution to quality assurance Hilton:2016:UsageCI; duvall2007continuous.

However, the effectiveness of Continuous Integration depends on one key property: each commit should include at least one test case $t_{new}$ that specifies the intended change. For instance, assume one wants to integrate a bug fix. In this case, the developer is expected to include a new test method, $t_{new}$, that specifies the program’s desired behavior after the bug fix is applied. This can be mechanically verified: $t_{new}$ should fail on the version of the code that does not include the fix (the pre-commit version), and pass on the version that includes the fix (the post-commit version). However, many commits either do not include a $t_{new}$ or $t_{new}$ does not meet this fail/pass criterion. The reason is that developers sometimes cut corners because of lack of time, expertise or discipline. This is the problem we address in this paper.

In this paper, we aim to automatically generate test methods for each commit that is submitted to the CI. In particular, we generate a test case $t_{gen}$ that specifies the behavioral change of each commit. We consider a generated test case $t_{gen}$ to be relevant if it satisfies the following property: $t_{gen}$ passes on the pre-commit version and fails on the post-commit version. To do so, we developed a new approach, called DCI, that works in two steps. First, we analyze the test cases of the pre-commit version and select the ones that exercise the parts of the code modified by the commit. Second, our test generation techniques produce variant test cases that either add assertions TaoXie2006 to existing tests or explore new inputs following a search-based test input generation approach tonella. This process of automatic generation of $t_{gen}$ from existing tests is called test amplification zhang2012. We evaluate our approach on a benchmark of 60 commits selected from 6 open source Java projects, constructed with a novel and systematic methodology. We analyzed 1576 commits and selected those that introduce a behavioral change (e.g., we do not want to generate tests for commits that only change comments). We also make sure that all selected commits contain a developer-written test case that detects the behavioral change. In our protocol, the developer’s test case acts as a ground-truth to analyze the tests generated by DCI. Overall, we found 60 commits that satisfy the two essential properties we are looking for:

1. the commit introduces a behavioral change;
2. the commit has a human written test we can use for ground truth. This corresponds to 15.3% of commits in average. While this may appear to be a low proportion of commits, our approach is fully automated and developers can still benefit from its output without any manual intervention.

To sum up, our contributions are:

• •

DCI (Detecting behavioral changes in CI), an approach based on test amplification to generate new tests that detect the behavioral change introduced by a commit.

• •

An open-source implementation of DCI for Java.

• •

A curated benchmark of 60 commits that introduce a behavioral change and include a test case to detect it, selected from 6 notable open source Java projects111https://github.com/STAMP-project/dspot-experiments.

• •

A comprehensive evaluation based on 4 research questions that combines quantitative and qualitative analysis with manual assessment.

In