[Demonstration 1]

[Buggy Method]
@SuppressWarnings({ "WeakerAccess", "unused" })
public Observable<Permission> requestEach(final String... permissions) {
    return Observable.just(null).compose(ensureEach(permissions));
}

[Buggy Hunk]
return Observable.just(null).compose(ensureEach(permissions));

[Patch]
return Observable.just(new Object()).compose(ensureEach(permissions));

[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]
@SuppressWarnings("unchecked")
@Override
protected LinkedList<Column> compose(LinkedList<Column> stack) {
    int size;
    Optional<Periodicity<?>> windowFrequency;
    if (getArgs().length < 1) {
        if (countIncludesCurrent) {
            throw new IllegalArgumentException("window requires at least one parameter (window size)");
        } else {
            size = 2;
        }
    } else {
        try {
            size = Math.abs(Integer.parseInt(getArgs()[0].replaceAll("\\s+", "")));
            size += countIncludesCurrent ? 0 : 1;
        } catch (NumberFormatException nfe) {
            throw new IllegalArgumentException("Non-numeric argument \"" + getArgs()[0] + "\" for window" + " size in rolling function args: \"" + Joiner.on(",").join(getArgs()) + "\"");
        }
    }
    int finalSize = size;
    if (getArgs().length < 2) {
        windowFrequency = Optional.empty();
    } else {
        Periodicity<?> p = Periodicities.get(getArgs()[1].replaceAll("\\s+", ""));
        if (p == null) {
            throw new IllegalArgumentException("invalid periodicity code for window: \"" + getArgs()[1] + "\"");
        }
        windowFrequency = Optional.of(p);
    }
    LinkedList<Column> outputs = new LinkedList<>();
    for (Column function : stack) {
        outputs.add(new Column(inputs -> join(inputs[0].toString(), toString()), inputs -> range -> {
            Periodicity<Period> wf = (Periodicity<Period>) windowFrequency.orElse(range.periodicity());
            Period expandedWindowStart = wf.offset(wf.from(range.start().endDate()), -1 * (finalSize - 1));
            Period windowEnd = wf.from(range.end().endDate());
            PeriodicRange<Period> expandedWindow = wf.range(expandedWindowStart, windowEnd, range.clearCache());
            Builder b = DoubleStream.builder();
            double[] data = inputs[0].getSeries(expandedWindow).get().toArray();
            for (Period p : range.values()) {
                long windowStartIndex = wf.distance(expandedWindowStart, wf.from(p.endDate())) - finalSize + 1;
                DoubleCollector dc = Arrays.stream(data, (int) windowStartIndex, (int) windowStartIndex + finalSize).collect(collectorSupplier, (v, d) -> v.add(d), (v, v1) -> v.combine(v1));
                b.accept(dc.finish());
            }
            return b.build();
        }, function));
    }
    return outputs;
}

[Buggy Hunk]
throw new IllegalArgumentException("window requires at least one parameter (window size)");

[Patch]
throw new IllegalArgumentException(name + " requires at least one argument (window size)");