nus-yam/ex-repair huggingface dataset:
Program: 26948
Project: 26948
Buggy source:
@Override String setColumnAccessString(TypeName fieldType,String elementName,String formattedAccess,boolean isModelContainerAdapter,String variableNameString){
  String newFormattedAccess=CodeBlock.builder().add("String_Node_Str",variableNameString,formattedAccess).build().toString();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,newFormattedAccess,isModelContainerAdapter,variableNameString);
}

Fixed version (ground truth):
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,String formattedAccess){
  String newFormattedAccess=CodeBlock.builder().add("String_Node_Str",variableNameString,formattedAccess).build().toString();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}
Program: 26949
Project: 26949
Buggy source:
public CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  return DefinitionUtils.getSQLiteStatementMethod(index,elementName,columnAccess,elementTypeName,isModelContainerAdapter).build();
}

Fixed version (ground truth):
public CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  return DefinitionUtils.getSQLiteStatementMethod(index,elementName,elementName,elementTypeName,isModelContainerAdapter,columnAccess).build();
}
Program: 26950
Project: 26950
Buggy source:
public CodeBlock getLoadFromCursorMethod(boolean isModelContainerAdapter){
  return DefinitionUtils.getLoadFromCursorMethod(elementName,columnAccess,elementTypeName,columnName,isModelContainerAdapter).build();
}

Fixed version (ground truth):
public CodeBlock getLoadFromCursorMethod(boolean isModelContainerAdapter){
  return DefinitionUtils.getLoadFromCursorMethod(elementName,elementName,elementTypeName,columnName,isModelContainerAdapter,columnAccess).build();
}
Program: 26951
Project: 26951
Buggy source:
public CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  return DefinitionUtils.getContentValuesStatement(elementName,columnAccess,columnName,elementTypeName,isModelContainerAdapter).build();
}

Fixed version (ground truth):
public CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  return DefinitionUtils.getContentValuesStatement(elementName,elementName,columnName,elementTypeName,isModelContainerAdapter,columnAccess).build();
}
Program: 26952
Project: 26952
Buggy source:
public String getColumnAccessString(boolean isModelContainerAdapter){
  return columnAccess.getColumnAccessString(elementTypeName,elementName,isModelContainerAdapter,ModelUtils.getVariable(isModelContainerAdapter));
}

Fixed version (ground truth):
public String getColumnAccessString(boolean isModelContainerAdapter){
  return columnAccess.getColumnAccessString(elementTypeName,elementName,elementName,ModelUtils.getVariable(isModelContainerAdapter),isModelContainerAdapter);
}
Program: 26953
Project: 26953
Buggy source:
public static CodeBlock.Builder getSQLiteStatementMethod(AtomicInteger index,String elementName,BaseColumnAccess columnAccess,TypeName elementTypeName,boolean isModelContainerAdapter){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,isModelContainerAdapter,ModelUtils.getVariable(isModelContainerAdapter));
  CodeBlock.Builder codeBuilder=CodeBlock.builder();
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement="String_Node_Str" + elementName;
    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",BindToStatementMethod.PARAM_STATEMENT,columnAccess.getSqliteTypeForTypeName(elementTypeName,isModelContainerAdapter).getSQLiteStatementMethod(),index.intValue(),finalAccessStatement);
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str",BindToStatementMethod.PARAM_STATEMENT,index.intValue()).endControlFlow();
  }
  return codeBuilder;
}

