nus-yam/ex-repair huggingface dataset:
Program: 26887
Project: 26887
Buggy source:
public void writeAdapter(ProcessingEnvironment processingEnvironment) throws IOException {
  TypeSpec.Builder typeBuilder=TypeSpec.classBuilder(adapterName).addModifiers(Modifier.PUBLIC,Modifier.FINAL).superclass(ParameterizedTypeName.get(ClassNames.QUERY_MODEL_ADAPTER,elementClassName));
  for (  MethodDefinition method : methods) {
    MethodSpec methodSpec=method.getMethodSpec();
    if (methodSpec != null) {
      typeBuilder.addMethod(methodSpec);
    }
  }
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addStatement("String_Node_Str",elementClassName).build());
  JavaFile javaFile=JavaFile.builder(packageName,typeBuilder.build()).build();
  javaFile.writeTo(processingEnvironment.getFiler());
}

Fixed version (ground truth):
public void writeAdapter(ProcessingEnvironment processingEnvironment) throws IOException {
  TypeSpec.Builder typeBuilder=TypeSpec.classBuilder(adapterName).addModifiers(Modifier.PUBLIC,Modifier.FINAL).superclass(ParameterizedTypeName.get(ClassNames.QUERY_MODEL_ADAPTER,elementClassName));
  for (  MethodDefinition method : methods) {
    MethodSpec methodSpec=method.getMethodSpec();
    if (methodSpec != null) {
      typeBuilder.addMethod(methodSpec);
    }
  }
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).returns(elementClassName).addStatement("String_Node_Str",elementClassName).build());
  JavaFile javaFile=JavaFile.builder(packageName,typeBuilder.build()).build();
  javaFile.writeTo(processingEnvironment.getFiler());
}
Program: 26891
Project: 26891
Buggy source:
public static CodeBlock.Builder getContentValuesStatement(String elementName,String fullElementName,String columnName,TypeName elementTypeName,boolean isModelContainerAdapter,BaseColumnAccess columnAccess,String variableNameString){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,fullElementName,variableNameString,isModelContainerAdapter);
  CodeBlock.Builder codeBuilder=CodeBlock.builder();
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement="String_Node_Str" + fullElementName;
    TypeName typeName;
    if (columnAccess instanceof TypeConverterAccess) {
      typeName=((TypeConverterAccess)columnAccess).typeConverterDefinition.getDbTypeName();
    }
 else {
      typeName=elementTypeName;
    }
    codeBuilder.addStatement("String_Node_Str",typeName,finalAccessStatement,statement);
  }
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.beginControlFlow("String_Node_Str",finalAccessStatement);
  }
  codeBuilder.addStatement("String_Node_Str",BindToContentValuesMethod.PARAM_CONTENT_VALUES,QueryBuilder.quote(columnName),finalAccessStatement);
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str",BindToContentValuesMethod.PARAM_CONTENT_VALUES,QueryBuilder.quote(columnName)).endControlFlow();
  }
  return codeBuilder;
}

Fixed version (ground truth):
public static CodeBlock.Builder getContentValuesStatement(String elementName,String fullElementName,String columnName,TypeName elementTypeName,boolean isModelContainerAdapter,BaseColumnAccess columnAccess,String variableNameString){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,fullElementName,variableNameString,isModelContainerAdapter);
  CodeBlock.Builder codeBuilder=CodeBlock.builder();
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement=(isModelContainerAdapter ? (variableNameString + elementName) : ("String_Node_Str" + fullElementName));
    TypeName typeName;
    if (columnAccess instanceof TypeConverterAccess) {
      typeName=((TypeConverterAccess)columnAccess).typeConverterDefinition.getDbTypeName();
    }
 else {
      typeName=elementTypeName;
    }
    codeBuilder.addStatement("String_Node_Str",typeName,finalAccessStatement,statement);
  }
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.beginControlFlow("String_Node_Str",finalAccessStatement);
  }
  codeBuilder.addStatement("String_Node_Str",BindToContentValuesMethod.PARAM_CONTENT_VALUES,QueryBuilder.quote(columnName),finalAccessStatement);
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str",BindToContentValuesMethod.PARAM_CONTENT_VALUES,QueryBuilder.quote(columnName)).endControlFlow();
  }
  return codeBuilder;
}
Program: 26892
Project: 26892
Buggy source:
private String getFinalAccessStatement(CodeBlock.Builder codeBuilder,boolean isModelContainerAdapter,String statement){
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement=getRefName();
    TypeName typeName;
    if (columnAccess instanceof TypeConverterAccess) {
      typeName=((TypeConverterAccess)columnAccess).typeConverterDefinition.getDbTypeName();
    }
 else {
      typeName=ModelUtils.getModelContainerType(manager,elementTypeName);
      statement=ModelUtils.getVariable(isModelContainerAdapter) + "String_Node_Str" + statement+ "String_Node_Str"+ referencedTableClassName+ "String_Node_Str";
    }
    codeBuilder.addStatement("String_Node_Str",typeName,finalAccessStatement,statement);
  }
  return finalAccessStatement;
}

Fixed version (ground truth):
private String getFinalAccessStatement(CodeBlock.Builder codeBuilder,boolean isModelContainerAdapter,String statement){
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || columnAccess instanceof ModelContainerAccess || isModelContainerAdapter) {
    finalAccessStatement=getRefName();
    TypeName typeName;
    if (columnAccess instanceof TypeConverterAccess) {
      typeName=((TypeConverterAccess)columnAccess).typeConverterDefinition.getDbTypeName();
    }
 else     if (columnAccess instanceof ModelContainerAccess) {
      typeName=ModelUtils.getModelContainerType(manager,elementTypeName);
    }
 else {
      typeName=ModelUtils.getModelContainerType(manager,elementTypeName);
      statement=ModelUtils.getVariable(isModelContainerAdapter) + "String_Node_Str" + statement+ "String_Node_Str"+ referencedTableClassName+ "String_Node_Str";
    }
    codeBuilder.addStatement("String_Node_Str",typeName,finalAccessStatement,statement);
  }
  return finalAccessStatement;
}
Program: 26893
Project: 26893
Buggy source:
public ModelContainerAccess(ProcessorManager manager,ColumnDefinition columnDefinition){
  this.columnDefinition=columnDefinition;
  this.existingColumnAccess=columnDefinition.columnAccess;
  this.manager=manager;
  ContainerKey containerKey=columnDefinition.element.getAnnotation(ContainerKey.class);
  if (containerKey != null) {
    containerKeyName=containerKey.value();
  }
 else {
    containerKeyName=columnDefinition.columnName;
  }
}

