[Demonstration 1]

[Buggy Method]
public static File getUniqueFile(File parentFile, String name, boolean includeSpaces, boolean uniquePerSession) {
    if (!includeSpaces)
        name = name.replace(" ", "");
    String baseName, ext;
    int i = name.lastIndexOf('.');
    if (i == -1) {
        ext = "";
        baseName = name;
    } else {
        ext = name.substring(i);
        baseName = name.substring(0, i);
    }
    AtomicLong ctr;
    if (uniquePerSession) {
        synchronized (dirMap) {
            Map<String, AtomicLong> m = dirMap.get(parentFile);
            if (m == null) {
                m = new HashMap<String, AtomicLong>();
                dirMap.put(parentFile, m);
            }
            ctr = m.get(parentFile);
            if (ctr == null) {
                ctr = new AtomicLong(1);
                m.put(name, ctr);
            }
        }
    } else {
        if (Character.isDigit(baseName.charAt(baseName.length() - 1))) {
            //it ends with a number, so use that as our base number:
            i = baseName.length() - 1;
            while (i >= 0 && Character.isDigit(baseName.charAt(i))) {
                i--;
            }
            long k = Long.parseLong(baseName.substring(i + 1));
            //k necessarily exists (since we just found it), so increment:
            ctr = new AtomicLong(k + 1);
        } else {
            ctr = new AtomicLong(1);
        }
    }
    while (true) {
        File file;
        long k;
        synchronized (ctr) {
            k = ctr.getAndIncrement();
        }
        if (k == 1) {
            file = new File(parentFile, name);
        } else {
            String newName;
            if (includeSpaces) {
                newName = baseName + " " + k + ext;
            } else {
                newName = baseName + k + ext;
            }
            file = new File(parentFile, newName);
        }
        if (!file.exists()) {
            return file;
        }
    }
}

[Buggy Hunk]
ctr = m.get(parentFile);

[Patch]
ctr = m.get(name);

[Demonstration 2]

[Buggy Method]
protected final Module loadModuleLocal(String name) throws ModuleLoadException {
    FutureModule futureModule = moduleMap.get(name);
    if (futureModule != null) {
        return futureModule.getModule();
    }
    FutureModule newFuture = new FutureModule(name);
    futureModule = moduleMap.putIfAbsent(name, newFuture);
    if (futureModule != null) {
        return futureModule.getModule();
    }
    boolean ok = false;
    try {
        final ModuleLogger log = Module.log;
        log.trace("Locally loading module %s from %s", name, this);
        final long startTime = Metrics.getCurrentCPUTime();
        final ModuleSpec moduleSpec = findModule(name);
        loadTime.addAndGet(Metrics.getCurrentCPUTime() - startTime);
        if (moduleSpec == null) {
            log.trace("Module %s not found from %s", name, this);
            return null;
        }
        if (!moduleSpec.getName().equals(name)) {
            throw new ModuleLoadException("Module loader found a module with the wrong name");
        }
        final Module module;
        if (moduleSpec instanceof AliasModuleSpec) {
            final String aliasName = ((AliasModuleSpec) moduleSpec).getAliasName();
            try {
                newFuture.setModule(module = loadModuleLocal(name));
            } catch (RuntimeException | Error e) {
                log.trace(e, "Failed to load module %s (alias for %s)", name, aliasName);
                throw e;
            }
        } else {
            module = defineModule((ConcreteModuleSpec) moduleSpec, newFuture);
        }
        log.trace("Loaded module %s from %s", name, this);
        ok = true;
        return module;
    } finally {
        if (!ok) {
            newFuture.setModule(null);
            moduleMap.remove(name, newFuture);
        }
    }
}

[Buggy Hunk]
newFuture.setModule(module = loadModuleLocal(name));

[Patch]
newFuture.setModule(module = loadModuleLocal(aliasName));

[Demonstration 3]

[Buggy Method]
public boolean equals(final Object obj) {
    if (obj instanceof Step) {
        final Step other = (Step) obj;
        return obj == other || (other.rule.equals(this.rule) && other.pos == this.pos);
    } else {
        return false;
    }
}

[Buggy Hunk]
return obj == other || (other.rule.equals(this.rule) && other.pos == this.pos);

[Patch]
return other.rule.equals(this.rule) && other.pos == this.pos;