nus-yam/ex-repair huggingface dataset:
Program: 60964
Project: 60964
Buggy source:
protected Flow executeFromState(TestProcEnv env,TestSMProcedureState state){
  LOG.info("String_Node_Str" + state + "String_Node_Str"+ this);
  env.execCount.incrementAndGet();
switch (state) {
case STEP_1:
    if (!env.loop) {
      setNextState(TestSMProcedureState.STEP_2);
    }
  break;
case STEP_2:
addChildProcedure(new SimpleChildProcedure());
return Flow.NO_MORE_STATE;
}
return Flow.HAS_MORE_STATE;
}

Fixed version (ground truth):
@Override protected Flow executeFromState(TestProcEnv env,TestSMProcedureState state){
  LOG.info("String_Node_Str" + state + "String_Node_Str"+ this);
  env.execCount.incrementAndGet();
switch (state) {
case STEP_1:
    if (!env.loop) {
      setNextState(TestSMProcedureState.STEP_2);
    }
  break;
case STEP_2:
addChildProcedure(new SimpleChildProcedure());
return Flow.NO_MORE_STATE;
}
return Flow.HAS_MORE_STATE;
}
Program: 60965
Project: 60965
Buggy source:
protected Procedure[] execute(TestProcEnv env){
  LOG.info("String_Node_Str" + this);
  env.execCount.incrementAndGet();
  if (env.triggerChildRollback) {
    setFailure("String_Node_Str",TEST_FAILURE_EXCEPTION);
  }
  return null;
}

Fixed version (ground truth):
@Override protected Procedure[] execute(TestProcEnv env){
  LOG.info("String_Node_Str" + this);
  env.execCount.incrementAndGet();
  if (env.triggerChildRollback) {
    setFailure("String_Node_Str",TEST_FAILURE_EXCEPTION);
  }
  return null;
}
Program: 60966
Project: 60966
Buggy source:
protected void rollbackState(TestProcEnv env,TestSMProcedureState state){
  LOG.info("String_Node_Str" + state + "String_Node_Str"+ this);
  env.rollbackCount.incrementAndGet();
}

Fixed version (ground truth):
@Override protected void rollbackState(TestProcEnv env,TestSMProcedureState state){
  LOG.info("String_Node_Str" + state + "String_Node_Str"+ this);
  env.rollbackCount.incrementAndGet();
}
Program: 60967
Project: 60967
Buggy source:
protected int getStateId(TestSMProcedureState state){
  return state.ordinal();
}

Fixed version (ground truth):
@Override protected int getStateId(TestSMProcedureState state){
  return state.ordinal();
}
Program: 60968
Project: 60968
Buggy source:
protected TestSMProcedureState getState(int stateId){
  return TestSMProcedureState.values()[stateId];
}

Fixed version (ground truth):
@Override protected TestSMProcedureState getState(int stateId){
  return TestSMProcedureState.values()[stateId];
}
Program: 60969
Project: 60969
Buggy source:
private void writeWals() throws IOException {
  List<Integer> procStates=shuffleProcWriteSequence();
  TestProcedure[] procs=new TestProcedure[numProcs + 1];
  int numProcsPerWal=numWals > 0 ? (int)Math.ceil(procStates.size() / numWals) : Integer.MAX_VALUE;
  long startTime=currentTimeMillis();
  long lastTime=startTime;
  for (int i=0; i < procStates.size(); ++i) {
    int procId=procStates.get(i);
    if (procId < 0) {
      store.delete(procs[-procId].getProcId());
      procs[-procId]=null;
    }
 else     if (procs[procId] == null) {
      procs[procId]=new TestProcedure(procId,0);
      procs[procId].setData(serializedState);
      store.insert(procs[procId],null);
    }
 else {
      store.update(procs[procId]);
    }
    if (i > 0 && i % numProcsPerWal == 0) {
      long currentTime=currentTimeMillis();
      System.out.println("String_Node_Str" + (currentTime - lastTime) / 1000.0f + "String_Node_Str");
      store.rollWriterForTesting();
      lastTime=currentTime;
    }
  }
  long timeTaken=currentTimeMillis() - startTime;
  System.out.println("String_Node_Str" + numProcs + "String_Node_Str"+ StringUtils.humanTimeDiff(timeTaken)+ "String_Node_Str");
}

Fixed version (ground truth):
private void writeWals() throws IOException {
  List<Integer> procStates=shuffleProcWriteSequence();
  TestProcedure[] procs=new TestProcedure[numProcs + 1];
  int numProcsPerWal=numWals > 0 ? procStates.size() / numWals : Integer.MAX_VALUE;
  long startTime=currentTimeMillis();
  long lastTime=startTime;
  for (int i=0; i < procStates.size(); ++i) {
    int procId=procStates.get(i);
    if (procId < 0) {
      store.delete(procs[-procId].getProcId());
      procs[-procId]=null;
    }
 else     if (procs[procId] == null) {
      procs[procId]=new TestProcedure(procId,0);
      procs[procId].setData(serializedState);
      store.insert(procs[procId],null);
    }
 else {
      store.update(procs[procId]);
    }
    if (i > 0 && i % numProcsPerWal == 0) {
      long currentTime=currentTimeMillis();
      System.out.println("String_Node_Str" + (currentTime - lastTime) / 1000.0f + "String_Node_Str");
      store.rollWriterForTesting();
      lastTime=currentTime;
    }
  }
  long timeTaken=currentTimeMillis() - startTime;
  System.out.println("String_Node_Str" + numProcs + "String_Node_Str"+ StringUtils.humanTimeDiff(timeTaken)+ "String_Node_Str");
}
Program: 60970
Project: 60970
Buggy source:
public long getCount(){
  return counter.getCount();
}

Fixed version (ground truth):
@Override public long getCount(){
  return counter.getCount();
}
Program: 60971
Project: 60971
Buggy source:
public Snapshot snapshot(){
  return histogram.snapshotAndReset();
}

Fixed version (ground truth):
@Override public Snapshot snapshot(){
  return histogram.snapshotAndReset();
}
Program: 60972
Project: 60972
Buggy source:
public Optional<MetricRegistry> get(MetricRegistryInfo info){
  return Optional.ofNullable(registries.get(info));
}

Fixed version (ground truth):
@Override public Optional<MetricRegistry> get(MetricRegistryInfo info){
  return Optional.ofNullable(registries.get(info));
}
Program: 60973
Project: 60973
Buggy source:
public void clear(){
  registries.clear();
}

