[Demonstration 1]

[Buggy Method]
public synchronized void readEntryComplete(final int rc, final long ledgerId, final long entryId, final ByteBuf buffer, final Object ctx) {
    int bookieIndex = (Integer) ctx;
    numResponsesPending--;
    boolean heardValidResponse = false;
    if (rc == BKException.Code.OK) {
        try {
            RecoveryData recoveryData = lh.macManager.verifyDigestAndReturnLastConfirmed(buffer);
            if (recoveryData.lastAddConfirmed > maxRecoveredData.lastAddConfirmed) {
                maxRecoveredData = recoveryData;
            }
            heardValidResponse = true;
        } catch (BKDigestMatchException e) {
            // Too bad, this bookie didn't give us a valid answer, we
            // still might be able to recover though so continue
            LOG.error("Mac mismatch for ledger: " + ledgerId + ", entry: " + entryId + " while reading last entry from bookie: " + lh.metadata.currentEnsemble.get(bookieIndex));
        }
    }
    buffer.release();
    if (rc == BKException.Code.NoSuchLedgerExistsException || rc == BKException.Code.NoSuchEntryException) {
        // this still counts as a valid response, e.g., if the client crashed without writing any entry
        heardValidResponse = true;
    }
    if (rc == BKException.Code.UnauthorizedAccessException && !completed) {
        cb.readLastConfirmedDataComplete(rc, maxRecoveredData);
        completed = true;
    }
    if (!heardValidResponse && BKException.Code.OK != rc) {
        lastSeenError = rc;
    }
    // other return codes dont count as valid responses
    if (heardValidResponse && coverageSet.addBookieAndCheckCovered(bookieIndex) && !completed) {
        completed = true;
        LOG.debug("Read Complete with enough validResponses for ledger: {}, entry: {}", ledgerId, entryId);
        cb.readLastConfirmedDataComplete(BKException.Code.OK, maxRecoveredData);
        return;
    }
    if (numResponsesPending == 0 && !completed) {
        // Have got all responses back but was still not enough, just fail the operation
        LOG.error("While readLastConfirmed ledger: " + ledgerId + " did not hear success responses from all quorums");
        cb.readLastConfirmedDataComplete(lastSeenError, maxRecoveredData);
    }
}

[Buggy Hunk]
buffer.release();

[Patch]
ReferenceCountUtil.release(buffer);

[Demonstration 2]

[Buggy Method]
private Observable<FeedEntry<E>> feedWrapperObservable(final ClientState state, final int intervalInMs) {
    Observable<FeedWrapper<E>> observableFeedPage = Observable.create((subscriber) -> {
        Scheduler.Worker worker = Schedulers.newThread().createWorker();
        worker.schedulePeriodically(() -> {
            logger.debug("Scheduled work started");
            String url = state.lastSeenSelfHref.orElse("");
            try {
                while (!subscriber.isUnsubscribed() && url != null) {
                    logger.debug("Start polling");
                    Optional<String> etag = Optional.empty();
                    etag = state.lastSeenEtag;
                    logger.debug("Retrieving page: " + url);
                    Observable<FeedWrapper<E>> feedObservable = createFeedWrapperObservable(url, etag);
                    FeedWrapper<E> feed = prune(feedObservable.toBlocking().last(), state);
                    if (!feed.isEmpty()) {
                        logger.debug("Emitting: " + feed.getEntries());
                        subscriber.onNext(feed);
                        state.lastSeenEtag = feed.getEtag();
                        state.lastSeenEntryId = Optional.of(feed.getLastEntryId());
                        state.lastSeenSelfHref = Optional.of(feed.getSelfHref());
                        logger.debug("Setting lastseenSelfHref to :" + feed.getSelfHref());
                    } else {
                        logger.debug("Received 304");
                    }
                    url = feed.getPreviousHref().orElse(null);
                }
                if (subscriber.isUnsubscribed()) {
                    logger.debug("Worker unsubscribe");
                    worker.unsubscribe();
                }
            } catch (Exception e) {
                subscriber.onError(e);
                worker.unsubscribe();
                logger.debug("Worker unsubscribe after error");
            }
            logger.debug("Scheduled work finished.");
        }, 0, intervalInMs, TimeUnit.MILLISECONDS);
    });
    return observableFeedPage.flatMap(feed -> Observable.from(feed.getEntries()).map(entry -> new FeedEntry<>(entry, feed)));
}

[Buggy Hunk]
if (!feed.isEmpty()) {

[Patch]
if (!feed.getEntries().isEmpty()) {

[Demonstration 3]

[Buggy Method]
private void releaseWakeLock() {
    if (mWakeLock != null) {
        Log.d(LOG_TAG, "Releasing wake lock: " + mWakeLock);
        mWakeLock.release();
    } else {
        Log.d(LOG_TAG, "Wake lock not found");
    }
}

[Buggy Hunk]
if (mWakeLock != null) {

[Patch]
if (mWakeLock != null && mWakeLock.isHeld()) {