nus-yam/ex-repair huggingface dataset:
Program: 87886
Project: 87886
Buggy source:
/** 
 * Attempts to find the responsible type of   {@link InputSplitAssigner} for the given type of input split from theconfiguration and instantiate an object for it.
 * @param inputSplitType the type of input split to load the  {@link InputSplitAssigner} for
 * @return the newly loaded {@link InputSplitAssigner} object or <code>null</code> if no such object could belocated or loaded
 */
private InputSplitAssigner loadInputSplitAssigner(final Class<? extends InputSplit> inputSplitType){
  final String typeClassName=inputSplitType.getSimpleName();
  final String assignerKey=INPUT_SPLIT_CONFIG_KEY_PREFIX + typeClassName;
  LOG.info("String_Node_Str" + typeClassName);
  String assignerClassName=GlobalConfiguration.getString(assignerKey,null);
  if (assignerClassName == null) {
    if (FileInputSplit.class.getSimpleName().equals(typeClassName)) {
      assignerClassName=FileInputSplitAssigner.class.getName();
    }
 else {
      return null;
    }
  }
  try {
    @SuppressWarnings("String_Node_Str") final Class<? extends InputSplitAssigner> assignerClass=(Class<? extends InputSplitAssigner>)Class.forName(assignerClassName);
    return assignerClass.newInstance();
  }
 catch (  Exception e) {
    LOG.error(StringUtils.stringifyException(e));
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Attempts to find the responsible type of   {@link InputSplitAssigner} for the given type of input split from theconfiguration and instantiate an object for it.
 * @param inputSplitType the type of input split to load the  {@link InputSplitAssigner} for
 * @return the newly loaded {@link InputSplitAssigner} object or <code>null</code> if no such object could belocated or loaded
 */
@SuppressWarnings("String_Node_Str") private InputSplitAssigner loadInputSplitAssigner(final Class<? extends InputSplit> inputSplitType,JobID jid){
  final String typeClassName=inputSplitType.getSimpleName();
  final String assignerKey=INPUT_SPLIT_CONFIG_KEY_PREFIX + typeClassName;
  LOG.info("String_Node_Str" + typeClassName);
  String assignerClassName=GlobalConfiguration.getString(assignerKey,null);
  if (assignerClassName == null) {
    if (FileInputSplit.class.getSimpleName().equals(typeClassName)) {
      assignerClassName=FileInputSplitAssigner.class.getName();
    }
 else {
      return null;
    }
  }
  try {
    Class<? extends InputSplitAssigner> assignerClass;
    boolean useUserJar=GlobalConfiguration.getBoolean(INPUT_SPLIT_CONFIG_KEY_PREFIX + "String_Node_Str",false);
    if (useUserJar) {
      final ClassLoader cl=LibraryCacheManager.getClassLoader(jid);
      assignerClass=(Class<? extends InputSplitAssigner>)Class.forName(assignerClassName,true,cl);
    }
 else {
      assignerClass=(Class<? extends InputSplitAssigner>)Class.forName(assignerClassName);
    }
    return assignerClass.newInstance();
  }
 catch (  Exception e) {
    LOG.error(StringUtils.stringifyException(e));
  }
  return null;
}
Program: 87887
Project: 87887
Buggy source:
/** 
 * Returns the   {@link InputSplitAssigner} which is defined for the given type of input split.
 * @param inputSplitType the type of input split to find the corresponding  {@link InputSplitAssigner} for
 * @param allowLoading <code>true</code> to indicate that the input split assigner is allowed to load additional classes if necessary, <code>false</code> otherwise
 * @return the {@link InputSplitAssigner} responsible for the given type of input split
 */
private InputSplitAssigner getAssignerByType(final Class<? extends InputSplit> inputSplitType,final boolean allowLoading){
synchronized (this.loadedAssigners) {
    InputSplitAssigner assigner=this.loadedAssigners.get(inputSplitType);
    if (assigner == null && allowLoading) {
      assigner=loadInputSplitAssigner(inputSplitType);
      if (assigner != null) {
        this.loadedAssigners.put(inputSplitType,assigner);
      }
    }
    if (assigner != null) {
      return assigner;
    }
  }
  LOG.warn("String_Node_Str" + inputSplitType.getName() + "String_Node_Str");
  return this.defaultAssigner;
}

Fixed version (ground truth):
/** 
 * Returns the   {@link InputSplitAssigner} which is defined for the given type of input split.
 * @param inputSplitType the type of input split to find the corresponding  {@link InputSplitAssigner} for
 * @param allowLoading <code>true</code> to indicate that the input split assigner is allowed to load additional classes if necessary, <code>false</code> otherwise
 * @return the {@link InputSplitAssigner} responsible for the given type of input split
 */
private InputSplitAssigner getAssignerByType(final Class<? extends InputSplit> inputSplitType,final boolean allowLoading,JobID jid){
synchronized (this.loadedAssigners) {
    InputSplitAssigner assigner=this.loadedAssigners.get(inputSplitType);
    if (assigner == null && allowLoading) {
      assigner=loadInputSplitAssigner(inputSplitType,jid);
      if (assigner != null) {
        this.loadedAssigners.put(inputSplitType,assigner);
      }
    }
    if (assigner != null) {
      return assigner;
    }
  }
  LOG.warn("String_Node_Str" + inputSplitType.getName() + "String_Node_Str");
  return this.defaultAssigner;
}
Program: 87888
Project: 87888
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void accept(Visitor<Contract> visitor){
  boolean descend=visitor.preVisit(this);
  if (descend) {
    if (visitor.preVisit(this)) {
      for (      Contract c : this.input1) {
        c.accept(visitor);
      }
      for (      Contract c : this.input2) {
        c.accept(visitor);
      }
    }
    visitor.postVisit(this);
  }
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void accept(Visitor<Contract> visitor){
  boolean descend=visitor.preVisit(this);
  if (descend) {
    for (    Contract c : this.input1) {
      c.accept(visitor);
    }
    for (    Contract c : this.input2) {
      c.accept(visitor);
    }
    visitor.postVisit(this);
  }
}
Program: 87889
Project: 87889
Buggy source:
/** 
 * Retrieves the index of the <tt>BlockLocation</tt> that contains the part of the file described by the given offset.
 * @param blocks The different blocks of the file. Must be ordered by their offset.
 * @param offset The offset of the position in the file.
 * @param startIndex The earliest index to look at.
 * @return The index of the block containing the given position.
 */
private final int getBlockIndexForPosition(BlockLocation[] blocks,long offset,long halfSplitSize,int startIndex){
  for (int i=startIndex; i < blocks.length; i++) {
    long blockStart=blocks[i].getOffset();
    long blockEnd=blockStart + blocks[i].getLength();
    if (offset >= blockStart && offset < blockEnd) {
      if (i < blocks.length - 1 && blockEnd - offset < halfSplitSize) {
        return i + 1;
      }
 else {
        return i;
      }
    }
  }
  throw new IllegalArgumentException("String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Retrieves the index of the <tt>BlockLocation</tt> that contains the part of the file described by the given offset.
 * @param blocks The different blocks of the file. Must be ordered by their offset.
 * @param offset The offset of the position in the file.
 * @param startIndex The earliest index to look at.
 * @return The index of the block containing the given position.
 */
protected final int getBlockIndexForPosition(BlockLocation[] blocks,long offset,long halfSplitSize,int startIndex){
  for (int i=startIndex; i < blocks.length; i++) {
    long blockStart=blocks[i].getOffset();
    long blockEnd=blockStart + blocks[i].getLength();
    if (offset >= blockStart && offset < blockEnd) {
      if (i < blocks.length - 1 && blockEnd - offset < halfSplitSize) {
        return i + 1;
      }
 else {
        return i;
      }
    }
  }
  throw new IllegalArgumentException("String_Node_Str");
}
Program: 87890
Project: 87890
Buggy source:
/** 
 * Opens an input stream to the file defined in the input format. The stream is positioned at the beginning of the given split. <p> The stream is actually opened in an asynchronous thread to make sure any interruptions to the thread  working on the input format do not reach the file system.
 * @see eu.stratosphere.pact.common.io.InputFormat#open(eu.stratosphere.nephele.template.InputSplit)
 */
@Override public void open(FileInputSplit split) throws IOException {
  if (!(split instanceof FileInputSplit)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final FileInputSplit fileSplit=(FileInputSplit)split;
  this.start=fileSplit.getStart();
  this.length=fileSplit.getLength();
  if (LOG.isDebugEnabled())   LOG.debug("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str");
  final InputSplitOpenThread isot=new InputSplitOpenThread(fileSplit,OPEN_TIMEOUT_MILLIES);
  isot.start();
  try {
    isot.waitForCompletion();
  }
 catch (  Throwable t) {
    throw new IOException("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str"+ t.getMessage(),t);
  }
  this.stream=isot.getFSDataInputStream();
  this.stream.seek(this.start);
}

Fixed version (ground truth):
/** 
 * Opens an input stream to the file defined in the input format. The stream is positioned at the beginning of the given split. <p> The stream is actually opened in an asynchronous thread to make sure any interruptions to the thread  working on the input format do not reach the file system.
 * @see eu.stratosphere.pact.common.io.InputFormat#open(eu.stratosphere.nephele.template.InputSplit)
 */
@Override public void open(FileInputSplit split) throws IOException {
  if (!(split instanceof FileInputSplit)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final FileInputSplit fileSplit=(FileInputSplit)split;
  fileNumber=Integer.parseInt(split.getPath().getName());
  this.start=fileSplit.getStart();
  this.length=fileSplit.getLength();
  if (LOG.isDebugEnabled())   LOG.debug("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str");
  final InputSplitOpenThread isot=new InputSplitOpenThread(fileSplit,OPEN_TIMEOUT_MILLIES);
  isot.start();
  try {
    isot.waitForCompletion();
  }
 catch (  Throwable t) {
    throw new IOException("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str"+ t.getMessage(),t);
  }
  this.stream=isot.getFSDataInputStream();
  this.stream.seek(this.start);
}
Program: 87891
Project: 87891
Buggy source:
/** 
 * Registers a new job represented by its   {@link ExecutionGraph} with the input split manager.
 * @param executionGraph the job to be registered
 */
public void registerJob(final ExecutionGraph executionGraph){
  final Iterator<ExecutionGroupVertex> it=new ExecutionGroupVertexIterator(executionGraph,true,-1);
  while (it.hasNext()) {
    final ExecutionGroupVertex groupVertex=it.next();
    final InputSplit[] inputSplits=groupVertex.getInputSplits();
    if (inputSplits == null) {
      continue;
    }
    if (inputSplits.length == 0) {
      continue;
    }
    final AbstractInvokable invokable=groupVertex.getGroupMember(0).getEnvironment().getInvokable();
    if (!(invokable instanceof AbstractInputTask)) {
      LOG.error(groupVertex.getName() + "String_Node_Str" + inputSplits.length+ "String_Node_Str");
      continue;
    }
    @SuppressWarnings("String_Node_Str") final AbstractInputTask<? extends InputSplit> inputTask=(AbstractInputTask<? extends InputSplit>)invokable;
    final Class<? extends InputSplit> splitType=inputTask.getInputSplitType();
    final InputSplitAssigner assigner=getAssignerByType(splitType,true,executionGraph.getJobID());
    this.assignerCache.put(groupVertex,assigner);
    assigner.registerGroupVertex(groupVertex);
  }
}

Fixed version (ground truth):
/** 
 * Registers a new job represented by its   {@link ExecutionGraph} with the input split manager.
 * @param executionGraph the job to be registered
 */
public void registerJob(final ExecutionGraph executionGraph){
  final Iterator<ExecutionGroupVertex> it=new ExecutionGroupVertexIterator(executionGraph,true,-1);
  while (it.hasNext()) {
    final ExecutionGroupVertex groupVertex=it.next();
    final InputSplit[] inputSplits=groupVertex.getInputSplits();
    if (inputSplits == null) {
      continue;
    }
    if (inputSplits.length == 0) {
      continue;
    }
    final AbstractInvokable invokable=groupVertex.getGroupMember(0).getEnvironment().getInvokable();
    if (!(invokable instanceof AbstractInputTask)) {
      LOG.error(groupVertex.getName() + "String_Node_Str" + inputSplits.length+ "String_Node_Str");
      continue;
    }
    @SuppressWarnings("String_Node_Str") final AbstractInputTask<? extends InputSplit> inputTask=(AbstractInputTask<? extends InputSplit>)invokable;
    final Class<? extends InputSplit> splitType=inputTask.getInputSplitType();
    final InputSplitAssigner assigner=getAssignerByType(splitType,true);
    this.assignerCache.put(groupVertex,assigner);
    assigner.registerGroupVertex(groupVertex);
  }
}
Program: 87892
Project: 87892
Buggy source:
/** 
 * Attempts to find the responsible type of   {@link InputSplitAssigner} for the given type of input split from theconfiguration and instantiate an object for it.
 * @param inputSplitType the type of input split to load the  {@link InputSplitAssigner} for
 * @return the newly loaded {@link InputSplitAssigner} object or <code>null</code> if no such object could belocated or loaded
 */
@SuppressWarnings("String_Node_Str") private InputSplitAssigner loadInputSplitAssigner(final Class<? extends InputSplit> inputSplitType,JobID jid){
  final String typeClassName=inputSplitType.getSimpleName();
  final String assignerKey=INPUT_SPLIT_CONFIG_KEY_PREFIX + typeClassName;
  LOG.info("String_Node_Str" + typeClassName);
  String assignerClassName=GlobalConfiguration.getString(assignerKey,null);
  if (assignerClassName == null) {
    if (FileInputSplit.class.getSimpleName().equals(typeClassName)) {
      assignerClassName=FileInputSplitAssigner.class.getName();
    }
 else {
      return null;
    }
  }
  try {
    Class<? extends InputSplitAssigner> assignerClass;
    boolean useUserJar=GlobalConfiguration.getBoolean(INPUT_SPLIT_CONFIG_KEY_PREFIX + "String_Node_Str",false);
    if (useUserJar) {
      final ClassLoader cl=LibraryCacheManager.getClassLoader(jid);
      assignerClass=(Class<? extends InputSplitAssigner>)Class.forName(assignerClassName,true,cl);
    }
 else {
      assignerClass=(Class<? extends InputSplitAssigner>)Class.forName(assignerClassName);
    }
    return assignerClass.newInstance();
  }
 catch (  Exception e) {
    LOG.error(StringUtils.stringifyException(e));
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Attempts to find the responsible type of   {@link InputSplitAssigner} for the given type of input split from theconfiguration and instantiate an object for it.
 * @param inputSplitType the type of input split to load the  {@link InputSplitAssigner} for
 * @return the newly loaded {@link InputSplitAssigner} object or <code>null</code> if no such object could belocated or loaded
 */
private InputSplitAssigner loadInputSplitAssigner(final Class<? extends InputSplit> inputSplitType){
  final String typeClassName=inputSplitType.getSimpleName();
  final String assignerKey=INPUT_SPLIT_CONFIG_KEY_PREFIX + typeClassName;
  LOG.info("String_Node_Str" + typeClassName);
  String assignerClassName=GlobalConfiguration.getString(assignerKey,null);
  if (assignerClassName == null) {
    if (FileInputSplit.class.getSimpleName().equals(typeClassName)) {
      assignerClassName=FileInputSplitAssigner.class.getName();
    }
 else {
      return null;
    }
  }
  try {
    @SuppressWarnings("String_Node_Str") final Class<? extends InputSplitAssigner> assignerClass=(Class<? extends InputSplitAssigner>)Class.forName(assignerClassName);
    return assignerClass.newInstance();
  }
 catch (  Exception e) {
    LOG.error(StringUtils.stringifyException(e));
  }
  return null;
}
Program: 87893
Project: 87893
Buggy source:
/** 
 * Returns the   {@link InputSplitAssigner} which is defined for the given type of input split.
 * @param inputSplitType the type of input split to find the corresponding  {@link InputSplitAssigner} for
 * @param allowLoading <code>true</code> to indicate that the input split assigner is allowed to load additional classes if necessary, <code>false</code> otherwise
 * @return the {@link InputSplitAssigner} responsible for the given type of input split
 */
private InputSplitAssigner getAssignerByType(final Class<? extends InputSplit> inputSplitType,final boolean allowLoading,JobID jid){
synchronized (this.loadedAssigners) {
    InputSplitAssigner assigner=this.loadedAssigners.get(inputSplitType);
    if (assigner == null && allowLoading) {
      assigner=loadInputSplitAssigner(inputSplitType,jid);
      if (assigner != null) {
        this.loadedAssigners.put(inputSplitType,assigner);
      }
    }
    if (assigner != null) {
      return assigner;
    }
  }
  LOG.warn("String_Node_Str" + inputSplitType.getName() + "String_Node_Str");
  return this.defaultAssigner;
}

Fixed version (ground truth):
/** 
 * Returns the   {@link InputSplitAssigner} which is defined for the given type of input split.
 * @param inputSplitType the type of input split to find the corresponding  {@link InputSplitAssigner} for
 * @param allowLoading <code>true</code> to indicate that the input split assigner is allowed to load additional classes if necessary, <code>false</code> otherwise
 * @return the {@link InputSplitAssigner} responsible for the given type of input split
 */
private InputSplitAssigner getAssignerByType(final Class<? extends InputSplit> inputSplitType,final boolean allowLoading){
synchronized (this.loadedAssigners) {
    InputSplitAssigner assigner=this.loadedAssigners.get(inputSplitType);
    if (assigner == null && allowLoading) {
      assigner=loadInputSplitAssigner(inputSplitType);
      if (assigner != null) {
        this.loadedAssigners.put(inputSplitType,assigner);
      }
    }
    if (assigner != null) {
      return assigner;
    }
  }
  LOG.warn("String_Node_Str" + inputSplitType.getName() + "String_Node_Str");
  return this.defaultAssigner;
}
Program: 87894
Project: 87894
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void accept(Visitor<Contract> visitor){
  boolean descend=visitor.preVisit(this);
  if (descend) {
    for (    Contract c : this.input1) {
      c.accept(visitor);
    }
    for (    Contract c : this.input2) {
      c.accept(visitor);
    }
    visitor.postVisit(this);
  }
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void accept(Visitor<Contract> visitor){
  boolean descend=visitor.preVisit(this);
  if (descend) {
    if (visitor.preVisit(this)) {
      for (      Contract c : this.input1) {
        c.accept(visitor);
      }
      for (      Contract c : this.input2) {
        c.accept(visitor);
      }
    }
    visitor.postVisit(this);
  }
}
Program: 87895
Project: 87895
Buggy source:
/** 
 * Retrieves the index of the <tt>BlockLocation</tt> that contains the part of the file described by the given offset.
 * @param blocks The different blocks of the file. Must be ordered by their offset.
 * @param offset The offset of the position in the file.
 * @param startIndex The earliest index to look at.
 * @return The index of the block containing the given position.
 */
protected final int getBlockIndexForPosition(BlockLocation[] blocks,long offset,long halfSplitSize,int startIndex){
  for (int i=startIndex; i < blocks.length; i++) {
    long blockStart=blocks[i].getOffset();
    long blockEnd=blockStart + blocks[i].getLength();
    if (offset >= blockStart && offset < blockEnd) {
      if (i < blocks.length - 1 && blockEnd - offset < halfSplitSize) {
        return i + 1;
      }
 else {
        return i;
      }
    }
  }
  throw new IllegalArgumentException("String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Retrieves the index of the <tt>BlockLocation</tt> that contains the part of the file described by the given offset.
 * @param blocks The different blocks of the file. Must be ordered by their offset.
 * @param offset The offset of the position in the file.
 * @param startIndex The earliest index to look at.
 * @return The index of the block containing the given position.
 */
private final int getBlockIndexForPosition(BlockLocation[] blocks,long offset,long halfSplitSize,int startIndex){
  for (int i=startIndex; i < blocks.length; i++) {
    long blockStart=blocks[i].getOffset();
    long blockEnd=blockStart + blocks[i].getLength();
    if (offset >= blockStart && offset < blockEnd) {
      if (i < blocks.length - 1 && blockEnd - offset < halfSplitSize) {
        return i + 1;
      }
 else {
        return i;
      }
    }
  }
  throw new IllegalArgumentException("String_Node_Str");
}
Program: 87896
Project: 87896
Buggy source:
/** 
 * Opens an input stream to the file defined in the input format. The stream is positioned at the beginning of the given split. <p> The stream is actually opened in an asynchronous thread to make sure any interruptions to the thread  working on the input format do not reach the file system.
 * @see eu.stratosphere.pact.common.io.InputFormat#open(eu.stratosphere.nephele.template.InputSplit)
 */
@Override public void open(FileInputSplit split) throws IOException {
  if (!(split instanceof FileInputSplit)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final FileInputSplit fileSplit=(FileInputSplit)split;
  fileNumber=Integer.parseInt(split.getPath().getName());
  this.start=fileSplit.getStart();
  this.length=fileSplit.getLength();
  if (LOG.isDebugEnabled())   LOG.debug("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str");
  final InputSplitOpenThread isot=new InputSplitOpenThread(fileSplit,OPEN_TIMEOUT_MILLIES);
  isot.start();
  try {
    isot.waitForCompletion();
  }
 catch (  Throwable t) {
    throw new IOException("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str"+ t.getMessage(),t);
  }
  this.stream=isot.getFSDataInputStream();
  this.stream.seek(this.start);
}

Fixed version (ground truth):
/** 
 * Opens an input stream to the file defined in the input format. The stream is positioned at the beginning of the given split. <p> The stream is actually opened in an asynchronous thread to make sure any interruptions to the thread  working on the input format do not reach the file system.
 * @see eu.stratosphere.pact.common.io.InputFormat#open(eu.stratosphere.nephele.template.InputSplit)
 */
@Override public void open(FileInputSplit split) throws IOException {
  if (!(split instanceof FileInputSplit)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final FileInputSplit fileSplit=(FileInputSplit)split;
  this.start=fileSplit.getStart();
  this.length=fileSplit.getLength();
  if (LOG.isDebugEnabled())   LOG.debug("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str");
  final InputSplitOpenThread isot=new InputSplitOpenThread(fileSplit,OPEN_TIMEOUT_MILLIES);
  isot.start();
  try {
    isot.waitForCompletion();
  }
 catch (  Throwable t) {
    throw new IOException("String_Node_Str" + fileSplit.getPath() + "String_Node_Str"+ start+ "String_Node_Str"+ length+ "String_Node_Str"+ t.getMessage(),t);
  }
  this.stream=isot.getFSDataInputStream();
  this.stream.seek(this.start);
}
Program: 87897
Project: 87897
Buggy source:
private void initBufferSizes(){
  int bufferSize=GlobalConfiguration.getInteger("String_Node_Str",GlobalBufferPool.DEFAULT_BUFFER_SIZE_IN_BYTES);
  long now=System.currentTimeMillis();
  for (  ProfilingPath path : profilingModel.getProfilingSubgraph().getProfilingPaths()) {
    for (    ManagementAttachment pathElement : path.getPathElements()) {
      if (pathElement instanceof ManagementEdge) {
        ManagementEdge edge=(ManagementEdge)pathElement;
        BufferSizeHistory bufferSizeHistory=new BufferSizeHistory(edge,2);
        bufferSizeHistory.addToHistory(now,bufferSize);
        bufferSizes.put(edge,bufferSizeHistory);
      }
    }
  }
}

Fixed version (ground truth):
private void initBufferSizes(){
  int bufferSize=GlobalConfiguration.getInteger("String_Node_Str",GlobalBufferPool.DEFAULT_BUFFER_SIZE_IN_BYTES);
  this.maximumBufferSize=bufferSize;
  long now=System.currentTimeMillis();
  for (  ProfilingPath path : profilingModel.getProfilingSubgraph().getProfilingPaths()) {
    for (    ManagementAttachment pathElement : path.getPathElements()) {
      if (pathElement instanceof ManagementEdge) {
        ManagementEdge edge=(ManagementEdge)pathElement;
        BufferSizeHistory bufferSizeHistory=new BufferSizeHistory(edge,2);
        bufferSizeHistory.addToHistory(now,bufferSize);
        bufferSizes.put(edge,bufferSizeHistory);
      }
    }
  }
}
Program: 87898
Project: 87898
Buggy source:
private void increaseBufferSize(ManagementEdge edge,HashMap<ManagementEdge,Integer> edgesToAdjust){
  int oldBufferSize=bufferSizes.get(edge).getLastEntry().getBufferSize();
  int newBufferSize=proposedIncreasedBufferSize(oldBufferSize);
  edgesToAdjust.put(edge,newBufferSize);
}

Fixed version (ground truth):
private void increaseBufferSize(ManagementEdge edge,HashMap<ManagementEdge,Integer> edgesToAdjust){
  int oldBufferSize=bufferSizes.get(edge).getLastEntry().getBufferSize();
  int newBufferSize=Math.min(proposedIncreasedBufferSize(oldBufferSize),this.maximumBufferSize);
  if (isRelevantIncrease(oldBufferSize,newBufferSize)) {
    edgesToAdjust.put(edge,newBufferSize);
  }
}
Program: 87899
Project: 87899
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void transferEvent(AbstractEvent event) throws IOException, InterruptedException {
  this.outputChannelBroker.transferEventToInputChannel(event);
  flush();
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void transferEvent(AbstractEvent event) throws IOException, InterruptedException {
  flush();
  this.outputChannelBroker.transferEventToInputChannel(event);
}
Program: 87900
Project: 87900
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void requestClose() throws IOException, InterruptedException {
  if (!this.closeRequested) {
    this.closeRequested=true;
    flush();
    transferEvent(new ByteBufferedChannelCloseEvent());
  }
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void requestClose() throws IOException, InterruptedException {
  if (!this.closeRequested) {
    this.closeRequested=true;
    transferEvent(new ByteBufferedChannelCloseEvent());
    flush();
  }
}
Program: 87902
Project: 87902
Buggy source:
@Override public void releaseConsumedReadBuffer(){
  TransferEnvelope transferEnvelope=null;
synchronized (this.queuedEnvelopes) {
    if (this.queuedEnvelopes.isEmpty()) {
      LOG.error("String_Node_Str");
      return;
    }
    transferEnvelope=this.queuedEnvelopes.poll();
    if (transferEnvelope.getBuffer() != null) {
      if (transferEnvelope.getBuffer().isBackedByMemory()) {
        --this.numberOfMemoryBuffers;
      }
 else {
        --this.numberOfFileBuffers;
      }
    }
  }
  final Buffer consumedBuffer=transferEnvelope.getBuffer();
  if (consumedBuffer == null) {
    LOG.error("String_Node_Str");
    return;
  }
  if (consumedBuffer.remaining() > 0) {
    LOG.error("String_Node_Str" + consumedBuffer.remaining() + "String_Node_Str");
  }
  consumedBuffer.recycleBuffer();
  if (this.uncompressedDataBuffer != null) {
    this.uncompressedDataBuffer.recycleBuffer();
    this.uncompressedDataBuffer=null;
  }
}

Fixed version (ground truth):
@Override public void releaseConsumedReadBuffer(){
  TransferEnvelope transferEnvelope=null;
synchronized (this.queuedEnvelopes) {
    if (this.queuedEnvelopes.isEmpty()) {
      LOG.error("String_Node_Str");
      return;
    }
    transferEnvelope=this.queuedEnvelopes.poll();
    if (transferEnvelope.getBuffer() != null) {
      if (transferEnvelope.getBuffer().isBackedByMemory()) {
        --this.numberOfMemoryBuffers;
      }
 else {
        --this.numberOfFileBuffers;
      }
    }
  }
  final EventList eventList=transferEnvelope.getEventList();
  if (!eventList.isEmpty()) {
    final Iterator<AbstractEvent> it=eventList.iterator();
    while (it.hasNext()) {
      this.byteBufferedInputChannel.processEvent(it.next());
    }
  }
  final Buffer consumedBuffer=transferEnvelope.getBuffer();
  if (consumedBuffer == null) {
    LOG.error("String_Node_Str");
    return;
  }
  if (consumedBuffer.remaining() > 0) {
    LOG.error("String_Node_Str" + consumedBuffer.remaining() + "String_Node_Str");
  }
  consumedBuffer.recycleBuffer();
  if (this.uncompressedDataBuffer != null) {
    this.uncompressedDataBuffer.recycleBuffer();
    this.uncompressedDataBuffer=null;
  }
}
Program: 87903
Project: 87903
Buggy source:
@Override public StringBuilder toString(StringBuilder sb){
  for (  final JsonNode row : this.getRows())   sb.append("String_Node_Str").append(row).append("String_Node_Str").append(this.get(row)).append("String_Node_Str");
  return sb.append("String_Node_Str");
}

Fixed version (ground truth):
@Override public StringBuilder toString(StringBuilder sb){
  for (  final JsonNode row : this.getRows())   sb.append("String_Node_Str").append(row).append("String_Node_Str").append(this.get(row)).append("String_Node_Str");
  return sb;
}
Program: 87904
Project: 87904
Buggy source:
@Override public SopremoModule asElementaryOperators(){
  final SopremoModule sopremoModule=new SopremoModule(this.getName(),2,1);
  JsonStream phase1=sopremoModule.getInput(0);
  JsonStream matrix=sopremoModule.getInput(1);
  final TransformDiagonal transDia=new TransformDiagonal().withInputs(phase1);
  final GenerateRows rows=new GenerateRows().withInputs(matrix);
  final ComputeBlockTuples computeRows=new ComputeBlockTuples().withInputs(transDia,rows);
  sopremoModule.getOutput(0).setInput(0,computeRows);
  return sopremoModule;
}

Fixed version (ground truth):
@Override public SopremoModule asElementaryOperators(){
  final SopremoModule sopremoModule=new SopremoModule(this.getName(),2,1);
  JsonStream phase1=sopremoModule.getInput(0);
  JsonStream matrix=sopremoModule.getInput(1);
  final TransformDiagonal transDia=new TransformDiagonal().withInputs(phase1);
  final GenerateRows rows=new GenerateRows().withInputs(matrix);
  final ComputeBlockTuples computeRows=new ComputeBlockTuples().withInputs(transDia,rows);
  final ExtractMirroredMatrix mirroredMatrix=new ExtractMirroredMatrix().withInputs(computeRows);
  final FillMatrix fillMatrix=new FillMatrix().withInputs(computeRows,mirroredMatrix);
  sopremoModule.getOutput(0).setInput(0,fillMatrix);
  return sopremoModule;
}
Program: 87905
Project: 87905
Buggy source:
@Override protected void map(JsonNode key,JsonNode value,JsonCollector out){
  ArrayNode castedKey=(ArrayNode)key;
  if (!castedKey.get(0).equals(castedKey.get(1))) {
    out.collect(castedKey.get(1),new ArrayNode(key,value));
  }
}

Fixed version (ground truth):
@Override protected void map(JsonNode key,JsonNode value,JsonCollector out){
  if (((ArrayNode)key).get(0).compareTo(((ArrayNode)key).get(1)) > 0) {
    out.collect(new ArrayNode(((ArrayNode)key).get(1),((ArrayNode)key).get(0)),value);
  }
}
Program: 87906
Project: 87906
Buggy source:
@Override protected void coGroup(JsonNode key,ArrayNode values1,ArrayNode values2,JsonCollector out){
  if (!key.isArray()) {
    for (    JsonNode array : values2) {
      out.collect(((ArrayNode)array).get(0),((ArrayNode)array).get(1));
    }
  }
 else {
    for (    JsonNode value2 : values2) {
      BinarySparseMatrix matrixB=(BinarySparseMatrix)((ArrayNode)(((ArrayNode)value2).get(0))).get(1);
      BinarySparseMatrix matrixX=(BinarySparseMatrix)((ArrayNode)(((ArrayNode)value2).get(1))).get(1);
      JsonNode oldKeyX=((ArrayNode)(((ArrayNode)value2).get(1))).get(0);
      if (!values1.isEmpty()) {
      }
 else {
        JsonNode oldKeyB=((ArrayNode)(((ArrayNode)value2).get(0))).get(0);
        out.collect(oldKeyB,matrixB);
      }
      out.collect(oldKeyX,matrixX);
    }
  }
}

Fixed version (ground truth):
@Override protected void coGroup(JsonNode key,ArrayNode values1,ArrayNode values2,JsonCollector out){
  if (!key.isArray()) {
    for (    JsonNode array : values2) {
      out.collect(((ArrayNode)array).get(0),((ArrayNode)array).get(1));
    }
  }
 else {
    if (values2.isEmpty()) {
      out.collect(key,values1.get(0));
    }
 else {
      for (      JsonNode value2 : values2) {
        BinarySparseMatrix matrixB=(BinarySparseMatrix)((ArrayNode)(((ArrayNode)value2).get(0))).get(1);
        BinarySparseMatrix matrixX=(BinarySparseMatrix)((ArrayNode)(((ArrayNode)value2).get(1))).get(1);
        JsonNode oldKeyX=((ArrayNode)(((ArrayNode)value2).get(1))).get(0);
        if (!values1.isEmpty()) {
        }
        out.collect(oldKeyX,matrixX);
      }
    }
  }
}
Program: 87907
Project: 87907
Buggy source:
@Override public SopremoModule asElementaryOperators(){
  final SopremoModule sopremoModule=new SopremoModule(this.getName(),1,1);
  JsonStream input=sopremoModule.getInput(0);
  int itCount=2;
  TransformAKey[] a=new TransformAKey[itCount];
  TransformBKey[] b=new TransformBKey[itCount];
  TransformXKey[] x=new TransformXKey[itCount];
  BAndXCoGroup[] xb=new BAndXCoGroup[itCount];
  ACoGroup axb[]=new ACoGroup[itCount];
  for (int i=0; i < itCount; i++) {
    a[i]=new TransformAKey().withInputs(i == 0 ? input : axb[i - 1]);
    a[i].setIterationStep(i + 1);
    b[i]=new TransformBKey().withInputs(i == 0 ? input : axb[i - 1]);
    b[i].setIterationStep(i + 1);
    x[i]=new TransformXKey().withInputs(i == 0 ? input : axb[i - 1]);
    xb[i]=new BAndXCoGroup().withInputs(b[i],x[i]);
    axb[i]=new ACoGroup().withInputs(a[i],xb[i]);
  }
  sopremoModule.getOutput(0).setInput(0,axb[itCount - 1]);
  return sopremoModule;
}

Fixed version (ground truth):
@Override public SopremoModule asElementaryOperators(){
  final SopremoModule sopremoModule=new SopremoModule(this.getName(),1,1);
  JsonStream input=sopremoModule.getInput(0);
  int itCount=3;
  TransformAKey[] a=new TransformAKey[itCount];
  TransformBKey[] b=new TransformBKey[itCount];
  TransformXKey[] x=new TransformXKey[itCount];
  BAndXCoGroup[] xb=new BAndXCoGroup[itCount];
  ACoGroup axb[]=new ACoGroup[itCount];
  for (int i=0; i < itCount; i++) {
    a[i]=new TransformAKey().withInputs(i == 0 ? input : axb[i - 1]);
    a[i].setIterationStep(i + 1);
    b[i]=new TransformBKey().withInputs(i == 0 ? input : axb[i - 1]);
    b[i].setIterationStep(i + 1);
    x[i]=new TransformXKey().withInputs(i == 0 ? input : axb[i - 1]);
    xb[i]=new BAndXCoGroup().withInputs(b[i],x[i]);
    axb[i]=new ACoGroup().withInputs(a[i],xb[i]);
  }
  sopremoModule.getOutput(0).setInput(0,axb[itCount - 1]);
  return sopremoModule;
}
Program: 87908
Project: 87908
Buggy source:
public void refreshEdgeLatency(long timestamp,ChannelLatency channelLatency){
  ManagementEdgeID sourceEdgeID=profilingSubgraph.getEdgeByReceiverVertexID(channelLatency.getSinkVertexID().toManagementVertexID());
  EdgeCharacteristics edgeCharacteristics=profilingSubgraph.getEdgeCharacteristicsBySourceEdgeID(sourceEdgeID);
  edgeCharacteristics.addLatencyMeasurement(timestamp,channelLatency.getChannelLatency());
}

Fixed version (ground truth):
public void refreshEdgeLatency(long timestamp,ChannelLatency channelLatency){
  if (Double.isInfinite(channelLatency.getChannelLatency()) || Double.isNaN(channelLatency.getChannelLatency())) {
    return;
  }
  if (!channelLatency.getSourceVertexID().equals(channelLatency.getSinkVertexID())) {
    XoredVertexID xored=new XoredVertexID(channelLatency.getSourceVertexID().toManagementVertexID(),channelLatency.getSinkVertexID().toManagementVertexID());
    ManagementEdgeID sourceEdgeID=profilingSubgraph.getSourceEdgeIDByXoredVertexID(xored);
    if (sourceEdgeID == null) {
      ExecutionVertex source=executionGraph.getVertexByID(channelLatency.getSourceVertexID());
      ExecutionVertex sink=executionGraph.getVertexByID(channelLatency.getSinkVertexID());
      throw new RuntimeException("String_Node_Str" + getName(source) + "String_Node_Str"+ getName(sink)+ "String_Node_Str"+ xored.toString());
    }
    EdgeCharacteristics edgeCharacteristics=profilingSubgraph.getEdgeCharacteristicsBySourceEdgeID(sourceEdgeID);
    edgeCharacteristics.addLatencyMeasurement(timestamp,channelLatency.getChannelLatency());
  }
}
Program: 87909
Project: 87909
Buggy source:
public void refreshChannelThroughput(long timestamp,ChannelThroughput channelThroughput){
  ManagementEdgeID edgeID=new ManagementEdgeID(channelThroughput.getSourceChannelID());
  EdgeCharacteristics edgeCharaceristics=profilingSubgraph.getEdgeCharacteristicsBySourceEdgeID(edgeID);
  edgeCharaceristics.addThroughputMeasurement(timestamp,channelThroughput.getThroughput());
}

Fixed version (ground truth):
public void refreshChannelThroughput(long timestamp,ChannelThroughput channelThroughput){
  if (Double.isInfinite(channelThroughput.getThroughput()) || Double.isNaN(channelThroughput.getThroughput())) {
    return;
  }
  ManagementEdgeID edgeID=new ManagementEdgeID(channelThroughput.getSourceChannelID());
  EdgeCharacteristics edgeCharaceristics=profilingSubgraph.getEdgeCharacteristicsBySourceEdgeID(edgeID);
  edgeCharaceristics.addThroughputMeasurement(timestamp,channelThroughput.getThroughput());
}
Program: 87910
Project: 87910
Buggy source:
public void refreshTaskLatency(long timestamp,TaskLatency taskLatency){
  VertexLatency vertexLatency=profilingSubgraph.getVertexLatency(taskLatency.getVertexID().toManagementVertexID());
  vertexLatency.addLatencyMeasurement(timestamp,taskLatency.getTaskLatency());
}

Fixed version (ground truth):
public void refreshTaskLatency(long timestamp,TaskLatency taskLatency){
  if (Double.isInfinite(taskLatency.getTaskLatency()) || Double.isNaN(taskLatency.getTaskLatency())) {
    return;
  }
  VertexLatency vertexLatency=profilingSubgraph.getVertexLatency(taskLatency.getVertexID().toManagementVertexID());
  vertexLatency.addLatencyMeasurement(timestamp,taskLatency.getTaskLatency());
}
Program: 87911
Project: 87911
Buggy source:
private void initReceiverVertexToSourceEdgeIDMap(final ManagementGraph managementGraph){
  final Iterator<ManagementVertex> it=new ManagementGraphIterator(managementGraph,true);
  while (it.hasNext()) {
    final ManagementVertex source=it.next();
    final int numberOfOutputGates=source.getNumberOfOutputGates();
    for (int i=0; i < numberOfOutputGates; ++i) {
      final ManagementGate outputGate=source.getOutputGate(i);
      final int numberOfOutgoingEdges=outputGate.getNumberOfForwardEdges();
      for (int j=0; j < numberOfOutgoingEdges; ++j) {
        final ManagementEdge edge=outputGate.getForwardEdge(j);
        final ManagementVertex receiver=edge.getTarget().getVertex();
        this.receiverVertexToSourceEdgeIDMap.put(receiver.getID(),edge.getSourceEdgeID());
      }
    }
  }
}

Fixed version (ground truth):
private void initReceiverVertexToSourceEdgeIDMap(final ManagementGraph managementGraph){
  final Iterator<ManagementVertex> it=new ManagementGraphIterator(managementGraph,true);
  while (it.hasNext()) {
    final ManagementVertex source=it.next();
    final int numberOfOutputGates=source.getNumberOfOutputGates();
    for (int i=0; i < numberOfOutputGates; ++i) {
      final ManagementGate outputGate=source.getOutputGate(i);
      final int numberOfOutgoingEdges=outputGate.getNumberOfForwardEdges();
      for (int j=0; j < numberOfOutgoingEdges; ++j) {
        final ManagementEdge edge=outputGate.getForwardEdge(j);
        final ManagementVertex receiver=edge.getTarget().getVertex();
        XoredVertexID xored=new XoredVertexID(source.getID(),receiver.getID());
        System.out.println("String_Node_Str" + getName(source) + "String_Node_Str"+ getName(receiver)+ "String_Node_Str"+ xored.toString());
        this.xoredVertexToSourceEdgeIDMap.put(xored,edge.getSourceEdgeID());
      }
    }
  }
}
Program: 87912
Project: 87912
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public T readRecord(final T target) throws IOException, InterruptedException {
  T record=null;
  if (this.executingThread == null) {
    this.executingThread=Thread.currentThread();
  }
  if (this.executingThread.isInterrupted()) {
    throw new InterruptedException();
  }
  while (true) {
    if (this.channelToReadFrom == -1) {
      this.availableChannelRetVal=waitForAnyChannelToBecomeAvailable();
      this.channelToReadFrom=this.availableChannelRetVal;
    }
    try {
      record=this.getInputChannel(this.channelToReadFrom).readRecord(target);
    }
 catch (    EOFException e) {
      if (this.isClosed()) {
        return null;
      }
    }
    if (++this.channelToReadFrom == getNumberOfInputChannels()) {
      this.channelToReadFrom=0;
    }
    if (record != null) {
      break;
    }
 else {
      if (this.channelToReadFrom == this.availableChannelRetVal) {
        this.channelToReadFrom=-1;
      }
    }
  }
  this.streamListener.recordReceived(record);
  return record;
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public T readRecord(final T target) throws IOException, InterruptedException {
  T record=null;
  if (this.executingThread == null) {
    this.executingThread=Thread.currentThread();
  }
  if (this.executingThread.isInterrupted()) {
    throw new InterruptedException();
  }
  final int numberOfInputChannels=getNumberOfInputChannels();
  while (true) {
    if (this.channelToReadFrom == -1) {
      this.availableChannelRetVal=waitForAnyChannelToBecomeAvailable();
      this.channelToReadFrom=this.availableChannelRetVal;
    }
    try {
      record=this.getInputChannel(this.channelToReadFrom).readRecord(target);
    }
 catch (    EOFException e) {
      if (this.isClosed()) {
        return null;
      }
    }
    if (record == null && this.channelToReadFrom == this.availableChannelRetVal) {
      this.channelToReadFrom=-1;
      continue;
    }
    if (++this.channelToReadFrom == numberOfInputChannels) {
      this.channelToReadFrom=0;
    }
    if (record != null) {
      break;
    }
  }
  this.streamListener.recordReceived(record);
  return record;
}
Program: 87913
Project: 87913
Buggy source:
@Override public void close(){
  this.running=false;
  if (this.currentBuffer.isEmpty()) {
    this.queues.empty.add(this.currentElement);
  }
 else {
    this.queues.sort.add(this.currentElement);
    if (LOG.isDebugEnabled()) {
      LOG.debug("String_Node_Str" + this.currentElement.id + "String_Node_Str");
    }
  }
  this.currentBuffer=null;
  this.currentElement=null;
  this.queues.sort.add(SENTINEL);
  if (LOG.isDebugEnabled())   LOG.debug("String_Node_Str");
}

Fixed version (ground truth):
@Override public void close(){
  if (this.running) {
    this.running=false;
    if (this.currentBuffer != null && this.currentElement != null) {
      if (this.currentBuffer.isEmpty()) {
        this.queues.empty.add(this.currentElement);
      }
 else {
        this.queues.sort.add(this.currentElement);
        if (LOG.isDebugEnabled()) {
          LOG.debug("String_Node_Str" + this.currentElement.id + "String_Node_Str");
        }
      }
    }
    this.currentBuffer=null;
    this.currentElement=null;
    this.queues.sort.add(SENTINEL);
  }
}
Program: 87914
Project: 87914
Buggy source:
public ProfilingValue(double value,long timestamp){
  this.value=value;
  this.timestamp=timestamp;
}

Fixed version (ground truth):
public ProfilingValue(double value,long timestamp){
  this.value=value;
  this.timestamp=timestamp;
  this.id=nextFreeId++;
}
Program: 87915
Project: 87915
Buggy source:
/** 
 * Sorts first by value and then by timestamp.
 */
@Override public int compareTo(ProfilingValue other){
  if (this.value > other.value) {
    return 1;
  }
 else   if (this.value < other.value) {
    return -1;
  }
 else {
    if (this.timestamp > other.timestamp) {
      return 1;
    }
 else     if (this.timestamp < other.timestamp) {
      return -1;
    }
 else {
      return 0;
    }
  }
}

Fixed version (ground truth):
/** 
 * Sorts first by value and then by id.
 */
@Override public int compareTo(ProfilingValue other){
  if (this.value > other.value) {
    return 1;
  }
 else   if (this.value < other.value) {
    return -1;
  }
 else {
    if (this.id > other.id) {
      return 1;
    }
 else     if (this.id < other.id) {
      return -1;
    }
 else {
      return 0;
    }
  }
}
Program: 87916
Project: 87916
Buggy source:
public ProfilingValueStatistic(int valueSetSize){
  this.sortedByTimestamp=new LinkedList<ProfilingValue>();
  this.sortedByValue=new ArrayList<ProfilingValue>();
  this.valueArraySize=valueSetSize;
  this.noOfStoredValues=0;
  this.sumOfValues=0;
}

Fixed version (ground truth):
public ProfilingValueStatistic(int statisticWindowSize){
  this.sortedById=new LinkedList<ProfilingValue>();
  this.sortedByValue=new ArrayList<ProfilingValue>();
  this.statisticWindowSize=statisticWindowSize;
  this.noOfStoredValues=0;
  this.sumOfValues=0;
}
Program: 87917
Project: 87917
Buggy source:
private ProfilingValue insertIntoSortedByTimestamp(ProfilingValue value){
  if (!sortedByTimestamp.isEmpty() && sortedByTimestamp.getLast().getTimestamp() > value.getTimestamp()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  sortedByTimestamp.add(value);
  if (noOfStoredValues >= valueArraySize) {
    return sortedByTimestamp.removeFirst();
  }
 else {
    return null;
  }
}

Fixed version (ground truth):
private ProfilingValue insertIntoSortedByTimestamp(ProfilingValue value){
  if (!sortedById.isEmpty() && sortedById.getLast().getId() >= value.getId()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  sortedById.add(value);
  if (noOfStoredValues >= statisticWindowSize) {
    return sortedById.removeFirst();
  }
 else {
    return null;
  }
}
Program: 87918
Project: 87918
Buggy source:
public static PluginID fromByteArray(final byte[] byteArray){
  if (byteArray == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (byteArray.length != SIZE) {
    throw new IllegalArgumentException("String_Node_Str" + SIZE);
  }
  return new PluginID(byteArray);
}

Fixed version (ground truth):
/** 
 * Constructs a new plugin ID from the given byte array.
 * @param byteArray the byte array to construct the plugin ID from
 */
public static PluginID fromByteArray(final byte[] byteArray){
  if (byteArray == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (byteArray.length != SIZE) {
    throw new IllegalArgumentException("String_Node_Str" + SIZE);
  }
  return new PluginID(byteArray);
}
Program: 87919
Project: 87919
Buggy source:
private PluginID(final byte[] byteArray){
  super(byteArray);
}

Fixed version (ground truth):
/** 
 * Default constructor required for the deserialization.
 */
public PluginID(){
  super();
}
Program: 87920
Project: 87920
Buggy source:
/** 
 * Creates a new file input channel and assigns it to the input gate.
 * @param channelID the channel ID to assign to the new channel, <code>null</code> to generate a new ID
 * @param compressionLevel the level of compression to be used for this channel
 * @return the new file input channel
 */
FileInputChannel<T> createFileInputChannel(ChannelID channelID,CompressionLevel compressionLevel);

Fixed version (ground truth):
/** 
 * Creates a new file input channel and assigns it to the given input gate.
 * @param inputGate the input gate the channel shall be assigned to
 * @param channelID the channel ID to assign to the new channel, <code>null</code> to generate a new ID
 * @param compressionLevel the level of compression to be used for this channel
 * @return the new file input channel
 */
FileInputChannel<T> createFileInputChannel(InputGate<T> inputGate,ChannelID channelID,CompressionLevel compressionLevel);