Fixed version (ground truth):
@Override public void clear(){
  registries.clear();
}
Program: 60974
Project: 60974
Buggy source:
public Set<MetricRegistryInfo> getMetricRegistryInfos(){
  return Collections.unmodifiableSet(registries.keySet());
}

Fixed version (ground truth):
@Override public Set<MetricRegistryInfo> getMetricRegistryInfos(){
  return Collections.unmodifiableSet(registries.keySet());
}
Program: 60975
Project: 60975
Buggy source:
public Collection<MetricRegistry> getMetricRegistries(){
  return Collections.unmodifiableCollection(registries.values());
}

Fixed version (ground truth):
@Override public Collection<MetricRegistry> getMetricRegistries(){
  return Collections.unmodifiableCollection(registries.values());
}
Program: 60976
Project: 60976
Buggy source:
public boolean remove(MetricRegistryInfo key){
  return registries.remove(key) == null;
}

Fixed version (ground truth):
@Override public boolean remove(MetricRegistryInfo key){
  return registries.remove(key) == null;
}
Program: 60977
Project: 60977
Buggy source:
/** 
 * Cluster test which starts a region server with a region, then removes the data from HDFS underneath it, and ensures that errors are bubbled to the client.
 */
@Test(timeout=5 * 60 * 1000) public void testFullSystemBubblesFSErrors() throws Exception {
  Assume.assumeTrue(!util.isReadShortCircuitOn());
  try {
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,1);
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD,90000);
    util.getConfiguration().setInt("String_Node_Str",10000);
    util.getConfiguration().setInt("String_Node_Str",1000);
    util.startMiniCluster(1);
    final TableName tableName=TableName.valueOf(name.getMethodName());
    byte[] fam=Bytes.toBytes("String_Node_Str");
    Admin admin=util.getAdmin();
    HTableDescriptor desc=new HTableDescriptor(tableName);
    desc.addFamily(new HColumnDescriptor(fam).setMaxVersions(1).setBlockCacheEnabled(false));
    admin.createTable(desc);
    try (Table table=util.getConnection().getTable(tableName)){
      util.loadTable(table,fam,false);
      util.flush();
      util.countRows(table);
      util.getDFSCluster().shutdownDataNodes();
      try {
        util.countRows(table);
        fail("String_Node_Str");
      }
 catch (      Exception e) {
        LOG.info("String_Node_Str",e);
        assertTrue(e.getMessage().contains("String_Node_Str"));
      }
    }
     util.getDFSCluster().restartDataNodes();
  }
  finally {
    MiniHBaseCluster cluster=util.getMiniHBaseCluster();
    if (cluster != null)     cluster.killAll();
    util.shutdownMiniCluster();
  }
}

Fixed version (ground truth):
/** 
 * Cluster test which starts a region server with a region, then removes the data from HDFS underneath it, and ensures that errors are bubbled to the client.
 */
@Test(timeout=5 * 60 * 1000) public void testFullSystemBubblesFSErrors() throws Exception {
  Assume.assumeTrue(!util.isReadShortCircuitOn());
  try {
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,1);
    util.getConfiguration().setInt("String_Node_Str",10000);
    util.getConfiguration().setInt("String_Node_Str",1000);
    util.startMiniCluster(1);
    final TableName tableName=TableName.valueOf(name.getMethodName());
    byte[] fam=Bytes.toBytes("String_Node_Str");
    Admin admin=util.getAdmin();
    HTableDescriptor desc=new HTableDescriptor(tableName);
    desc.addFamily(new HColumnDescriptor(fam).setMaxVersions(1).setBlockCacheEnabled(false));
    admin.createTable(desc);
    try (Table table=util.getConnection().getTable(tableName)){
      util.loadTable(table,fam,false);
      util.flush();
      util.countRows(table);
      util.getDFSCluster().shutdownDataNodes();
      try {
        util.countRows(table);
        fail("String_Node_Str");
      }
 catch (      Exception e) {
        LOG.info("String_Node_Str",e);
        assertTrue(e.getMessage().contains("String_Node_Str"));
      }
    }
     util.getDFSCluster().restartDataNodes();
  }
  finally {
    MiniHBaseCluster cluster=util.getMiniHBaseCluster();
    if (cluster != null)     cluster.killAll();
    util.shutdownMiniCluster();
  }
}
Program: 60978
Project: 60978
Buggy source:
/** 
 * Cluster test which starts a region server with a region, then removes the data from HDFS underneath it, and ensures that errors are bubbled to the client.
 */
@Test(timeout=5 * 60 * 1000) public void testFullSystemBubblesFSErrors() throws Exception {
  Assume.assumeTrue(!util.isReadShortCircuitOn());
  try {
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,1);
    util.getConfiguration().setInt("String_Node_Str",10000);
    util.getConfiguration().setInt("String_Node_Str",1000);
    util.startMiniCluster(1);
    final TableName tableName=TableName.valueOf(name.getMethodName());
    byte[] fam=Bytes.toBytes("String_Node_Str");
    Admin admin=util.getAdmin();
    HTableDescriptor desc=new HTableDescriptor(tableName);
    desc.addFamily(new HColumnDescriptor(fam).setMaxVersions(1).setBlockCacheEnabled(false));
    admin.createTable(desc);
    try (Table table=util.getConnection().getTable(tableName)){
      util.loadTable(table,fam,false);
      util.flush();
      util.countRows(table);
      util.getDFSCluster().shutdownDataNodes();
      try {
        util.countRows(table);
        fail("String_Node_Str");
      }
 catch (      Exception e) {
        LOG.info("String_Node_Str",e);
        assertTrue(e.getMessage().contains("String_Node_Str"));
      }
    }
     util.getDFSCluster().restartDataNodes();
  }
  finally {
    MiniHBaseCluster cluster=util.getMiniHBaseCluster();
    if (cluster != null)     cluster.killAll();
    util.shutdownMiniCluster();
  }
}

Fixed version (ground truth):
/** 
 * Cluster test which starts a region server with a region, then removes the data from HDFS underneath it, and ensures that errors are bubbled to the client.
 */