Fixed version (ground truth):
public ModelContainerAccess(BaseColumnAccess existingColumnAccess,String containerKeyName){
  this.existingColumnAccess=existingColumnAccess;
  this.containerKeyName=containerKeyName;
}
Program: 26896
Project: 26896
Buggy source:
public void writeSave(CodeBlock.Builder codeBuilder){
  if (isSave()) {
    codeBuilder.addStatement("String_Node_Str",ParameterizedTypeName.get(ClassNames.SAVE_MODEL_LIST_TRANSACTION),ClassNames.PROCESS_MODEL_INFO,getMethodName());
  }
}

Fixed version (ground truth):
public void writeSave(CodeBlock.Builder codeBuilder){
  if (isSave()) {
    codeBuilder.addStatement("String_Node_Str",ClassNames.SAVE_MODEL_LIST_TRANSACTION,ClassNames.PROCESS_MODEL_INFO,getMethodName());
  }
}
Program: 26897
Project: 26897
Buggy source:
/** 
 * Writes a delete method that will delete all related objects.
 * @param codeBuilder
 */
public void writeDelete(CodeBlock.Builder codeBuilder){
  if (isDelete()) {
    codeBuilder.addStatement("String_Node_Str",ParameterizedTypeName.get(ClassNames.DELETE_MODEL_LIST_TRANSACTION),ClassNames.PROCESS_MODEL_INFO,getMethodName());
    codeBuilder.addStatement("String_Node_Str",getVariableName());
  }
}

Fixed version (ground truth):
/** 
 * Writes a delete method that will delete all related objects.
 * @param codeBuilder
 */
public void writeDelete(CodeBlock.Builder codeBuilder){
  if (isDelete()) {
    codeBuilder.addStatement("String_Node_Str",ClassNames.DELETE_MODEL_LIST_TRANSACTION,ClassNames.PROCESS_MODEL_INFO,getMethodName());
    codeBuilder.addStatement("String_Node_Str",getVariableName());
  }
}
Program: 26898
Project: 26898
Buggy source:
public OneToManyDefinition(Element typeElement,ProcessorManager processorManager){
  super(typeElement,processorManager);
  OneToMany oneToMany=typeElement.getAnnotation(OneToMany.class);
  methodName=typeElement.getSimpleName().toString();
  variableName=oneToMany.variableName();
  if (variableName == null || variableName.isEmpty()) {
    variableName=methodName.replace("String_Node_Str","String_Node_Str");
    variableName=variableName.substring(0,1).toLowerCase() + variableName.substring(1);
  }
  methods.addAll(Arrays.asList(oneToMany.methods()));
}

Fixed version (ground truth):
public OneToManyDefinition(ExecutableElement typeElement,ProcessorManager processorManager){
  super(typeElement,processorManager);
  OneToMany oneToMany=typeElement.getAnnotation(OneToMany.class);
  methodName=typeElement.getSimpleName().toString();
  variableName=oneToMany.variableName();
  if (variableName == null || variableName.isEmpty()) {
    variableName=methodName.replace("String_Node_Str","String_Node_Str");
    variableName=variableName.substring(0,1).toLowerCase() + variableName.substring(1);
  }
  methods.addAll(Arrays.asList(oneToMany.methods()));
}
Program: 26903
Project: 26903
Buggy source:
public void setContainer(AutoIncrementContainer autoIncrementContainer){
  container=new ForeignKeyContainer<>(AutoIncrementContainer.class);
  container.put(AutoIncrementContainer_Table.A_ID,autoIncrementContainer.a_id);
  container.put(AutoIncrementContainer_Table.NAME,autoIncrementContainer.name);
  container.put(AutoIncrementContainer_Table.ID,autoIncrementContainer.id);
}

Fixed version (ground truth):
public void setContainer(AutoIncrementContainer autoIncrementContainer){
  container=new ForeignKeyContainer<>(AutoIncrementContainer.class);
}
Program: 26904
Project: 26904
Buggy source:
public void setTestModel1(ParentModel model1){
  testModel1=new ForeignKeyContainer<>(ParentModel.class);
  Map<String,Object> map=new HashMap<>();
  map.put(ParentModel_Table.NAME,model1.name);
  map.put(ParentModel_Table.TYPE,model1.type);
  testModel1.setData(map);
}

Fixed version (ground truth):
public void setTestModel1(ParentModel model1){
  testModel1=new ForeignKeyContainer<>(ParentModel.class);
  Map<String,Object> map=new HashMap<>();
  testModel1.setData(map);
}
Program: 26905
Project: 26905
Buggy source:
@OneToMany(methods={OneToMany.Method.ALL},variableName="String_Node_Str") public List<Ant> getMyAnts(){
  if (ants == null) {
    ants=new Select().from(Ant.class).where(column(Ant_Table.containerQueenId).eq(id)).queryList();
  }
  return ants;
}

Fixed version (ground truth):
@OneToMany(methods={OneToMany.Method.ALL},variableName="String_Node_Str") public List<Ant> getMyAnts(){
  if (ants == null) {
  }
  return ants;
}
Program: 26906
Project: 26906
Buggy source:
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,CodeBlock formattedAccess){
  CodeBlock newFormattedAccess=CodeBlock.builder().add("String_Node_Str",variableNameString,formattedAccess).build();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}

Fixed version (ground truth):
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,CodeBlock formattedAccess){
  CodeBlock newFormattedAccess=CodeBlock.builder().add("String_Node_Str",ClassName.get(Blob.class),formattedAccess).build();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}
