nus-yam/ex-repair huggingface dataset:
Program: 48141
Project: 48141
Buggy source:
public void processTaskAndSendResponse(int taskId,ConsoleRequest task){
  try {
    HttpURLConnection connection=openPostResponseConnection();
    OutputStream outputStream=connection.getOutputStream();
    final OutputStreamWriter writer=new OutputStreamWriter(outputStream);
    try {
      JsonObject root=new JsonObject();
      root.add("String_Node_Str",identifier.toJson());
      root.add("String_Node_Str",taskId);
      root.add("String_Node_Str",task.getType());
      task.writeResponse(ManagementCenterService.this,root);
      root.writeTo(writer);
      writer.flush();
      outputStream.flush();
      post(connection);
    }
  finally {
      closeResource(writer);
      closeResource(outputStream);
    }
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + task,e);
  }
}

Fixed version (ground truth):
public void processTaskAndSendResponse(int taskId,ConsoleRequest task){
  try {
    HttpURLConnection connection=openPostResponseConnection();
    OutputStream outputStream=connection.getOutputStream();
    final OutputStreamWriter writer=new OutputStreamWriter(outputStream,"String_Node_Str");
    try {
      JsonObject root=new JsonObject();
      root.add("String_Node_Str",identifier.toJson());
      root.add("String_Node_Str",taskId);
      root.add("String_Node_Str",task.getType());
      task.writeResponse(ManagementCenterService.this,root);
      root.writeTo(writer);
      writer.flush();
      outputStream.flush();
      post(connection);
    }
  finally {
      closeResource(writer);
      closeResource(outputStream);
    }
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + task,e);
  }
}
Program: 48142
Project: 48142
Buggy source:
public boolean set(Data dataKey,Object value,long ttl){
  checkIfLoaded();
  earlyWriteCleanup();
  Record record=records.get(dataKey);
  boolean newRecord=false;
  if (record == null) {
    value=mapService.interceptPut(name,null,value);
    value=mapStoreWrite(dataKey,value,null);
    record=mapService.createRecord(name,dataKey,value,ttl);
    records.put(dataKey,record);
    updateSizeEstimator(calculateRecordSize(record));
    newRecord=true;
  }
 else {
    value=mapService.interceptPut(name,record.getValue(),value);
    value=mapStoreWrite(dataKey,value,record);
    updateSizeEstimator(-calculateRecordSize(record));
    setRecordValue(record,value);
    updateSizeEstimator(calculateRecordSize(record));
    updateTtl(record,ttl);
  }
  saveIndex(record);
  return newRecord;
}

Fixed version (ground truth):
public boolean set(Data key,Object value,long ttl){
  checkIfLoaded();
  earlyWriteCleanup();
  Record record=records.get(key);
  boolean newRecord=false;
  if (record == null) {
    value=mapService.interceptPut(name,null,value);
    value=mapStoreWrite(key,value,null);
    record=mapService.createRecord(name,key,value,ttl);
    records.put(key,record);
    updateSizeEstimator(calculateRecordSize(record));
    newRecord=true;
  }
 else {
    value=mapService.interceptPut(name,record.getValue(),value);
    value=mapStoreWrite(key,value,record);
    updateSizeEstimator(-calculateRecordSize(record));
    setRecordValue(record,value);
    updateSizeEstimator(calculateRecordSize(record));
    updateTtl(record,ttl);
  }
  saveIndex(record);
  removeFromWriteBehindWaitingDeletions(key);
  return newRecord;
}
Program: 48144
Project: 48144
Buggy source:
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new PostPonePartitionProcessing();
}

Fixed version (ground truth):
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new HashMapAdapter();
}
Program: 48145
Project: 48145
Buggy source:
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  Map<KeyIn,Chunk> chunkMap=new HashMap<KeyIn,Chunk>(combiners.size());
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    chunkMap.put(entry.getKey(),chunk);
  }
  collected.set(0);
  return chunkMap;
}

Fixed version (ground truth):
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  int mapSize=MapReduceUtil.mapSize(combiners.size());
  Map<KeyIn,Chunk> chunkMap=new HashMapAdapter<KeyIn,Chunk>(mapSize);
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    if (chunk != null) {
      chunkMap.put(entry.getKey(),chunk);
    }
  }
  collected.set(0);
  return chunkMap;
}
Program: 48146
Project: 48146
Buggy source:
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapsize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMap<Object,Object>(mapsize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}

