nus-yam/ex-repair huggingface dataset:
Program: 160850
Project: 160850
Buggy source:
public final Initializer_listContext initializer_list() throws RecognitionException {
  Initializer_listContext _localctx=new Initializer_listContext(_ctx,getState());
  enterRule(_localctx,104,RULE_initializer_list);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(462);
      initializer();
      setState(467);
      _errHandler.sync(this);
      _la=_input.LA(1);
      while (_la == 26) {
{
{
            setState(463);
            match(26);
            setState(464);
            initializer();
          }
        }
        setState(469);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Initializer_listContext initializer_list() throws RecognitionException {
  Initializer_listContext _localctx=new Initializer_listContext(_ctx,getState());
  enterRule(_localctx,104,RULE_initializer_list);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(475);
      initializer();
      setState(480);
      _errHandler.sync(this);
      _la=_input.LA(1);
      while (_la == 27) {
{
{
            setState(476);
            match(27);
            setState(477);
            initializer();
          }
        }
        setState(482);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160851
Project: 160851
Buggy source:
public final Init_declarator_listContext init_declarator_list() throws RecognitionException {
  Init_declarator_listContext _localctx=new Init_declarator_listContext(_ctx,getState());
  enterRule(_localctx,100,RULE_init_declarator_list);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(445);
      init_declarator();
      setState(450);
      _errHandler.sync(this);
      _la=_input.LA(1);
      while (_la == 26) {
{
{
            setState(446);
            match(26);
            setState(447);
            init_declarator();
          }
        }
        setState(452);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
      setState(453);
      match(45);
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Init_declarator_listContext init_declarator_list() throws RecognitionException {
  Init_declarator_listContext _localctx=new Init_declarator_listContext(_ctx,getState());
  enterRule(_localctx,100,RULE_init_declarator_list);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(458);
      init_declarator();
      setState(463);
      _errHandler.sync(this);
      _la=_input.LA(1);
      while (_la == 27) {
{
{
            setState(459);
            match(27);
            setState(460);
            init_declarator();
          }
        }
        setState(465);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
      setState(466);
      match(46);
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160852
Project: 160852
Buggy source:
public final Class_defContext class_def() throws RecognitionException {
  Class_defContext _localctx=new Class_defContext(_ctx,getState());
  enterRule(_localctx,106,RULE_class_def);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(470);
      match(CLASS_KEY);
      setState(472);
      _la=_input.LA(1);
      if (_la == ALPHA_NUMERIC) {
{
          setState(471);
          class_name();
        }
      }
      setState(475);
      _la=_input.LA(1);
      if (_la == 29) {
{
          setState(474);
          base_classes();
        }
      }
      setState(477);
      match(OPENING_CURLY);
      skipToEndOfObject();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Class_defContext class_def() throws RecognitionException {
  Class_defContext _localctx=new Class_defContext(_ctx,getState());
  enterRule(_localctx,106,RULE_class_def);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(483);
      match(CLASS_KEY);
      setState(485);
      _la=_input.LA(1);
      if (_la == ALPHA_NUMERIC) {
{
          setState(484);
          class_name();
        }
      }
      setState(488);
      _la=_input.LA(1);
      if (_la == 30) {
{
          setState(487);
          base_classes();
        }
      }
      setState(490);
      match(OPENING_CURLY);
      skipToEndOfObject();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160853
Project: 160853
Buggy source:
public final No_squaresContext no_squares() throws RecognitionException {
  No_squaresContext _localctx=new No_squaresContext(_ctx,getState());
  enterRule(_localctx,36,RULE_no_squares);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(238);
      _la=_input.LA(1);
      if (_la <= 0 || (_la == 3 || _la == 22)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_squaresContext no_squares() throws RecognitionException {
  No_squaresContext _localctx=new No_squaresContext(_ctx,getState());
  enterRule(_localctx,36,RULE_no_squares);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(238);
      _la=_input.LA(1);
      if (_la <= 0 || (_la == 3 || _la == 23)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160855
Project: 160855
Buggy source:
public final No_squares_or_semicolonContext no_squares_or_semicolon() throws RecognitionException {
  No_squares_or_semicolonContext _localctx=new No_squares_or_semicolonContext(_ctx,getState());
  enterRule(_localctx,38,RULE_no_squares_or_semicolon);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(240);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 22) | (1L << 45))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_squares_or_semicolonContext no_squares_or_semicolon() throws RecognitionException {
  No_squares_or_semicolonContext _localctx=new No_squares_or_semicolonContext(_ctx,getState());
  enterRule(_localctx,38,RULE_no_squares_or_semicolon);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(240);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 23) | (1L << 46))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160856
Project: 160856
Buggy source:
public final DeclaratorContext declarator() throws RecognitionException {
  DeclaratorContext _localctx=new DeclaratorContext(_ctx,getState());
  enterRule(_localctx,92,RULE_declarator);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(414);
      _la=_input.LA(1);
      if (_la == 1 || _la == 2) {
{
          setState(413);
          ptrs();
        }
      }
      setState(416);
      identifier();
      setState(418);
switch (getInterpreter().adaptivePredict(_input,32,_ctx)) {
case 1:
{
          setState(417);
          type_suffix();
        }
      break;
  }
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}

Fixed version (ground truth):
public final DeclaratorContext declarator() throws RecognitionException {
  DeclaratorContext _localctx=new DeclaratorContext(_ctx,getState());
  enterRule(_localctx,92,RULE_declarator);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(427);
      _la=_input.LA(1);
      if (_la == 1 || _la == 2) {
{
          setState(426);
          ptrs();
        }
      }
      setState(429);
      identifier();
      setState(431);
switch (getInterpreter().adaptivePredict(_input,33,_ctx)) {
case 1:
{
          setState(430);
          type_suffix();
        }
      break;
  }
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}
Program: 160857
Project: 160857
Buggy source:
public final No_bracketsContext no_brackets() throws RecognitionException {
  No_bracketsContext _localctx=new No_bracketsContext(_ctx,getState());
  enterRule(_localctx,26,RULE_no_brackets);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(228);
      _la=_input.LA(1);
      if (_la <= 0 || (_la == 12 || _la == 28)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_bracketsContext no_brackets() throws RecognitionException {
  No_bracketsContext _localctx=new No_bracketsContext(_ctx,getState());
  enterRule(_localctx,26,RULE_no_brackets);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(228);
      _la=_input.LA(1);
      if (_la <= 0 || (_la == 12 || _la == 29)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160858
Project: 160858
Buggy source:
protected void consolidateBlockStarters(ASTNode stmt){
  while (true) {
    try {
      BlockStarter bItem=(BlockStarter)itemStack.peek();
      bItem=(BlockStarter)itemStack.pop();
      bItem.addChild(stmt);
      stmt=bItem;
    }
 catch (    ClassCastException ex) {
      break;
    }
  }
  CompoundStatement root=(CompoundStatement)itemStack.peek();
  root.addStatement(stmt);
}

Fixed version (ground truth):
protected void consolidateBlockStarters(ASTNode stmt){
  while (true) {
    try {
      BlockStarter bItem=(BlockStarter)itemStack.peek();
      bItem=(BlockStarter)itemStack.pop();
      bItem.addChild(stmt);
      stmt=bItem;
    }
 catch (    ClassCastException ex) {
      break;
    }
  }
  ASTNode root=itemStack.peek();
  root.addChild(stmt);
}
Program: 160859
Project: 160859
Buggy source:
@Override public int getChildCount(){
  if (condition == null || statement == null)   throw new RuntimeException("String_Node_Str");
  return 2;
}

Fixed version (ground truth):
@Override public int getChildCount(){
  if (condition == null || statement == null)   throw new RuntimeException("String_Node_Str");
  return super.getChildCount();
}
Program: 160860
Project: 160860
Buggy source:
@Override public void addChild(ASTNode node){
  if (node instanceof Condition)   setCondition((Condition)node);
  if (node instanceof Statement)   setStatement((Statement)node);
  super.addChild(node);
}

Fixed version (ground truth):
@Override public void addChild(ASTNode node){
  if (node instanceof Condition)   setCondition((Condition)node);
 else   if (node instanceof Statement)   setStatement((Statement)node);
  super.addChild(node);
}
Program: 160861
Project: 160861
Buggy source:
@Override public void addChild(ASTNode item){
  if (forInitStatement instanceof DummyNode)   forInitStatement=item;
 else   if (expression instanceof DummyNode)   expression=item;
  super.addChild(item);
}

Fixed version (ground truth):
@Override public void addChild(ASTNode item){
  if (forInitStatement instanceof DummyNode)   forInitStatement=item;
 else   if (expression instanceof DummyNode && condition != null)   expression=item;
  super.addChild(item);
}
Program: 160862
Project: 160862
Buggy source:
private CFG convertStatement(Statement node){
  if (node instanceof CompoundStatement)   return convertCompoundStatement((CompoundStatement)node);
  if (node instanceof IfStatement)   return convertIfStatement((IfStatement)node);
  if (node instanceof WhileStatement)   return convertWhileStatement((WhileStatement)node);
  return defaultStatementConverter(node);
}

Fixed version (ground truth):
private CFG convertStatement(Statement node){
  if (node instanceof CompoundStatement)   return convertCompoundStatement((CompoundStatement)node);
  if (node instanceof IfStatement)   return convertIfStatement((IfStatement)node);
  if (node instanceof WhileStatement)   return convertWhileStatement((WhileStatement)node);
  if (node instanceof DoStatement)   return convertDoStatement((DoStatement)node);
  if (node instanceof ForStatement)   return convertForStatement((ForStatement)node);
  return defaultStatementConverter(node);
}
Program: 160863
Project: 160863
Buggy source:
@Test public void ifElse(){
  String input="String_Node_Str";
  CompoundStatement contentItem=(CompoundStatement)FineFuncContentTestUtil.parseAndWalk(input);
  IfStatement ifItem=(IfStatement)contentItem.getStatements().get(0);
  System.out.println(contentItem.getStatements().size());
  assertTrue(ifItem.getElseNode() != null);
  assertTrue(ifItem.getElseNode().getChild(1) != null);
  assertTrue(contentItem.getStatements().size() == 1);
}

Fixed version (ground truth):
@Test public void ifElse(){
  String input="String_Node_Str";
  CompoundStatement contentItem=(CompoundStatement)FineFuncContentTestUtil.parseAndWalk(input);
  IfStatement ifItem=(IfStatement)contentItem.getStatements().get(0);
  System.out.println(contentItem.getStatements().size());
  assertTrue(ifItem.getElseNode() != null);
  assertTrue(ifItem.getElseNode().getChild(0) != null);
  assertTrue(contentItem.getStatements().size() == 1);
}
Program: 160864
Project: 160864
Buggy source:
public void enterAssignment(Assign_exprContext ctx){
  ExprStatementItem exprStmt=new ExprStatementItem();
  exprStmt.expr=new AssignmentExpr();
  exprStmt.expr.initializeFromContext(ctx);
  replaceTopOfStack(exprStmt);
}

Fixed version (ground truth):
public void enterAssignment(Assign_exprContext ctx){
  if (ctx.assignment_operator().size() == 0)   return;
  ExprStatementItem exprStmt=new ExprStatementItem();
  exprStmt.expr=new AssignmentExpr();
  exprStmt.expr.initializeFromContext(ctx);
  replaceTopOfStack(exprStmt);
}
Program: 160865
Project: 160865
Buggy source:
@Override public void visit(ClassDef item){
  ClassDefToDocumentConverter.convert(item,filename,d);
}

Fixed version (ground truth):
@Override public void visit(ClassDef item){
  d=new Document();
  ClassDefToDocumentConverter.convert(item,filename,d);
}
Program: 160866
Project: 160866
Buggy source:
public ScoreDoc[] find(String queryString){
  try {
    Query query=parser.parse(queryString,defaultField);
    TopDocs topDocs=searcher.search(query,maxHits);
    for (    ScoreDoc doc : topDocs.scoreDocs) {
      Document document=searcher.doc(doc.doc);
      String codeStr=document.getField("String_Node_Str").stringValue();
      System.out.println(codeStr);
    }
  }
 catch (  QueryNodeException e) {
    e.printStackTrace();
  }
catch (  IOException e) {
    e.printStackTrace();
  }
  return null;
}

Fixed version (ground truth):
public ScoreDoc[] find(String queryString) throws QueryNodeException, IOException {
  Query query=parser.parse(queryString,defaultField);
  TopDocs topDocs=searcher.search(query,maxHits);
  return topDocs.scoreDocs;
}
Program: 160867
Project: 160867
Buggy source:
public static void convert(FunctionDef item,String filename,Document d){
  d=new Document();
  CodeItemToDocumentConverter.addStandardFields(item,filename,d);
  d.add(new TextField("String_Node_Str",item.name.getCodeStr(),Field.Store.YES));
  d.add(new TextField("String_Node_Str",item.returnType.getCodeStr(),Field.Store.YES));
  addParameters(item,d);
  CodeItemToDocumentConverter.addContent(item.content,d);
}

Fixed version (ground truth):
public static void convert(FunctionDef item,String filename,Document d){
  CodeItemToDocumentConverter.addStandardFields(item,filename,d);
  d.add(new TextField("String_Node_Str",item.name.getCodeStr(),Field.Store.YES));
  d.add(new TextField("String_Node_Str",item.returnType.getCodeStr(),Field.Store.YES));
  addParameters(item,d);
  CodeItemToDocumentConverter.addContent(item.content,d);
}
Program: 160868
Project: 160868
Buggy source:
@Override public void startOfUnit(ParserRuleContext ctx,String filename){
}

Fixed version (ground truth):
@Override public void startOfUnit(ParserRuleContext ctx,String aFilename){
  filename=aFilename;
}
Program: 160869
Project: 160869
Buggy source:
@Override public void processItem(CodeItem item,Stack<CodeItemBuilder> itemStack){
  CodeItemToDocumentConverter converter=new CodeItemToDocumentConverter();
  converter.setFilename("String_Node_Str");
  item.accept(converter);
  Document doc=converter.getDocument();
  if (doc == null)   return;
  try {
    indexWriter.addDocument(doc);
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
}

Fixed version (ground truth):
@Override public void processItem(CodeItem item,Stack<CodeItemBuilder> itemStack){
  CodeItemToDocumentConverter converter=new CodeItemToDocumentConverter();
  converter.setFilename(filename);
  item.accept(converter);
  Document doc=converter.getDocument();
  if (doc == null)   return;
  try {
    indexWriter.addDocument(doc);
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
}
Program: 160870
Project: 160870
Buggy source:
private void emitDeclarations(ParserRuleContext decl_list,ParserRuleContext typeName){
  IdentifierDeclBuilder builder=new IdentifierDeclBuilder();
  List<IdentifierDecl> declarations=builder.getDeclarations(decl_list,typeName);
  IdentifierDeclStatement stmt=new IdentifierDeclStatement();
  Iterator<IdentifierDecl> it=declarations.iterator();
  while (it.hasNext()) {
    IdentifierDecl decl=it.next();
    stmt.addDeclaration(decl);
  }
  p.notifyObserversOfItem(stmt);
}

Fixed version (ground truth):
private void emitDeclarations(ParserRuleContext decl_list,ParserRuleContext typeName){
  IdentifierDeclBuilder builder=new IdentifierDeclBuilder();
  List<IdentifierDecl> declarations=builder.getDeclarations(decl_list,typeName);
  IdentifierDeclStatement stmt=new IdentifierDeclStatement();
  stmt.nodeTypeName="String_Node_Str";
  Iterator<IdentifierDecl> it=declarations.iterator();
  while (it.hasNext()) {
    IdentifierDecl decl=it.next();
    stmt.addDeclaration(decl);
  }
  p.notifyObserversOfItem(stmt);
}
Program: 160871
Project: 160871
Buggy source:
private void outputDecl(CodeItem aItem,Stack<CodeItemBuilder> itemStack){
  IdentifierDecl item=(IdentifierDecl)aItem;
  int level=itemStack.size();
  item.setCodeStr(item.name.getCodeStr());
  if (item.type.completeType != "String_Node_Str")   item.setCodeStr(item.type.completeType + "String_Node_Str" + item.name.getCodeStr());
  defaultOut(item,level);
}

Fixed version (ground truth):
private void outputDecl(CodeItem aItem,Stack<CodeItemBuilder> itemStack){
  IdentifierDeclStatement stmt=(IdentifierDeclStatement)aItem;
  Iterator<IdentifierDecl> it=stmt.identifierDeclList.iterator();
  while (it.hasNext()) {
    IdentifierDecl item=it.next();
    int level=itemStack.size();
    item.setCodeStr(item.name.getCodeStr());
    if (item.type.completeType != "String_Node_Str")     item.setCodeStr(item.type.completeType + "String_Node_Str" + item.name.getCodeStr());
    defaultOut(item,level);
  }
}
Program: 160872
Project: 160872
Buggy source:
@Override public void run(){
  parser.addObserver(new LuceneIndexCreator());
  processBatch();
}

Fixed version (ground truth):
@Override public void run(){
  parser.addObserver(new CSVPrinter());
  processBatch();
}
Program: 160873
Project: 160873
Buggy source:
public static void main(String[] args){
  String queryString="String_Node_Str";
  String directoryName="String_Node_Str";
  Finder finder=new Finder(directoryName);
  finder.find(queryString);
}

Fixed version (ground truth):
public static void main(String[] args){
  CommandLineInterface cli=new CommandLineInterface();
  try {
    cli.parseCommandLine(args);
  }
 catch (  RuntimeException|ParseException e) {
    System.err.println(e.getMessage());
    cli.outputHelp();
    return;
  }
  String queryString=cli.getQuery();
  String directoryName=cli.getIndexDir();
  Finder finder=new Finder(directoryName);
  ScoreDoc[] documents;
  try {
    documents=finder.find(queryString);
  }
 catch (  QueryNodeException|IOException e) {
    System.err.println(e.getMessage());
    return;
  }
  LocationPrinter locationPrinter=new LocationPrinter(finder);
  locationPrinter.print(documents);
}
Program: 160874
Project: 160874
Buggy source:
public static void convert(ClassDef item,String filename,Document d){
  d=new Document();
  CodeItemToDocumentConverter.addStandardFields(item,filename,d);
  String className="String_Node_Str";
  if (item.name != null)   className=item.getName().getCodeStr();
  d.add(new TextField("String_Node_Str",className,Field.Store.YES));
  CodeItemToDocumentConverter.addContent(item.content,d);
}

Fixed version (ground truth):
public static void convert(ClassDef item,String filename,Document d){
  CodeItemToDocumentConverter.addStandardFields(item,filename,d);
  String className="String_Node_Str";
  if (item.name != null)   className=item.getName().getCodeStr();
  d.add(new TextField("String_Node_Str",className,Field.Store.YES));
  CodeItemToDocumentConverter.addContent(item.content,d);
}
Program: 160875
Project: 160875
Buggy source:
@Override public void run(){
  parser.addObserver(new CSVPrinter());
  processBatch();
}

Fixed version (ground truth):
@Override public void run(){
  parser.addObserver(new LuceneIndexCreator());
  processBatch();
}
Program: 160876
Project: 160876
Buggy source:
public void print(ScoreDoc[] documents){
  try {
    for (    ScoreDoc doc : documents) {
      Document document=finder.getDocumentById(doc.doc);
      String filename=document.getField("String_Node_Str").stringValue();
      String stringValue=document.getField("String_Node_Str").stringValue();
      System.out.println(filename + "String_Node_Str" + stringValue);
    }
  }
 catch (  IOException e) {
    System.err.println(e.getMessage());
  }
}

Fixed version (ground truth):
public void print(ScoreDoc[] documents){
  try {
    for (    ScoreDoc doc : documents) {
      Document document=finder.getDocumentById(doc.doc);
      String filename=document.getField("String_Node_Str").stringValue();
      String stringValue=document.getField("String_Node_Str").stringValue();
      String name=document.getField("String_Node_Str").stringValue();
      System.out.println(filename + "String_Node_Str" + stringValue+ "String_Node_Str"+ name);
    }
  }
 catch (  IOException e) {
    System.err.println(e.getMessage());
  }
}
Program: 160877
Project: 160877
Buggy source:
@Override public void run(){
  parser.addObserver(new CSVPrinter());
  processBatch();
}

Fixed version (ground truth):
@Override public void run(){
  parser.addObserver(new LuceneIndexCreator());
  processBatch();
}
Program: 160878
Project: 160878
Buggy source:
private void parseClassContent(CodeSensorParser.DeclByClassContext ctx){
  restrictStreamToClassContent(ctx);
  ShallowParser shallowParser=new ShallowParser();
  shallowParser.setStack(itemStack);
  shallowParser.parseTokenStream(stream);
  stream.resetRestriction();
}

Fixed version (ground truth):
private void parseClassContent(CodeSensorParser.DeclByClassContext ctx){
  restrictStreamToClassContent(ctx);
  ShallowParser shallowParser=new ShallowParser();
  shallowParser.setStack(itemStack);
  shallowParser.parseAndWalk(stream);
  stream.resetRestriction();
}
Program: 160879
Project: 160879
Buggy source:
public void setStack(Stack<CodeItemBuilder> aStack){
  stack=aStack;
}

Fixed version (ground truth):
public void setStack(Stack<CodeItemBuilder> aStack){
  listener.setStack(aStack);
  ;
}
Program: 160880
Project: 160880
Buggy source:
public void parseAndWalk(String filename) throws IOException {
  initializeContext(filename);
  ParseTree tree=parseTokenStream(context.stream);
  walkParseTree(context.stream,tree);
}

Fixed version (ground truth):
public void parseAndWalk(TokenSubStream stream){
  initializeContext(stream);
  ParseTree tree=parseTokenStream(context.stream);
  walkParseTree(context.stream,tree);
}
Program: 160881
Project: 160881
Buggy source:
private void walkParseTree(TokenSubStream tokens,ParseTree tree){
  ShallowParseTreeListener listener=new ShallowParseTreeListener(context);
  if (stack != null)   listener.setStack(stack);
  ParseTreeWalker walker=new ParseTreeWalker();
  walker.walk(listener,tree);
}

Fixed version (ground truth):
public void walkParseTree(TokenSubStream tokens,ParseTree tree){
  ParseTreeWalker walker=new ParseTreeWalker();
  walker.walk(listener,tree);
}
Program: 160882
Project: 160882
Buggy source:
private void initializeContext(String filename) throws IOException {
  context=new ParserContext();
  context.filename=filename;
  context.stream=createTokenStreamFromFile(context.filename);
}

Fixed version (ground truth):
private void initializeContext(TokenSubStream stream){
  context=new ParserContext();
  context.filename="String_Node_Str";
  context.stream=stream;
  listener.initializeContext(context);
}
Program: 160883
Project: 160883
Buggy source:
@Override public void exitDeclByClass(CodeSensorParser.DeclByClassContext ctx){
  CodeItemBuilder builder=itemStack.pop();
  processor.processItem(builder.getItem(),itemStack);
  parseClassContent(ctx);
}

Fixed version (ground truth):
@Override public void exitDeclByClass(CodeSensorParser.DeclByClassContext ctx){
  CodeItemBuilder builder=itemStack.pop();
  processor.processItem(builder.getItem(),itemStack);
  parseClassContent(ctx);
  emitDeclarationsForClass(ctx);
}
Program: 160884
Project: 160884
Buggy source:
@Override public void enterDeclByClass(CodeSensorParser.DeclByClassContext ctx){
  ClassDefBuilder builder=new ClassDefBuilder();
  builder.createNew(ctx);
  itemStack.push(builder);
  emitDeclarationsForClass(ctx);
}

Fixed version (ground truth):
@Override public void enterDeclByClass(CodeSensorParser.DeclByClassContext ctx){
  ClassDefBuilder builder=new ClassDefBuilder();
  builder.createNew(ctx);
  itemStack.push(builder);
}
Program: 160885
Project: 160885
Buggy source:
public String getCodeStr(){
  if (codeStr != null)   return codeStr;
  codeStr=ParseTreeUtils.childTokenString(rootRule);
  return codeStr;
}

Fixed version (ground truth):
public String getCodeStr(){
  if (codeStr != null)   return codeStr;
  Iterator<Parameter> i=parameters.iterator();
  StringBuilder s=new StringBuilder();
  for (; i.hasNext(); ) {
    Parameter param=i.next();
    s.append(param.getCodeStr() + "String_Node_Str");
  }
  codeStr=s.toString();
  codeStr=codeStr.substring(0,s.length() - 3);
  return codeStr;
}
Program: 160886
Project: 160886
Buggy source:
@Test public void testFunction_defStaticUnsigned(){
  String input="String_Node_Str";
  CodeSensorParser parser=createParser(input);
  String output=parser.function_def().toStringTree(parser);
  System.out.println(output);
  assertTrue(output.startsWith("String_Node_Str"));
}

Fixed version (ground truth):
@Test public void testFunction_defStaticUnsigned(){
  String input="String_Node_Str";
  CodeSensorParser parser=createParser(input);
  String output=parser.function_def().toStringTree(parser);
  assertTrue(output.startsWith("String_Node_Str"));
}
Program: 160887
Project: 160887
Buggy source:
@Override public void enterDeclByType(CodeSensorParser.DeclByTypeContext ctx){
  Init_declarator_listContext decl_list=ctx.init_declarator_list();
  String typeName=ctx.type_name().getText();
  emitDeclarations(decl_list,typeName);
}

Fixed version (ground truth):
@Override public void enterDeclByType(CodeSensorParser.DeclByTypeContext ctx){
  Init_declarator_listContext decl_list=ctx.init_declarator_list();
  Type_nameContext typeName=ctx.type_name();
  emitDeclarations(decl_list,typeName);
}
Program: 160888
Project: 160888
Buggy source:
@Override public void enterDeclByClass(CodeSensorParser.DeclByClassContext ctx){
  ClassDef classDef=new ClassDef();
  classDef.create(ctx,itemStack);
  itemStack.push(classDef);
  Init_declarator_listContext decl_list=ctx.init_declarator_list();
  if (decl_list != null) {
    String typeName="String_Node_Str";
    Class_nameContext class_name=ctx.class_def().class_name();
    if (class_name != null)     typeName=class_name.getText();
    emitDeclarations(decl_list,typeName);
  }
}

Fixed version (ground truth):
@Override public void enterDeclByClass(CodeSensorParser.DeclByClassContext ctx){
  ClassDef classDef=new ClassDef();
  classDef.create(ctx,itemStack);
  itemStack.push(classDef);
  Init_declarator_listContext decl_list=ctx.init_declarator_list();
  if (decl_list != null) {
    Class_nameContext class_name=ctx.class_def().class_name();
    ParserRuleContext typeName=class_name;
    emitDeclarations(decl_list,typeName);
  }
}
Program: 160889
Project: 160889
Buggy source:
private void emitDeclarations(Init_declarator_listContext decl_list,String typeName){
  Init_declaratorContext decl_ctx;
  for (Iterator<ParseTree> i=decl_list.children.iterator(); i.hasNext(); ) {
    try {
      decl_ctx=(Init_declaratorContext)i.next();
    }
 catch (    java.lang.ClassCastException e) {
      continue;
    }
    IdentifierDecl idDecl=new IdentifierDecl();
    idDecl.create(decl_ctx,itemStack);
    idDecl.setName(decl_ctx.identifier(),itemStack);
    String completeType=typeName;
    if (decl_ctx.ptrs() != null)     completeType+=decl_ctx.ptrs().getText();
    if (decl_ctx.type_suffix() != null)     completeType+=decl_ctx.type_suffix().getText();
    idDecl.setType(typeName,completeType);
    nodePrinter.printItem(idDecl);
  }
}

Fixed version (ground truth):
private void emitDeclarations(Init_declarator_listContext decl_list,ParserRuleContext typeName){
  Init_declaratorContext decl_ctx;
  for (Iterator<ParseTree> i=decl_list.children.iterator(); i.hasNext(); ) {
    try {
      decl_ctx=(Init_declaratorContext)i.next();
    }
 catch (    java.lang.ClassCastException e) {
      continue;
    }
    IdentifierDecl idDecl=new IdentifierDecl();
    idDecl.create(decl_ctx,itemStack);
    idDecl.setName(decl_ctx.identifier(),itemStack);
    idDecl.setType(decl_ctx,typeName);
    nodePrinter.printItem(idDecl);
  }
}
Program: 160890
Project: 160890
Buggy source:
public void setType(String baseType,String completeType){
  type=new IdentifierDeclType();
  type.baseType=baseType;
  type.completeType=completeType;
}

Fixed version (ground truth):
public void setType(Init_declaratorContext decl_ctx,ParserRuleContext typeName){
  String baseType="String_Node_Str";
  if (typeName != null)   baseType=childTokenString(typeName);
  String completeType=baseType;
  if (decl_ctx.ptrs() != null)   completeType+=childTokenString(decl_ctx.ptrs());
  if (decl_ctx.type_suffix() != null)   completeType+=childTokenString(decl_ctx.type_suffix());
  type=new IdentifierDeclType();
  type.baseType=baseType;
  type.completeType=completeType;
}
Program: 160891
Project: 160891
Buggy source:
@Override public void create(ParserRuleContext aCtx,Stack<CodeItem> itemStack){
  Parameter_declContext ctx=(Parameter_declContext)aCtx;
  nodeTypeName="String_Node_Str";
  baseType=childTokenString(ctx.param_decl_specifiers());
  String typeName=baseType;
  Type_suffixContext type_suffix=ctx.type_suffix();
  PtrsContext ptrs=ctx.ptrs();
  if (ptrs != null)   typeName+="String_Node_Str" + ptrs.getText();
  if (type_suffix != null)   typeName+="String_Node_Str" + type_suffix.getText();
  completeType=typeName;
  super.create(ctx,itemStack);
  codeStr=typeName;
}

Fixed version (ground truth):
@Override public void create(ParserRuleContext aCtx,Stack<CodeItem> itemStack){
  Parameter_declContext ctx=(Parameter_declContext)aCtx;
  nodeTypeName="String_Node_Str";
  baseType=childTokenString(ctx.param_decl_specifiers());
  String typeName=baseType;
  Type_suffixContext type_suffix=ctx.type_suffix();
  PtrsContext ptrs=ctx.ptrs();
  if (ptrs != null)   typeName+="String_Node_Str" + childTokenString(ptrs);
  if (type_suffix != null)   typeName+="String_Node_Str" + childTokenString(type_suffix);
  completeType=typeName;
  super.create(ctx,itemStack);
  codeStr=typeName;
}
Program: 160892
Project: 160892
Buggy source:
private void defaultOut(CodeItem item){
  String output=item.nodeTypeName + SEPARATOR;
  output+=createLocationString(item) + SEPARATOR + item.level;
  output+=SEPARATOR + escapeCodeStr(item.codeStr);
  System.out.println(output);
}

Fixed version (ground truth):
private void defaultOut(CodeItem item){
  if (item == null)   return;
  String output=item.nodeTypeName + SEPARATOR;
  output+=createLocationString(item) + SEPARATOR + item.level;
  output+=SEPARATOR + escapeCodeStr(item.codeStr);
  System.out.println(output);
}
Program: 160893
Project: 160893
Buggy source:
private void setCompleteType(Parameter_idContext parameter_id,String baseType){
  completeType=baseType;
  while (parameter_id.parameter_name() == null) {
    String newCompleteType="String_Node_Str";
    newCompleteType+="String_Node_Str";
    if (parameter_id.ptrs() != null)     newCompleteType+=childTokenString(parameter_id.ptrs()) + "String_Node_Str";
    if (parameter_id.type_suffix() != null)     newCompleteType+=childTokenString(parameter_id.type_suffix()) + "String_Node_Str";
    newCompleteType+=completeType;
    newCompleteType+="String_Node_Str";
    completeType=newCompleteType;
  }
}

Fixed version (ground truth):
private void setCompleteType(Parameter_idContext parameter_id,String baseType){
  completeType=baseType;
  while (parameter_id.parameter_name() == null) {
    String newCompleteType="String_Node_Str";
    newCompleteType+="String_Node_Str";
    if (parameter_id.ptrs() != null)     newCompleteType+=childTokenString(parameter_id.ptrs()) + "String_Node_Str";
    if (parameter_id.type_suffix() != null)     newCompleteType+=childTokenString(parameter_id.type_suffix()) + "String_Node_Str";
    newCompleteType+=completeType;
    newCompleteType+="String_Node_Str";
    completeType=newCompleteType;
    parameter_id=parameter_id.parameter_id();
  }
}
Program: 160895
Project: 160895
Buggy source:
@Override public void paintTrack(Graphics g2d){
  Graphics2D g=(Graphics2D)g2d;
  Rectangle trackBounds=trackRect;
  final int arc=JBUI.scale(5);
  int trackSize=JBUI.scale(5);
  final GraphicsConfig config=GraphicsUtil.setupAAPainting(g);
  final Color bg=ColorUtil.fromHex("String_Node_Str");
  final Color selection=slider.isEnabled() ? getSelectedTrackColor() : getDisabledTickColor();
  if (slider.getOrientation() == JSlider.HORIZONTAL) {
    int cy=(trackBounds.height / 2) - trackSize / 2;
    int cw=trackBounds.width;
    final Area shape=new Area(new RoundRectangle2D.Double(0,0,cw,trackSize,arc,arc));
    g.translate(trackBounds.x,trackBounds.y + cy);
    g.setColor(bg);
    g.fill(shape);
    int x=thumbRect.x;
    shape.intersect(new Area(new Rectangle2D.Double(0,0,x,trackSize)));
    g.setColor(selection);
    g.fill(shape);
    g.translate(-trackBounds.x,-(trackBounds.y + cy));
  }
 else {
    int cx=(trackBounds.width / 2) - trackSize / 2;
    int ch=trackBounds.height;
    g.translate(trackBounds.x + cx,trackBounds.y);
    g.setColor(bg);
    g.fillRoundRect(0,0,trackSize,ch,arc,arc);
    g.translate(-(trackBounds.x + cx),-trackBounds.y);
  }
  config.restore();
}

Fixed version (ground truth):
@Override public void paintTrack(Graphics g2d){
  Graphics2D g=(Graphics2D)g2d;
  Rectangle trackBounds=trackRect;
  final int arc=JBUI.scale(6);
  int trackSize=JBUI.scale(6);
  final GraphicsConfig config=GraphicsUtil.setupAAPainting(g);
  final Color bg=getTrackBackground();
  final Color selection=slider.isEnabled() ? getSelectedTrackColor() : getDisabledTickColor();
  if (slider.getOrientation() == JSlider.HORIZONTAL) {
    int cy=(trackBounds.height / 2) - trackSize / 2;
    int cw=trackBounds.width;
    final Area shape=new Area(new RoundRectangle2D.Double(0,0,cw,trackSize,arc,arc));
    g.translate(trackBounds.x,trackBounds.y + cy);
    g.setColor(bg);
    g.fill(shape);
    int x=thumbRect.x;
    shape.intersect(new Area(new Rectangle2D.Double(0,0,x,trackSize)));
    g.setColor(selection);
    g.fill(shape);
    g.translate(-trackBounds.x,-(trackBounds.y + cy));
  }
 else {
    int cx=(trackBounds.width / 2) - trackSize / 2;
    int ch=trackBounds.height;
    g.translate(trackBounds.x + cx,trackBounds.y);
    g.setColor(bg);
    g.fillRoundRect(0,0,trackSize,ch,arc,arc);
    g.translate(-(trackBounds.x + cx),-trackBounds.y);
  }
  config.restore();
}
Program: 160896
Project: 160896
Buggy source:
@Override public List<Music> searchSimilarTitle(String title){
  return musics=entityManager.createQuery("String_Node_Str",Music.class).setParameter("String_Node_Str","String_Node_Str" + title + "String_Node_Str").getResultList();
}

Fixed version (ground truth):
@Override public List<Music> searchSimilarTitle(String title){
  return entityManager.createQuery("String_Node_Str",Music.class).setParameter("String_Node_Str","String_Node_Str" + title + "String_Node_Str").getResultList();
}
Program: 160897
Project: 160897
Buggy source:
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String path=request.getContextPath();
  return referer.substring(referer.indexOf(path) + path.length());
}

Fixed version (ground truth):
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=null;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String ctxPath=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(ctxPath) + ctxPath.length());
}
Program: 160898
Project: 160898
Buggy source:
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String path=request.getContextPath();
  return referer.substring(referer.indexOf(path) + path.length());
}

Fixed version (ground truth):
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=referer;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String path=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(path) + path.length());
}
Program: 160899
Project: 160899
Buggy source:
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=referer;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String path=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(path) + path.length());
}

Fixed version (ground truth):
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=null;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String ctxPath=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(ctxPath) + ctxPath.length());
}
Program: 160900
Project: 160900
Buggy source:
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=referer;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String path=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(path) + path.length());
}

Fixed version (ground truth):
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String path=request.getContextPath();
  return referer.substring(referer.indexOf(path) + path.length());
}
Program: 160901
Project: 160901
Buggy source:
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=null;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String ctxPath=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(ctxPath) + ctxPath.length());
}

Fixed version (ground truth):
private String getReferer(){
  String referer=request.getHeader("String_Node_Str");
  checkState(referer != null,"String_Node_Str");
  String refererPath=referer;
  try {
    refererPath=new URL(referer).getPath();
  }
 catch (  MalformedURLException e) {
    refererPath=referer;
  }
  String path=request.getContextPath();
  return refererPath.substring(refererPath.indexOf(path) + path.length());
}
Program: 160903
Project: 160903
Buggy source:
/** 
 * This implementation don't actually use request dispatcher for the forwarding. It runs forwarding logic, and renders its <b>default</b> view.
 */
@Override public <T>T forwardTo(final Class<T> type){
  return proxifier.proxify(type,new MethodInvocation<T>(){
    @Override public Object intercept(    T proxy,    Method method,    Object[] args,    SuperMethod superMethod){
      try {
        logger.debug("String_Node_Str",method);
        ControllerMethod old=methodInfo.getControllerMethod();
        methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type,method));
        Object methodResult=method.invoke(container.instanceFor(type),args);
        methodInfo.setControllerMethod(old);
        Type returnType=method.getGenericReturnType();
        if (!(returnType == void.class)) {
          request.setAttribute(extractor.nameFor(returnType),methodResult);
        }
        if (response.isCommitted() || result.used()) {
          logger.debug("String_Node_Str");
          return null;
        }
        String path=resolver.pathFor(DefaultControllerMethod.instanceFor(type,method));
        logger.debug("String_Node_Str",path);
        request.getRequestDispatcher(path).forward(request,response);
        return null;
      }
 catch (      InvocationTargetException e) {
        propagateIfPossible(e.getCause());
        throw new ProxyInvocationException(e);
      }
catch (      Exception e) {
        throw new ProxyInvocationException(e);
      }
    }
  }
);
}

Fixed version (ground truth):
/** 
 * This implementation don't actually use request dispatcher for the forwarding. It runs forwarding logic, and renders its <b>default</b> view.
 */
@Override public <T>T forwardTo(final Class<T> type){
  return proxifier.proxify(type,new MethodInvocation<T>(){
    @Override public Object intercept(    T proxy,    Method method,    Object[] args,    SuperMethod superMethod){
      try {
        logger.debug("String_Node_Str",method);
        ControllerMethod old=methodInfo.getControllerMethod();
        methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type,method));
        Object methodResult=method.invoke(container.instanceFor(type),args);
        methodInfo.setControllerMethod(old);
        Type returnType=method.getGenericReturnType();
        if (!(returnType == void.class)) {
          request.setAttribute(extractor.nameFor(returnType),methodResult);
        }
        if (response.isCommitted()) {
          logger.debug("String_Node_Str");
          return null;
        }
        String path=resolver.pathFor(DefaultControllerMethod.instanceFor(type,method));
        logger.debug("String_Node_Str",path);
        request.getRequestDispatcher(path).forward(request,response);
        return null;
      }
 catch (      InvocationTargetException e) {
        propagateIfPossible(e.getCause());
        throw new ProxyInvocationException(e);
      }
catch (      Exception e) {
        throw new ProxyInvocationException(e);
      }
    }
  }
);
}
Program: 160904
Project: 160904
Buggy source:
@Inject public DefaultLogicResult(Proxifier proxifier,Router router,MutableRequest request,HttpServletResponse response,Container container,PathResolver resolver,TypeNameExtractor extractor,FlashScope flash,MethodInfo methodInfo,Result result){
  this.proxifier=proxifier;
  this.result=result;
  this.response=unproxifyIfPossible(response);
  this.request=unproxifyIfPossible(request);
  this.router=router;
  this.container=container;
  this.resolver=resolver;
  this.extractor=extractor;
  this.flash=flash;
  this.methodInfo=methodInfo;
}