Program: 26907
Project: 26907
Buggy source:
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,CodeBlock formattedAccess){
  CodeBlock newFormattedAccess=CodeBlock.builder().add("String_Node_Str",columnDefinition.elementClassName,formattedAccess).build();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}

Fixed version (ground truth):
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,CodeBlock formattedAccess){
  CodeBlock newFormattedAccess=CodeBlock.builder().add("String_Node_Str",columnDefinition.elementTypeName,formattedAccess).build();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}
Program: 26910
Project: 26910
Buggy source:
public DatabaseDefinition(ProcessorManager manager,Element element){
  super(element,manager);
  packageName=ClassNames.FLOW_MANAGER_PACKAGE;
  Database database=element.getAnnotation(Database.class);
  databaseName=database.name();
  if (databaseName == null || databaseName.isEmpty()) {
    databaseName=element.getSimpleName().toString();
  }
  if (!isValidDatabaseName(databaseName)) {
    throw new Error("String_Node_Str" + databaseName + "String_Node_Str"+ "String_Node_Str");
  }
  TypeMirror openHelper=ProcessorUtils.getOpenHelperClass(database);
  if (openHelper != null) {
    sqliteOpenHelperClass=TypeName.get(openHelper);
  }
  consistencyChecksEnabled=database.consistencyCheckEnabled();
  backupEnabled=database.backupEnabled();
  classSeparator=database.generatedClassSeparator();
  setOutputClassName(databaseName + classSeparator + "String_Node_Str");
  databaseVersion=database.version();
  foreignKeysSupported=database.foreignKeysSupported();
  insertConflict=database.insertConflict();
  updateConflict=database.updateConflict();
}

Fixed version (ground truth):
public DatabaseDefinition(ProcessorManager manager,Element element){
  super(element,manager);
  packageName=ClassNames.FLOW_MANAGER_PACKAGE;
  Database database=element.getAnnotation(Database.class);
  databaseName=database.name();
  if (databaseName == null || databaseName.isEmpty()) {
    databaseName=element.getSimpleName().toString();
  }
  if (!isValidDatabaseName(databaseName)) {
    throw new Error("String_Node_Str" + databaseName + "String_Node_Str"+ "String_Node_Str");
  }
  TypeMirror openHelper=ProcessorUtils.getOpenHelperClass(database);
  if (openHelper != null) {
    sqliteOpenHelperClass=TypeName.get(openHelper);
    if (sqliteOpenHelperClass.equals(TypeName.VOID.box())) {
      sqliteOpenHelperClass=ClassNames.FLOW_SQLITE_OPEN_HELPER;
    }
  }
 else {
    sqliteOpenHelperClass=ClassNames.FLOW_SQLITE_OPEN_HELPER;
  }
  consistencyChecksEnabled=database.consistencyCheckEnabled();
  backupEnabled=database.backupEnabled();
  classSeparator=database.generatedClassSeparator();
  setOutputClassName(databaseName + classSeparator + "String_Node_Str");
  databaseVersion=database.version();
  foreignKeysSupported=database.foreignKeysSupported();
  insertConflict=database.insertConflict();
  updateConflict=database.updateConflict();
}
Program: 26912
Project: 26912
Buggy source:
@Override protected void onProcessElement(ProcessorManager processorManager,Element element){
  ModelContainerDefinition modelContainerDefinition=new ModelContainerDefinition((TypeElement)element,processorManager);
  processorManager.addModelContainerDefinition(modelContainerDefinition);
  WriterUtils.writeBaseDefinition(modelContainerDefinition,processorManager);
}

