[Demonstration 1]

[Buggy Method]
@Override
public void parseColorMap(String id) {
    Retrofit retrofit = new Retrofit.Builder().baseUrl(BASE_URL).addConverterFactory(SimpleXmlConverterFactory.create()).build();
    ColorMapAPI api = retrofit.create(ColorMapAPI.class);
    Call<ColorMap> map = api.fetchData(id);
    Observable.just(map).map(map_call -> {
        Response<ColorMap> r = null;
        try {
            r = map_call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return r;
    }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Response<ColorMap>>() {

        @Override
        public void onSubscribe(Disposable disposable) {
        }

        @Override
        public void onComplete() {
        }

        @Override
        public void onError(Throwable e) {
            Log.w(getClass().getSimpleName(), e);
        }

        @Override
        public void onNext(Response<ColorMap> r) {
            if (viewRef.get() != null) {
                cleanColorMap(r.body());
                viewRef.get().setColorMapData(r.body());
            }
        }
    });
}

[Buggy Hunk]
if(viewRef.get() != null) {

[Patch]
if(viewRef != null && viewRef.get() != null) {

[Demonstration 2]

[Buggy Method]
public boolean hasInducedFaultTimestamp() {
    return getFautlTimestamp() != Long.MAX_VALUE;
}

[Buggy Hunk]
return getFautlTimestamp() != Long.MAX_VALUE;

[Patch]
return getFaultTimestamp() != Long.MAX_VALUE;

[Demonstration 3]

[Buggy Method]
@Override
public Report load(final Sink sink) {
    this.sink = sink;
    Objects.nonNull(source);
    Objects.nonNull(mapper);
    Objects.nonNull(this.sink);
    log.info("Starting harvest from {} to {} with {}", source, this.sink, mapper);
    Report report = new ReportImpl();
    try {
        boolean prepareSink = sink.prepare(mapper.getMapper());
        if (!prepareSink) {
            String msg = "The sink could not be prepared. Stopping load, please check the logs.";
            log.error(msg);
            report.addMessage(msg);
            return report;
        }
    } catch (SinkError e) {
        log.error("Problem preparing sink", e);
        report.addMessage(String.format("Problem preparing sink: %s", e.getMessage()));
        return report;
    }
    final Stopwatch timer = Stopwatch.createStarted();
    long pageStart = startPosition;
    long count = source.getRecordCount();
    final long limit = Math.min(recordsLimit + startPosition, count);
    final Stopwatch sourceTimer = Stopwatch.createUnstarted();
    final Stopwatch mappingTimer = Stopwatch.createUnstarted();
    final Stopwatch sinkTimer = Stopwatch.createUnstarted();
    final Stopwatch currentBulkTimer = Stopwatch.createUnstarted();
    double bulkTimeAvg = 0d;
    long runNumber = 0;
    while (pageStart <= limit) {
        currentBulkTimer.start();
        long recordsLeft = limit - pageStart + 1;
        long size = Math.min(recordsLeft, bulkSize);
        if (size <= 0) {
            break;
        }
        log.info("### [{}] Requesting {} records from {} starting at {}, last requested record will be {} ###", runNumber, size, source.getEndpoint(), pageStart, limit);
        try {
            sourceTimer.start();
            Collection<SourceRecord> records = source.getRecords(pageStart, size, report);
            sourceTimer.stop();
            log.debug("Mapping {} retrieved records.", records.size());
            mappingTimer.start();
            List<SinkRecord> mappedRecords = records.stream().map(record -> {
                try {
                    return mapper.map(record);
                } catch (MappingError e) {
                    report.addFailedRecord(record.toString(), "Problem during mapping: " + e.getMessage());
                    return null;
                }
            }).filter(Objects::nonNull).collect(Collectors.toList());
            mappingTimer.stop();
            log.debug("Storing {} mapped records.", mappedRecords.size());
            if (!testRun) {
                sinkTimer.start();
                mappedRecords.forEach(record -> {
                    try {
                        boolean result = sink.store(record);
                        if (result) {
                            report.addSuccessfulRecord(record.getId());
                        } else {
                            report.addFailedRecord(record.getId(), "see sink log");
                        }
                    } catch (SinkError e) {
                        report.addFailedRecord(record.toString(), "Problem during mapping: " + e.getMessage());
                    }
                });
                sinkTimer.stop();
            } else {
                log.info("TESTRUN, created documents are:\n{}", Arrays.toString(mappedRecords.toArray()));
            }
        } catch (RuntimeException e) {
            if (sourceTimer.isRunning()) {
                sourceTimer.stop();
            }
            if (mappingTimer.isRunning()) {
                mappingTimer.stop();
            }
            if (sinkTimer.isRunning()) {
                sinkTimer.stop();
            }
            String msg = String.format("Problem processing records %s to %s: %s", pageStart, pageStart + size, e.getMessage());
            log.error(msg, e);
            report.addMessage(msg);
        }
        pageStart += bulkSize;
        currentBulkTimer.stop();
        bulkTimeAvg = ((bulkTimeAvg * runNumber) + currentBulkTimer.elapsed(TimeUnit.SECONDS)) / (runNumber + 1);
        updateAndLog(runNumber, (runNumber + 1) * bulkSize, currentBulkTimer.elapsed(TimeUnit.SECONDS), bulkTimeAvg);
        currentBulkTimer.reset();
        runNumber++;
    }
    timer.stop();
    log.info("Completed harvesting for {} ({} failed) of {} records in {} minutes", report.getNumberOfRecordsAdded(), report.getNumberOfRecordsFailed(), source.getRecordCount(), timer.elapsed(TimeUnit.MINUTES));
    log.info("Time spent (minutes): source={}, mapping={}, sink={}", sourceTimer.elapsed(TimeUnit.MINUTES), mappingTimer.elapsed(TimeUnit.MINUTES), sinkTimer.elapsed(TimeUnit.MINUTES));
    return report;
}

[Buggy Hunk]
final long limit = Math.min(recordsLimit + startPosition, count);

[Patch]
final long limit = recordsLimit == Long.MAX_VALUE ? count : Math.min(recordsLimit + startPosition, count);