nus-yam/ex-repair huggingface dataset:
Program: 165120
Project: 165120
Buggy source:
public static float parseFloat(char[] chars,int offset,int length){
  return Float.parseFloat(StringCellValueReader.readString(chars,offset,length));
}

Fixed version (ground truth):
public static float parseFloat(char[] chars,int offset,int length){
  if (length == 0)   return Float.NaN;
  return Float.parseFloat(StringCellValueReader.readString(chars,offset,length));
}
Program: 165121
Project: 165121
Buggy source:
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  this.value=reader.readBoolean(chars,offset,length,parsingContext);
}

Fixed version (ground truth):
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  isNull=length == 0;
  this.value=reader.readBoolean(chars,offset,length,parsingContext);
}
Program: 165122
Project: 165122
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public boolean getBoolean(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((BooleanDelayedCellSetter<T>)target[index]).getBoolean();
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public boolean getBoolean(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((BooleanDelayedCellSetter<T>)target[index]).consumeBoolean();
}
Program: 165123
Project: 165123
Buggy source:
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  this.value=reader.readByte(chars,offset,length,parsingContext);
}

Fixed version (ground truth):
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  isNull=length == 0;
  this.value=reader.readByte(chars,offset,length,parsingContext);
}
Program: 165124
Project: 165124
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public byte getByte(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((ByteDelayedCellSetter<T>)target[index]).getByte();
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public byte getByte(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((ByteDelayedCellSetter<T>)target[index]).consumeByte();
}
Program: 165125
Project: 165125
Buggy source:
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  this.value=reader.readChar(chars,offset,length,parsingContext);
}

Fixed version (ground truth):
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  isNull=length == 0;
  this.value=reader.readChar(chars,offset,length,parsingContext);
}
Program: 165126
Project: 165126
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public char getCharacter(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((CharDelayedCellSetter<T>)target[index]).getCharacter();
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public char getCharacter(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((CharDelayedCellSetter<T>)target[index]).consumeCharacter();
}
Program: 165127
Project: 165127
Buggy source:
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  this.value=reader.readDouble(chars,offset,length,parsingContext);
}