Fixed version (ground truth):
public static CodeBlock.Builder getSQLiteStatementMethod(AtomicInteger index,String elementName,String fullElementName,TypeName elementTypeName,boolean isModelContainerAdapter,BaseColumnAccess columnAccess){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,fullElementName,ModelUtils.getVariable(isModelContainerAdapter),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",BindToStatementMethod.PARAM_STATEMENT,columnAccess.getSqliteTypeForTypeName(elementTypeName,isModelContainerAdapter).getSQLiteStatementMethod(),index.intValue(),finalAccessStatement);
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str",BindToStatementMethod.PARAM_STATEMENT,index.intValue()).endControlFlow();
  }
  return codeBuilder;
}
Program: 26954
Project: 26954
Buggy source:
public static CodeBlock.Builder getLoadFromCursorMethod(String elementName,BaseColumnAccess columnAccess,TypeName elementTypeName,String columnName,boolean isModelContainerAdapter){
  String method="String_Node_Str";
  if (SQLiteType.containsMethod(elementTypeName)) {
    method=SQLiteType.getMethod(elementTypeName);
  }
 else   if (columnAccess instanceof TypeConverterAccess) {
    method=SQLiteType.getMethod(((TypeConverterAccess)columnAccess).typeConverterDefinition.getDbTypeName());
  }
  CodeBlock.Builder codeBuilder=CodeBlock.builder();
  String indexName="String_Node_Str" + columnName;
  codeBuilder.addStatement("String_Node_Str",indexName,LoadFromCursorMethod.PARAM_CURSOR,columnName);
  codeBuilder.beginControlFlow("String_Node_Str",indexName,LoadFromCursorMethod.PARAM_CURSOR,indexName);
  codeBuilder.addStatement(columnAccess.setColumnAccessString(elementTypeName,elementName,CodeBlock.builder().add("String_Node_Str",LoadFromCursorMethod.PARAM_CURSOR,method,indexName).build().toString(),isModelContainerAdapter,ModelUtils.getVariable(isModelContainerAdapter)));
  codeBuilder.endControlFlow();
  return codeBuilder;
}

Fixed version (ground truth):
public static CodeBlock.Builder getLoadFromCursorMethod(String elementName,String fullElementName,TypeName elementTypeName,String columnName,boolean isModelContainerAdapter,BaseColumnAccess columnAccess){
  String method="String_Node_Str";
  if (SQLiteType.containsMethod(elementTypeName)) {
    method=SQLiteType.getMethod(elementTypeName);
  }
 else   if (columnAccess instanceof TypeConverterAccess) {
    method=SQLiteType.getMethod(((TypeConverterAccess)columnAccess).typeConverterDefinition.getDbTypeName());
  }
  CodeBlock.Builder codeBuilder=CodeBlock.builder();
  String indexName="String_Node_Str" + columnName;
  codeBuilder.addStatement("String_Node_Str",indexName,LoadFromCursorMethod.PARAM_CURSOR,columnName);
  codeBuilder.beginControlFlow("String_Node_Str",indexName,LoadFromCursorMethod.PARAM_CURSOR,indexName);
  codeBuilder.addStatement(columnAccess.setColumnAccessString(elementTypeName,elementName,fullElementName,isModelContainerAdapter,ModelUtils.getVariable(isModelContainerAdapter),CodeBlock.builder().add("String_Node_Str",LoadFromCursorMethod.PARAM_CURSOR,method,indexName).build().toString()));
  codeBuilder.endControlFlow();
  return codeBuilder;
}
Program: 26955
Project: 26955
Buggy source:
public static CodeBlock.Builder getContentValuesStatement(String elementName,BaseColumnAccess columnAccess,String columnName,TypeName elementTypeName,boolean isModelContainerAdapter){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,isModelContainerAdapter,ModelUtils.getVariable(isModelContainerAdapter));
  CodeBlock.Builder codeBuilder=CodeBlock.builder();
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement="String_Node_Str" + elementName;
    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 statement=columnAccess.getColumnAccessString(elementTypeName,elementName,fullElementName,ModelUtils.getVariable(isModelContainerAdapter),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;
}
Program: 26956
Project: 26956
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();
}
Program: 26957
Project: 26957
Buggy source:
@Override String setColumnAccessString(TypeName fieldType,String elementName,String formattedAccess,boolean isModelContainerAdapter,String variableNameString){
  String newFormattedAccess=CodeBlock.builder().add("String_Node_Str",columnDefinition.elementClassName,formattedAccess).build().toString();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,newFormattedAccess,isModelContainerAdapter,variableNameString);
}

Fixed version (ground truth):
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,String formattedAccess){
  String newFormattedAccess=CodeBlock.builder().add("String_Node_Str",columnDefinition.elementClassName,formattedAccess).build().toString();
  return getExistingColumnAccess().setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}