Fixed version (ground truth):
@Override protected void onProcessElement(ProcessorManager processorManager,Element element){
  ModelContainerDefinition modelContainerDefinition=new ModelContainerDefinition((TypeElement)element,processorManager);
  processorManager.addModelContainerDefinition(modelContainerDefinition);
}
Program: 26913
Project: 26913
Buggy source:
@Override protected void onProcessElement(ProcessorManager processorManager,Element element){
  ModelViewDefinition modelViewDefinition=new ModelViewDefinition(processorManager,element);
  processorManager.addModelViewDefinition(modelViewDefinition);
  WriterUtils.writeBaseDefinition(modelViewDefinition,processorManager);
  try {
    modelViewDefinition.writeViewTable();
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
}

Fixed version (ground truth):
@Override protected void onProcessElement(ProcessorManager processorManager,Element element){
  ModelViewDefinition modelViewDefinition=new ModelViewDefinition(processorManager,element);
  processorManager.addModelViewDefinition(modelViewDefinition);
  try {
    modelViewDefinition.writeViewTable();
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
}
Program: 26914
Project: 26914
Buggy source:
@Override protected void onProcessElement(ProcessorManager processorManager,Element element){
  try {
    TableDefinition tableDefinition=new TableDefinition(processorManager,(TypeElement)element);
    if (definitionValidator.validate(processorManager,tableDefinition)) {
      WriterUtils.writeBaseDefinition(tableDefinition,processorManager);
      tableDefinition.writeAdapter(processorManager.getProcessingEnvironment());
      processorManager.addTableDefinition(tableDefinition);
    }
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
}

Fixed version (ground truth):
@Override protected void onProcessElement(ProcessorManager processorManager,Element element){
  TableDefinition tableDefinition=new TableDefinition(processorManager,(TypeElement)element);
  if (definitionValidator.validate(processorManager,tableDefinition)) {
    WriterUtils.writeBaseDefinition(tableDefinition,processorManager);
    processorManager.addTableDefinition(tableDefinition);
  }
}
Program: 26916
Project: 26916
Buggy source:
/** 
 * Constructs this UPDATE query with both a WHERE and SET   {@link com.raizlabs.android.dbflow.sql.builder.ConditionQueryBuilder}
 * @param dbTransactionInfo     The information about this transaction
 * @param whereConditionBuilder The set of WHERE conditions to use.
 * @param setConditionBuilder   The set of SET conditions to use.
 */
public UpdateTransaction(DBTransactionInfo dbTransactionInfo,ConditionQueryBuilder<ModelClass> whereConditionBuilder,ConditionQueryBuilder<ModelClass> setConditionBuilder){
  super(dbTransactionInfo,new Update<>(whereConditionBuilder.getTableClass()).set(setConditionBuilder).where(whereConditionBuilder));
}

Fixed version (ground truth):
/** 
 * Constructs this UPDATE query with both a WHERE and SET   {@link com.raizlabs.android.dbflow.sql.builder.ConditionQueryBuilder}
 * @param dbTransactionInfo     The information about this transaction
 * @param whereConditionBuilder The set of WHERE conditions to use.
 * @param setConditionBuilder   The set of SET conditions to use.
 */
public UpdateTransaction(DBTransactionInfo dbTransactionInfo,Class<ModelClass> table,ConditionGroup whereConditionGroup,ConditionGroup setConditionGroup){
  super(dbTransactionInfo,new Update<>(table).set(setConditionGroup).where(whereConditionGroup));
}
Program: 26917
Project: 26917
Buggy source:
/** 
 * Applies the   {@link Operation#AND} to all of the passed{@link SQLCondition}.
 * @param sqlConditions
 * @return
 */
public ConditionGroup andAll(SQLCondition... sqlConditions){
  for (  SQLCondition sqlCondition : sqlConditions) {
    and(sqlCondition);
  }
  return this;
}

Fixed version (ground truth):
/** 
 * Applies the   {@link Operation#AND} to all of the passed{@link SQLCondition}.
 * @param sqlConditions
 * @return
 */
public ConditionGroup andAll(List<SQLCondition> sqlConditions){
  for (  SQLCondition sqlCondition : sqlConditions) {
    and(sqlCondition);
  }
  return this;
}
Program: 26918
Project: 26918
Buggy source:
/** 
 * Applies the   {@link Operation#AND} to all of the passed{@link SQLCondition}.
 * @param sqlConditions
 * @return
 */
public ConditionGroup orAll(SQLCondition... sqlConditions){
  for (  SQLCondition sqlCondition : sqlConditions) {
    or(sqlCondition);
  }
  return this;
}

Fixed version (ground truth):
/** 
 * Applies the   {@link Operation#AND} to all of the passed{@link SQLCondition}.
 * @param sqlConditions
 * @return
 */
public ConditionGroup orAll(List<SQLCondition> sqlConditions){
  for (  SQLCondition sqlCondition : sqlConditions) {
    or(sqlCondition);
  }
  return this;
}
Program: 26919
Project: 26919
Buggy source:
/** 
 * Specifies a varg of conditions to append to this SET
 * @param conditions The varg of conditions
 * @return This instance.
 */
public Set<ModelClass> conditions(Condition... conditions){
  conditionGroup.andAll(conditions);
  return this;
}

Fixed version (ground truth):
/** 
 * Specifies a varg of conditions to append to this SET
 * @param conditions The varg of conditions
 * @return This instance.
 */
public Set<ModelClass> conditions(SQLCondition... conditions){
  conditionGroup.andAll(conditions);
  return this;
}
Program: 26920
Project: 26920
Buggy source:
/** 
 * Begins a SET piece of this query with a string clause with args
 * @param setClause The clause to use as a string clause.
 * @param args      The arguments to append that will get properly type-converted.
 * @return A SET query piece of this statement.
 */
public Set<ModelClass> set(String setClause,Object... args){
  return set().conditionClause(setClause,args);
}

Fixed version (ground truth):
/** 
 * Begins a SET piece of the SQL query
 * @param conditions The array of conditions that define this SET statement
 * @return A SET query piece of this statement
 */
public Set<ModelClass> set(SQLCondition... conditions){
  return new Set<>(this,table).conditions(conditions);
}
Program: 26921
Project: 26921
Buggy source:
public Update conflictAction(ConflictAction conflictAction){
  mConflictAction=conflictAction;
  return this;
}

Fixed version (ground truth):
public Update conflictAction(ConflictAction conflictAction){
  this.conflictAction=conflictAction;
  return this;
}
Program: 26922
Project: 26922
Buggy source:
/** 
 * Constructs new instace of an UPDATE query with the specified table.
 * @param table The table to use.
 */
public Update(Class<ModelClass> table){
  mTable=table;
}

Fixed version (ground truth):
/** 
 * Constructs new instace of an UPDATE query with the specified table.
 * @param table The table to use.
 */
public Update(Class<ModelClass> table){
  this.table=table;
}
Program: 26923
Project: 26923
Buggy source:
/** 
 * @param table        The table to update.
 * @param < ModelClass > The class that implements {@link Model}
 * @return A new update object. Begins a generic UPDATE query.
 */
public static <ModelClass extends Model>Update table(Class<ModelClass> table){
  return new Update(table);
}

Fixed version (ground truth):
/** 
 * @param table        The table to update.
 * @param < ModelClass > The class that implements {@link Model}
 * @return A new update object. Begins a generic UPDATE query.
 */
public static <ModelClass extends Model>Update table(Class<ModelClass> table){
  return new Update<>(table);
}
Program: 26924
Project: 26924
Buggy source:
@Override public String getQuery(){
  QueryBuilder queryBuilder=new QueryBuilder("String_Node_Str");
  if (mConflictAction != null && !mConflictAction.equals(ConflictAction.NONE)) {
    queryBuilder.append("String_Node_Str").appendSpaceSeparated(mConflictAction.name());
  }
  queryBuilder.appendQuoted(FlowManager.getTableName(mTable)).appendSpace();
  return queryBuilder.getQuery();
}

Fixed version (ground truth):
@Override public String getQuery(){
  QueryBuilder queryBuilder=new QueryBuilder("String_Node_Str");
  if (conflictAction != null && !conflictAction.equals(ConflictAction.NONE)) {
    queryBuilder.append("String_Node_Str").appendSpaceSeparated(conflictAction.name());
  }
  queryBuilder.appendQuoted(FlowManager.getTableName(table)).appendSpace();
  return queryBuilder.getQuery();
}
Program: 26925
Project: 26925
Buggy source:
/** 
 * Appends an OR with a Condition to the WHERE clause with the specified   {@link SQLCondition}
 * @param condition
 * @return
 */
public Where<ModelClass> or(SQLCondition condition){
  conditionQueryBuilder.or(condition);
  return this;
}

Fixed version (ground truth):
/** 
 * Appends an OR with a Condition to the WHERE clause with the specified   {@link SQLCondition}
 * @param condition
 * @return
 */
public Where<ModelClass> or(SQLCondition condition){
  conditionGroup.or(condition);
  return this;
}
Program: 26926
Project: 26926
Buggy source:
/** 
 * Defines a SQL HAVING statement without the HAVING.
 * @param conditions The array of {@link SQLCondition}
 * @return
 */
@Override public Where<ModelClass> having(SQLCondition... conditions){
  having.addConditions(conditions);
  return this;
}

Fixed version (ground truth):
/** 
 * Defines a SQL HAVING statement without the HAVING.
 * @param conditions The array of {@link SQLCondition}
 * @return
 */
@Override public Where<ModelClass> having(SQLCondition... conditions){
  havingGroup.andAll(conditions);
  return this;
}
Program: 26927
Project: 26927
Buggy source:
/** 
 * Adds a param to the WHERE clause with the custom   {@link SQLCondition}
 * @param condition The {@link SQLCondition} to use
 * @return
 */
public Where<ModelClass> and(SQLCondition condition){
  conditionQueryBuilder.and(condition);
  return this;
}

Fixed version (ground truth):
/** 
 * Adds a param to the WHERE clause with the custom   {@link SQLCondition}
 * @param condition The {@link SQLCondition} to use
 * @return
 */
public Where<ModelClass> and(SQLCondition condition){
  conditionGroup.and(condition);
  return this;
}
Program: 26928
Project: 26928
Buggy source:
/** 
 * Constructs this class with the specified   {@link com.raizlabs.android.dbflow.config.FlowManager}and   {@link From} chunk
 * @param whereBase The FROM or SET statement chunk
 */
Where(WhereBase<ModelClass> whereBase,SQLCondition... conditions){
  super(whereBase.getTable());
  this.whereBase=whereBase;
  databaseDefinition=FlowManager.getDatabaseForTable(this.whereBase.getTable());
  conditionQueryBuilder=new ConditionQueryBuilder<>(this.whereBase.getTable());
  having=new ConditionQueryBuilder<>(this.whereBase.getTable());
  conditionQueryBuilder.addConditions(conditions);
}

Fixed version (ground truth):
/** 
 * Constructs this class with the specified   {@link com.raizlabs.android.dbflow.config.FlowManager}and   {@link From} chunk
 * @param whereBase The FROM or SET statement chunk
 */
Where(WhereBase<ModelClass> whereBase,SQLCondition... conditions){
  super(whereBase.getTable());
  this.whereBase=whereBase;
  databaseDefinition=FlowManager.getDatabaseForTable(this.whereBase.getTable());
  conditionGroup=new ConditionGroup();
  havingGroup=new ConditionGroup();
  conditionGroup.andAll(conditions);
}
Program: 26929
Project: 26929
Buggy source:
@Override public String getQuery(){
  String fromQuery=whereBase.getQuery();
  QueryBuilder queryBuilder=new QueryBuilder().append(fromQuery).appendQualifier("String_Node_Str",conditionQueryBuilder.getQuery()).appendQualifier("String_Node_Str",QueryBuilder.join("String_Node_Str",groupByList)).appendQualifier("String_Node_Str",having.getQuery()).appendQualifier("String_Node_Str",QueryBuilder.join("String_Node_Str",orderByList));
  if (limit > VALUE_UNSET) {
    queryBuilder.appendQualifier("String_Node_Str",String.valueOf(limit));
  }
  if (offset > VALUE_UNSET) {
    queryBuilder.appendQualifier("String_Node_Str",String.valueOf(offset));
  }
  return queryBuilder.getQuery();
}

Fixed version (ground truth):
@Override public String getQuery(){
  String fromQuery=whereBase.getQuery();
  QueryBuilder queryBuilder=new QueryBuilder().append(fromQuery).appendQualifier("String_Node_Str",conditionGroup.getQuery()).appendQualifier("String_Node_Str",QueryBuilder.join("String_Node_Str",groupByList)).appendQualifier("String_Node_Str",havingGroup.getQuery()).appendQualifier("String_Node_Str",QueryBuilder.join("String_Node_Str",orderByList));
  if (limit > VALUE_UNSET) {
    queryBuilder.appendQualifier("String_Node_Str",String.valueOf(limit));
  }
  if (offset > VALUE_UNSET) {
    queryBuilder.appendQualifier("String_Node_Str",String.valueOf(offset));
  }
  return queryBuilder.getQuery();
}
Program: 26930
Project: 26930
Buggy source:
public BaseDefinition(TypeElement element,ProcessorManager processorManager){
  this.manager=processorManager;
  this.typeElement=element;
  elementClassName=ClassName.get(typeElement);
  elementName=element.getSimpleName().toString();
  packageName=manager.getElements().getPackageOf(element).toString();
}

Fixed version (ground truth):
public BaseDefinition(TypeElement element,ProcessorManager processorManager){
  this.manager=processorManager;
  this.typeElement=element;
  elementClassName=ClassName.get(typeElement);
  elementTypeName=TypeName.get(element.asType());
  elementName=element.getSimpleName().toString();
  packageName=manager.getElements().getPackageOf(element).toString();
}
Program: 26931
Project: 26931
Buggy source:
public ContentProviderDefinition(Element typeElement,ProcessorManager processorManager){
  super(typeElement,processorManager);
  ContentProvider provider=element.getAnnotation(ContentProvider.class);
  databaseName=provider.databaseName();
  DatabaseMethod databaseMethod=manager.getDatabaseWriter(databaseName);
  setOutputClassName(databaseMethod.classSeparator + DEFINITION_NAME);
  authority=provider.authority();
  TableEndpointValidator validator=new TableEndpointValidator();
  List<? extends Element> elements=manager.getElements().getAllMembers((TypeElement)typeElement);
  for (  Element innerElement : elements) {
    if (innerElement.getAnnotation(TableEndpoint.class) != null) {
      TableEndpointDefinition endpointDefinition=new TableEndpointDefinition(innerElement,manager);
      if (validator.validate(processorManager,endpointDefinition)) {
        endpointDefinitions.add(endpointDefinition);
      }
    }
  }
  methods=new MethodDefinition[]{new QueryMethod(this,manager),new InsertMethod(this),new DeleteMethod(this,manager),new UpdateWriter(this,manager)};
}

Fixed version (ground truth):
public ContentProviderDefinition(Element typeElement,ProcessorManager processorManager){
  super(typeElement,processorManager);
  ContentProvider provider=element.getAnnotation(ContentProvider.class);
  databaseName=provider.databaseName();
  DatabaseMethod databaseMethod=manager.getDatabaseWriter(databaseName);
  setOutputClassName(databaseMethod.classSeparator + DEFINITION_NAME);
  authority=provider.authority();
  TableEndpointValidator validator=new TableEndpointValidator();
  List<? extends Element> elements=manager.getElements().getAllMembers((TypeElement)typeElement);
  for (  Element innerElement : elements) {
    if (innerElement.getAnnotation(TableEndpoint.class) != null) {
      TableEndpointDefinition endpointDefinition=new TableEndpointDefinition(innerElement,manager);
      if (validator.validate(processorManager,endpointDefinition)) {
        endpointDefinitions.add(endpointDefinition);
      }
    }
  }
  methods=new MethodDefinition[]{new QueryMethod(this,manager),new InsertMethod(this,false),new InsertMethod(this,true),new DeleteMethod(this,manager),new UpdateMethod(this,manager)};
}
Program: 26933
Project: 26933
Buggy source:
public static void writeGetModelClass(TypeSpec.Builder typeBuilder,final ClassName modelClassName) throws IOException {
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addStatement("String_Node_Str",modelClassName).returns(ParameterizedTypeName.get(ClassName.get(Class.class),modelClassName)).build());
}

Fixed version (ground truth):
public static void writeGetModelClass(TypeSpec.Builder typeBuilder,final ClassName modelClassName){
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addStatement("String_Node_Str",modelClassName).returns(ParameterizedTypeName.get(ClassName.get(Class.class),modelClassName)).build());
}
Program: 26934
Project: 26934
Buggy source:
public static void writeGetTableName(TypeSpec.Builder typeBuilder,final String tableName) throws IOException {
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addModifiers(Modifier.PUBLIC,Modifier.FINAL).addStatement("String_Node_Str",tableName).returns(ClassName.get(String.class)).build());
}