Fixed version (ground truth):
@Override public void set(char[] chars,int offset,int length,ParsingContext parsingContext) throws Exception {
  isNull=length == 0;
  this.value=reader.readDouble(chars,offset,length,parsingContext);
}
Program: 165128
Project: 165128
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public double getDouble(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((DoubleDelayedCellSetter<T>)target[index]).getDouble();
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public double getDouble(DelayedCellSetter<T,?>[] target) throws Exception {
  return ((DoubleDelayedCellSetter<T>)target[index]).consumeDouble();
}
Program: 165129
Project: 165129
Buggy source:
public void flush(int cellIndex){
  if (cellIndex > 0) {
    T instance=currentInstance;
    if (instance == null) {
      instance=createInstance();
      applyDelayedSetters(instance);
      callHandler(instance);
    }
 else {
      applyDelayedSetters(instance);
      callHandler(instance);
      currentInstance=null;
    }
    this.cellIndex=-1;
  }
}

Fixed version (ground truth):
public void flush(int cellIndex){
  if (cellIndex >= 0) {
    T instance=currentInstance;
    if (instance == null) {
      instance=createInstance();
      applyDelayedSetters(instance);
      callHandler(instance);
    }
 else {
      applyDelayedSetters(instance);
      callHandler(instance);
      currentInstance=null;
    }
    this.cellIndex=-1;
  }
}
Program: 165131
Project: 165131
Buggy source:
protected <P>void addMapping(K columnKey,PropertyMeta<T,P> prop){
  propertyMappingsBuilder.addProperty(columnKey,identity,prop);
}

Fixed version (ground truth):
protected <P>void addMapping(K columnKey,FieldMapperColumnDefinition<K,S> columnDefinition,PropertyMeta<T,P> prop){
  propertyMappingsBuilder.addProperty(columnKey,columnDefinition,prop);
}
Program: 165132
Project: 165132
Buggy source:
@SuppressWarnings("String_Node_Str") private <P>void addPropertyBuilder(PropertyMapping<T,?,K,FieldMapperColumnDefinition<K,S>> t,SubPropertyMeta<T,?> subProp,AbstractFieldMapperMapperBuilder<S,?,K> builder){
  ((AbstractFieldMapperMapperBuilder<S,P,K>)builder).addMapping(t.getColumnKey(),((SubPropertyMeta<T,P>)subProp).getSubProperty());
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private <P>void addPropertyBuilder(PropertyMapping<T,?,K,FieldMapperColumnDefinition<K,S>> t,SubPropertyMeta<T,?> subProp,AbstractFieldMapperMapperBuilder<S,?,K> builder){
  ((AbstractFieldMapperMapperBuilder<S,P,K>)builder).addMapping(t.getColumnKey(),t.getColumnDefinition(),((SubPropertyMeta<T,P>)subProp).getSubProperty());
}
Program: 165133
Project: 165133
Buggy source:
private <P>void addSubProperty(PropertyMapping<T,?,K,FieldMapperColumnDefinition<K,S>> pm,SubPropertyMeta<T,?> subPropertyMeta,K key){
  PropertyMeta<T,?> propertyOwner=subPropertyMeta.getOwnerProperty();
  if (!propertyOwner.isConstructorProperty()) {
    AbstractFieldMapperMapperBuilder<S,P,K> builder=(AbstractFieldMapperMapperBuilder<S,P,K>)builders.get(propertyOwner.getName());
    if (builder == null) {
      builder=(AbstractFieldMapperMapperBuilder<S,P,K>)newSubBuilder(propertyOwner.getType(),propertyOwner.getClassMeta());
      builders.put(propertyOwner.getName(),builder);
      buildersByOwner.put(pm,builder);
    }
    builder.addMapping(key,((SubPropertyMeta<T,P>)subPropertyMeta).getSubProperty());
  }
}

Fixed version (ground truth):
private <P>void addSubProperty(PropertyMapping<T,?,K,FieldMapperColumnDefinition<K,S>> pm,SubPropertyMeta<T,?> subPropertyMeta,K key){
  PropertyMeta<T,?> propertyOwner=subPropertyMeta.getOwnerProperty();
  if (!propertyOwner.isConstructorProperty()) {
    AbstractFieldMapperMapperBuilder<S,P,K> builder=(AbstractFieldMapperMapperBuilder<S,P,K>)builders.get(propertyOwner.getName());
    if (builder == null) {
      builder=(AbstractFieldMapperMapperBuilder<S,P,K>)newSubBuilder(propertyOwner.getType(),propertyOwner.getClassMeta());
      builders.put(propertyOwner.getName(),builder);
      buildersByOwner.put(pm,builder);
    }
    builder.addMapping(key,pm.getColumnDefinition(),((SubPropertyMeta<T,P>)subPropertyMeta).getSubProperty());
  }
}
Program: 165135
Project: 165135
Buggy source:
public <P>void addProperty(final K key,final D columnDefinition,final PropertyMeta<T,P> prop){
  if (columnDefinition.hasCustomSource()) {
    if (!checkTypeCompatibility(key,columnDefinition.getCustomSourceReturnType(),prop.getType())) {
      properties.add(null);
      return;
    }
  }
  properties.add(new PropertyMapping<T,P,K,D>(prop,key,columnDefinition));
}

Fixed version (ground truth):
public <P>void addProperty(final K key,final D columnDefinition,final PropertyMeta<T,P> prop){
  if (columnDefinition.hasCustomSource()) {
    Type type;
    if (prop.isSubProperty()) {
      type=((SubPropertyMeta<T,P>)prop).getLeafType();
    }
 else {
      type=prop.getType();
    }
    if (!checkTypeCompatibility(key,columnDefinition.getCustomSourceReturnType(),type)) {
      properties.add(null);
      return;
    }
  }
  properties.add(new PropertyMapping<T,P,K,D>(prop,key,columnDefinition));
}
Program: 165136
Project: 165136
Buggy source:
public MapToDSL(DSL dsl,ClassMeta<T> classMeta,Type mapToClass,String[] headers){
  this.dsl=dsl;
  this.classMeta=classMeta;
  this.mapper=newStaticMapper(classMeta,headers);
  this.mapToClass=mapToClass;
}

Fixed version (ground truth):
public MapToDSL(DSL dsl,ClassMeta<T> classMeta,Type mapToClass,String[] headers){
  this.dsl=dsl;
  this.classMeta=classMeta;
  this.mapToClass=mapToClass;
  this.mapper=newStaticMapper(classMeta,headers);
}
Program: 165137
Project: 165137
Buggy source:
@Override public PropertyMeta<T,?> findProperty(PropertyNameMatcher propertyNameMatcher){
  IndexedColumn indexedColumn=propertyNameMatcher.matchesIndex();
  if (indexedColumn == null) {
    indexedColumn=extrapolateIndex(propertyNameMatcher);
  }
  if (indexedColumn == null) {
    return null;
  }
  IndexedElement<T,E> indexedElement=getIndexedElement(indexedColumn);
  if (!indexedColumn.hasSubProperty()) {
    return indexedElement.getPropertyMeta();
  }
  PropertyFinder<?> propertyFinder=indexedElement.getPropertyFinder();
  PropertyMeta<?,?> subProp=propertyFinder.findProperty(indexedColumn.getSubPropertyNameMatcher());
  if (subProp == null) {
    return null;
  }
  indexedElement.addProperty(subProp);
  return new SubPropertyMeta(arrayClassMeta.getReflectionService(),indexedElement.getPropertyMeta(),subProp);
}

Fixed version (ground truth):
@Override public PropertyMeta<T,?> findProperty(PropertyNameMatcher propertyNameMatcher){
  IndexedColumn indexedColumn=propertyNameMatcher.matchesIndex();
  if (indexedColumn == null) {
    indexedColumn=extrapolateIndex(propertyNameMatcher);
  }
  if (indexedColumn == null) {
    return null;
  }
  IndexedElement<T,E> indexedElement=getIndexedElement(indexedColumn);
  if (!indexedColumn.hasSubProperty()) {
    return indexedElement.getPropertyMeta();
  }
  PropertyFinder<?> propertyFinder=indexedElement.getPropertyFinder();
  if (propertyFinder == null) {
    return null;
  }
  PropertyMeta<?,?> subProp=propertyFinder.findProperty(indexedColumn.getSubPropertyNameMatcher());
  if (subProp == null) {
    return null;
  }
  indexedElement.addProperty(subProp);
  return new SubPropertyMeta(arrayClassMeta.getReflectionService(),indexedElement.getPropertyMeta(),subProp);
}
Program: 165138
Project: 165138
Buggy source:
@Override public <E>PropertyMeta<T,E> findProperty(PropertyNameMatcher propertyNameMatcher){
  IndexedColumn indexedColumn=propertyNameMatcher.matchesIndex();
  if (indexedColumn == null) {
    indexedColumn=extrapolateIndex(propertyNameMatcher);
  }
  if (indexedColumn == null || calculateTupleIndex(indexedColumn) >= elements.size()) {
    return null;
  }
  IndexedElement indexedElement=elements.get(calculateTupleIndex(indexedColumn));
  if (!indexedColumn.hasSubProperty()) {
    return indexedElement.getPropertyMeta();
  }
  PropertyFinder<?> propertyFinder=indexedElement.getPropertyFinder();
  PropertyMeta<?,?> subProp=propertyFinder.findProperty(indexedColumn.getSubPropertyNameMatcher());
  if (subProp == null) {
    return null;
  }
  indexedElement.addProperty(subProp);
  return new SubPropertyMeta(tupleClassMeta.getReflectionService(),indexedElement.getPropertyMeta(),subProp);
}

Fixed version (ground truth):
@Override public <E>PropertyMeta<T,E> findProperty(PropertyNameMatcher propertyNameMatcher){
  IndexedColumn indexedColumn=propertyNameMatcher.matchesIndex();
  if (indexedColumn == null) {
    indexedColumn=extrapolateIndex(propertyNameMatcher);
  }
  if (indexedColumn == null || calculateTupleIndex(indexedColumn) >= elements.size()) {
    return null;
  }
  IndexedElement indexedElement=elements.get(calculateTupleIndex(indexedColumn));
  if (!indexedColumn.hasSubProperty()) {
    return indexedElement.getPropertyMeta();
  }
  PropertyFinder<?> propertyFinder=indexedElement.getPropertyFinder();
  if (propertyFinder == null) {
    return null;
  }
  PropertyMeta<?,?> subProp=propertyFinder.findProperty(indexedColumn.getSubPropertyNameMatcher());
  if (subProp == null) {
    return null;
  }
  indexedElement.addProperty(subProp);
  return new SubPropertyMeta(tupleClassMeta.getReflectionService(),indexedElement.getPropertyMeta(),subProp);
}
Program: 165139
Project: 165139
Buggy source:
@Test public void testDSLWitStatichMapper() throws IOException {
  Iterator<Tuple2<String,String>> iterate=CsvParser.<Tuple2<String,String>>mapTo(Tuples.typeDef(String.class,String.class)).headers("String_Node_Str").iterate(new StringReader("String_Node_Str"));
  assertTrue(iterate.hasNext());
  Tuple2<String,String> tuple2=iterate.next();
  assertEquals("String_Node_Str",tuple2.first());
  assertEquals("String_Node_Str",tuple2.second());
  assertFalse(iterate.hasNext());
}

Fixed version (ground truth):
@Test public void testDSLWitStatichMapper() throws IOException {
  Iterator<Tuple2<String,String>> iterate=CsvParser.<Tuple2<String,String>>mapTo(Tuples.typeDef(String.class,String.class)).headers("String_Node_Str","String_Node_Str").iterate(new StringReader("String_Node_Str"));
  assertTrue(iterate.hasNext());
  Tuple2<String,String> tuple2=iterate.next();
  assertEquals("String_Node_Str",tuple2.first());
  assertEquals("String_Node_Str",tuple2.second());
  assertFalse(iterate.hasNext());
}
Program: 165140
Project: 165140
Buggy source:
/** 
 * parse cvs
 * @return
 * @throws IOException
 */
public void parseAll(CellConsumer cellConsumer) throws IOException {
  do {
    consumer.parseFull(buffer,cellConsumer);
  }
 while (buffer.fillBuffer(reader));
  consumer.finish(buffer,cellConsumer);
}

Fixed version (ground truth):
/** 
 * parse cvs
 * @throws IOException
 */
public void parseAll(CellConsumer cellConsumer) throws IOException {
  do {
    consumer.parseFull(buffer,cellConsumer);
  }
 while (buffer.fillBuffer(reader));
  consumer.finish(buffer,cellConsumer);
}
Program: 165141
Project: 165141
Buggy source:
/** 
 * parse cvs
 * @return
 * @throws IOException
 */
public void parseLine(CellConsumer cellConsumer) throws IOException {
  do {
    if (consumer.nextLine(buffer,cellConsumer)) {
      return;
    }
  }
 while (buffer.fillBuffer(reader));
  consumer.finish(buffer,cellConsumer);
}

Fixed version (ground truth):
/** 
 * parse cvs
 * @throws IOException
 */
public void parseLine(CellConsumer cellConsumer) throws IOException {
  do {
    if (consumer.nextLine(buffer,cellConsumer)) {
      return;
    }
  }
 while (buffer.fillBuffer(reader));
  consumer.finish(buffer,cellConsumer);
}
Program: 165142
Project: 165142
Buggy source:
/** 
 * map source object to a new instance of T
 * @param source object to map from
 * @return a new mapped instance of T
 * @throws Exception
 */
T map(S source) throws MappingException ;

Fixed version (ground truth):
/** 
 * map source object to a new instance of T
 * @param source object to map from
 * @return a new mapped instance of T
 * @throws MappingException
 */
T map(S source) throws MappingException ;
Program: 165143
Project: 165143
Buggy source:
public AbstractResultSetMapperBuilder(Class<T> target,SetterFactory setterFactory) throws NoSuchMethodException, SecurityException, IOException {
  this.target=target;
  this.primitiveFieldMapperFactory=new PrimitiveFieldMapperFactory<>(setterFactory);
  this.asmFactory=setterFactory.getAsmFactory();
  this.instantiatorFactory=new InstantiatorFactory(asmFactory);
  if (AsmHelper.isAsmPresent()) {
    this.constructors=ConstructorDefinition.extractConstructors(target);
    this.constructorInjection=new HashMap<Parameter,Getter<ResultSet,?>>();
  }
 else {
    this.constructors=null;
    this.constructorInjection=null;
  }
}

Fixed version (ground truth):
public AbstractResultSetMapperBuilder(Class<T> target,SetterFactory setterFactory,boolean asmPresent) throws NoSuchMethodException, SecurityException, IOException {
  this.target=target;
  this.primitiveFieldMapperFactory=new PrimitiveFieldMapperFactory<>(setterFactory);
  this.asmFactory=setterFactory.getAsmFactory();
  this.instantiatorFactory=new InstantiatorFactory(asmFactory);
  if (asmPresent) {
    this.constructors=ConstructorDefinition.extractConstructors(target);
    this.constructorInjection=new HashMap<Parameter,Getter<ResultSet,?>>();
  }
 else {
    this.constructors=null;
    this.constructorInjection=null;
  }
}
Program: 165144
Project: 165144
Buggy source:
public static boolean isAsmPresent(){
  try {
    Class.forName("String_Node_Str");
    return true;
  }
 catch (  Exception e) {
    return false;
  }
}

Fixed version (ground truth):
public static boolean isAsmPresent(){
  return asmPresent;
}
Program: 165145
Project: 165145
Buggy source:
public CachedResultSetMapperBuilder(final Class<T> target,final Map<String,Setter<T,Object>> setters,final SetterFactory setterFactory) throws NoSuchMethodException, SecurityException, IOException {
  super(target,setterFactory);
  this.setters=setters;
}

Fixed version (ground truth):
public CachedResultSetMapperBuilder(final Class<T> target,final Map<String,Setter<T,Object>> setters,final SetterFactory setterFactory,final boolean asmPresent) throws NoSuchMethodException, SecurityException, IOException {
  super(target,setterFactory,asmPresent);
  this.setters=setters;
}
Program: 165146
Project: 165146
Buggy source:
private JdbcMapper<T> buildMapper(final ResultSetMetaData metaData) throws SQLException, NoSuchMethodException, SecurityException, IOException {
  final MapperKey key=MapperKey.valueOf(metaData);
  JdbcMapper<T> mapper=getMapper(key);
  if (mapper == null) {
    final CachedResultSetMapperBuilder<T> builder=new CachedResultSetMapperBuilder<T>(target,setters,setterFactory);
    builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
    builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
    builder.addMapping(metaData);
    mapper=builder.mapper();
    addToMapperCache(new CacheEntry<>(key,mapper));
  }
  return mapper;
}

Fixed version (ground truth):
private JdbcMapper<T> buildMapper(final ResultSetMetaData metaData) throws SQLException, NoSuchMethodException, SecurityException, IOException {
  final MapperKey key=MapperKey.valueOf(metaData);
  JdbcMapper<T> mapper=getMapper(key);
  if (mapper == null) {
    final CachedResultSetMapperBuilder<T> builder=new CachedResultSetMapperBuilder<T>(target,setters,setterFactory,AsmHelper.isAsmPresent());
    builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
    builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
    builder.addMapping(metaData);
    mapper=builder.mapper();
    addToMapperCache(new CacheEntry<>(key,mapper));
  }
  return mapper;
}
Program: 165147
Project: 165147
Buggy source:
public ResultSetMapperBuilderImpl(final Class<T> target,final SetterFactory setterFactory) throws NoSuchMethodException, SecurityException, IOException {
  super(target,setterFactory);
  this.setterFactory=setterFactory;
}

Fixed version (ground truth):
public ResultSetMapperBuilderImpl(final Class<T> target,final SetterFactory setterFactory,final boolean asmPresent) throws NoSuchMethodException, SecurityException, IOException {
  super(target,setterFactory,asmPresent);
  this.setterFactory=setterFactory;
}
Program: 165148
Project: 165148
Buggy source:
@SuppressWarnings("String_Node_Str") public EnumIndexedResultSetGetter(final int column,final Class<E> enumType){
  this.columnIndex=column;
  this.enumType=enumType;
  try {
    this.values=(E[])enumType.getDeclaredMethod("String_Node_Str").invoke(enumType);
  }
 catch (  Exception e) {
    throw new Error("String_Node_Str" + e,e);
  }
}

Fixed version (ground truth):
public EnumIndexedResultSetGetter(final int column,final Class<E> enumType){
  this.columnIndex=column;
  this.enumType=enumType;
  this.values=EnumHelper.getValues(enumType);
}
Program: 165149
Project: 165149
Buggy source:
@SuppressWarnings("String_Node_Str") public EnumNamedResultSetGetter(final String column,final Class<E> enumType){
  this.column=column;
  this.enumType=enumType;
  try {
    this.values=(E[])enumType.getDeclaredMethod("String_Node_Str").invoke(enumType);
  }
 catch (  Exception e) {
    throw new Error("String_Node_Str" + e,e);
  }
}

Fixed version (ground truth):
public EnumNamedResultSetGetter(final String column,final Class<E> enumType){
  this.column=column;
  this.enumType=enumType;
  this.values=EnumHelper.getValues(enumType);
}
Program: 165150
Project: 165150
Buggy source:
@SuppressWarnings("String_Node_Str") public OrdinalEnumIndexedResultSetGetter(final int column,final Class<E> enumType){
  this.columnIndex=column;
  try {
    this.values=(E[])enumType.getDeclaredMethod("String_Node_Str").invoke(enumType);
  }
 catch (  Exception e) {
    throw new Error("String_Node_Str" + e,e);
  }
}

Fixed version (ground truth):
public OrdinalEnumIndexedResultSetGetter(final int column,final Class<E> enumType){
  this.columnIndex=column;
  this.values=EnumHelper.getValues(enumType);
}
Program: 165151
Project: 165151
Buggy source:
@SuppressWarnings("String_Node_Str") public OrdinalEnumNamedResultSetGetter(final String column,final Class<E> enumType){
  this.column=column;
  try {
    this.values=(E[])enumType.getDeclaredMethod("String_Node_Str").invoke(enumType);
  }
 catch (  Exception e) {
    throw new Error("String_Node_Str" + e,e);
  }
}

Fixed version (ground truth):
public OrdinalEnumNamedResultSetGetter(final String column,final Class<E> enumType){
  this.column=column;
  this.values=EnumHelper.getValues(enumType);
}
Program: 165152
Project: 165152
Buggy source:
private void handleByte(final BytesCellHandler handler,final byte c,final int i){
  if (c == QUOTES) {
    if (currentStart == i) {
      currentState=State.IN_QUOTE;
    }
 else     if (currentState == State.IN_QUOTE) {
      currentState=State.QUOTE;
    }
 else {
      if (currentState == State.QUOTE) {
        currentState=State.IN_QUOTE;
      }
    }
  }
 else   if (c == COMMA) {
    if (currentState != State.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=State.NONE;
    }
  }
 else   if (c == CARRIAGE_RETURN) {
    if (currentState != State.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=State.NONE;
      handler.newRow();
    }
  }
}

Fixed version (ground truth):
private void handleByte(final BytesCellHandler handler,final byte c,final int i){
  if (c == QUOTES) {
    if (currentStart == i) {
      currentState=CsvParserState.IN_QUOTE;
    }
 else     if (currentState == CsvParserState.IN_QUOTE) {
      currentState=CsvParserState.QUOTE;
    }
 else {
      if (currentState == CsvParserState.QUOTE) {
        currentState=CsvParserState.IN_QUOTE;
      }
    }
  }
 else   if (c == COMMA) {
    if (currentState != CsvParserState.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=CsvParserState.NONE;
    }
  }
 else   if (c == CARRIAGE_RETURN) {
    if (currentState != CsvParserState.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=CsvParserState.NONE;
      handler.newRow();
    }
  }
}
Program: 165153
Project: 165153
Buggy source:
private void handleByte(final CharsCellHandler handler,final char c,final int i){
  if (c == '"') {
    if (currentStart == i) {
      currentState=State.IN_QUOTE;
    }
 else     if (currentState == State.IN_QUOTE) {
      currentState=State.QUOTE;
    }
 else {
      if (currentState == State.QUOTE) {
        currentState=State.IN_QUOTE;
      }
    }
  }
 else   if (c == ',') {
    if (currentState != State.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=State.NONE;
    }
  }
 else   if (c == '\n') {
    if (currentState != State.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=State.NONE;
      handler.newRow();
    }
  }
}

Fixed version (ground truth):
private void handleByte(final CharsCellHandler handler,final char c,final int i){
  if (c == '"') {
    if (currentStart == i) {
      currentState=CsvParserState.IN_QUOTE;
    }
 else     if (currentState == CsvParserState.IN_QUOTE) {
      currentState=CsvParserState.QUOTE;
    }
 else {
      if (currentState == CsvParserState.QUOTE) {
        currentState=CsvParserState.IN_QUOTE;
      }
    }
  }
 else   if (c == ',') {
    if (currentState != CsvParserState.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=CsvParserState.NONE;
    }
  }
 else   if (c == '\n') {
    if (currentState != CsvParserState.IN_QUOTE) {
      handler.newCell(buffer,currentStart,i - currentStart);
      currentStart=i + 1;
      currentState=CsvParserState.NONE;
      handler.newRow();
    }
  }
}
Program: 165154
Project: 165154
Buggy source:
@Override public final JdbcMapper<T> mapper() throws NoSuchMethodException, SecurityException {
  if (asmFactory != null) {
    try {
      return asmFactory.createJdbcMapper(fields(),getInstantiator(),target);
    }
 catch (    Exception e) {
      return new JdbcMapperImpl<T>(fields(),getInstantiator());
    }
  }
 else {
    return new JdbcMapperImpl<T>(fields(),getInstantiator());
  }
}

Fixed version (ground truth):
@Override public final JdbcMapper<T> mapper() throws MapperBuildingException {
  if (asmFactory != null) {
    try {
      return asmFactory.createJdbcMapper(fields(),getInstantiator(),target,jdbcMapperErrorHandler);
    }
 catch (    Exception e) {
      return new JdbcMapperImpl<T>(fields(),getInstantiator(),jdbcMapperErrorHandler);
    }
  }
 else {
    return new JdbcMapperImpl<T>(fields(),getInstantiator(),jdbcMapperErrorHandler);
  }
}
Program: 165155
Project: 165155
Buggy source:
private Instantiator<ResultSet,T> getInstantiator() throws NoSuchMethodException, SecurityException {
  if (constructors == null) {
    return instantiatorFactory.getInstantiator(ResultSet.class,target);
  }
 else {
    return instantiatorFactory.getInstantiator(ResultSet.class,constructors,constructorInjection);
  }
}

Fixed version (ground truth):
private Instantiator<ResultSet,T> getInstantiator() throws MapperBuildingException {
  if (constructors == null) {
    try {
      return instantiatorFactory.getInstantiator(ResultSet.class,target);
    }
 catch (    Exception e) {
      throw new MapperBuildingException(e.getMessage(),e);
    }
  }
 else {
    try {
      return instantiatorFactory.getInstantiator(ResultSet.class,constructors,constructorInjection);
    }
 catch (    Exception e) {
      throw new MapperBuildingException(e.getMessage(),e);
    }
  }
}
Program: 165156
Project: 165156
Buggy source:
public AbstractResultSetMapperBuilder(Class<T> target,SetterFactory setterFactory,boolean asmPresent) throws NoSuchMethodException, SecurityException, IOException {
  this.target=target;
  this.primitiveFieldMapperFactory=new PrimitiveFieldMapperFactory<>(setterFactory);
  this.asmFactory=setterFactory.getAsmFactory();
  this.instantiatorFactory=new InstantiatorFactory(asmFactory);
  if (asmPresent) {
    this.constructors=ConstructorDefinition.extractConstructors(target);
    this.constructorInjection=new HashMap<Parameter,Getter<ResultSet,?>>();
  }
 else {
    this.constructors=null;
    this.constructorInjection=null;
  }
}

Fixed version (ground truth):
public AbstractResultSetMapperBuilder(Class<T> target,SetterFactory setterFactory,boolean asmPresent) throws MapperBuildingException {
  this.target=target;
  this.primitiveFieldMapperFactory=new PrimitiveFieldMapperFactory<>(setterFactory);
  this.asmFactory=setterFactory.getAsmFactory();
  this.instantiatorFactory=new InstantiatorFactory(asmFactory);
  if (asmPresent) {
    try {
      this.constructors=ConstructorDefinition.extractConstructors(target);
    }
 catch (    Exception e) {
      throw new MapperBuildingException(e.getMessage(),e);
    }
    this.constructorInjection=new HashMap<Parameter,Getter<ResultSet,?>>();
  }
 else {
    this.constructors=null;
    this.constructorInjection=null;
  }
}
Program: 165157
Project: 165157
Buggy source:
public CachedResultSetMapperBuilder(final Class<T> target,final Map<String,Setter<T,Object>> setters,final SetterFactory setterFactory,final boolean asmPresent) throws NoSuchMethodException, SecurityException, IOException {
  super(target,setterFactory,asmPresent);
  this.setters=setters;
}

Fixed version (ground truth):
public CachedResultSetMapperBuilder(final Class<T> target,final Map<String,Setter<T,Object>> setters,final SetterFactory setterFactory,final boolean asmPresent) throws MapperBuildingException {
  super(target,setterFactory,asmPresent);
  this.setters=setters;
}
Program: 165158
Project: 165158
Buggy source:
private JdbcMapper<T> buildMapper(final ResultSetMetaData metaData) throws SQLException, NoSuchMethodException, SecurityException, IOException {
  final MapperKey key=MapperKey.valueOf(metaData);
  JdbcMapper<T> mapper=getMapper(key);
  if (mapper == null) {
    final CachedResultSetMapperBuilder<T> builder=new CachedResultSetMapperBuilder<T>(target,setters,setterFactory,AsmHelper.isAsmPresent());
    builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
    builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
    builder.addMapping(metaData);
    mapper=builder.mapper();
    addToMapperCache(new CacheEntry<>(key,mapper));
  }
  return mapper;
}

Fixed version (ground truth):
private JdbcMapper<T> buildMapper(final ResultSetMetaData metaData) throws MapperBuildingException, SQLException {
  final MapperKey key=MapperKey.valueOf(metaData);
  JdbcMapper<T> mapper=getMapper(key);
  if (mapper == null) {
    final CachedResultSetMapperBuilder<T> builder=new CachedResultSetMapperBuilder<T>(target,setters,setterFactory,AsmHelper.isAsmPresent());
    builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
    builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
    builder.addMapping(metaData);
    mapper=builder.mapper();
    addToMapperCache(new CacheEntry<>(key,mapper));
  }
  return mapper;
}
Program: 165159
Project: 165159
Buggy source:
@Override public final <H extends Handler<T>>H forEach(final ResultSet rs,final H handle) throws Exception {
  final JdbcMapper<T> mapper=buildMapper(rs.getMetaData());
  return mapper.forEach(rs,handle);
}

Fixed version (ground truth):
@Override public final <H extends Handler<T>>H forEach(final ResultSet rs,final H handle) throws SQLException, MappingException {
  final JdbcMapper<T> mapper=buildMapper(rs.getMetaData());
  return mapper.forEach(rs,handle);
}
Program: 165160
Project: 165160
Buggy source:
@Override public final T map(final ResultSet source) throws Exception {
  final JdbcMapper<T> mapper=buildMapper(source.getMetaData());
  return mapper.map(source);
}

Fixed version (ground truth):
@Override public final T map(final ResultSet source) throws MappingException {
  try {
    final JdbcMapper<T> mapper=buildMapper(source.getMetaData());
    return mapper.map(source);
  }
 catch (  SQLException e) {
    throw new SQLMappingException(e.getMessage(),e);
  }
}
Program: 165161
Project: 165161
Buggy source:
/** 
 * Loop over the resultSet, map each row to a new instance of T and call back the handler
 * @param rs the resultSet
 * @param handle the handler that will get the callback
 * @return the handler passed in
 * @throws Exception if anything bad occurs
 */
<H extends Handler<T>>H forEach(ResultSet rs,H handle) throws Exception ;

Fixed version (ground truth):
/** 
 * Loop over the resultSet, map each row to a new instance of T and call back the handler
 * @param rs the resultSet
 * @param handle the handler that will get the callback
 * @return the handler passed in
 * @throws SQLException if sql error occurs
 * @throws MappingException if an error occurs during the mapping
 */
<H extends Handler<T>>H forEach(ResultSet rs,H handle) throws SQLException, MappingException ;
Program: 165162
Project: 165162
Buggy source:
@Override public <H extends Handler<T>>H forEach(final ResultSet rs,final H handler) throws Exception {
  while (rs.next()) {
    T t=map(rs);
    handler.handle(t);
  }
  return handler;
}

Fixed version (ground truth):
@Override public <H extends Handler<T>>H forEach(final ResultSet rs,final H handler) throws SQLException, MappingException {
  while (rs.next()) {
    T t=map(rs);
    try {
      handler.handle(t);
    }
 catch (    Throwable error) {
      errorHandler.handlerError(error,t);
    }
  }
  return handler;
}
Program: 165163
Project: 165163
Buggy source:
@Override public T map(final ResultSet source) throws Exception {
  final T target=instantiator.newInstance(source);
  for (int i=0; i < fieldMappers.length; i++) {
    fieldMappers[i].map(source,target);
  }
  return target;
}

Fixed version (ground truth):
@Override public T map(final ResultSet source) throws MappingException {
  final T target;
  try {
    target=instantiator.newInstance(source);
  }
 catch (  Exception e) {
    throw new InstantiationMappingException(e.getMessage(),e);
  }
  for (int i=0; i < fieldMappers.length; i++) {
    fieldMappers[i].map(source,target);
  }
  return target;
}
Program: 165164
Project: 165164
Buggy source:
public JdbcMapperImpl(final FieldMapper<ResultSet,T>[] mappers,final Instantiator<ResultSet,T> instantiator){
  this.fieldMappers=mappers;
  this.instantiator=instantiator;
}

Fixed version (ground truth):
public JdbcMapperImpl(final FieldMapper<ResultSet,T>[] mappers,final Instantiator<ResultSet,T> instantiator,final JdbcMapperErrorHandler errorHandler){
  this.fieldMappers=mappers;
  this.instantiator=instantiator;
  this.errorHandler=errorHandler;
}
Program: 165165
Project: 165165
Buggy source:
JdbcMapper<T> mapper() throws NoSuchMethodException, SecurityException ;

Fixed version (ground truth):
JdbcMapper<T> mapper() throws MapperBuildingException ;
Program: 165166
Project: 165166
Buggy source:
@Override public final void map(final S source,final T target) throws Exception {
  try {
    mapUnsafe(source,target);
  }
 catch (  Exception ge) {
    errorHandler.errorMappingField(name,source,target,ge);
  }
}

Fixed version (ground truth):
@Override public final void map(final S source,final T target) throws MappingException {
  try {
    mapUnsafe(source,target);
  }
 catch (  Exception ge) {
    errorHandler.errorMappingField(name,source,target,ge);
  }
}
Program: 165167
Project: 165167
Buggy source:
/** 
 * map source object to target object.
 * @param source object to map from
 * @param target object to map to
 * @throws Exception
 */
void map(S source,T target) throws Exception ;

Fixed version (ground truth):
/** 
 * map source object to target object.
 * @param source object to map from
 * @param target object to map to
 * @throws Exception
 */
void map(S source,T target) throws MappingException ;
Program: 165168
Project: 165168
Buggy source:
void errorMappingField(String name,Object source,Object target,Exception error) throws Exception ;

Fixed version (ground truth):
void errorMappingField(String name,Object source,Object target,Exception error) throws MappingException ;
Program: 165169
Project: 165169
Buggy source:
@Override public void errorMappingField(final String name,final Object source,final Object target,final Exception error) throws Exception {
  logger.log(Level.WARNING,"String_Node_Str" + source,error);
}

Fixed version (ground truth):
@Override public void errorMappingField(final String name,final Object source,final Object target,final Exception error) throws MappingException {
  logger.log(Level.WARNING,"String_Node_Str" + source,error);
}
Program: 165170
Project: 165170
Buggy source:
/** 
 * map source object to a new instance of T
 * @param source object to map from
 * @return a new mapped instance of T
 * @throws Exception
 */
T map(S source) throws Exception ;

Fixed version (ground truth):
/** 
 * map source object to a new instance of T
 * @param source object to map from
 * @return a new mapped instance of T
 * @throws Exception
 */
T map(S source) throws MappingException ;
Program: 165171
Project: 165171
Buggy source:
public BenchmarkRunner(int limit,int iteration,QueryExecutor exec){
  this.limit=limit;
  this.iteration=iteration;
  if (limit > 0) {
    this.innerIteration=1000000 / (limit);
    this.warmup=1000000 / limit;
  }
 else {
    this.innerIteration=1;
    this.warmup=1;
  }
  this.exec=exec;
}

Fixed version (ground truth):
public BenchmarkRunner(int limit,int iteration,int nbobjects,QueryExecutor exec){
  this.limit=limit;
  this.iteration=iteration;
  if (limit > 0) {
    this.innerIteration=nbobjects / (limit);
    this.warmup=nbobjects / limit;
  }
 else {
    this.innerIteration=1;
    this.warmup=1;
  }
  this.exec=exec;
}
Program: 165172
Project: 165172
Buggy source:
@Override public void forEach(final ForEachListener ql,int limit) throws Exception {
  SqlSession session=sqlSessionFactory.openSession();
  try {
    if (limit != -1) {
      session.select("String_Node_Str",new RowBounds(0,limit),new ResultHandler(){
        @Override public void handleResult(        ResultContext arg0){
          ql.object((DbObject)arg0.getResultObject());
        }
      }
);
    }
 else {
      session.select("String_Node_Str",new ResultHandler(){
        @Override public void handleResult(        ResultContext arg0){
          ql.object((DbObject)arg0.getResultObject());
        }
      }
);
    }
  }
  finally {
    session.close();
  }
}

Fixed version (ground truth):
@Override public void forEach(final ForEachListener ql,int limit) throws Exception {
  SqlSession session=sqlSessionFactory.openSession();
  try {
    if (limit != -1) {
      session.select("String_Node_Str",limit,new ResultHandler(){
        @Override public void handleResult(        ResultContext arg0){
          ql.object((DbObject)arg0.getResultObject());
        }
      }
);
    }
 else {
      session.select("String_Node_Str",new ResultHandler(){
        @Override public void handleResult(        ResultContext arg0){
          ql.object((DbObject)arg0.getResultObject());
        }
      }
);
    }
  }
  finally {
    session.close();
  }
}
Program: 165173
Project: 165173
Buggy source:
private void validateConfig(){
  if (hasText(dbName)) {
    throw new MongobeeConfigurationException("String_Node_Str");
  }
  if (hasText(changelogsScanPackage)) {
    throw new MongobeeConfigurationException("String_Node_Str");
  }
}

Fixed version (ground truth):
private void validateConfig(){
  if (!hasText(dbName)) {
    throw new MongobeeConfigurationException("String_Node_Str");
  }
  if (!hasText(changeLogsScanPackage)) {
    throw new MongobeeConfigurationException("String_Node_Str");
  }
}
Program: 165175
Project: 165175
Buggy source:
public ChangeEntry(String changeId,String author,Date timestamp,String changelogClass,String changesetMethodName){
  this.changeId=changeId;
  this.author=author;
  this.timestamp=new Date(timestamp.getTime());
  this.changelogClass=changelogClass;
  this.changesetMethodName=changesetMethodName;
}

Fixed version (ground truth):
public ChangeEntry(String changeId,String author,Date timestamp,String changeLogClass,String changeSetMethodName){
  this.changeId=changeId;
  this.author=author;
  this.timestamp=new Date(timestamp.getTime());
  this.changeLogClass=changeLogClass;
  this.changeSetMethodName=changeSetMethodName;
}
Program: 165176
Project: 165176
Buggy source:
public DBObject buildFullDBObject(){
  BasicDBObject entry=new BasicDBObject();
  entry.append("String_Node_Str",this.changeId).append("String_Node_Str",this.author).append("String_Node_Str",this.timestamp).append("String_Node_Str",this.changelogClass).append("String_Node_Str",this.changesetMethodName);
  return entry;
}

Fixed version (ground truth):
public DBObject buildFullDBObject(){
  BasicDBObject entry=new BasicDBObject();
  entry.append("String_Node_Str",this.changeId).append("String_Node_Str",this.author).append("String_Node_Str",this.timestamp).append("String_Node_Str",this.changeLogClass).append("String_Node_Str",this.changeSetMethodName);
  return entry;
}
Program: 165177
Project: 165177
Buggy source:
@Override public String toString(){
  return "String_Node_Str" + this.changeId + "String_Node_Str"+ this.author+ "String_Node_Str"+ this.changelogClass+ "String_Node_Str"+ this.changesetMethodName+ "String_Node_Str";
}

Fixed version (ground truth):
@Override public String toString(){
  return "String_Node_Str" + this.changeId + "String_Node_Str"+ this.author+ "String_Node_Str"+ this.changeLogClass+ "String_Node_Str"+ this.changeSetMethodName+ "String_Node_Str";
}
Program: 165178
Project: 165178
Buggy source:
public DB connectMongoDb(MongoClientURI mongoClientURI,String dbName) throws UnknownHostException {
  MongoClient mongoClient=new MongoClient(mongoClientURI);
  String database=(hasText(dbName)) ? mongoClientURI.getDatabase() : dbName;
  if (hasText(database)) {
    throw new MongobeeConfigurationException("String_Node_Str");
  }
 else {
    db=mongoClient.getDB(database);
    return db;
  }
}

Fixed version (ground truth):
public DB connectMongoDb(MongoClientURI mongoClientURI,String dbName) throws UnknownHostException {
  MongoClient mongoClient=new MongoClient(mongoClientURI);
  String database=(!hasText(dbName)) ? mongoClientURI.getDatabase() : dbName;
  if (!hasText(database)) {
    throw new MongobeeConfigurationException("String_Node_Str");
  }
 else {
    db=mongoClient.getDB(database);
    return db;
  }
}
Program: 165179
Project: 165179
Buggy source:
public WriteResult save(ChangeEntry changeEntry){
  verifyDbConnection();
  DBCollection mongobeelog=getDb().getCollection(CHANGELOG_COLLECTION);
  return mongobeelog.save(changeEntry.buildFullDBObject());
}

Fixed version (ground truth):
public WriteResult save(ChangeEntry changeEntry){
  verifyDbConnection();
  DBCollection mongobeeLog=getDb().getCollection(CHANGELOG_COLLECTION);
  return mongobeeLog.save(changeEntry.buildFullDBObject());
}
Program: 165180
Project: 165180
Buggy source:
public boolean isNewChange(ChangeEntry changeEntry){
  verifyDbConnection();
  DBCollection mongobeeChangelog=getDb().getCollection(CHANGELOG_COLLECTION);
  DBObject entry=mongobeeChangelog.findOne(changeEntry.buildSearchQueryDBObject());
  return entry == null ? true : false;
}

Fixed version (ground truth):
public boolean isNewChange(ChangeEntry changeEntry){
  verifyDbConnection();
  DBCollection mongobeeChangeLog=getDb().getCollection(CHANGELOG_COLLECTION);
  DBObject entry=mongobeeChangeLog.findOne(changeEntry.buildSearchQueryDBObject());
  return entry == null ? true : false;
}
Program: 165181
Project: 165181
Buggy source:
public ChangeService(String changelogsBasePackage,Environment environment){
  this.changelogsBasePackage=changelogsBasePackage;
  if (environment != null && environment.getActiveProfiles() != null && environment.getActiveProfiles().length > 0) {
    this.activeProfiles=asList(environment.getActiveProfiles());
  }
 else {
    this.activeProfiles=asList(DEFAULT_PROFILE);
  }
}

Fixed version (ground truth):
public ChangeService(String changeLogsBasePackage,Environment environment){
  this.changeLogsBasePackage=changeLogsBasePackage;
  if (environment != null && environment.getActiveProfiles() != null && environment.getActiveProfiles().length > 0) {
    this.activeProfiles=asList(environment.getActiveProfiles());
  }
 else {
    this.activeProfiles=asList(DEFAULT_PROFILE);
  }
}
Program: 165182
Project: 165182
Buggy source:
public ChangeEntry createChangeEntry(Method changesetMethod){
  if (changesetMethod.isAnnotationPresent(Changeset.class)) {
    Changeset annotation=changesetMethod.getAnnotation(Changeset.class);
    return new ChangeEntry(annotation.id(),annotation.author(),new Date(),changesetMethod.getDeclaringClass().getName(),changesetMethod.getName());
  }
 else {
    return null;
  }
}

Fixed version (ground truth):
public ChangeEntry createChangeEntry(Method changesetMethod){
  if (changesetMethod.isAnnotationPresent(ChangeSet.class)) {
    ChangeSet annotation=changesetMethod.getAnnotation(ChangeSet.class);
    return new ChangeEntry(annotation.id(),annotation.author(),new Date(),changesetMethod.getDeclaringClass().getName(),changesetMethod.getName());
  }
 else {
    return null;
  }
}
Program: 165183
Project: 165183
Buggy source:
public DBObject buildSearchQueryDBObject(){
  return new BasicDBObject().append("String_Node_Str",changeId).append("String_Node_Str",author);
}

Fixed version (ground truth):
public DBObject buildSearchQueryDBObject(){
  return new BasicDBObject().append("String_Node_Str",this.changeId).append("String_Node_Str",this.author);
}
Program: 165184
Project: 165184
Buggy source:
public String getAuthor(){
  return author;
}

Fixed version (ground truth):
public String getAuthor(){
  return this.author;
}
Program: 165185
Project: 165185
Buggy source:
public Date getTimestamp(){
  return timestamp;
}

Fixed version (ground truth):
public Date getTimestamp(){
  return this.timestamp;
}
Program: 165186
Project: 165186
Buggy source:
public ChangeEntry(String changeId,String author,Date timestamp,String changelogClass,String changesetMethodName){
  this.changeId=changeId;
  this.author=author;
  this.timestamp=timestamp;
  this.changelogClass=changelogClass;
  this.changesetMethodName=changesetMethodName;
}

Fixed version (ground truth):
public ChangeEntry(String changeId,String author,Date timestamp,String changelogClass,String changesetMethodName){
  this.changeId=changeId;
  this.author=author;
  this.timestamp=new Date(timestamp.getTime());
  this.changelogClass=changelogClass;
  this.changesetMethodName=changesetMethodName;
}
Program: 165187
Project: 165187
Buggy source:
public DBObject buildFullDBObject(){
  BasicDBObject entry=new BasicDBObject();
  entry.append("String_Node_Str",changeId).append("String_Node_Str",author).append("String_Node_Str",timestamp).append("String_Node_Str",changelogClass).append("String_Node_Str",changesetMethodName);
  return entry;
}

Fixed version (ground truth):
public DBObject buildFullDBObject(){
  BasicDBObject entry=new BasicDBObject();
  entry.append("String_Node_Str",this.changeId).append("String_Node_Str",this.author).append("String_Node_Str",this.timestamp).append("String_Node_Str",this.changelogClass).append("String_Node_Str",this.changesetMethodName);
  return entry;
}
Program: 165188
Project: 165188
Buggy source:
@Override public String toString(){
  return "String_Node_Str" + changeId + "String_Node_Str"+ author+ "String_Node_Str"+ changelogClass+ "String_Node_Str"+ changesetMethodName+ "String_Node_Str";
}

Fixed version (ground truth):
@Override public String toString(){
  return "String_Node_Str" + this.changeId + "String_Node_Str"+ this.author+ "String_Node_Str"+ this.changelogClass+ "String_Node_Str"+ this.changesetMethodName+ "String_Node_Str";
}
Program: 165189
Project: 165189
Buggy source:
public String getChangeId(){
  return changeId;
}

Fixed version (ground truth):
public String getChangeId(){
  return this.changeId;
}
Program: 165190
Project: 165190
Buggy source:
public String getChangelogClass(){
  return changelogClass;
}

Fixed version (ground truth):
public String getChangelogClass(){
  return this.changelogClass;
}
Program: 165191
Project: 165191
Buggy source:
public String getChangesetMethodName(){
  return changesetMethodName;
}

Fixed version (ground truth):
public String getChangesetMethodName(){
  return this.changesetMethodName;
}
Program: 165192
Project: 165192
Buggy source:
@Override public String[] getActiveProfiles(){
  return activeProfiles;
}

Fixed version (ground truth):
@Override public String[] getActiveProfiles(){
  return this.activeProfiles;
}