[Demonstration 1]

[Buggy Method]
public void replaceExpression(String expressionToReplace, String replacementExpression) {
    if (isMultipleExpression(expressionToReplace) || isMultipleExpression(replacementExpression)) {
        throw new WrongFormatException();
    }
    ParsedExpression parsedExpressionToReplace = parseExpression(expressionToReplace);
    ParsedExpression parsedReplacementExpression = parseExpression(replacementExpression);
    Set<Integer> indexesToReplace = parsedExpressionToReplace.getVariables();
    Set<Integer> indexesReplacement = parsedReplacementExpression.getVariables();
    Map<List<Integer>, Integer> afterReplacement = new HashMap<>();
    VariablePowers: for (List<Integer> variablePowers : polynomialMap.keySet()) {
        int initialConstant = polynomialMap.get(variablePowers);
        if (parsedExpressionToReplace.getConstant().isPresent() && parsedExpressionToReplace.getConstant().get().equals(polynomialMap.get(variablePowers))) {
            insertExpressionIntoMap(afterReplacement, variablePowers, initialConstant);
            continue;
        }
        int size = variablePowers.size();
        for (Integer index : indexesToReplace) {
            if (index > size || variablePowers.get(index - 1) != parsedExpressionToReplace.getVariablePower(index)) {
                insertExpressionIntoMap(afterReplacement, variablePowers, initialConstant);
                continue VariablePowers;
            }
        }
        size = findMaximumVariableIndex(size, parsedReplacementExpression.getVariables());
        List<Integer> powers = new ArrayList<>(Collections.nCopies(size, 0));
        for (int i = 0; i < variablePowers.size(); i++) {
            if (!indexesToReplace.contains(i + 1)) {
                powers.set(i, variablePowers.get(i));
            }
        }
        for (Integer index : indexesReplacement) {
            powers.set(index - 1, powers.get(index - 1) + parsedReplacementExpression.getVariablePower(index));
        }
        int constant = parsedReplacementExpression.getConstant().isPresent() ? parsedExpressionToReplace.getConstant().isPresent() ? parsedReplacementExpression.getConstant().get() : initialConstant * parsedReplacementExpression.getConstant().get() : initialConstant;
        insertExpressionIntoMap(afterReplacement, powers, constant);
    }
    setPolynomialMap(afterReplacement);
}

[Buggy Hunk]
if (parsedExpressionToReplace.getConstant().isPresent() && parsedExpressionToReplace.getConstant().get().equals(polynomialMap.get(variablePowers))) {

[Patch]
if (parsedExpressionToReplace.getConstant().isPresent() && !parsedExpressionToReplace.getConstant().get().equals(polynomialMap.get(variablePowers))) {

[Demonstration 2]

[Buggy Method]
private static String buildSearchValue(String value) {
    if (value.contains(" or ")) {
        String[] values = value.split(" or ");
        for (int i = 0; i < values.length; i++) {
            values[i] = values[i].trim().replace(" ", "\\ ");
        }
        value = StringUtils.join(values, " OR ");
    } else if (value.contains(" and ")) {
        String[] values = value.split(" and ");
        for (int i = 0; i < values.length; i++) {
            values[i] = values[i].trim().replace(" ", "\\ ");
        }
        value = StringUtils.join(values, " AND ");
    } else if (value.contains(" ")) {
        value = value.replace(" ", "\\ ");
    }
    return value;
}

[Buggy Hunk]
} else if (value.contains(" ")) {

[Patch]
} else if (value.contains(" ") && !value.contains(" or")) {

[Demonstration 3]

[Buggy Method]
public ApiSurface includingPackage(String packageName) throws IOException {
    ClassPath classPath = ClassPath.from(ClassLoader.getSystemClassLoader());
    Set<Class<?>> newRootClasses = Sets.newHashSet();
    for (ClassInfo classInfo : classPath.getTopLevelClassesRecursive(packageName)) {
        Class clazz = classInfo.load();
        if (exposed(clazz.getModifiers())) {
            newRootClasses.add(clazz);
        }
    }
    LOG.debug("Including package {} and subpackages: {}", packageName, newRootClasses);
    newRootClasses.addAll(rootClasses);
    return new ApiSurface(newRootClasses, patternsToPrune);
}

[Buggy Hunk]
ClassPath classPath = ClassPath.from(ClassLoader.getSystemClassLoader());

[Patch]
ClassPath classPath = ClassPath.from(getSdkClassLoader());