Fixed version (ground truth):
public static void writeGetTableName(TypeSpec.Builder typeBuilder,final String tableName){
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addModifiers(Modifier.PUBLIC,Modifier.FINAL).addStatement("String_Node_Str",tableName).returns(ClassName.get(String.class)).build());
}
Program: 26935
Project: 26935
Buggy source:
@Override protected String getExtendsClass(){
  return "String_Node_Str" + elementClassName + "String_Node_Str";
}

Fixed version (ground truth):
@Override protected TypeName getExtendsClass(){
  return ParameterizedTypeName.get(ClassNames.MODEL_CONTAINER_ADAPTER,elementClassName);
}
Program: 26936
Project: 26936
Buggy source:
@Override public void onWriteDefinition(TypeSpec.Builder typeBuilder){
  javaWriter.emitField("String_Node_Str","String_Node_Str",Sets.newHashSet(Modifier.PRIVATE,Modifier.FINAL),"String_Node_Str");
  javaWriter.emitEmptyLine();
  javaWriter.beginConstructor(Sets.newHashSet(Modifier.PUBLIC));
  for (  ColumnDefinition columnDefinition : tableDefinition.columnDefinitions) {
    javaWriter.emitStatement("String_Node_Str","String_Node_Str",columnDefinition.columnName,columnDefinition.columnFieldType);
  }
  javaWriter.endConstructor();
  javaWriter.emitEmptyLine();
  javaWriter.emitAnnotation(Override.class);
  WriterUtils.emitMethod(javaWriter,new FlowWriter(){
    @Override public void write(    JavaWriter javaWriter) throws IOException {
      javaWriter.emitStatement("String_Node_Str","String_Node_Str","String_Node_Str");
    }
  }
,"String_Node_Str","String_Node_Str",Sets.newHashSet(Modifier.PUBLIC,Modifier.FINAL),"String_Node_Str","String_Node_Str");
  InternalAdapterHelper.writeGetModelClass(javaWriter,getModelClassQualifiedName());
  InternalAdapterHelper.writeGetTableName(javaWriter,elementClassName + tableDefinition.databaseMethod.classSeparator + TableDefinition.DBFLOW_TABLE_TAG);
  for (  FlowWriter writer : methodWriters) {
    writer.write(javaWriter);
  }
}

