[Demonstration 1]

[Buggy Method]
public void run() {
    FileWriter output;
    try {
        // warmups
        for (int i = 0; i < warmupRuns; i++) {
            System.err.println(test.getClass().getSimpleName() + " warmup " + i);
            final RecordIterator iter = new RecordIterator(testFilePath, pollingInterval);
            test.doRun(iter);
        }
        // read the stats file
        output = new FileWriter(statsOutfilePath);
        output.write("run,record_number,time,time_diff\n");
        output.flush();
        // observed runs
        for (int i = 0; i < observationRuns; i++) {
            System.err.println(test.getClass().getSimpleName() + " obs " + i);
            final RecordIterator iter = new RecordIterator(testFilePath, pollingInterval);
            test.doRun(iter);
            // write stats to file
            final long[] polledTimes = iter.getPolledTimes();
            long lastTime = 0;
            for (int j = 0; j < polledTimes.length; j++) {
                final int recordCount = (j + 1) * pollingInterval;
                final long time = polledTimes[j];
                final long timeDiff = time - lastTime;
                output.write(i + "," + recordCount + "," + time + "," + timeDiff + "\n");
                lastTime = time;
            }
            output.flush();
        }
        output.close();
    } catch (IOException e) {
        e.printStackTrace();
        throw new RuntimeException("Couldn't open file " + statsOutfilePath);
    }
}

[Buggy Hunk]
long lastTime = 0;

[Patch]
long lastTime = iter.getStart();

[Demonstration 2]

[Buggy Method]
public static Result service(String ownerName, String projectName, String service, boolean isAdvertise) throws IOException, UnsupportedOperationException, ServletException {
    if (!isSupportedService(service)) {
        return forbidden(String.format("Unsupported service: '%s'", service));
    }
    Project project = Project.findByOwnerAndProjectName(ownerName, projectName);
    if (project == null) {
        return notFound();
    }
    models.User user = UserApp.currentUser();
    if (!isAllowed(project, service)) {
        if (user.isAnonymous()) {
            return BasicAuthAction.unauthorized(response());
        } else {
            // If you want the Git client showing your custom message to
            // the user, the Content-Type should be exact "text/plain"
            // without any parameter. For more details, see the code at
            // https://github.com/git/git/commit/426e70d4a11ce3b4f70636d57c6a0ab16ae08a00#diff-eea0ad565ec5903a11b6023755d491cfR154
            response().setHeader("Content-Type", "text/plain");
            return forbidden(String.format("'%s' has no permission to '%s/%s'.", user.name, ownerName, projectName));
        }
    }
    if (isAdvertise) {
        return ok(RepositoryService.gitAdvertise(project, service, response()));
    } else {
        if (request().body().isMaxSizeExceeded()) {
            return status(REQUEST_ENTITY_TOO_LARGE);
        } else {
            user.visits(project);
            return ok(RepositoryService.gitRpc(project, service, request(), response()));
        }
    }
}

[Buggy Hunk]
user.name, ownerName, projectName));

[Patch]
user.loginId, ownerName, projectName));

[Demonstration 3]

[Buggy Method]
@Override
public KafkaMessageSender<K, V> getSender() {
    try {
        // how long should it wait for getting the sender instance
        if (!freeSender.tryAcquire(KafkaConstants.WAIT_TIME_MS, TimeUnit.MILLISECONDS))
            throw new RuntimeException("Timeout waiting for idle object in the pool.");
    } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted waiting for idle object in the pool .");
    }
    KafkaMessageSender<K, V> sender = null;
    closingLock.readLock().lock();
    try {
        sender = queue.poll();
        if (sender == null) {
            sender = new KafkaMessageSenderImpl<K, V>(props);
            logger.info("Add new sender to the pool.");
            queue.offer(sender);
        }
    } catch (Exception e) {
        logger.error("Failed to get the MessageSender", e);
    } finally {
        closingLock.readLock().unlock();
    }
    return sender;
}

[Buggy Hunk]
if (!freeSender.tryAcquire(KafkaConstants.WAIT_TIME_MS, TimeUnit.MILLISECONDS))

[Patch]
if (freeSender != null && !freeSender.tryAcquire(KafkaConstants.WAIT_TIME_MS, TimeUnit.MILLISECONDS))