@Test(timeout=5 * 60 * 1000) public void testFullSystemBubblesFSErrors() throws Exception {
  Assume.assumeTrue(!util.isReadShortCircuitOn());
  try {
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,1);
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD,90000);
    util.getConfiguration().setInt("String_Node_Str",10000);
    util.getConfiguration().setInt("String_Node_Str",1000);
    util.startMiniCluster(1);
    final TableName tableName=TableName.valueOf(name.getMethodName());
    byte[] fam=Bytes.toBytes("String_Node_Str");
    Admin admin=util.getAdmin();
    HTableDescriptor desc=new HTableDescriptor(tableName);
    desc.addFamily(new HColumnDescriptor(fam).setMaxVersions(1).setBlockCacheEnabled(false));
    admin.createTable(desc);
    try (Table table=util.getConnection().getTable(tableName)){
      util.loadTable(table,fam,false);
      util.flush();
      util.countRows(table);
      util.getDFSCluster().shutdownDataNodes();
      try {
        util.countRows(table);
        fail("String_Node_Str");
      }
 catch (      Exception e) {
        LOG.info("String_Node_Str",e);
        assertTrue(e.getMessage().contains("String_Node_Str"));
      }
    }
     util.getDFSCluster().restartDataNodes();
  }
  finally {
    MiniHBaseCluster cluster=util.getMiniHBaseCluster();
    if (cluster != null)     cluster.killAll();
    util.shutdownMiniCluster();
  }
}
Program: 60979
Project: 60979
Buggy source:
/** 
 * Cluster test which starts a region server with a region, then removes the data from HDFS underneath it, and ensures that errors are bubbled to the client.
 */
@Test(timeout=5 * 60 * 1000) public void testFullSystemBubblesFSErrors() throws Exception {
  Assume.assumeTrue(!util.isReadShortCircuitOn());
  try {
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,1);
    util.getConfiguration().setInt("String_Node_Str",10000);
    util.getConfiguration().setInt("String_Node_Str",1000);
    util.startMiniCluster(1);
    final TableName tableName=TableName.valueOf(name.getMethodName());
    byte[] fam=Bytes.toBytes("String_Node_Str");
    Admin admin=util.getAdmin();
    HTableDescriptor desc=new HTableDescriptor(tableName);
    desc.addFamily(new HColumnDescriptor(fam).setMaxVersions(1).setBlockCacheEnabled(false));
    admin.createTable(desc);
    try (Table table=util.getConnection().getTable(tableName)){
      util.loadTable(table,fam,false);
      util.flush();
      util.countRows(table);
      util.getDFSCluster().shutdownDataNodes();
      try {
        util.countRows(table);
        fail("String_Node_Str");
      }
 catch (      Exception e) {
        LOG.info("String_Node_Str",e);
        assertTrue(e.getMessage().contains("String_Node_Str"));
      }
    }
     util.getDFSCluster().restartDataNodes();
  }
  finally {
    MiniHBaseCluster cluster=util.getMiniHBaseCluster();
    if (cluster != null)     cluster.killAll();
    util.shutdownMiniCluster();
  }
}

Fixed version (ground truth):
/** 
 * Cluster test which starts a region server with a region, then removes the data from HDFS underneath it, and ensures that errors are bubbled to the client.
 */
@Test(timeout=5 * 60 * 1000) public void testFullSystemBubblesFSErrors() throws Exception {
  Assume.assumeTrue(!util.isReadShortCircuitOn());
  try {
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,1);
    util.getConfiguration().setInt(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD,90000);
    util.getConfiguration().setInt("String_Node_Str",10000);
    util.getConfiguration().setInt("String_Node_Str",1000);
    util.startMiniCluster(1);
    final TableName tableName=TableName.valueOf(name.getMethodName());
    byte[] fam=Bytes.toBytes("String_Node_Str");
    Admin admin=util.getAdmin();
    HTableDescriptor desc=new HTableDescriptor(tableName);
    desc.addFamily(new HColumnDescriptor(fam).setMaxVersions(1).setBlockCacheEnabled(false));
    admin.createTable(desc);
    try (Table table=util.getConnection().getTable(tableName)){
      util.loadTable(table,fam,false);
      util.flush();
      util.countRows(table);
      util.getDFSCluster().shutdownDataNodes();
      try {
        util.countRows(table);
        fail("String_Node_Str");
      }
 catch (      Exception e) {
        LOG.info("String_Node_Str",e);
        assertTrue(e.getMessage().contains("String_Node_Str"));
      }
    }
     util.getDFSCluster().restartDataNodes();
  }
  finally {
    MiniHBaseCluster cluster=util.getMiniHBaseCluster();
    if (cluster != null)     cluster.killAll();
    util.shutdownMiniCluster();
  }
}
Program: 60981
Project: 60981
Buggy source:
@Override public void setUp() throws Exception {
  compactingSetUp();
  this.conf=HBaseConfiguration.create();
  conf.set(CompactingMemStore.COMPACTING_MEMSTORE_TYPE_KEY,String.valueOf(MemoryCompactionPolicy.EAGER));
  this.memstore=new MyCompactingMemStore(conf,CellComparatorImpl.COMPARATOR,store,regionServicesForStores,MemoryCompactionPolicy.EAGER);
}

Fixed version (ground truth):
@Override public void setUp() throws Exception {
  compactingSetUp();
  this.conf=HBaseConfiguration.create();
  conf.set(CompactingMemStore.COMPACTING_MEMSTORE_TYPE_KEY,String.valueOf(MemoryCompactionPolicy.EAGER));
  conf.setDouble(CompactingMemStore.IN_MEMORY_FLUSH_THRESHOLD_FACTOR_KEY,0.02);
  this.memstore=new MyCompactingMemStore(conf,CellComparatorImpl.COMPARATOR,store,regionServicesForStores,MemoryCompactionPolicy.EAGER);
}
Program: 60982
Project: 60982
Buggy source:
/** 
 * @return Offset of actual tag bytes within the backed buffer
 */
public int getValueOffset(){
  return this.offset + INFRASTRUCTURE_SIZE;
}

Fixed version (ground truth):
/** 
 * @return Offset of actual tag bytes within the backed buffer
 */
@Override public int getValueOffset(){
  return this.offset + INFRASTRUCTURE_SIZE;
}
Program: 60983
Project: 60983
Buggy source:
/** 
 * @return Length of actual tag bytes within the backed buffer
 */
public int getValueLength(){
  return this.length - INFRASTRUCTURE_SIZE;
}

Fixed version (ground truth):
/** 
 * @return Length of actual tag bytes within the backed buffer
 */
@Override public int getValueLength(){
  return this.length - INFRASTRUCTURE_SIZE;
}
Program: 60984
Project: 60984
Buggy source:
/** 
 * @return the tag type
 */
public byte getType(){
  return this.type;
}

Fixed version (ground truth):
/** 
 * @return the tag type
 */
@Override public byte getType(){
  return this.type;
}
Program: 60985
Project: 60985
Buggy source:
/** 
 * @return The byte array backing this Tag.
 */
public byte[] getValueArray(){
  return this.bytes;
}