Fixed version (ground truth):
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapSize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMapAdapter<Object,Object>(mapSize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}
Program: 48147
Project: 48147
Buggy source:
public void checkFullyProcessed(JobProcessInformation processInformation){
  if (isOwnerNode()) {
    JobPartitionState[] partitionStates=processInformation.getPartitionStates();
    for (    JobPartitionState partitionState : partitionStates) {
      if (partitionState == null || partitionState.getState() != JobPartitionState.State.PROCESSED) {
        return;
      }
    }
    String name=configuration.getName();
    String jobId=configuration.getJobId();
    NodeEngine nodeEngine=configuration.getNodeEngine();
    GetResultOperationFactory operationFactory=new GetResultOperationFactory(name,jobId);
    List<Map> results=MapReduceUtil.executeOperation(operationFactory,mapReduceService,nodeEngine,true);
    boolean reducedResult=configuration.getReducerFactory() != null;
    if (results != null) {
      Map<Object,Object> mergedResults=new HashMap<Object,Object>();
      for (      Map<?,?> map : results) {
        for (        Map.Entry entry : map.entrySet()) {
          collectResults(reducedResult,mergedResults,entry);
        }
      }
      TrackableJobFuture future=jobTracker.unregisterTrackableJob(jobId);
      jobTracker.unregisterMapCombineTask(jobId);
      jobTracker.unregisterReducerTask(jobId);
      mapReduceService.destroyJobSupervisor(this);
      future.setResult(mergedResults);
    }
  }
}

Fixed version (ground truth):
public void checkFullyProcessed(JobProcessInformation processInformation){
  if (isOwnerNode()) {
    JobPartitionState[] partitionStates=processInformation.getPartitionStates();
    for (    JobPartitionState partitionState : partitionStates) {
      if (partitionState == null || partitionState.getState() != JobPartitionState.State.PROCESSED) {
        return;
      }
    }
    String name=configuration.getName();
    String jobId=configuration.getJobId();
    NodeEngine nodeEngine=configuration.getNodeEngine();
    GetResultOperationFactory operationFactory=new GetResultOperationFactory(name,jobId);
    try {
      List<Map> results=MapReduceUtil.executeOperation(operationFactory,mapReduceService,nodeEngine,true);
      boolean reducedResult=configuration.getReducerFactory() != null;
      if (results != null) {
        Map<Object,Object> mergedResults=new HashMap<Object,Object>();
        for (        Map<?,?> map : results) {
          for (          Map.Entry entry : map.entrySet()) {
            collectResults(reducedResult,mergedResults,entry);
          }
        }
        TrackableJobFuture future=jobTracker.unregisterTrackableJob(jobId);
        jobTracker.unregisterMapCombineTask(jobId);
        jobTracker.unregisterReducerTask(jobId);
        mapReduceService.destroyJobSupervisor(this);
        future.setResult(mergedResults);
      }
    }
 catch (    Exception e) {
      TrackableJobFuture future=jobTracker.unregisterTrackableJob(jobId);
      jobTracker.unregisterMapCombineTask(jobId);
      jobTracker.unregisterReducerTask(jobId);
      mapReduceService.destroyJobSupervisor(this);
      future.setResult(e);
    }
  }
}
Program: 48148
Project: 48148
Buggy source:
@Override public void setResult(Object result){
  Object finalResult=result;
  if (collator != null) {
    finalResult=collator.collate(((Map)finalResult).entrySet());
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}

Fixed version (ground truth):
@Override public void setResult(Object result){
  Object finalResult=result;
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    if (!(finalResult instanceof CancellationException)) {
      finalResult=new ExecutionException((Throwable)finalResult);
    }
    super.setResult(finalResult);
    latch.countDown();
    return;
  }
  if (collator != null) {
    try {
      finalResult=collator.collate(((Map)finalResult).entrySet());
    }
 catch (    Exception e) {
      finalResult=e;
    }
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}
Program: 48149
Project: 48149
Buggy source:
private Set<String> selectKeys(){
  Set<String> keys=new HashSet<String>();
  if (!deferredWrite) {
    for (    String qualifiedAttributeKey : getClusterMap().keySet(new SessionAttributePredicate(id))) {
      keys.add(extractAttributeKey(qualifiedAttributeKey));
    }
  }
 else {
    for (    Entry<String,LocalCacheEntry> entry : localCache.entrySet()) {
      if (!entry.getValue().removed) {
        keys.add(entry.getKey());
      }
    }
  }
  return keys;
}

Fixed version (ground truth):
private Set<String> selectKeys(){
  Set<String> keys=new HashSet<String>();
  if (!deferredWrite) {
    for (    String qualifiedAttributeKey : getClusterMap().keySet(new SessionAttributePredicate(id))) {
      keys.add(extractAttributeKey(qualifiedAttributeKey));
    }
  }
 else {
    for (    Entry<String,LocalCacheEntry> entry : localCache.entrySet()) {
      if (!entry.getValue().removed && entry.getValue() != NULL_ENTRY) {
        keys.add(entry.getKey());
      }
    }
  }
  return keys;
}
Program: 48150
Project: 48150
Buggy source:
@Override protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
  HttpSession session=req.getSession();
  if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    Object value=session.getAttribute("String_Node_Str");
    resp.getWriter().write(value == null ? "String_Node_Str" : value.toString());
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.removeAttribute("String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    session=req.getSession();
    session.setAttribute("String_Node_Str","String_Node_Str");
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
}

Fixed version (ground truth):
@Override protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
  HttpSession session=req.getSession();
  if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    Object value=session.getAttribute("String_Node_Str");
    resp.getWriter().write(value == null ? "String_Node_Str" : value.toString());
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.removeAttribute("String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    List<String> names=Collections.list(session.getAttributeNames());
    String nameList=names.toString();
    resp.getWriter().write(nameList.substring(1,nameList.length() - 1).replace("String_Node_Str","String_Node_Str"));
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    session=req.getSession();
    session.setAttribute("String_Node_Str","String_Node_Str");
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
}
Program: 48151
Project: 48151
Buggy source:
private Set<String> selectKeys(){
  Set<String> keys=new HashSet<String>();
  if (!deferredWrite) {
    for (    String qualifiedAttributeKey : getClusterMap().keySet(new SessionAttributePredicate(id))) {
      keys.add(extractAttributeKey(qualifiedAttributeKey));
    }
  }
 else {
    for (    Entry<String,LocalCacheEntry> entry : localCache.entrySet()) {
      if (!entry.getValue().removed) {
        keys.add(entry.getKey());
      }
    }
  }
  return keys;
}

Fixed version (ground truth):
private Set<String> selectKeys(){
  Set<String> keys=new HashSet<String>();
  if (!deferredWrite) {
    for (    String qualifiedAttributeKey : getClusterMap().keySet(new SessionAttributePredicate(id))) {
      keys.add(extractAttributeKey(qualifiedAttributeKey));
    }
  }
 else {
    for (    Entry<String,LocalCacheEntry> entry : localCache.entrySet()) {
      if (!entry.getValue().removed && entry.getValue() != NULL_ENTRY) {
        keys.add(entry.getKey());
      }
    }
  }
  return keys;
}
Program: 48152
Project: 48152
Buggy source:
@Override protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
  HttpSession session=req.getSession();
  if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    Object value=session.getAttribute("String_Node_Str");
    resp.getWriter().write(value == null ? "String_Node_Str" : value.toString());
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.removeAttribute("String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    session=req.getSession();
    session.setAttribute("String_Node_Str","String_Node_Str");
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
}

Fixed version (ground truth):
@Override protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
  HttpSession session=req.getSession();
  if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    Object value=session.getAttribute("String_Node_Str");
    resp.getWriter().write(value == null ? "String_Node_Str" : value.toString());
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.removeAttribute("String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    List<String> names=Collections.list(session.getAttributeNames());
    String nameList=names.toString();
    resp.getWriter().write(nameList.substring(1,nameList.length() - 1).replace("String_Node_Str","String_Node_Str"));
  }
 else   if (req.getRequestURI().endsWith("String_Node_Str")) {
    session.invalidate();
    session=req.getSession();
    session.setAttribute("String_Node_Str","String_Node_Str");
    session.setAttribute("String_Node_Str","String_Node_Str");
    resp.getWriter().write("String_Node_Str");
  }
}
Program: 48153
Project: 48153
Buggy source:
@Override protected Operation prepareOperation(){
  return new CallableTaskOperation(name,uuid,callable);
}