Program: 26958
Project: 26958
Buggy source:
@Override public CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  CodeBlock.Builder builder=CodeBlock.builder();
  builder.beginControlFlow("String_Node_Str",columnAccess.getColumnAccessString(elementTypeName,elementName,isModelContainerAdapter,BindToStatementMethod.PARAM_MODEL));
  CodeBlock.Builder elseBuilder=CodeBlock.builder();
  for (  ForeignKeyReferenceDefinition referenceDefinition : foreignKeyReferenceDefinitionList) {
    builder.add(referenceDefinition.getSQLiteStatementMethod(index,isModelContainerAdapter));
    elseBuilder.addStatement("String_Node_Str",BindToStatementMethod.PARAM_STATEMENT,index.intValue());
    index.incrementAndGet();
  }
  builder.nextControlFlow("String_Node_Str").add(elseBuilder.build()).endControlFlow();
  return builder.build();
}

Fixed version (ground truth):
@Override public CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  CodeBlock.Builder builder=CodeBlock.builder();
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,elementName,ModelUtils.getVariable(isModelContainerAdapter),isModelContainerAdapter);
  String finalAccessStatement=getFinalAccessStatement(builder,isModelContainerAdapter,statement);
  builder.beginControlFlow("String_Node_Str",finalAccessStatement);
  CodeBlock.Builder elseBuilder=CodeBlock.builder();
  for (  ForeignKeyReferenceDefinition referenceDefinition : foreignKeyReferenceDefinitionList) {
    builder.add(referenceDefinition.getSQLiteStatementMethod(index,isModelContainerAdapter));
    elseBuilder.addStatement("String_Node_Str",BindToStatementMethod.PARAM_STATEMENT,index.intValue());
    index.incrementAndGet();
  }
  builder.nextControlFlow("String_Node_Str").add(elseBuilder.build()).endControlFlow();
  return builder.build();
}
Program: 26960
Project: 26960
Buggy source:
@Override public CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  CodeBlock.Builder builder=CodeBlock.builder();
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,isModelContainerAdapter,ModelUtils.getVariable(isModelContainerAdapter));
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement="String_Node_Str" + elementName;
    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";
    }
    builder.addStatement("String_Node_Str",typeName,finalAccessStatement,statement);
  }
  builder.beginControlFlow("String_Node_Str",finalAccessStatement);
  CodeBlock.Builder elseBuilder=CodeBlock.builder();
  for (  ForeignKeyReferenceDefinition referenceDefinition : foreignKeyReferenceDefinitionList) {
    builder.add(referenceDefinition.getContentValuesStatement(isModelContainerAdapter));
    elseBuilder.addStatement("String_Node_Str",BindToContentValuesMethod.PARAM_CONTENT_VALUES,referenceDefinition.columnName);
  }
  builder.nextControlFlow("String_Node_Str").add(elseBuilder.build()).endControlFlow();
  return builder.build();
}

Fixed version (ground truth):
@Override public CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  CodeBlock.Builder builder=CodeBlock.builder();
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,elementName,ModelUtils.getVariable(isModelContainerAdapter),isModelContainerAdapter);
  String finalAccessStatement=getFinalAccessStatement(builder,isModelContainerAdapter,statement);
  builder.beginControlFlow("String_Node_Str",finalAccessStatement);
  CodeBlock.Builder elseBuilder=CodeBlock.builder();
  for (  ForeignKeyReferenceDefinition referenceDefinition : foreignKeyReferenceDefinitionList) {
    builder.add(referenceDefinition.getContentValuesStatement(isModelContainerAdapter));
    elseBuilder.addStatement("String_Node_Str",BindToContentValuesMethod.PARAM_CONTENT_VALUES,referenceDefinition.columnName);
  }
  builder.nextControlFlow("String_Node_Str").add(elseBuilder.build()).endControlFlow();
  return builder.build();
}
Program: 26961
Project: 26961
Buggy source:
CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  return DefinitionUtils.getSQLiteStatementMethod(index,tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter) + "String_Node_Str" + columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter),simpleColumnAccess,columnClassName,isModelContainerAdapter).build();
}

Fixed version (ground truth):
CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  String shortAccess=tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter);
  String columnShortAccess=columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter);
  String combined=shortAccess + (isModelContainerAdapter ? "String_Node_Str" : "String_Node_Str") + columnShortAccess;
  return DefinitionUtils.getSQLiteStatementMethod(index,columnShortAccess,combined,columnClassName,isModelContainerAdapter,simpleColumnAccess).build();
}
Program: 26962
Project: 26962
Buggy source:
CodeBlock getLoadFromCursorMethod(boolean isModelContainerAdapter){
  return DefinitionUtils.getLoadFromCursorMethod(tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter) + "String_Node_Str" + columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter),simpleColumnAccess,columnClassName,columnName,isModelContainerAdapter).build();
}