Fixed version (ground truth):
@Override public void onWriteDefinition(TypeSpec.Builder typeBuilder){
  typeBuilder.addField(FieldSpec.builder(ParameterizedTypeName.get(ClassName.get(Map.class),ClassName.get(String.class),ClassName.get(Class.class)),"String_Node_Str",Modifier.PRIVATE,Modifier.FINAL).initializer("String_Node_Str",ParameterizedTypeName.get(HashMap.class)).build());
  CodeBlock.Builder constructorCode=CodeBlock.builder();
  for (  ColumnDefinition columnDefinition : tableDefinition.columnDefinitions) {
    constructorCode.addStatement("String_Node_Str","String_Node_Str",columnDefinition.columnName,columnDefinition.elementTypeName);
  }
  typeBuilder.addMethod(MethodSpec.constructorBuilder().addCode(constructorCode.build()).addModifiers(Modifier.PUBLIC).build());
  typeBuilder.addMethod(MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(ClassName.get(String.class),"String_Node_Str").addStatement("String_Node_Str","String_Node_Str","String_Node_Str").returns(ParameterizedTypeName.get(ClassName.get(Class.class))).build());
  InternalAdapterHelper.writeGetModelClass(typeBuilder,elementClassName);
  InternalAdapterHelper.writeGetTableName(typeBuilder,elementClassName + tableDefinition.databaseMethod.classSeparator + TableDefinition.DBFLOW_TABLE_TAG);
  for (  MethodDefinition method : methods) {
    MethodSpec methodSpec=method.getMethodSpec();
    if (methodSpec != null) {
      typeBuilder.addMethod(methodSpec);
    }
  }
}
Program: 26937
Project: 26937
Buggy source:
public ModelContainerDefinition(TypeElement classElement,ProcessorManager manager){
  super(classElement,manager);
  tableDefinition=manager.getTableDefinition(manager.getDatabase(elementClassName),classElement);
  setOutputClassName(tableDefinition.databaseMethod.classSeparator + DBFLOW_MODEL_CONTAINER_TAG);
  methodWriters=new FlowWriter[]{new SQLiteStatementWriter(tableDefinition,true,tableDefinition.implementsSqlStatementListener,tableDefinition.implementsContentValuesListener),new ExistenceWriter(tableDefinition,true),new WhereQueryWriter(tableDefinition,true),new ToModelMethod(tableDefinition,true),new LoadCursorWriter(tableDefinition,true,tableDefinition.implementsLoadFromCursorListener)};
}