Fixed version (ground truth):
/** 
 * @return The byte array backing this Tag.
 */
@Override public byte[] getValueArray(){
  return this.bytes;
}
Program: 60986
Project: 60986
Buggy source:
public void activateOptions(){
  consoleAppender.activateOptions();
  super.activateOptions();
}

Fixed version (ground truth):
@Override public void activateOptions(){
  consoleAppender.activateOptions();
  super.activateOptions();
}
Program: 60987
Project: 60987
Buggy source:
public void setSequenceId(long seqId){
  this.seqId=seqId;
}

Fixed version (ground truth):
@Override public void setSequenceId(long seqId){
  this.seqId=seqId;
}
Program: 60988
Project: 60988
Buggy source:
protected <V>java.util.concurrent.RunnableScheduledFuture<V> decorateTask(Callable<V> callable,java.util.concurrent.RunnableScheduledFuture<V> task){
  return new JitteredRunnableScheduledFuture<>(task);
}

Fixed version (ground truth):
@Override protected <V>java.util.concurrent.RunnableScheduledFuture<V> decorateTask(Callable<V> callable,java.util.concurrent.RunnableScheduledFuture<V> task){
  return new JitteredRunnableScheduledFuture<>(task);
}
Program: 60989
Project: 60989
Buggy source:
/** 
 * Returns any tags embedded in the KeyValue.  Used in testcases.
 * @return The tags
 */
public List<Tag> getTags(){
  int tagsLength=getTagsLength();
  if (tagsLength == 0) {
    return EMPTY_ARRAY_LIST;
  }
  return TagUtil.asList(getTagsArray(),getTagsOffset(),tagsLength);
}

Fixed version (ground truth):
/** 
 * Returns any tags embedded in the KeyValue.  Used in testcases.
 * @return The tags
 */
@Override public List<Tag> getTags(){
  int tagsLength=getTagsLength();
  if (tagsLength == 0) {
    return EMPTY_ARRAY_LIST;
  }
  return TagUtil.asList(getTagsArray(),getTagsOffset(),tagsLength);
}
Program: 60990
Project: 60990
Buggy source:
/** 
 * Write out a KeyValue in the manner in which we used to when KeyValue was a Writable but do not require a   {@link DataOutput}, just take plain   {@link OutputStream}Named <code>oswrite</code> so does not clash with   {@link #write(KeyValue,DataOutput)}
 * @param kv
 * @param out
 * @param withTags
 * @return Length written on stream
 * @throws IOException
 * @see #create(DataInput) for the inverse function
 * @see #write(KeyValue,DataOutput)
 * @see KeyValueUtil#oswrite(Cell,OutputStream,boolean)
 * @deprecated As of release 2.0.0, this will be removed in HBase 3.0.0.Instead use  {@link #write(OutputStream,boolean)}
 */
@Deprecated public static long oswrite(final KeyValue kv,final OutputStream out,final boolean withTags) throws IOException {
  ByteBufferUtils.putInt(out,kv.getSerializedSize(withTags));
  return kv.write(out,withTags) + Bytes.SIZEOF_INT;
}

Fixed version (ground truth):
/** 
 * Write out a KeyValue in the manner in which we used to when KeyValue was a Writable but do not require a   {@link DataOutput}, just take plain   {@link OutputStream}Named <code>oswrite</code> so does not clash with   {@link #write(KeyValue,DataOutput)}
 * @param kv
 * @param out
 * @param withTags
 * @return Length written on stream
 * @throws IOException
 * @see #create(DataInput) for the inverse function
 * @see #write(KeyValue,DataOutput)
 * @see KeyValueUtil#oswrite(Cell,OutputStream,boolean)
 * @deprecated As of release 2.0.0, this will be removed in HBase 3.0.0.Instead use  {@link #write(OutputStream,boolean)}
 */
@Deprecated public static long oswrite(final KeyValue kv,final OutputStream out,final boolean withTags) throws IOException {
  ByteBufferUtils.putInt(out,kv.getSerializedSize(withTags));
  return (long)kv.write(out,withTags) + Bytes.SIZEOF_INT;
}
Program: 60991
Project: 60991
Buggy source:
/** 
 * Computes the number of bytes that a <code>KeyValue</code> instance with the provided characteristics would take up for its underlying data structure.
 * @param klength key length
 * @param vlength value length
 * @param tagsLength total length of the tags
 * @return the <code>KeyValue</code> data structure length
 */
public static long getKeyValueDataStructureSize(int klength,int vlength,int tagsLength){
  if (tagsLength == 0) {
    return KeyValue.KEYVALUE_INFRASTRUCTURE_SIZE + klength + vlength;
  }
  return KeyValue.KEYVALUE_WITH_TAGS_INFRASTRUCTURE_SIZE + klength + vlength+ tagsLength;
}

Fixed version (ground truth):
/** 
 * Computes the number of bytes that a <code>KeyValue</code> instance with the provided characteristics would take up for its underlying data structure.
 * @param klength key length
 * @param vlength value length
 * @param tagsLength total length of the tags
 * @return the <code>KeyValue</code> data structure length
 */
public static long getKeyValueDataStructureSize(int klength,int vlength,int tagsLength){
  if (tagsLength == 0) {
    return (long)KeyValue.KEYVALUE_INFRASTRUCTURE_SIZE + klength + vlength;
  }
  return (long)KeyValue.KEYVALUE_WITH_TAGS_INFRASTRUCTURE_SIZE + klength + vlength+ tagsLength;
}
Program: 60992
Project: 60992
Buggy source:
/** 
 * Computes the number of bytes that a <code>KeyValue</code> instance with the provided characteristics would take up in its underlying data structure for the key.
 * @param rlength row length
 * @param flength family length
 * @param qlength qualifier length
 * @return the key data structure length
 */
public static long getKeyDataStructureSize(int rlength,int flength,int qlength){
  return KeyValue.KEY_INFRASTRUCTURE_SIZE + rlength + flength+ qlength;
}

Fixed version (ground truth):
/** 
 * Computes the number of bytes that a <code>KeyValue</code> instance with the provided characteristics would take up in its underlying data structure for the key.
 * @param rlength row length
 * @param flength family length
 * @param qlength qualifier length
 * @return the key data structure length
 */
public static long getKeyDataStructureSize(int rlength,int flength,int qlength){
  return (long)KeyValue.KEY_INFRASTRUCTURE_SIZE + rlength + flength+ qlength;
}
Program: 60993
Project: 60993
Buggy source:
/** 
 * Write out a KeyValue in the manner in which we used to when KeyValue was a Writable.
 * @param kv
 * @param out
 * @return Length written on stream
 * @throws IOException
 * @see #create(DataInput) for the inverse function
 */
