[Demonstration 1]

[Buggy Method]
@Override
public CheckedFuture<Void, TransactionCommitFailedException> submit() throws DTxException.SubmitFailedException, DTxException.RollbackFailedException {
    int totalSubmitSize = getNumberofNodes();
    final Map<InstanceIdentifier<?>, PerNodeTxState> commitStatus = Maps.newHashMapWithExpectedSize(totalSubmitSize);
    final SettableFuture<Void> distributedSubmitFuture = SettableFuture.create();
    for (DTXLogicalTXProviderType type : this.perNodeTransactionsbyLogicalType.keySet()) {
        Map<InstanceIdentifier<?>, CachingReadWriteTx> transactions = this.perNodeTransactionsbyLogicalType.get(type);
        for (final Map.Entry<InstanceIdentifier<?>, CachingReadWriteTx> perNodeTx : transactions.entrySet()) {
            CheckedFuture<Void, TransactionCommitFailedException> submitFuture = null;
            try {
                submitFuture = perNodeTx.getValue().submit();
            } catch (Throwable submitFailException) {
                new PerNodeSubmitCallback(type, commitStatus, perNodeTx, distributedSubmitFuture).failedWithException(submitFailException);
                continue;
            }
            Futures.addCallback(submitFuture, new PerNodeSubmitCallback(type, commitStatus, perNodeTx, distributedSubmitFuture));
        }
    }
    return Futures.makeChecked(distributedSubmitFuture, new Function<Exception, TransactionCommitFailedException>() {

        @Nullable
        @Override
        public TransactionCommitFailedException apply(@Nullable final Exception input) {
            return new TransactionCommitFailedException("Submit failed. Check nested exception for rollback status", input);
        }
    });
}

[Buggy Hunk]
}catch (Throwable submitFailException){

[Patch]
}catch (Exception submitFailException){

[Demonstration 2]

[Buggy Method]
public static List<Vertex> getPathByState(final Path path, final StateMachineAccessor stateMachine) {
    final List<Vertex> vertices = new ArrayList<Vertex>();
    final Iterator<Node> nodes = path.getNodeIterator();
    while (nodes.hasNext()) {
        final Node node = nodes.next();
        vertices.add(stateMachine.getReversedStateMappings().get(node.toString()));
    }
    return vertices;
}

[Buggy Hunk]
final List<Vertex> vertices = new ArrayList<Vertex>();

[Patch]
final List<Vertex> vertices = new ArrayList<>();

[Demonstration 3]

[Buggy Method]
public SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) {
    if (lexer.token() == Token.DEFAULT) {
        lexer.nextToken();
        column.setDefaultExpr(bitOr());
        return parseColumnRest(column);
    }
    if (lexer.token() == Token.NOT) {
        lexer.nextToken();
        accept(Token.NULL);
        column.getConstraints().add(new NotNullConstraint());
        return parseColumnRest(column);
    }
    if (lexer.token() == Token.NULL) {
        lexer.nextToken();
        column.setDefaultExpr(new SQLNullExpr());
        return parseColumnRest(column);
    }
    if (lexer.token == Token.PRIMARY) {
        lexer.nextToken();
        accept(Token.KEY);
        column.getConstraints().add(new SQLColumnPrimaryKey());
        return parseColumnRest(column);
    }
    if (lexer.token == Token.UNIQUE) {
        lexer.nextToken();
        if (lexer.token() == Token.KEY) {
            lexer.nextToken();
        }
        column.getConstraints().add(new SQLColumnPrimaryKey());
        return parseColumnRest(column);
    }
    if (lexer.token == Token.CONSTRAINT) {
        lexer.nextToken();
        SQLName name = this.name();
        if (lexer.token() == Token.PRIMARY) {
            lexer.nextToken();
            accept(Token.KEY);
            SQLColumnPrimaryKey pk = new SQLColumnPrimaryKey();
            pk.setName(name);
            column.getConstraints().add(pk);
            return parseColumnRest(column);
        }
        if (lexer.token() == Token.UNIQUE) {
            lexer.nextToken();
            SQLColumnUniqueKey uk = new SQLColumnUniqueKey();
            uk.setName(name);
            column.getConstraints().add(uk);
            return parseColumnRest(column);
        }
        if (lexer.token() == Token.REFERENCES) {
            lexer.nextToken();
            SQLColumnReference ref = new SQLColumnReference();
            ref.setName(name);
            ref.setTable(this.name());
            accept(Token.LPAREN);
            this.names(ref.getColumns(), ref);
            accept(Token.RPAREN);
            column.getConstraints().add(ref);
            return parseColumnRest(column);
        }
        if (lexer.token() == Token.NOT) {
            lexer.nextToken();
            accept(Token.NULL);
            NotNullConstraint notNull = new NotNullConstraint();
            notNull.setName(name);
            column.getConstraints().add(notNull);
            return parseColumnRest(column);
        }
        if (lexer.token == Token.CHECK) {
            SQLColumnCheck check = parseColumnCheck();
            check.setName(name);
            check.setParent(column);
            column.getConstraints().add(check);
            return parseColumnRest(column);
        }
        if (lexer.token == Token.DEFAULT) {
            lexer.nextToken();
            SQLExpr expr = this.expr();
            column.setDefaultExpr(expr);
            return parseColumnRest(column);
        }
        throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
    }
    if (lexer.token == Token.CHECK) {
        SQLColumnCheck check = parseColumnCheck();
        column.getConstraints().add(check);
        return parseColumnRest(column);
    }
    if (lexer.token() == Token.COMMENT) {
        lexer.nextToken();
        column.setComment(primary());
    }
    return column;
}

[Buggy Hunk]
column.getConstraints().add(new SQLColumnPrimaryKey());

[Patch]
column.getConstraints().add(new SQLColumnUniqueKey());