[Demonstration 1]

[Buggy Method]
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (remoteContentServiceConnection != null) {
        remoteContentServiceConnection = new ContentServiceConnection(this);
    }
    downloadFragment = (DownloadProgressFragment) getActivity().getSupportFragmentManager().findFragmentByTag("download-fragment");
    if (downloadFragment == null) {
        downloadFragment = new DownloadProgressFragment();
        getActivity().getSupportFragmentManager().beginTransaction().add(R.id.download_fragment, downloadFragment, "download-fragment").hide(downloadFragment).addToBackStack(null).commit();
    }
    ContentDialog contentDialog = (ContentDialog) getActivity().getSupportFragmentManager().findFragmentByTag("content-dialog");
    if (contentDialog != null) {
        contentDialog.setListener(this);
    }
    downloadFragment.setListener(this);
    setHasOptionsMenu(true);
    if (getArguments() != null && getArguments().getBoolean("suggest")) {
        suggestItem();
    }
}

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

[Patch]
if (remoteContentServiceConnection == null) {

[Demonstration 2]

[Buggy Method]
@Test
public void shouldCompleteSuccessfully() throws Exception {
    PlatformTransactionManager transactionManager = createNonFailingTransactionManager("single");
    setupTransactionManagers(transactionManager);
    createAndCommitTransaction();
    assertThat(transactionManager, isCommitted());
}

[Buggy Hunk]
public void shouldCompleteSuccessfully() throws Exception {

[Patch]
public void shouldCompleteSuccessfully() {

[Demonstration 3]

[Buggy Method]
@Test(timeout = 10000)
public void testMultipleTaskletsFailure() throws Exception {
    // The tasklets that need to be executed
    final ArrayList<VortexFuture> vortexFutures = new ArrayList<>();
    final RunningWorkers runningWorkers = new RunningWorkers(new RandomSchedulingPolicy());
    final PendingTasklets pendingTasklets = new PendingTasklets();
    final DefaultVortexMaster vortexMaster = new DefaultVortexMaster(runningWorkers, pendingTasklets, 5);
    // Allocate iniital evaluators (will all be preempted later...)
    final List<VortexWorkerManager> initialWorkers = new ArrayList<>();
    final int numOfWorkers = 100;
    for (int i = 0; i < numOfWorkers; i++) {
        final VortexWorkerManager vortexWorkerManager = testUtil.newWorker();
        initialWorkers.add(vortexWorkerManager);
        vortexMaster.workerAllocated(vortexWorkerManager);
    }
    // Schedule tasklets
    final int numOfTasklets = 100;
    for (int i = 0; i < numOfTasklets; i++) {
        vortexFutures.add(vortexMaster.enqueueTasklet(testUtil.newFunction(), null, Optional.<FutureCallback<Integer>>empty()));
    }
    final ArrayList<Integer> taskletIds1 = launchTasklets(runningWorkers, pendingTasklets, numOfTasklets);
    // Preempt all evaluators
    for (int i = 0; i < numOfWorkers; i++) {
        vortexMaster.workerPreempted(initialWorkers.get(i).getId());
    }
    // Allocate new evaluators and reschedule
    for (int i = 0; i < numOfWorkers; i++) {
        vortexMaster.workerAllocated(testUtil.newWorker());
    }
    final ArrayList<Integer> taskletIds2 = launchTasklets(runningWorkers, pendingTasklets, numOfTasklets);
    assertEquals("Must contain same tasklet ids", new HashSet<>(taskletIds1), new HashSet<>(taskletIds2));
    // Completed?
    for (final int taskletId : taskletIds2) {
        final String workerId = runningWorkers.getWhereTaskletWasScheduledTo(taskletId);
        assertNotNull("The tasklet must have been scheduled", workerId);
        vortexMaster.taskletCompleted(workerId, taskletId, EMPTY_RESULT);
    }
    for (final VortexFuture vortexFuture : vortexFutures) {
        assertTrue("The VortexFuture should be done", vortexFuture.isDone());
    }
}

[Buggy Hunk]
Optional.<FutureCallback<Integer>>empty()));

[Patch]
Optional.<FutureCallback<Void>>empty()));