Fixed version (ground truth):
@Override protected Operation prepareOperation(){
  SecurityContext securityContext=getClientEngine().getSecurityContext();
  if (securityContext != null) {
    callable=securityContext.createSecureCallable(getEndpoint().getSubject(),callable);
  }
  return new CallableTaskOperation(name,uuid,callable);
}
Program: 48154
Project: 48154
Buggy source:
@Override protected Operation prepareOperation(){
  return new CallableTaskOperation(name,uuid,callable);
}

Fixed version (ground truth):
@Override protected Operation prepareOperation(){
  SecurityContext securityContext=getClientEngine().getSecurityContext();
  if (securityContext != null) {
    callable=securityContext.createSecureCallable(getEndpoint().getSubject(),callable);
  }
  return new CallableTaskOperation(name,uuid,callable);
}
Program: 48156
Project: 48156
Buggy source:
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new PostPonePartitionProcessing();
}

Fixed version (ground truth):
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new HashMapAdapter();
}
Program: 48157
Project: 48157
Buggy source:
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  Map<KeyIn,Chunk> chunkMap=new HashMap<KeyIn,Chunk>(combiners.size());
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    chunkMap.put(entry.getKey(),chunk);
  }
  COLLECTED_UPDATER.set(this,0);
  return chunkMap;
}

Fixed version (ground truth):
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  int mapSize=MapReduceUtil.mapSize(combiners.size());
  Map<KeyIn,Chunk> chunkMap=new HashMapAdapter<KeyIn,Chunk>(mapSize);
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    if (chunk != null) {
      chunkMap.put(entry.getKey(),chunk);
    }
  }
  COLLECTED_UPDATER.set(this,0);
  return chunkMap;
}
Program: 48158
Project: 48158
Buggy source:
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapsize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMap<Object,Object>(mapsize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}