public static long write(final KeyValue kv,final DataOutput out) throws IOException {
  int length=kv.getLength();
  out.writeInt(length);
  out.write(kv.getBuffer(),kv.getOffset(),length);
  return length + Bytes.SIZEOF_INT;
}

Fixed version (ground truth):
/** 
 * Write out a KeyValue in the manner in which we used to when KeyValue was a Writable.
 * @param kv
 * @param out
 * @return Length written on stream
 * @throws IOException
 * @see #create(DataInput) for the inverse function
 */
public static long write(final KeyValue kv,final DataOutput out) throws IOException {
  int length=kv.getLength();
  out.writeInt(length);
  out.write(kv.getBuffer(),kv.getOffset(),length);
  return (long)length + Bytes.SIZEOF_INT;
}
Program: 60994
Project: 60994
Buggy source:
/** 
 * @see java.lang.Object#hashCode()
 */
public int hashCode(){
  return Objects.hashCode(hbaseVersion,liveServers,deadServers,master,backupMasters,clusterId,masterInfoPort);
}

Fixed version (ground truth):
@Override public int hashCode(){
  return Objects.hashCode(hbaseVersion,liveServers,deadServers,master,backupMasters,clusterId,masterInfoPort);
}
Program: 60995
Project: 60995
Buggy source:
/** 
 * @return the number of regions deployed on the cluster
 */
public int getRegionsCount(){
  int count=0;
  if (liveServers != null && !liveServers.isEmpty()) {
    for (    Map.Entry<ServerName,ServerLoad> e : this.liveServers.entrySet()) {
      count+=e.getValue().getNumberOfRegions();
    }
  }
  return count;
}

Fixed version (ground truth):
/** 
 * @return the number of regions deployed on the cluster
 */
public int getRegionsCount(){
  int count=0;
  if (liveServers != null && !liveServers.isEmpty()) {
    for (    Map.Entry<ServerName,ServerLoad> e : this.liveServers.entrySet()) {
      count=count + e.getValue().getNumberOfRegions();
    }
  }
  return count;
}
Program: 60996
Project: 60996
Buggy source:
/** 
 * @see java.lang.Object#equals(java.lang.Object)
 */
public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (!(o instanceof ClusterStatus)) {
    return false;
  }
  ClusterStatus other=(ClusterStatus)o;
  return Objects.equal(getHBaseVersion(),other.getHBaseVersion()) && Objects.equal(this.liveServers,other.liveServers) && getDeadServerNames().containsAll(other.getDeadServerNames())&& Arrays.equals(getMasterCoprocessors(),other.getMasterCoprocessors())&& Objects.equal(getMaster(),other.getMaster())&& getBackupMasters().containsAll(other.getBackupMasters())&& Objects.equal(getClusterId(),other.getClusterId())&& getMasterInfoPort() == other.getMasterInfoPort();
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (!(o instanceof ClusterStatus)) {
    return false;
  }
  ClusterStatus other=(ClusterStatus)o;
  return Objects.equal(getHBaseVersion(),other.getHBaseVersion()) && Objects.equal(this.liveServers,other.liveServers) && getDeadServerNames().containsAll(other.getDeadServerNames())&& Arrays.equals(getMasterCoprocessors(),other.getMasterCoprocessors())&& Objects.equal(getMaster(),other.getMaster())&& getBackupMasters().containsAll(other.getBackupMasters())&& Objects.equal(getClusterId(),other.getClusterId())&& getMasterInfoPort() == other.getMasterInfoPort();
}
Program: 60997
Project: 60997
Buggy source:
public String toString(){
  StringBuilder sb=new StringBuilder(1024);
  sb.append("String_Node_Str" + master);
  int backupMastersSize=getBackupMastersSize();
  sb.append("String_Node_Str" + backupMastersSize);
  if (backupMastersSize > 0) {
    for (    ServerName serverName : backupMasters) {
      sb.append("String_Node_Str" + serverName);
    }
  }
  int serversSize=getServersSize();
  sb.append("String_Node_Str" + serversSize);
  if (serversSize > 0) {
    for (    ServerName serverName : liveServers.keySet()) {
      sb.append("String_Node_Str" + serverName.getServerName());
    }
  }
  int deadServerSize=getDeadServersSize();
  sb.append("String_Node_Str" + deadServerSize);
  if (deadServerSize > 0) {
    for (    ServerName serverName : deadServers) {
      sb.append("String_Node_Str" + serverName);
    }
  }
  sb.append("String_Node_Str" + getAverageLoad());
  sb.append("String_Node_Str" + getRequestCount());
  sb.append("String_Node_Str" + getRegionsCount());
  int ritSize=(intransition != null) ? intransition.size() : 0;
  sb.append("String_Node_Str" + ritSize);
  if (ritSize > 0) {
    for (    RegionState state : intransition) {
      sb.append("String_Node_Str" + state.toDescriptiveString());
    }
  }
  return sb.toString();
}

Fixed version (ground truth):
@Override public String toString(){
  StringBuilder sb=new StringBuilder(1024);
  sb.append("String_Node_Str" + master);
  int backupMastersSize=getBackupMastersSize();
  sb.append("String_Node_Str" + backupMastersSize);
  if (backupMastersSize > 0) {
    for (    ServerName serverName : backupMasters) {
      sb.append("String_Node_Str" + serverName);
    }
  }
  int serversSize=getServersSize();
  sb.append("String_Node_Str" + serversSize);
  if (serversSize > 0) {
    for (    ServerName serverName : liveServers.keySet()) {
      sb.append("String_Node_Str" + serverName.getServerName());
    }
  }
  int deadServerSize=getDeadServersSize();
  sb.append("String_Node_Str" + deadServerSize);
  if (deadServerSize > 0) {
    for (    ServerName serverName : deadServers) {
      sb.append("String_Node_Str" + serverName);
    }
  }
  sb.append("String_Node_Str" + getAverageLoad());
  sb.append("String_Node_Str" + getRequestCount());
  sb.append("String_Node_Str" + getRegionsCount());
  int ritSize=(intransition != null) ? intransition.size() : 0;
  sb.append("String_Node_Str" + ritSize);
  if (ritSize > 0) {
    for (    RegionState state : intransition) {
      sb.append("String_Node_Str" + state.toDescriptiveString());
    }
  }
  return sb.toString();
}
Program: 60998
Project: 60998
Buggy source:
/** 
 * By default, HBase only consider timestamp in versions. So a previous Delete with higher ts will mask a later Put with lower ts. Set this to true to enable new semantics of versions. We will also consider mvcc in versions. See HBASE-15968 for details.
 */