Fixed version (ground truth):
public ModelContainerDefinition(TypeElement classElement,ProcessorManager manager){
  super(classElement,manager);
  tableDefinition=manager.getTableDefinition(manager.getDatabase(elementClassName),classElement);
  setOutputClassName(tableDefinition.databaseMethod.classSeparator + DBFLOW_MODEL_CONTAINER_TAG);
  methods=new MethodDefinition[]{new BindToContentValuesMethod(tableDefinition,true,true,tableDefinition.implementsContentValuesListener),new BindToContentValuesMethod(tableDefinition,false,true,tableDefinition.implementsContentValuesListener),new BindToStatementMethod(tableDefinition,true,true),new BindToStatementMethod(tableDefinition,false,true),new ExistenceMethod(tableDefinition,true),new PrimaryConditionClause(tableDefinition,true),new ToModelMethod(tableDefinition,true),new LoadFromCursorMethod(tableDefinition,true,tableDefinition.implementsLoadFromCursorListener)};
}
Program: 26940
Project: 26940
Buggy source:
public ForeignKeyColumnDefinition(ProcessorManager manager,Element typeElement){
  super(manager,typeElement);
  ForeignKey foreignKey=typeElement.getAnnotation(ForeignKey.class);
  onUpdate=foreignKey.onUpdate();
  onDelete=foreignKey.onDelete();
  try {
    foreignKey.tableClass();
  }
 catch (  MirroredTypeException mte) {
    referencedTableClassName=ClassName.get(manager.getElements().getTypeElement(mte.getTypeMirror().toString()));
  }
  if (referencedTableClassName.equals(TypeName.OBJECT)) {
    referencedTableClassName=ClassName.get(manager.getElements().getTypeElement(typeElement.asType().toString()));
  }
  isModel=ProcessorUtils.implementsClass(manager.getProcessingEnvironment(),ClassNames.MODEL,modelType);
  if (columnAccess instanceof TypeConverterAccess) {
    if (typeElement.getModifiers().contains(Modifier.PRIVATE)) {
      columnAccess=new PrivateColumnAccess(typeElement.getAnnotation(Column.class));
    }
 else {
      columnAccess=new SimpleColumnAccess();
    }
  }
  ForeignKeyReference[] references=foreignKey.references();
  for (  ForeignKeyReference reference : references) {
    ForeignKeyReferenceDefinition referenceDefinition=new ForeignKeyReferenceDefinition(manager,elementName,reference,columnAccess);
    foreignKeyReferenceDefinitionList.add(referenceDefinition);
  }
}

Fixed version (ground truth):
public ForeignKeyColumnDefinition(ProcessorManager manager,Element typeElement){
  super(manager,typeElement);
  ForeignKey foreignKey=typeElement.getAnnotation(ForeignKey.class);
  onUpdate=foreignKey.onUpdate();
  onDelete=foreignKey.onDelete();
  try {
    foreignKey.tableClass();
  }
 catch (  MirroredTypeException mte) {
    referencedTableClassName=ClassName.get(manager.getElements().getTypeElement(mte.getTypeMirror().toString()));
  }
  if (referencedTableClassName.equals(TypeName.OBJECT)) {
    referencedTableClassName=ClassName.get(manager.getElements().getTypeElement(typeElement.asType().toString()));
  }
  TypeElement element=manager.getProcessingEnvironment().getElementUtils().getTypeElement(elementTypeName.toString());
  isModel=ProcessorUtils.implementsClass(manager.getProcessingEnvironment(),ClassNames.MODEL.toString(),element);
  if (columnAccess instanceof TypeConverterAccess) {
    if (typeElement.getModifiers().contains(Modifier.PRIVATE)) {
      columnAccess=new PrivateColumnAccess(typeElement.getAnnotation(Column.class));
    }
 else {
      columnAccess=new SimpleColumnAccess();
    }
  }
  ForeignKeyReference[] references=foreignKey.references();
  for (  ForeignKeyReference reference : references) {
    ForeignKeyReferenceDefinition referenceDefinition=new ForeignKeyReferenceDefinition(manager,elementName,reference,columnAccess);
    foreignKeyReferenceDefinitionList.add(referenceDefinition);
  }
}
Program: 26941
Project: 26941
Buggy source:
public Set<QueryModelDefinition> getQueryModelDefinitions(String databaseName){
  Map<String,QueryModelDefinition> modelQueryDefinition=queryModelDefinitionMap.get(databaseName);
  if (modelQueryDefinition != null) {
    return Sets.newHashSet(queryModelDefinitionMap.get(databaseName).values());
  }
 else {
    return Sets.newHashSet();
  }
}