Fixed version (ground truth):
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapSize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMapAdapter<Object,Object>(mapSize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}
Program: 48159
Project: 48159
Buggy source:
public void checkFullyProcessed(JobProcessInformation processInformation){
  if (isOwnerNode()) {
    JobPartitionState[] partitionStates=processInformation.getPartitionStates();
    for (    JobPartitionState partitionState : partitionStates) {
      if (partitionState == null || partitionState.getState() != JobPartitionState.State.PROCESSED) {
        return;
      }
    }
    String name=configuration.getName();
    String jobId=configuration.getJobId();
    NodeEngine nodeEngine=configuration.getNodeEngine();
    GetResultOperationFactory operationFactory=new GetResultOperationFactory(name,jobId);
    List<Map> results=MapReduceUtil.executeOperation(operationFactory,mapReduceService,nodeEngine,true);
    boolean reducedResult=configuration.getReducerFactory() != null;
    if (results != null) {
      Map<Object,Object> mergedResults=new HashMap<Object,Object>();
      for (      Map<?,?> map : results) {
        for (        Map.Entry entry : map.entrySet()) {
          collectResults(reducedResult,mergedResults,entry);
        }
      }
      TrackableJobFuture future=jobTracker.unregisterTrackableJob(jobId);
      jobTracker.unregisterMapCombineTask(jobId);
      jobTracker.unregisterReducerTask(jobId);
      mapReduceService.destroyJobSupervisor(this);
      future.setResult(mergedResults);
    }
  }
}

Fixed version (ground truth):
public void checkFullyProcessed(JobProcessInformation processInformation){
  if (isOwnerNode()) {
    JobPartitionState[] partitionStates=processInformation.getPartitionStates();
    for (    JobPartitionState partitionState : partitionStates) {
      if (partitionState == null || partitionState.getState() != JobPartitionState.State.PROCESSED) {
        return;
      }
    }
    String name=configuration.getName();
    String jobId=configuration.getJobId();
    NodeEngine nodeEngine=configuration.getNodeEngine();
    GetResultOperationFactory operationFactory=new GetResultOperationFactory(name,jobId);
    try {
      List<Map> results=MapReduceUtil.executeOperation(operationFactory,mapReduceService,nodeEngine,true);
      boolean reducedResult=configuration.getReducerFactory() != null;
      if (results != null) {
        Map<Object,Object> mergedResults=new HashMap<Object,Object>();
        for (        Map<?,?> map : results) {
          for (          Map.Entry entry : map.entrySet()) {
            collectResults(reducedResult,mergedResults,entry);
          }
        }
        TrackableJobFuture future=jobTracker.unregisterTrackableJob(jobId);
        jobTracker.unregisterMapCombineTask(jobId);
        jobTracker.unregisterReducerTask(jobId);
        mapReduceService.destroyJobSupervisor(this);
        future.setResult(mergedResults);
      }
    }
 catch (    Exception e) {
      TrackableJobFuture future=jobTracker.unregisterTrackableJob(jobId);
      jobTracker.unregisterMapCombineTask(jobId);
      jobTracker.unregisterReducerTask(jobId);
      mapReduceService.destroyJobSupervisor(this);
      future.setResult(e);
    }
  }
}
Program: 48160
Project: 48160
Buggy source:
@Override public void setResult(Object result){
  Object finalResult=result;
  if (collator != null) {
    finalResult=collator.collate(((Map)finalResult).entrySet());
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}

Fixed version (ground truth):
@Override public void setResult(Object result){
  Object finalResult=result;
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    if (!(finalResult instanceof CancellationException)) {
      finalResult=new ExecutionException((Throwable)finalResult);
    }
    super.setResult(finalResult);
    latch.countDown();
    return;
  }
  if (collator != null) {
    try {
      finalResult=collator.collate(((Map)finalResult).entrySet());
    }
 catch (    Exception e) {
      finalResult=e;
    }
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}
Program: 48161
Project: 48161
Buggy source:
@Override public void setResult(Object result){
  if (result instanceof Throwable && !(result instanceof CancellationException)) {
    if (!(result instanceof CancellationException)) {
      result=new ExecutionException((Throwable)result);
    }
    super.setResult(result);
    latch.countDown();
    return;
  }
  Object finalResult=result;
  if (collator != null) {
    try {
      finalResult=collator.collate(((Map)finalResult).entrySet());
    }
 catch (    Exception e) {
      finalResult=e;
    }
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}

Fixed version (ground truth):
@Override public void setResult(Object result){
  Object finalResult=result;
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    if (!(finalResult instanceof CancellationException)) {
      finalResult=new ExecutionException((Throwable)finalResult);
    }
    super.setResult(finalResult);
    latch.countDown();
    return;
  }
  if (collator != null) {
    try {
      finalResult=collator.collate(((Map)finalResult).entrySet());
    }
 catch (    Exception e) {
      finalResult=e;
    }
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}
Program: 48166
Project: 48166
Buggy source:
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new PostPonePartitionProcessing();
}

Fixed version (ground truth):
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new HashMapAdapter();
}
Program: 48167
Project: 48167
Buggy source:
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  Map<KeyIn,Chunk> chunkMap=new HashMap<KeyIn,Chunk>(combiners.size());
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    chunkMap.put(entry.getKey(),chunk);
  }
  COLLECTED_UPDATER.set(this,0);
  return chunkMap;
}