Fixed version (ground truth):
CodeBlock getLoadFromCursorMethod(boolean isModelContainerAdapter){
  return DefinitionUtils.getLoadFromCursorMethod(columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter),tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter) + "String_Node_Str" + columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter),columnClassName,columnName,isModelContainerAdapter,simpleColumnAccess).build();
}
Program: 26963
Project: 26963
Buggy source:
CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  return DefinitionUtils.getContentValuesStatement(tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter) + "String_Node_Str" + columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter),simpleColumnAccess,columnName,columnClassName,isModelContainerAdapter).build();
}

Fixed version (ground truth):
CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  String shortAccess=tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter);
  String columnShortAccess=columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter);
  String combined=shortAccess + (isModelContainerAdapter ? "String_Node_Str" : "String_Node_Str") + columnShortAccess;
  return DefinitionUtils.getContentValuesStatement(columnShortAccess,combined,columnName,columnClassName,isModelContainerAdapter,simpleColumnAccess).build();
}
Program: 26964
Project: 26964
Buggy source:
@Override String getColumnAccessString(TypeName fieldType,String elementName,boolean isModelContainerAdapter,String variableNameString){
  return CodeBlock.builder().add("String_Node_Str",existingColumnAccess.getColumnAccessString(fieldType,elementName,isModelContainerAdapter,variableNameString),containerKeyName).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",existingColumnAccess.getColumnAccessString(fieldType,elementName,fullElementName,variableNameString,isModelContainerAdapter),containerKeyName).build().toString();
}
Program: 26965
Project: 26965
Buggy source:
@Override String setColumnAccessString(TypeName fieldType,String elementName,String formattedAccess,boolean isModelContainerAdapter,String variableNameString){
  String newFormattedAccess=CodeBlock.builder().add("String_Node_Str",variableNameString,containerKeyName,formattedAccess).build().toString();
  return existingColumnAccess.setColumnAccessString(fieldType,elementName,newFormattedAccess,isModelContainerAdapter,variableNameString);
}

Fixed version (ground truth):
@Override String setColumnAccessString(TypeName fieldType,String elementName,String fullElementName,boolean isModelContainerAdapter,String variableNameString,String formattedAccess){
  String newFormattedAccess=CodeBlock.builder().add("String_Node_Str",variableNameString,containerKeyName,formattedAccess).build().toString();
  return existingColumnAccess.setColumnAccessString(fieldType,elementName,fullElementName,isModelContainerAdapter,variableNameString,newFormattedAccess);
}
Program: 26966
Project: 26966
Buggy source:
@Override public ClassName getPropertyClassName(){
  return ClassName.get(packageName,adapterName);
}

Fixed version (ground truth):
@Override public ClassName getPropertyClassName(){
  return outputClassName;
}
Program: 26968
Project: 26968
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()));
  }
  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);
  }
}

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()));
  }
 else {
    referencedTableClassName=elementClassName;
  }
  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: 26969
Project: 26969
Buggy source:
@Override public MethodSpec getMethodSpec(){
  MethodSpec.Builder methodBuilder=MethodSpec.methodBuilder("String_Node_Str").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC,Modifier.FINAL).addParameter(baseTableDefinition.elementClassName,PARAM_MODEL).addParameter(ClassNames.CURSOR,PARAM_CURSOR).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.elementClassName,PARAM_MODEL).returns(TypeName.VOID);
  List<ColumnDefinition> columnDefinitionList=baseTableDefinition.getColumnDefinitions();
  for (  ColumnDefinition columnDefinition : columnDefinitionList) {
    methodBuilder.addCode(columnDefinition.getLoadFromCursorMethod());
  }
  return methodBuilder.build();
}
Program: 26970
Project: 26970
Buggy source:
public void testInOperators(){
  Condition.In in=column(ConditionModel$Table.NAME).in("String_Node_Str","String_Node_Str","String_Node_Str");
  ConditionQueryBuilder<ConditionModel> conditionQueryBuilder=new ConditionQueryBuilder<>(ConditionModel.class,in);
  assertEquals("String_Node_Str",conditionQueryBuilder.getQuery().trim());
  Condition.In notIn=column(ConditionModel$Table.NAME).notIn("String_Node_Str","String_Node_Str","String_Node_Str");
  conditionQueryBuilder=new ConditionQueryBuilder<>(ConditionModel.class,notIn);
  assertEquals("String_Node_Str",conditionQueryBuilder.getQuery().trim());
}

