[Demonstration 1]

[Buggy Method]
public void severe(String toLog) {
    String message = "SEVERE: " + new Date().toString() + ": " + toLog;
    this.allCache.add(message);
    this.severeRecentCache.add(message);
    this.logger.warning(toLog);
}

[Buggy Hunk]
this.logger.warning(toLog);

[Patch]
this.logger.severe(toLog);

[Demonstration 2]

[Buggy Method]
public void testMultiDomain() {
    Random rand = new Random();
    StringBuilder domainName1 = new StringBuilder();
    domainName1.append(DOMAIN_NAME_PREFIX);
    domainName1.append(Integer.toString(rand.nextInt(100000) + 1));
    domainName1.append(DOMAIN_NAME_SUFFIX);
    StringBuilder domainName2 = new StringBuilder();
    domainName2.append(DOMAIN_NAME_PREFIX);
    domainName2.append(Integer.toString(rand.nextInt(100000) + 1));
    domainName2.append(DOMAIN_NAME_SUFFIX);
    try {
        String[] names = { domainName1.toString(), domainName2.toString() };
        ManagedDNSResponse response = client.createDomains(names);
        assertTrue(response != null);
        ManagedDNSResponse domains = client.getDomains();
        String[] ids = { String.valueOf(domains.getData()[0].getId()), String.valueOf(domains.getData()[1].getId()) };
        response = client.deleteDomains(ids);
        assertTrue(response != null);
    } catch (DNSMadeEasyException e) {
        log.error(e.toString(), e);
        assertTrue(false);
    }
}

[Buggy Hunk]
log.error(e.toString(), e);

[Patch]
log.error(e.getMessage(), e);

[Demonstration 3]

[Buggy Method]
public final void log() {
    if ("".equals(message)) {
        return;
    }
    if (exception == null) {
        switch(level) {
            case NULL:
                return;
            case DEBUG:
                log.debug(message);
                break;
            case ERROR:
                log.error(message);
                break;
            case FATAL:
                log.fatal(message);
                break;
            case INFO:
                log.info(message);
                break;
            case TRACE:
                log.trace(message);
                break;
            case WARN:
                log.warn(message);
                break;
        }
    } else {
        switch(level) {
            case NULL:
                return;
            case DEBUG:
                log.debug(message, exception);
                break;
            case ERROR:
                log.error(message, exception);
                break;
            case FATAL:
                log.fatal(message, exception);
                break;
            case INFO:
                log.info(message, exception);
                break;
            case TRACE:
                log.trace(message, exception);
                break;
            case WARN:
                log.warn(message, exception);
                break;
        }
    }
    clear();
}

[Buggy Hunk]
public final void log() {

[Patch]
protected final void log() {