public boolean isNewVersionBehavior(){
  return delegatee.isNewVersionBehavior();
}

Fixed version (ground truth):
/** 
 * By default, HBase only consider timestamp in versions. So a previous Delete with higher ts will mask a later Put with lower ts. Set this to true to enable new semantics of versions. We will also consider mvcc in versions. See HBASE-15968 for details.
 */
@Override public boolean isNewVersionBehavior(){
  return delegatee.isNewVersionBehavior();
}
Program: 60999
Project: 60999
Buggy source:
/** 
 * @return true if this region is a meta region 
 */
public boolean isMetaRegion(){
  return tableName.equals(HRegionInfo.FIRST_META_REGIONINFO.getTable());
}

Fixed version (ground truth):
/** 
 * @return true if this region is a meta region
 */
@Override public boolean isMetaRegion(){
  return tableName.equals(HRegionInfo.FIRST_META_REGIONINFO.getTable());
}
Program: 61000
Project: 61000
Buggy source:
/** 
 * @return the startKey 
 */
public byte[] getStartKey(){
  return startKey;
}

Fixed version (ground truth):
/** 
 * @return the startKey
 */
@Override public byte[] getStartKey(){
  return startKey;
}
Program: 61001
Project: 61001
Buggy source:
/** 
 * Returns the region replica id
 * @return returns region replica id
 */
public int getReplicaId(){
  return replicaId;
}

Fixed version (ground truth):
/** 
 * Returns the region replica id
 * @return returns region replica id
 */
@Override public int getReplicaId(){
  return replicaId;
}
Program: 61002
Project: 61002
Buggy source:
/** 
 * @return Region name as a String for use in logging, etc.
 */
public String getRegionNameAsString(){
  if (RegionInfo.hasEncodedName(this.regionName)) {
    return Bytes.toStringBinary(this.regionName);
  }
  return Bytes.toStringBinary(this.regionName) + "String_Node_Str" + this.getEncodedName();
}

Fixed version (ground truth):
/** 
 * @return Region name as a String for use in logging, etc.
 */
@Override public String getRegionNameAsString(){
  if (RegionInfo.hasEncodedName(this.regionName)) {
    return Bytes.toStringBinary(this.regionName);
  }
  return Bytes.toStringBinary(this.regionName) + "String_Node_Str" + this.getEncodedName();
}
Program: 61003
Project: 61003
Buggy source:
/** 
 * @return the regionName as an array of bytes.
 * @see #getRegionNameAsString()
 */
public byte[] getRegionName(){
  return regionName;
}

Fixed version (ground truth):
/** 
 * @return the regionName as an array of bytes.
 * @see #getRegionNameAsString()
 */
@Override public byte[] getRegionName(){
  return regionName;
}
Program: 61004
Project: 61004
Buggy source:
/** 
 * @return the regionId 
 */
public long getRegionId(){
  return regionId;
}

Fixed version (ground truth):
/** 
 * @return the regionId 
 */
@Override public long getRegionId(){
  return regionId;
}
Program: 61005
Project: 61005
Buggy source:
/** 
 * @return the endKey 
 */
public byte[] getEndKey(){
  return endKey;
}

Fixed version (ground truth):
/** 
 * @return the endKey
 */
@Override public byte[] getEndKey(){
  return endKey;
}
Program: 61006
Project: 61006
Buggy source:
/** 
 * Return true if the given row falls in this region.
 */
public boolean containsRow(byte[] row){
  return Bytes.compareTo(row,startKey) >= 0 && (Bytes.compareTo(row,endKey) < 0 || Bytes.equals(endKey,HConstants.EMPTY_BYTE_ARRAY));
}

Fixed version (ground truth):
/** 
 * @return true if the given row falls in this region.
 */
@Override public boolean containsRow(byte[] row){
  return Bytes.compareTo(row,startKey) >= 0 && (Bytes.compareTo(row,endKey) < 0 || Bytes.equals(endKey,HConstants.EMPTY_BYTE_ARRAY));
}
Program: 61007
Project: 61007
Buggy source:
public synchronized byte[] getEncodedNameAsBytes(){
  if (this.encodedNameAsBytes == null) {
    this.encodedNameAsBytes=Bytes.toBytes(getEncodedName());
  }
  return this.encodedNameAsBytes;
}

Fixed version (ground truth):
@Override public synchronized byte[] getEncodedNameAsBytes(){
  if (this.encodedNameAsBytes == null) {
    this.encodedNameAsBytes=Bytes.toBytes(getEncodedName());
  }
  return this.encodedNameAsBytes;
}
Program: 61008
Project: 61008
Buggy source:
/** 
 * @return True if has been split and has daughters.
 */
public boolean isSplit(){
  return this.split;
}

Fixed version (ground truth):
/** 
 * @return true if has been split and has daughters.
 */
@Override public boolean isSplit(){
  return this.split;
}
Program: 61009
Project: 61009
Buggy source:
/** 
 * @return the encoded region name 
 */
public synchronized String getEncodedName(){
  if (this.encodedName == null) {
    this.encodedName=RegionInfo.encodeRegionName(this.regionName);
  }
  return this.encodedName;
}

Fixed version (ground truth):
/** 
 * @return the encoded region name
 */
@Override public synchronized String getEncodedName(){
  if (this.encodedName == null) {
    this.encodedName=RegionInfo.encodeRegionName(this.regionName);
  }
  return this.encodedName;
}
Program: 61010
Project: 61010
Buggy source:
/** 
 * Get current table name of the region
 * @return TableName
 */
public TableName getTable(){
  if (tableName == null || tableName.getName().length == 0) {
    tableName=getTable(getRegionName());
  }
  return this.tableName;
}

Fixed version (ground truth):
/** 
 * Get current table name of the region
 * @return TableName
 */
@Override public TableName getTable(){
  if (tableName == null || tableName.getName().length == 0) {
    tableName=getTable(getRegionName());
  }
  return this.tableName;
}
Program: 61011
Project: 61011
Buggy source:
/** 
 * @return True if this is a split parent region.
 */
public boolean isSplitParent(){
  if (!isSplit())   return false;
  if (!isOffline()) {
    LOG.warn("String_Node_Str" + getRegionNameAsString());
  }
  return true;
}

Fixed version (ground truth):
/** 
 * @return true if this is a split parent region.
 */
