[Demonstration 1]

[Buggy Method]
@BindingAdapter({ "url", "thumbUrl", "manager" })
public static void loadImage(PhotoView photoView, String url, @Nullable String thumbUrl, DownloadPreferencesManager manager) {
    if (TextUtils.isEmpty(url)) {
        return;
    }
    Context context = photoView.getContext();
    RequestOptions requestOptions = new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA).downsample(new GlMaxTextureSizeDownSampleStrategy()).error(R.mipmap.error_symbol).fitCenter().priority(Priority.HIGH);
    RequestBuilder<Drawable> thumbnailRequest;
    if (!TextUtils.isEmpty(thumbUrl)) {
        thumbnailRequest = Glide.with(context).load(thumbUrl).apply(new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA));
        requestOptions = requestOptions.placeholder(R.drawable.loading);
    } else {
        thumbnailRequest = Glide.with(context).load(R.drawable.loading);
    }
    //avatar signature
    if (manager != null && Api.isAvatarUrl(url)) {
        requestOptions = requestOptions.signature(manager.getAvatarCacheInvalidationIntervalSignature());
    }
    RequestBuilder<Drawable> builder = Glide.with(context).load(new ForcePassUrl(url)).apply(requestOptions).thumbnail(thumbnailRequest).listener(new RequestListener<Drawable>() {

        @Override
        public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
            if (thumbUrl != null) {
                loadImage(photoView, thumbUrl, null, manager);
                return true;
            }
            return false;
        }

        @Override
        public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
            return false;
        }
    });
    builder.into(photoView);
}

[Buggy Hunk]
.downsample(new GlMaxTextureSizeDownSampleStrategy())

[Patch]
.transform(new GlMaxTextureSizeBitmapTransformation())

[Demonstration 2]

[Buggy Method]
private void startTicking() {
    if (mTimer == null) {
        mTimer = new Timer();
        mTimer.schedule(new TimerTask() {

            @Override
            public void run() {
                if (mPlayer.isPlaying())
                    EventBus.getDefault().post(new TickEvent(getDuration(), getCurrentPosition()));
            }
        }, 0, 100);
    }
}

[Buggy Hunk]
}, 0, 100);

[Patch]
}, 100, 100);

[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()));