Fixed version (ground truth):
public void testInOperators(){
  Condition.In in=column(ConditionModel$Table.NAME).in("String_Node_Str","String_Node_Str","String_Node_Str");
  ConditionGroup conditionQueryBuilder=ConditionGroup.clause().and(in);
  assertEquals("String_Node_Str",conditionQueryBuilder.getQuery().trim());
  Condition.In notIn=column(ConditionModel$Table.NAME).notIn("String_Node_Str","String_Node_Str","String_Node_Str");
  conditionQueryBuilder=ConditionGroup.clause().and(notIn);
  assertEquals("String_Node_Str",conditionQueryBuilder.getQuery().trim());
}
Program: 26971
Project: 26971
Buggy source:
public void testChainingConditions(){
  ConditionQueryBuilder<ConditionModel> conditionQueryBuilder=new ConditionQueryBuilder<>(ConditionModel.class);
  conditionQueryBuilder.addCondition(column(ConditionModel$Table.NAME).is("String_Node_Str").separator("String_Node_Str")).addCondition(column(ConditionModel$Table.NUMBER).is(6).separator("String_Node_Str")).addCondition(column(ConditionModel$Table.FRACTION).is(4.5d));
  assertEquals("String_Node_Str",conditionQueryBuilder.getQuery().trim());
}

Fixed version (ground truth):
public void testChainingConditions(){
  ConditionGroup conditionQueryBuilder=ConditionGroup.clause();
  conditionQueryBuilder.addCondition(column(ConditionModel$Table.NAME).is("String_Node_Str").separator("String_Node_Str")).addCondition(column(ConditionModel$Table.NUMBER).is(6).separator("String_Node_Str")).addCondition(column(ConditionModel$Table.FRACTION).is(4.5d));
  assertEquals("String_Node_Str",conditionQueryBuilder.getQuery().trim());
}
Program: 26972
Project: 26972
Buggy source:
/** 
 * Updates the model if it exists. If the model does not exist and no rows are changed, we will attempt an insert into the DB.
 * @param model        The model to update
 * @param modelAdapter The adapter to use
 * @return true if model was inserted, false if not. Also false could mean that it is placed on the{@link DBTransactionQueue} using async to true.
 */
@SuppressWarnings("String_Node_Str") public static <ModelClass extends Model,TableClass extends Model,AdapterClass extends RetrievalAdapter & InternalAdapter>boolean update(TableClass model,AdapterClass adapter,ModelAdapter<ModelClass> modelAdapter){
  boolean exists;
  SQLiteDatabase db=FlowManager.getDatabaseForTable(modelAdapter.getModelClass()).getWritableDatabase();
  ContentValues contentValues=new ContentValues();
  adapter.bindToContentValues(contentValues,model);
  exists=(SQLiteCompatibilityUtils.updateWithOnConflict(db,modelAdapter.getTableName(),contentValues,adapter.getPrimaryConditions(model).getQuery(),null,ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.getUpdateOnConflictAction())) != 0);
  if (!exists) {
    insert(model,adapter,modelAdapter);
  }
 else {
    notifyModelChanged(model,adapter,modelAdapter,Action.UPDATE);
  }
  return exists;
}

Fixed version (ground truth):
/** 
 * Updates the model if it exists. If the model does not exist and no rows are changed, we will attempt an insert into the DB.
 * @param model        The model to update
 * @param modelAdapter The adapter to use
 * @return true if model was inserted, false if not. Also false could mean that it is placed on the{@link DBTransactionQueue} using async to true.
 */