Fixed version (ground truth):
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  int mapSize=MapReduceUtil.mapSize(combiners.size());
  Map<KeyIn,Chunk> chunkMap=new HashMapAdapter<KeyIn,Chunk>(mapSize);
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    chunkMap.put(entry.getKey(),chunk);
  }
  COLLECTED_UPDATER.set(this,0);
  return chunkMap;
}
Program: 48168
Project: 48168
Buggy source:
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapsize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMap<Object,Object>(mapsize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}

Fixed version (ground truth):
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapSize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMapAdapter<Object,Object>(mapSize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}
Program: 48169
Project: 48169
Buggy source:
public void putRecord(Data key,Record record){
  records.put(key,record);
}

Fixed version (ground truth):
public Record putRecord(Data key,Record record){
  return records.put(key,record);
}
Program: 48170
Project: 48170
Buggy source:
void putRecord(Data key,Record record);

Fixed version (ground truth):
Record putRecord(Data key,Record record);
Program: 48171
Project: 48171
Buggy source:
private void updateSizeEstimator(Record record,RecordStore recordStore){
  final long cost=recordStore.getSizeEstimator().getCost(record);
  recordStore.getSizeEstimator().add(cost);
}

Fixed version (ground truth):
private void updateSizeEstimator(long recordSize,SizeEstimator sizeEstimator){
  sizeEstimator.add(recordSize);
}
Program: 48172
Project: 48172
Buggy source:
public void run(){
  MapService mapService=getService();
  if (data != null) {
    for (    Entry<String,Set<RecordReplicationInfo>> dataEntry : data.entrySet()) {
      Set<RecordReplicationInfo> recordReplicationInfos=dataEntry.getValue();
      final String mapName=dataEntry.getKey();
      RecordStore recordStore=mapService.getRecordStore(getPartitionId(),mapName);
      for (      RecordReplicationInfo recordReplicationInfo : recordReplicationInfos) {
        Data key=recordReplicationInfo.getKey();
        Record newRecord=mapService.createRecord(mapName,key,recordReplicationInfo.getValue(),-1,false);
        mapService.applyRecordInfo(newRecord,mapName,recordReplicationInfo);
        recordStore.putRecord(key,newRecord);
        updateSizeEstimator(newRecord,recordStore);
      }
    }
  }
  if (mapInitialLoadInfo != null) {
    for (    String mapName : mapInitialLoadInfo.keySet()) {
      RecordStore recordStore=mapService.getRecordStore(getPartitionId(),mapName);
      recordStore.setLoaded(mapInitialLoadInfo.get(mapName));
    }
  }
}

Fixed version (ground truth):
public void run(){
  MapService mapService=getService();
  if (data != null) {
    for (    Entry<String,Set<RecordReplicationInfo>> dataEntry : data.entrySet()) {
      Set<RecordReplicationInfo> recordReplicationInfos=dataEntry.getValue();
      final String mapName=dataEntry.getKey();
      RecordStore recordStore=mapService.getRecordStore(getPartitionId(),mapName);
      for (      RecordReplicationInfo recordReplicationInfo : recordReplicationInfos) {
        Data key=recordReplicationInfo.getKey();
        Record newRecord=mapService.createRecord(mapName,key,recordReplicationInfo.getValue(),-1,false);
        mapService.applyRecordInfo(newRecord,mapName,recordReplicationInfo);
        final Record existingRecord=recordStore.putRecord(key,newRecord);
        final SizeEstimator sizeEstimator=recordStore.getSizeEstimator();
        updateSizeEstimator(-calculateRecordSize(existingRecord,sizeEstimator),sizeEstimator);
        updateSizeEstimator(calculateRecordSize(newRecord,sizeEstimator),sizeEstimator);
      }
    }
  }
  if (mapInitialLoadInfo != null) {
    for (    String mapName : mapInitialLoadInfo.keySet()) {
      RecordStore recordStore=mapService.getRecordStore(getPartitionId(),mapName);
      recordStore.setLoaded(mapInitialLoadInfo.get(mapName));
    }
  }
}
Program: 48173
Project: 48173
Buggy source:
public void putForReplication(Data key,Record record){
  records.put(key,record);
  updateSizeEstimator(calculateRecordSize(record));
  removeFromWriteBehindWaitingDeletions(key);
}

Fixed version (ground truth):
public void putForReplication(Data key,Record record){
  final Record existingRecord=records.get(key);
  updateSizeEstimator(-calculateRecordSize(existingRecord));
  records.put(key,record);
  updateSizeEstimator(calculateRecordSize(record));
  removeFromWriteBehindWaitingDeletions(key);
}
Program: 48175
Project: 48175
Buggy source:
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new PostPonePartitionProcessing();
}

Fixed version (ground truth):
@Override public IdentifiedDataSerializable createNew(Integer arg){
  return new HashMapAdapter();
}
Program: 48176
Project: 48176
Buggy source:
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  Map<KeyIn,Chunk> chunkMap=new HashMap<KeyIn,Chunk>(combiners.size());
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    chunkMap.put(entry.getKey(),chunk);
  }
  collected.set(0);
  return chunkMap;
}