@Override public boolean isSplitParent(){
  if (!isSplit())   return false;
  if (!isOffline()) {
    LOG.warn("String_Node_Str" + getRegionNameAsString());
  }
  return true;
}
Program: 61012
Project: 61012
Buggy source:
/** 
 * @return True if this region is offline.
 */
public boolean isOffline(){
  return this.offLine;
}

Fixed version (ground truth):
/** 
 * @return true if this region is offline.
 */
@Override public boolean isOffline(){
  return this.offLine;
}
Program: 61013
Project: 61013
Buggy source:
private void setHashCode(){
  int result=Arrays.hashCode(this.regionName);
  result^=this.regionId;
  result^=Arrays.hashCode(this.startKey);
  result^=Arrays.hashCode(this.endKey);
  result^=Boolean.valueOf(this.offLine).hashCode();
  result^=Arrays.hashCode(this.tableName.getName());
  result^=this.replicaId;
  this.hashCode=result;
}

Fixed version (ground truth):
private void setHashCode(){
  int result=Arrays.hashCode(this.regionName);
  result=(int)(result ^ this.regionId);
  result^=Arrays.hashCode(this.startKey);
  result^=Arrays.hashCode(this.endKey);
  result^=Boolean.valueOf(this.offLine).hashCode();
  result^=Arrays.hashCode(this.tableName.getName());
  result^=this.replicaId;
  this.hashCode=result;
}
Program: 61014
Project: 61014
Buggy source:
/** 
 * Returns true if the given inclusive range of rows is fully contained by this region. For example, if the region is foo,a,g and this is passed ["b","c"] or ["a","c"] it will return true, but if this is passed ["b","z"] it will return false.
 * @throws IllegalArgumentException if the range passed is invalid (ie. end &lt; start)
 */
public boolean containsRange(byte[] rangeStartKey,byte[] rangeEndKey){
  if (Bytes.compareTo(rangeStartKey,rangeEndKey) > 0) {
    throw new IllegalArgumentException("String_Node_Str" + Bytes.toStringBinary(rangeStartKey) + "String_Node_Str"+ Bytes.toStringBinary(rangeEndKey));
  }
  boolean firstKeyInRange=Bytes.compareTo(rangeStartKey,startKey) >= 0;
  boolean lastKeyInRange=Bytes.compareTo(rangeEndKey,endKey) < 0 || Bytes.equals(endKey,HConstants.EMPTY_BYTE_ARRAY);
  return firstKeyInRange && lastKeyInRange;
}

Fixed version (ground truth):
/** 
 * Returns true if the given inclusive range of rows is fully contained by this region. For example, if the region is foo,a,g and this is passed ["b","c"] or ["a","c"] it will return true, but if this is passed ["b","z"] it will return false.
 * @throws IllegalArgumentException if the range passed is invalid (ie. end &lt; start)
 */
@Override public boolean containsRange(byte[] rangeStartKey,byte[] rangeEndKey){
  if (Bytes.compareTo(rangeStartKey,rangeEndKey) > 0) {
    throw new IllegalArgumentException("String_Node_Str" + Bytes.toStringBinary(rangeStartKey) + "String_Node_Str"+ Bytes.toStringBinary(rangeEndKey));
  }
  boolean firstKeyInRange=Bytes.compareTo(rangeStartKey,startKey) >= 0;
  boolean lastKeyInRange=Bytes.compareTo(rangeEndKey,endKey) < 0 || Bytes.equals(endKey,HConstants.EMPTY_BYTE_ARRAY);
  return firstKeyInRange && lastKeyInRange;
}
Program: 61015
Project: 61015
Buggy source:
/** 
 * @return current setting for returnResults
 */
public boolean isReturnResults(){
  return super.isReturnResults();
}

Fixed version (ground truth):
/** 
 * @return current setting for returnResults
 */
@Override public boolean isReturnResults(){
  return super.isReturnResults();
}
Program: 61016
Project: 61016
Buggy source:
/** 
 * @param returnResults True (default) if the append operation should return the results. A client that is not interested in the result can save network bandwidth setting this to false.
 */
public Append setReturnResults(boolean returnResults){
  super.setReturnResults(returnResults);
  return this;
}

Fixed version (ground truth):
/** 
 * @param returnResults True (default) if the append operation should return the results. A client that is not interested in the result can save network bandwidth setting this to false.
 */
@Override public Append setReturnResults(boolean returnResults){
  super.setReturnResults(returnResults);
  return this;
}
Program: 61017
Project: 61017
Buggy source:
CompletableFuture<T> call(){
  doCall();
  return future;
}

Fixed version (ground truth):
@Override CompletableFuture<T> call(){
  doCall();
  return future;
}
Program: 61018
Project: 61018
Buggy source:
public CompletableFuture<T> call(){
  doCall();
  return future;
}

Fixed version (ground truth):
@Override public CompletableFuture<T> call(){
  doCall();
  return future;
}
Program: 61020
Project: 61020
Buggy source:
CompletableFuture<T> call(){
  doCall();
  return future;
}

Fixed version (ground truth):
@Override CompletableFuture<T> call(){
  doCall();
  return future;
}
Program: 61021
Project: 61021
Buggy source:
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value="String_Node_Str",justification="String_Node_Str") public BufferedMutatorParams clone(){
  BufferedMutatorParams clone=new BufferedMutatorParams(this.tableName);
  clone.writeBufferSize=this.writeBufferSize;
  clone.maxKeyValueSize=maxKeyValueSize;
  clone.pool=this.pool;
  clone.listener=this.listener;
  clone.implementationClassName=this.implementationClassName;
  return clone;
}

Fixed version (ground truth):
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value="String_Node_Str",justification="String_Node_Str") @Override public BufferedMutatorParams clone(){
  BufferedMutatorParams clone=new BufferedMutatorParams(this.tableName);
  clone.writeBufferSize=this.writeBufferSize;
  clone.maxKeyValueSize=maxKeyValueSize;
  clone.pool=this.pool;
  clone.listener=this.listener;
  clone.implementationClassName=this.implementationClassName;
  return clone;
}
Program: 61022
Project: 61022
Buggy source:
/** 
 * By default, HBase only consider timestamp in versions. So a previous Delete with higher ts will mask a later Put with lower ts. Set this to true to enable new semantics of versions. We will also consider mvcc in versions. See HBASE-15968 for details.
 */
public boolean isNewVersionBehavior(){
  return getStringOrDefault(NEW_VERSION_BEHAVIOR_BYTES,Boolean::parseBoolean,DEFAULT_NEW_VERSION_BEHAVIOR);
}

