[Demonstration 1]

[Buggy Method]
public List<IFile> pickAudioFiles() throws CoreException {
    Set<IFile> used = findUsedFiles();
    List<IFile> audios = discoverAudioFiles();
    Set<IFile> result = new HashSet<>();
    if (audios.size() > 0) {
        for (IFile audio : audios) {
            if (!used.contains(audio)) {
                List<IFile> closure = AssetPackCore.getSameNameFiles(audio, audios);
                result.addAll(closure);
                break;
            }
        }
    }
    return new ArrayList<>(result);
}

[Buggy Hunk]
List<IFile> closure = AssetPackCore.getSameNameFiles(audio, audios);

[Patch]
List<IFile> closure = AssetPackCore.getSameNameFiles(audio, audios, AssetPackCore::isAudio);

[Demonstration 2]

[Buggy Method]
@Override
protected File load() {
    return buildExcelFile(true, true);
}

[Buggy Hunk]
return buildExcelFile(true ,true);

[Patch]
return buildExcelFile(blankSheet, includeComments);

[Demonstration 3]

[Buggy Method]
@Override
public Double getConsistency(RecordGroup<RecordType, SchemaElementType> group, EvaluationRule<RecordType, SchemaElementType> rule, Processable<Correspondence<SchemaElementType, Matchable>> schemaCorrespondences, SchemaElementType schemaElement) {
    List<RecordType> records = new ArrayList<>(group.getRecords());
    // remove non-existing values
    Iterator<RecordType> it = records.iterator();
    while (it.hasNext()) {
        RecordType record = it.next();
        Correspondence<SchemaElementType, Matchable> cor = group.getSchemaCorrespondenceForRecord(record, schemaCorrespondences, schemaElement);
        if (cor == null || !hasValue(record, cor)) {
            it.remove();
        }
    }
    if (records.size() == 0) {
        return null;
    } else if (records.size() == 1) {
        // this record group is consistent, as there is only one value
        return 1.0;
    }
    ConnectedComponentClusterer<RecordType> con = new ConnectedComponentClusterer<>();
    // calculate pair-wise similarities
    for (int i = 0; i < records.size(); i++) {
        RecordType r1 = records.get(i);
        Correspondence<SchemaElementType, Matchable> cor1 = group.getSchemaCorrespondenceForRecord(r1, schemaCorrespondences, schemaElement);
        if (cor1 != null) {
            for (int j = i + 1; j < records.size(); j++) {
                RecordType r2 = records.get(j);
                Correspondence<SchemaElementType, Matchable> cor2 = group.getSchemaCorrespondenceForRecord(r2, schemaCorrespondences, schemaElement);
                if (cor2 != null && !con.isEdgeAlreadyInCluster(r1, r2)) {
                    // assumption: in fusion we have a target schema, so all schema correspondences refer to the target schema
                    // this means that we can simply combine both schema correspondences to get a schema correspondence between the two records
                    Correspondence<SchemaElementType, Matchable> cor = Correspondence.<SchemaElementType, Matchable>combine(cor1, cor2);
                    if (rule.isEqual(r1, r2, cor)) {
                        con.addEdge(new Triple<>(r1, r2, 1.0));
                    }
                }
            }
        }
    }
    Map<Collection<RecordType>, RecordType> clusters = con.createResult();
    int largestClusterSize = 0;
    for (Collection<RecordType> cluster : clusters.keySet()) {
        if (cluster.size() > largestClusterSize) {
            largestClusterSize = cluster.size();
        }
    }
    if (largestClusterSize > group.getSize()) {
        System.out.println("Wrong cluster!");
    }
    return (double) largestClusterSize / (double) records.size();
}

[Buggy Hunk]
if(cor==null || !hasValue(record, cor)) {

[Patch]
if(!hasValue(record, cor)) {