Fixed version (ground truth):
public <Chunk>Map<KeyIn,Chunk> requestChunk(){
  int mapSize=MapReduceUtil.mapSize(combiners.size());
  Map<KeyIn,Chunk> chunkMap=new HashMapAdapter<KeyIn,Chunk>(mapSize);
  for (  Map.Entry<KeyIn,Combiner<KeyIn,ValueIn,?>> entry : combiners.entrySet()) {
    Chunk chunk=(Chunk)entry.getValue().finalizeChunk();
    chunkMap.put(entry.getKey(),chunk);
  }
  collected.set(0);
  return chunkMap;
}
Program: 48177
Project: 48177
Buggy source:
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapsize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMap<Object,Object>(mapsize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}

Fixed version (ground truth):
public Map<Object,Object> getJobResults(){
  Map<Object,Object> result;
  if (configuration.getReducerFactory() != null) {
    int mapSize=MapReduceUtil.mapSize(reducers.size());
    result=new HashMapAdapter<Object,Object>(mapSize);
    for (    Map.Entry<Object,Reducer> entry : reducers.entrySet()) {
      result.put(entry.getKey(),entry.getValue().finalizeReduce());
    }
  }
 else {
    DefaultContext currentContext=context.get();
    result=currentContext.finish();
  }
  return result;
}
Program: 48178
Project: 48178
Buggy source:
@Override public void setResult(Object result){
  if (result instanceof Throwable && !(result instanceof CancellationException)) {
    if (!(result instanceof CancellationException)) {
      result=new ExecutionException((Throwable)result);
    }
    super.setResult(result);
    latch.countDown();
    return;
  }
  Object finalResult=result;
  if (collator != null) {
    try {
      finalResult=collator.collate(((Map)finalResult).entrySet());
    }
 catch (    Exception e) {
      finalResult=e;
    }
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}

Fixed version (ground truth):
@Override public void setResult(Object result){
  Object finalResult=result;
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    if (!(finalResult instanceof CancellationException)) {
      finalResult=new ExecutionException((Throwable)finalResult);
    }
    super.setResult(finalResult);
    latch.countDown();
    return;
  }
  if (collator != null) {
    try {
      finalResult=collator.collate(((Map)finalResult).entrySet());
    }
 catch (    Exception e) {
      finalResult=e;
    }
  }
  if (finalResult instanceof Throwable && !(finalResult instanceof CancellationException)) {
    finalResult=new ExecutionException((Throwable)finalResult);
  }
  super.setResult(finalResult);
  latch.countDown();
}
Program: 48179
Project: 48179
Buggy source:
Integer getClassVersion(int factoryId,int classId);

Fixed version (ground truth):
int getClassVersion(int factoryId,int classId);
Program: 48180
Project: 48180
Buggy source:
static void compress(byte[] input,DataOutput out) throws IOException {
  Deflater deflater=new Deflater();
  deflater.setLevel(Deflater.DEFAULT_COMPRESSION);
  deflater.setStrategy(Deflater.FILTERED);
  deflater.setInput(input);
  deflater.finish();
  byte[] buf=new byte[1024];
  while (!deflater.finished()) {
    int count=deflater.deflate(buf);
    out.write(buf,0,count);
  }
  deflater.end();
}

Fixed version (ground truth):
static void compress(byte[] input,DataOutput out) throws IOException {
  Deflater deflater=new Deflater();
  deflater.setLevel(Deflater.DEFAULT_COMPRESSION);
  deflater.setStrategy(Deflater.FILTERED);
  deflater.setInput(input);
  deflater.finish();
  byte[] buf=new byte[COMPRESSION_BUFFER_LENGTH];
  while (!deflater.finished()) {
    int count=deflater.deflate(buf);
    out.write(buf,0,count);
  }
  deflater.end();
}
Program: 48181
Project: 48181
Buggy source:
Integer getClassVersion(int classId){
  return currentClassVersions.get(classId);
}

Fixed version (ground truth):
int getClassVersion(int classId){
  Integer version=currentClassVersions.get(classId);
  return version != null ? version : -1;
}
Program: 48182
Project: 48182
Buggy source:
void setClassVersion(int classId,int version){
  Integer current;
  if ((current=currentClassVersions.putIfAbsent(classId,version)) != null) {
    if (current != version) {
      throw new IllegalArgumentException("String_Node_Str" + classId + "String_Node_Str");
    }
  }
}

Fixed version (ground truth):
void setClassVersion(int classId,int version){
  Integer current=currentClassVersions.putIfAbsent(classId,version);
  if (current != null && current != version) {
    throw new IllegalArgumentException("String_Node_Str" + classId + "String_Node_Str");
  }
}
Program: 48183
Project: 48183
Buggy source:
static void decompress(byte[] compressedData,DataOutput out) throws IOException {
  Inflater inflater=new Inflater();
  inflater.setInput(compressedData);
  byte[] buf=new byte[1024];
  while (!inflater.finished()) {
    try {
      int count=inflater.inflate(buf);
      out.write(buf,0,count);
    }
 catch (    DataFormatException e) {
      throw new IOException(e);
    }
  }
  inflater.end();
}