Fixed version (ground truth):
public Set<QueryModelDefinition> getQueryModelDefinitions(String databaseName){
  Map<TypeName,QueryModelDefinition> modelQueryDefinition=queryModelDefinitionMap.get(databaseName);
  if (modelQueryDefinition != null) {
    return Sets.newHashSet(queryModelDefinitionMap.get(databaseName).values());
  }
 else {
    return Sets.newHashSet();
  }
}
Program: 26942
Project: 26942
Buggy source:
@Override public MethodSpec getMethodSpec(){
  MethodSpec.Builder methodBuilder=MethodSpec.methodBuilder(isInsert ? "String_Node_Str" : "String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(ClassNames.CONTENT_VALUES,PARAM_CONTENT_VALUES).addParameter(baseTableDefinition.getParameterClassName(isModelContainerAdapter),ModelUtils.getVariable(isModelContainerAdapter)).returns(TypeName.VOID);
  List<ColumnDefinition> columnDefinitionList=baseTableDefinition.getColumnDefinitions();
  for (  ColumnDefinition columnDefinition : columnDefinitionList) {
    methodBuilder.addCode(columnDefinition.getContentValuesStatement());
  }
  if (implementsContentValuesListener) {
    methodBuilder.addStatement("String_Node_Str",ModelUtils.getVariable(isModelContainerAdapter),isInsert ? "String_Node_Str" : "String_Node_Str",PARAM_CONTENT_VALUES);
  }
  return methodBuilder.build();
}

Fixed version (ground truth):
@Override public MethodSpec getMethodSpec(){
  MethodSpec.Builder methodBuilder=MethodSpec.methodBuilder(isInsert ? "String_Node_Str" : "String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(ClassNames.CONTENT_VALUES,PARAM_CONTENT_VALUES).addParameter(baseTableDefinition.getParameterClassName(isModelContainerAdapter),ModelUtils.getVariable(isModelContainerAdapter)).returns(TypeName.VOID);
  List<ColumnDefinition> columnDefinitionList=baseTableDefinition.getColumnDefinitions();
  for (  ColumnDefinition columnDefinition : columnDefinitionList) {
    methodBuilder.addCode(columnDefinition.getContentValuesStatement(isModelContainerAdapter));
  }
  if (implementsContentValuesListener) {
    methodBuilder.addStatement("String_Node_Str",ModelUtils.getVariable(isModelContainerAdapter),isInsert ? "String_Node_Str" : "String_Node_Str",PARAM_CONTENT_VALUES);
  }
  return methodBuilder.build();
}
Program: 26943
Project: 26943
Buggy source:
@Override public MethodSpec getMethodSpec(){
}

Fixed version (ground truth):
@Override public MethodSpec getMethodSpec(){
  MethodSpec.Builder methodBuilder=MethodSpec.methodBuilder(isInsert ? "String_Node_Str" : "String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(ClassNames.SQLITE_STATEMENT,PARAM_STATEMENT).addParameter(tableDefinition.getParameterClassName(isModelContainerAdapter),ModelUtils.getVariable(isModelContainerAdapter)).returns(TypeName.VOID);
  List<ColumnDefinition> columnDefinitionList=tableDefinition.getColumnDefinitions();
  AtomicInteger realCount=new AtomicInteger(1);
  for (  ColumnDefinition columnDefinition : columnDefinitionList) {
    if (!isInsert || (isInsert && !columnDefinition.isPrimaryKeyAutoIncrement)) {
      methodBuilder.addCode(columnDefinition.getSQLiteStatementMethod(realCount,isModelContainerAdapter));
      realCount.incrementAndGet();
    }
  }
  if (tableDefinition.implementsSqlStatementListener) {
    methodBuilder.addStatement("String_Node_Str",ModelUtils.getVariable(isModelContainerAdapter),isInsert ? "String_Node_Str" : "String_Node_Str",PARAM_STATEMENT);
  }
  return methodBuilder.build();
}
Program: 26944
Project: 26944
Buggy source:
@Override public MethodSpec getMethodSpec(){
  MethodSpec.Builder methodBuilder=MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(ClassNames.CURSOR,PARAM_CURSOR).addParameter(baseTableDefinition.getParameterClassName(isModelContainerAdapter),ModelUtils.getVariable(isModelContainerAdapter)).returns(TypeName.VOID);
  List<ColumnDefinition> columnDefinitionList=baseTableDefinition.getColumnDefinitions();
  for (  ColumnDefinition columnDefinition : columnDefinitionList) {
    methodBuilder.addCode(columnDefinition.getLoadFromCursorMethod());
  }
  return methodBuilder.build();
}

Fixed version (ground truth):
@Override public MethodSpec getMethodSpec(){
  MethodSpec.Builder methodBuilder=MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(ClassNames.CURSOR,PARAM_CURSOR).addParameter(baseTableDefinition.getParameterClassName(isModelContainerAdapter),ModelUtils.getVariable(isModelContainerAdapter)).returns(TypeName.VOID);
  List<ColumnDefinition> columnDefinitionList=baseTableDefinition.getColumnDefinitions();
  for (  ColumnDefinition columnDefinition : columnDefinitionList) {
    methodBuilder.addCode(columnDefinition.getLoadFromCursorMethod(isModelContainerAdapter));
  }
  return methodBuilder.build();
}
Program: 26945
Project: 26945
Buggy source:
abstract String getColumnAccessString(TypeName fieldType,String elementName,boolean isModelContainerAdapter,String variableNameString);

Fixed version (ground truth):
abstract String getColumnAccessString(TypeName fieldType,String elementName,String fullElementName,String variableNameString,boolean isModelContainerAdapter);
Program: 26946
Project: 26946
Buggy source:
abstract String setColumnAccessString(TypeName fieldType,String elementName,String formattedAccess,boolean isModelContainerAdapter,String variableNameString);

Fixed version (ground truth):
abstract String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,String formattedAccess);
Program: 26947
Project: 26947
Buggy source:
@Override String getColumnAccessString(TypeName fieldType,String elementName,boolean isModelContainerAdapter,String variableNameString){
  return CodeBlock.builder().add("String_Node_Str",getExistingColumnAccess().getColumnAccessString(fieldType,elementName,isModelContainerAdapter,variableNameString)).build().toString();
}

Fixed version (ground truth):
@Override String getColumnAccessString(TypeName fieldType,String elementName,String fullElementName,String variableNameString,boolean isModelContainerAdapter){
  return CodeBlock.builder().add("String_Node_Str",getExistingColumnAccess().getColumnAccessString(fieldType,elementName,fullElementName,variableNameString,isModelContainerAdapter)).build().toString();
}