@SuppressWarnings("String_Node_Str") public static <ModelClass extends Model,TableClass extends Model,AdapterClass extends RetrievalAdapter & InternalAdapter>boolean update(TableClass model,AdapterClass adapter,ModelAdapter<ModelClass> modelAdapter){
  boolean exists;
  SQLiteDatabase db=FlowManager.getDatabaseForTable(modelAdapter.getModelClass()).getWritableDatabase();
  ContentValues contentValues=new ContentValues();
  adapter.bindToContentValues(contentValues,model);
  exists=(SQLiteCompatibilityUtils.updateWithOnConflict(db,modelAdapter.getTableName(),contentValues,adapter.getPrimaryConditionClause(model).getQuery(),null,ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.getUpdateOnConflictAction())) != 0);
  if (!exists) {
    insert(model,adapter,modelAdapter);
  }
 else {
    notifyModelChanged(model,adapter,modelAdapter,Action.UPDATE);
  }
  return exists;
}
Program: 26973
Project: 26973
Buggy source:
/** 
 * Deletes   {@link Model} from the database using the specfied {@link FlowManager}
 * @param model The model to delete
 */
@SuppressWarnings("String_Node_Str") public static <ModelClass extends Model,TableClass extends Model,AdapterClass extends RetrievalAdapter & InternalAdapter>void delete(final TableClass model,AdapterClass adapter,ModelAdapter<ModelClass> modelAdapter){
  new Delete().from((Class<TableClass>)adapter.getModelClass()).where(adapter.getPrimaryConditions(model)).query();
  adapter.updateAutoIncrement(model,0);
  notifyModelChanged(model,adapter,modelAdapter,Action.DELETE);
}

Fixed version (ground truth):
/** 
 * Deletes   {@link Model} from the database using the specfied {@link FlowManager}
 * @param model The model to delete
 */
@SuppressWarnings("String_Node_Str") public static <ModelClass extends Model,TableClass extends Model,AdapterClass extends RetrievalAdapter & InternalAdapter>void delete(final TableClass model,AdapterClass adapter,ModelAdapter<ModelClass> modelAdapter){
  new Delete().from((Class<TableClass>)adapter.getModelClass()).where(adapter.getPrimaryConditionClause(model)).query();
  adapter.updateAutoIncrement(model,0);
  notifyModelChanged(model,adapter,modelAdapter,Action.DELETE);
}
Program: 26974
Project: 26974
Buggy source:
public CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  return DefinitionUtils.getSQLiteStatementMethod(index,elementName,elementName,elementTypeName,isModelContainerAdapter,columnAccess).build();
}

Fixed version (ground truth):
public CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  return DefinitionUtils.getSQLiteStatementMethod(index,containerKeyName,elementName,elementTypeName,isModelContainerAdapter,columnAccess,ModelUtils.getVariable(isModelContainerAdapter)).build();
}
Program: 26975
Project: 26975
Buggy source:
public CodeBlock getLoadFromCursorMethod(boolean isModelContainerAdapter){
  return DefinitionUtils.getLoadFromCursorMethod(elementName,elementName,elementTypeName,columnName,isModelContainerAdapter,columnAccess).build();
}

Fixed version (ground truth):
public CodeBlock getLoadFromCursorMethod(boolean isModelContainerAdapter){
  return DefinitionUtils.getLoadFromCursorMethod(containerKeyName,elementName,elementTypeName,columnName,isModelContainerAdapter,columnAccess).build();
}
Program: 26976
Project: 26976
Buggy source:
public CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  return DefinitionUtils.getContentValuesStatement(elementName,elementName,columnName,elementTypeName,isModelContainerAdapter,columnAccess).build();
}

Fixed version (ground truth):
public CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  return DefinitionUtils.getContentValuesStatement(containerKeyName,elementName,columnName,elementTypeName,isModelContainerAdapter,columnAccess,ModelUtils.getVariable(isModelContainerAdapter)).build();
}
Program: 26977
Project: 26977
Buggy source:
public String getColumnAccessString(boolean isModelContainerAdapter){
  return columnAccess.getColumnAccessString(elementTypeName,elementName,elementName,ModelUtils.getVariable(isModelContainerAdapter),isModelContainerAdapter);
}