Fixed version (ground truth):
static void decompress(byte[] compressedData,DataOutput out) throws IOException {
  Inflater inflater=new Inflater();
  inflater.setInput(compressedData);
  byte[] buf=new byte[COMPRESSION_BUFFER_LENGTH];
  while (!inflater.finished()) {
    try {
      int count=inflater.inflate(buf);
      out.write(buf,0,count);
    }
 catch (    DataFormatException e) {
      throw new IOException(e);
    }
  }
  inflater.end();
}
Program: 48184
Project: 48184
Buggy source:
ClassDefinition create(byte[] compressedBinary) throws IOException {
  if (compressedBinary == null || compressedBinary.length == 0) {
    throw new IOException("String_Node_Str");
  }
  final BufferObjectDataOutput out=serializationService.pop();
  final byte[] binary;
  try {
    decompress(compressedBinary,out);
    binary=out.toByteArray();
  }
  finally {
    serializationService.push(out);
  }
  final ClassDefinitionImpl cd=new ClassDefinitionImpl();
  cd.readData(serializationService.createObjectDataInput(binary));
  if (cd.getVersion() < 0) {
    throw new IOException("String_Node_Str" + cd);
  }
  cd.setBinary(compressedBinary);
  return register(cd);
}

Fixed version (ground truth):
ClassDefinition create(byte[] compressedBinary) throws IOException {
  if (compressedBinary == null || compressedBinary.length == 0) {
    throw new IOException("String_Node_Str");
  }
  final byte[] binary=getClassDefBinary(compressedBinary);
  final ClassDefinitionImpl cd=new ClassDefinitionImpl();
  cd.readData(serializationService.createObjectDataInput(binary));
  if (cd.getVersion() < 0) {
    throw new IOException("String_Node_Str" + cd);
  }
  cd.setBinary(compressedBinary);
  return register(cd);
}
Program: 48185
Project: 48185
Buggy source:
ClassDefinition register(ClassDefinition cd){
  if (cd == null) {
    return null;
  }
  if (cd instanceof ClassDefinitionImpl) {
    final ClassDefinitionImpl cdImpl=(ClassDefinitionImpl)cd;
    if (cdImpl.getVersion() < 0) {
      cdImpl.version=getVersion();
    }
    if (cdImpl.getBinary() == null) {
      final BufferObjectDataOutput out=serializationService.pop();
      try {
        cdImpl.writeData(out);
        final byte[] binary=out.toByteArray();
        out.clear();
        compress(binary,out);
        cdImpl.setBinary(out.toByteArray());
      }
 catch (      IOException e) {
        throw new HazelcastSerializationException(e);
      }
 finally {
        serializationService.push(out);
      }
    }
    registerNestedDefinitions(cdImpl);
  }
  final long versionedClassId=combineToLong(cd.getClassId(),cd.getVersion());
  final ClassDefinition currentCd=versionedDefinitions.putIfAbsent(versionedClassId,cd);
  if (currentCd == null) {
    return cd;
  }
  if (currentCd instanceof ClassDefinitionImpl) {
    return currentCd;
  }
  versionedDefinitions.put(versionedClassId,cd);
  return cd;
}