Fixed version (ground truth):
@Inject public DefaultLogicResult(Proxifier proxifier,Router router,MutableRequest request,HttpServletResponse response,Container container,PathResolver resolver,TypeNameExtractor extractor,FlashScope flash,MethodInfo methodInfo){
  this.proxifier=proxifier;
  this.response=unproxifyIfPossible(response);
  this.request=unproxifyIfPossible(request);
  this.router=router;
  this.container=container;
  this.resolver=resolver;
  this.extractor=extractor;
  this.flash=flash;
  this.methodInfo=methodInfo;
}
Program: 160905
Project: 160905
Buggy source:
@Before public void setup(){
  MockitoAnnotations.initMocks(this);
  proxifier=new JavassistProxifier();
  methodInfo=new MethodInfo(new ParanamerNameProvider());
  this.logicResult=new DefaultLogicResult(proxifier,router,request,response,container,resolver,extractor,flash,methodInfo,result);
}

Fixed version (ground truth):
@Before public void setup(){
  MockitoAnnotations.initMocks(this);
  proxifier=new JavassistProxifier();
  methodInfo=new MethodInfo(new ParanamerNameProvider());
  this.logicResult=new DefaultLogicResult(proxifier,router,request,response,container,resolver,extractor,flash,methodInfo);
}
Program: 160906
Project: 160906
Buggy source:
/** 
 * Creates an instance for build a   {@link ZipDownload}.<br> <code> List<Path> listOfFiles = [...]; Download download = DownloadBuilder.of(listOfFiles) .withFileName("resume.zip") .build(); </code>
 * @param files List of input files
 * @throws NullPointerException If the {@code input} argument is {@code null}
 */
public static ZipDownloadBuilder of(List<Path> files){
  return new ZipDownloadBuilder(files);
}

Fixed version (ground truth):
/** 
 * Creates an instance for build a   {@link ZipDownload}.<br>
 * @param files List of input files
 * @throws NullPointerException If the {@code input} argument is {@code null}
 */
public static ZipDownloadBuilder of(List<Path> files){
  return new ZipDownloadBuilder(files);
}
Program: 160907
Project: 160907
Buggy source:
@Override @SuppressWarnings("String_Node_Str") public <T>T of(T controller){
  return (T)of(CDIProxies.extractRawTypeIfPossible(controller.getClass()));
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") public <T>T of(T controller){
  return (T)of((Class<T>)extractRawTypeIfPossible(controller.getClass()));
}