Fixed version (ground truth):
/** 
 * By default, HBase only consider timestamp in versions. So a previous Delete with higher ts will mask a later Put with lower ts. Set this to true to enable new semantics of versions. We will also consider mvcc in versions. See HBASE-15968 for details.
 */
@Override public boolean isNewVersionBehavior(){
  return getStringOrDefault(NEW_VERSION_BEHAVIOR_BYTES,Boolean::parseBoolean,DEFAULT_NEW_VERSION_BEHAVIOR);
}
Program: 61023
Project: 61023
Buggy source:
public FastFailInterceptorContext prepare(RetryingCallable<?> callable,int tries){
  if (callable instanceof RegionServerCallable) {
    RegionServerCallable<?,?> retryingCallable=(RegionServerCallable<?,?>)callable;
    server=retryingCallable.getLocation().getServerName();
  }
  this.tries=tries;
  return this;
}

Fixed version (ground truth):
@Override public FastFailInterceptorContext prepare(RetryingCallable<?> callable,int tries){
  if (callable instanceof RegionServerCallable) {
    RegionServerCallable<?,?> retryingCallable=(RegionServerCallable<?,?>)callable;
    server=retryingCallable.getLocation().getServerName();
  }
  this.tries=tries;
  return this;
}
Program: 61024
Project: 61024
Buggy source:
public void clear(){
  server=null;
  fInfo=null;
  didTry=false;
  couldNotCommunicateWithServer.setValue(false);
  guaranteedClientSideOnly.setValue(false);
  retryDespiteFastFailMode=false;
  tries=0;
}

Fixed version (ground truth):
@Override public void clear(){
  server=null;
  fInfo=null;
  didTry=false;
  couldNotCommunicateWithServer.setValue(false);
  guaranteedClientSideOnly.setValue(false);
  retryDespiteFastFailMode=false;
  tries=0;
}
Program: 61025
Project: 61025
Buggy source:
public Get setLoadColumnFamiliesOnDemand(boolean value){
  return (Get)super.setLoadColumnFamiliesOnDemand(value);
}

Fixed version (ground truth):
@Override public Get setLoadColumnFamiliesOnDemand(boolean value){
  return (Get)super.setLoadColumnFamiliesOnDemand(value);
}
Program: 61026
Project: 61026
Buggy source:
/** 
 * Wakes up given waiting procedures by pushing them back into scheduler queues.
 * @return size of given {@code waitQueue}.
 */
protected int wakeWaitingProcedures(final ProcedureDeque waitQueue){
  int count=waitQueue.size();
  while (!waitQueue.isEmpty()) {
    wakeProcedure(waitQueue.removeLast());
  }
  return count;
}

Fixed version (ground truth):
/** 
 * Wakes up given waiting procedures by pushing them back into scheduler queues.
 * @return size of given {@code waitQueue}.
 */
protected int wakeWaitingProcedures(final ProcedureDeque waitQueue){
  int count=waitQueue.size();
  addFront(waitQueue.descendingIterator());
  waitQueue.clear();
  return count;
}
Program: 61027
Project: 61027
Buggy source:
public void addBack(final Procedure procedure){
  push(procedure,false,true);
}

Fixed version (ground truth):
@Override public void addBack(final Procedure procedure){
  push(procedure,false,true);
}
Program: 61028
Project: 61028
Buggy source:
@Override public void wakeEvents(final int count,final ProcedureEvent... events){
  final boolean traceEnabled=LOG.isTraceEnabled();
  schedLock();
  try {
    int waitingCount=0;
    for (int i=0; i < count; ++i) {
      final ProcedureEvent event=events[i];
synchronized (event) {
        if (!event.isReady()) {
          event.setReady(true);
          if (traceEnabled) {
            LOG.trace("String_Node_Str" + event);
          }
          waitingCount+=wakeWaitingProcedures(event.getSuspendedProcedures());
        }
 else {
          ProcedureDeque q=event.getSuspendedProcedures();
          if (q != null && !q.isEmpty()) {
            LOG.warn("String_Node_Str" + q.size() + "String_Node_Str");
            waitingCount+=wakeWaitingProcedures(event.getSuspendedProcedures());
          }
        }
      }
    }
    wakePollIfNeeded(waitingCount);
  }
  finally {
    schedUnlock();
  }
}

Fixed version (ground truth):
/** 
 * Wake up all of the given events. Note that we first take scheduler lock and then wakeInternal() synchronizes on the event. Access should remain package-private. Use ProcedureEvent class to wake/suspend events.
 * @param events the list of events to wake
 */
void wakeEvents(ProcedureEvent[] events){
  schedLock();
  try {
    for (    ProcedureEvent event : events) {
      if (event == null) {
        continue;
      }
      event.wakeInternal(this);
    }
  }
  finally {
    schedUnlock();
  }
}
Program: 61029
Project: 61029
Buggy source:
public void addFront(final Procedure procedure){
  push(procedure,true,true);
}

Fixed version (ground truth):
@Override public void addFront(Iterator<Procedure> procedureIterator){
  schedLock();
  try {
    int count=0;
    while (procedureIterator.hasNext()) {
      Procedure procedure=procedureIterator.next();
      if (LOG.isTraceEnabled()) {
        LOG.trace("String_Node_Str" + procedure);
      }
      push(procedure,true,false);
      count++;
    }
    wakePollIfNeeded(count);
  }
  finally {
    schedUnlock();
  }
}
Program: 61030
Project: 61030
Buggy source:
public ProcedureDeque getSuspendedProcedures(){
  return suspendedProcedures;
}

Fixed version (ground truth):
/** 
 * Access to suspendedProcedures is 'synchronized' on this object, but it's fine to return it here for tests.
 */
@VisibleForTesting public ProcedureDeque getSuspendedProcedures(){
  return suspendedProcedures;
}
Program: 61031
Project: 61031
Buggy source:
@Override public String toString(){
  return getClass().getSimpleName() + "String_Node_Str" + object+ "String_Node_Str"+ isReady()+ "String_Node_Str"+ getSuspendedProcedures();
}

Fixed version (ground truth):
@Override public String toString(){
  return getClass().getSimpleName() + "String_Node_Str" + object+ "String_Node_Str"+ isReady()+ "String_Node_Str"+ suspendedProcedures;
}
Program: 61032
Project: 61032
Buggy source:
/** 
 * Inserts the specified element at the front of this queue.
 * @param proc the Procedure to add
 */
void addFront(Procedure proc);

Fixed version (ground truth):
/** 
 * Inserts all elements in the iterator at the front of this queue.
 */
void addFront(Iterator<Procedure> procedureIterator);