Fixed version (ground truth):
ClassDefinition register(ClassDefinition cd){
  if (cd == null) {
    return null;
  }
  if (cd instanceof ClassDefinitionImpl) {
    final ClassDefinitionImpl cdImpl=(ClassDefinitionImpl)cd;
    if (cdImpl.getVersion() < 0) {
      cdImpl.version=getVersion();
    }
    setClassDefBinary(cdImpl);
    registerNestedDefinitions(cdImpl);
  }
  final long versionedClassId=combineToLong(cd.getClassId(),cd.getVersion());
  final ClassDefinition currentCd=versionedDefinitions.putIfAbsent(versionedClassId,cd);
  if (currentCd == null) {
    return cd;
  }
  if (currentCd instanceof ClassDefinitionImpl) {
    return currentCd;
  }
  versionedDefinitions.put(versionedClassId,cd);
  return cd;
}
Program: 48186
Project: 48186
Buggy source:
Portable read(ObjectDataInput in,int factoryId,int classId,int version) throws IOException {
  if (!(in instanceof BufferObjectDataInput)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final PortableFactory portableFactory=factories.get(factoryId);
  if (portableFactory == null) {
    throw new HazelcastSerializationException("String_Node_Str" + factoryId);
  }
  final Portable portable=portableFactory.create(classId);
  if (portable == null) {
    throw new HazelcastSerializationException("String_Node_Str" + classId);
  }
  final DefaultPortableReader reader;
  final ClassDefinition cd;
  final BufferObjectDataInput bufferedIn=(BufferObjectDataInput)in;
  Integer currentVersion=context.getClassVersion(factoryId,classId);
  if (currentVersion == null) {
    currentVersion=PortableVersionHelper.getVersion(portable,context.getVersion());
    if (currentVersion > 0) {
      context.setClassVersion(factoryId,classId,currentVersion);
    }
  }
  if (version < 0) {
    version=context.getVersion();
  }
  cd=context.lookup(factoryId,classId,version);
  if (cd == null) {
    throw new HazelcastSerializationException("String_Node_Str" + "String_Node_Str" + factoryId + "String_Node_Str"+ classId+ "String_Node_Str"+ version);
  }
  if (currentVersion == version) {
    reader=new DefaultPortableReader(this,bufferedIn,cd);
  }
 else {
    reader=new MorphingPortableReader(this,bufferedIn,cd);
  }
  portable.readPortable(reader);
  reader.end();
  return portable;
}

Fixed version (ground truth):
Portable read(ObjectDataInput in,int factoryId,int classId,int version) throws IOException {
  if (!(in instanceof BufferObjectDataInput)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final PortableFactory portableFactory=factories.get(factoryId);
  if (portableFactory == null) {
    throw new HazelcastSerializationException("String_Node_Str" + factoryId);
  }
  final Portable portable=portableFactory.create(classId);
  if (portable == null) {
    throw new HazelcastSerializationException("String_Node_Str" + classId);
  }
  final DefaultPortableReader reader;
  final ClassDefinition cd;
  final BufferObjectDataInput bufferedIn=(BufferObjectDataInput)in;
  int effectiveVersion=version;
  if (version < 0) {
    effectiveVersion=context.getVersion();
  }
  int currentVersion=context.getClassVersion(factoryId,classId);
  if (currentVersion < 0) {
    currentVersion=PortableVersionHelper.getVersion(portable,context.getVersion());
    if (currentVersion > 0) {
      context.setClassVersion(factoryId,classId,currentVersion);
    }
  }
  cd=context.lookup(factoryId,classId,effectiveVersion);
  if (cd == null) {
    throw new HazelcastSerializationException("String_Node_Str" + "String_Node_Str" + factoryId + "String_Node_Str"+ classId+ "String_Node_Str"+ effectiveVersion);
  }
  if (currentVersion == effectiveVersion) {
    reader=new DefaultPortableReader(this,bufferedIn,cd);
  }
 else {
    reader=new MorphingPortableReader(this,bufferedIn,cd);
  }
  portable.readPortable(reader);
  reader.end();
  return portable;
}
Program: 48187
Project: 48187
Buggy source:
private ClassDefinition lookupClassDefinition(Portable portable){
  final int version=PortableVersionHelper.getVersion(portable,serializationContext.version);
  return serializationContext.lookup(portable.getFactoryId(),portable.getClassId(),version);
}

Fixed version (ground truth):
private ClassDefinition lookupClassDefinition(Portable portable){
  final int version=PortableVersionHelper.getVersion(portable,serializationContext.getVersion());
  return serializationContext.lookup(portable.getFactoryId(),portable.getClassId(),version);
}
Program: 48188
Project: 48188
Buggy source:
protected final ClientContext getContext(){
  final ClientContext ctx=context;
  if (ctx == null) {
    throw new HazelcastInstanceNotActiveException();
  }
  return context;
}

Fixed version (ground truth):
protected final ClientContext getContext(){
  final ClientContext ctx=context;
  if (ctx == null) {
    throw new HazelcastInstanceNotActiveException();
  }
  return ctx;
}
Program: 48189
Project: 48189
Buggy source:
protected final ClientContext getContext(){
  final ClientContext ctx=context;
  if (ctx == null) {
    throw new HazelcastInstanceNotActiveException();
  }
  return context;
}

Fixed version (ground truth):
protected final ClientContext getContext(){
  final ClientContext ctx=context;
  if (ctx == null) {
    throw new HazelcastInstanceNotActiveException();
  }
  return ctx;
}
Program: 48190
Project: 48190
Buggy source:
public MultiReplicationMessage(String name,ReplicationMessage[] replicationMessages){
  this.name=name;
  this.replicationMessages=replicationMessages;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public MultiReplicationMessage(String name,ReplicationMessage[] replicationMessages){
  this.name=name;
  this.replicationMessages=replicationMessages;
}
Program: 48191
Project: 48191
Buggy source:
public ReplicationMessage[] getReplicationMessages(){
  return replicationMessages;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public ReplicationMessage[] getReplicationMessages(){
  return replicationMessages;
}
Program: 48192
Project: 48192
Buggy source:
public ReplicatedMapInitChunkOperation(String name,Member origin,ReplicatedRecord[] replicatedRecords,int recordCount,boolean finalChunk){
  this.name=name;
  this.origin=origin;
  this.replicatedRecords=replicatedRecords;
  this.recordCount=recordCount;
  this.finalChunk=finalChunk;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public ReplicatedMapInitChunkOperation(String name,Member origin,ReplicatedRecord[] replicatedRecords,int recordCount,boolean finalChunk){
  this.name=name;
  this.origin=origin;
  this.replicatedRecords=replicatedRecords;
  this.recordCount=recordCount;
  this.finalChunk=finalChunk;
}