Fixed version (ground truth):
public String getColumnAccessString(boolean isModelContainerAdapter){
  return columnAccess.getColumnAccessString(elementTypeName,containerKeyName,elementName,ModelUtils.getVariable(isModelContainerAdapter),isModelContainerAdapter);
}
Program: 26979
Project: 26979
Buggy source:
public static CodeBlock.Builder getSQLiteStatementMethod(AtomicInteger index,String elementName,String fullElementName,TypeName elementTypeName,boolean isModelContainerAdapter,BaseColumnAccess columnAccess){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,fullElementName,ModelUtils.getVariable(isModelContainerAdapter),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",BindToStatementMethod.PARAM_STATEMENT,columnAccess.getSqliteTypeForTypeName(elementTypeName,isModelContainerAdapter).getSQLiteStatementMethod(),index.intValue(),finalAccessStatement);
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str",BindToStatementMethod.PARAM_STATEMENT,index.intValue()).endControlFlow();
  }
  return codeBuilder;
}

Fixed version (ground truth):
public static CodeBlock.Builder getSQLiteStatementMethod(AtomicInteger index,String elementName,String fullElementName,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",BindToStatementMethod.PARAM_STATEMENT,columnAccess.getSqliteTypeForTypeName(elementTypeName,isModelContainerAdapter).getSQLiteStatementMethod(),index.intValue(),finalAccessStatement);
  if (!elementTypeName.isPrimitive()) {
    codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str",BindToStatementMethod.PARAM_STATEMENT,index.intValue()).endControlFlow();
  }
  return codeBuilder;
}
Program: 26980
Project: 26980
Buggy source:
public static CodeBlock.Builder getContentValuesStatement(String elementName,String fullElementName,String columnName,TypeName elementTypeName,boolean isModelContainerAdapter,BaseColumnAccess columnAccess){
  String statement=columnAccess.getColumnAccessString(elementTypeName,elementName,fullElementName,ModelUtils.getVariable(isModelContainerAdapter),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="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: 26981
Project: 26981
Buggy source:
private String getFinalAccessStatement(CodeBlock.Builder codeBuilder,boolean isModelContainerAdapter,String statement){
  String finalAccessStatement=statement;
  if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
    finalAccessStatement="String_Node_Str" + elementName;
    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 || 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;
}
Program: 26982
Project: 26982
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()));
  }
 else {
    referencedTableClassName=elementClassName;
  }
  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);
  }
}

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()));
  }
 else {
    referencedTableClassName=elementClassName;
  }
  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,this);
    foreignKeyReferenceDefinitionList.add(referenceDefinition);
  }
}
Program: 26983
Project: 26983
Buggy source:
CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  String shortAccess=tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter);
  String columnShortAccess=columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter);
  String combined=shortAccess + (isModelContainerAdapter ? "String_Node_Str" : "String_Node_Str") + columnShortAccess;
  return DefinitionUtils.getSQLiteStatementMethod(index,columnShortAccess,combined,columnClassName,isModelContainerAdapter,simpleColumnAccess).build();
}

Fixed version (ground truth):
CodeBlock getSQLiteStatementMethod(AtomicInteger index,boolean isModelContainerAdapter){
  String shortAccess=tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter);
  String columnShortAccess=columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter);
  String combined=shortAccess + (isModelContainerAdapter ? "String_Node_Str" : "String_Node_Str") + columnShortAccess;
  return DefinitionUtils.getSQLiteStatementMethod(index,columnShortAccess,combined,columnClassName,isModelContainerAdapter,simpleColumnAccess,getForeignKeyColumnVariable(isModelContainerAdapter)).build();
}
Program: 26984
Project: 26984
Buggy source:
CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  String shortAccess=tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter);
  String columnShortAccess=columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter);
  String combined=shortAccess + (isModelContainerAdapter ? "String_Node_Str" : "String_Node_Str") + columnShortAccess;
  return DefinitionUtils.getContentValuesStatement(columnShortAccess,combined,columnName,columnClassName,isModelContainerAdapter,simpleColumnAccess).build();
}

Fixed version (ground truth):
CodeBlock getContentValuesStatement(boolean isModelContainerAdapter){
  String shortAccess=tableColumnAccess.getShortAccessString(foreignKeyFieldName,isModelContainerAdapter);
  String columnShortAccess=columnAccess.getShortAccessString(foreignColumnName,isModelContainerAdapter);
  String combined=shortAccess + (isModelContainerAdapter ? "String_Node_Str" : "String_Node_Str") + columnShortAccess;
  return DefinitionUtils.getContentValuesStatement(columnShortAccess,combined,columnName,columnClassName,isModelContainerAdapter,simpleColumnAccess,getForeignKeyColumnVariable(isModelContainerAdapter)).build();
}