nus-yam/ex-repair huggingface dataset:
Program: 57105
Project: 57105
Buggy source:
@Override protected void setUpDataSetDescriptions(){
  sampleIDSpecification=new IDSpecification();
  sampleIDSpecification.setIdCategory("String_Node_Str");
  sampleIDSpecification.setIdType("String_Node_Str");
  IDTypeParsingRules idTypeParsingRules=new IDTypeParsingRules();
  idTypeParsingRules.setReplacementExpression(TCGADefinitions.TCGA_REPLACEMENT_STRING,TCGADefinitions.TCGA_REPLACING_EXPRESSIONS);
  idTypeParsingRules.setSubStringExpression(TCGADefinitions.TCGA_ID_SUBSTRING_REGEX);
  idTypeParsingRules.setDefault(true);
  sampleIDSpecification.setIdTypeParsingRules(idTypeParsingRules);
  projectDescription.add(setUpMRNAData());
  projectDescription.add(setUpCopyNumberData());
}

Fixed version (ground truth):
@Override protected void setUpDataSetDescriptions(){
  sampleIDSpecification=new IDSpecification();
  sampleIDSpecification.setIdCategory("String_Node_Str");
  sampleIDSpecification.setIdType("String_Node_Str");
  IDTypeParsingRules idTypeParsingRules=new IDTypeParsingRules();
  idTypeParsingRules.setReplacementExpression(TCGADefinitions.TCGA_REPLACEMENT_STRING,TCGADefinitions.TCGA_REPLACING_EXPRESSIONS);
  idTypeParsingRules.setSubStringExpression(TCGADefinitions.TCGA_ID_SUBSTRING_REGEX);
  idTypeParsingRules.setDefault(true);
  sampleIDSpecification.setIdTypeParsingRules(idTypeParsingRules);
  projectDescription.add(setUpMRNAData());
  projectDescription.add(setUpCopyNumberData());
  projectDescription.add(setUpMutationData());
}
Program: 57106
Project: 57106
Buggy source:
private DataSetDescription setUpMutationData(){
  DataSetDescription mutationDataMetaInfo=new DataSetDescription(ECreateDefaultProperties.CATEGORICAL);
  mutationDataMetaInfo.setDataSetName("String_Node_Str");
  mutationDataMetaInfo.setDataSourcePath(MUTATION);
  @SuppressWarnings("String_Node_Str") CategoricalClassDescription<Integer> categoricalClassDescription=(CategoricalClassDescription<Integer>)mutationDataMetaInfo.getDataDescription().getCategoricalClassDescription();
  categoricalClassDescription.addCategoryProperty(0,"String_Node_Str",Colors.NEUTRAL_GREY);
  categoricalClassDescription.addCategoryProperty(1,"String_Node_Str",Colors.RED);
  mutationDataMetaInfo.setNumberOfHeaderLines(1);
  ParsingRule parsingRule=new ParsingRule();
  parsingRule.setFromColumn(1);
  parsingRule.setParseUntilEnd(true);
  parsingRule.setColumnDescripton(new ColumnDescription());
  mutationDataMetaInfo.addParsingRule(parsingRule);
  mutationDataMetaInfo.setTransposeMatrix(true);
  IDSpecification geneIDSpecification=new IDSpecification();
  geneIDSpecification.setIDTypeGene(true);
  geneIDSpecification.setIdType("String_Node_Str");
  mutationDataMetaInfo.setRowIDSpecification(geneIDSpecification);
  mutationDataMetaInfo.setColumnIDSpecification(sampleIDSpecification);
  return mutationDataMetaInfo;
}

Fixed version (ground truth):
private DataSetDescription setUpMutationData(){
  DataSetDescription mutationDataDescription=new DataSetDescription(ECreateDefaultProperties.CATEGORICAL);
  mutationDataDescription.setDataSetName("String_Node_Str");
  mutationDataDescription.setDataSourcePath(MUTATION);
  @SuppressWarnings("String_Node_Str") CategoricalClassDescription<Integer> categoricalClassDescription=(CategoricalClassDescription<Integer>)mutationDataDescription.getDataDescription().getCategoricalClassDescription();
  categoricalClassDescription.addCategoryProperty(0,"String_Node_Str",Colors.NEUTRAL_GREY);
  categoricalClassDescription.addCategoryProperty(1,"String_Node_Str",Colors.RED);
  mutationDataDescription.setNumberOfHeaderLines(1);
  ParsingRule parsingRule=new ParsingRule();
  parsingRule.setFromColumn(1);
  parsingRule.setParseUntilEnd(true);
  parsingRule.setColumnDescripton(new ColumnDescription());
  mutationDataDescription.addParsingRule(parsingRule);
  mutationDataDescription.setTransposeMatrix(true);
  IDSpecification geneIDSpecification=new IDSpecification();
  geneIDSpecification.setIDTypeGene(true);
  geneIDSpecification.setIdType("String_Node_Str");
  mutationDataDescription.setRowIDSpecification(geneIDSpecification);
  mutationDataDescription.setColumnIDSpecification(sampleIDSpecification);
  return mutationDataDescription;
}
Program: 57107
Project: 57107
Buggy source:
public static ClusterResult cluster(ClusterConfiguration config){
  log.info("String_Node_Str" + config);
  Stopwatch w=new Stopwatch().start();
  try {
    ClusterResult clusterResult=null;
    SafeCallable<PerspectiveInitializationData> clusterer=createClusterer(config);
    if (clusterer == null) {
      log.error("String_Node_Str" + config);
      throw new IllegalStateException("String_Node_Str" + config);
    }
    PerspectiveInitializationData data=clusterer.call();
    ClusterResult result=new ClusterResult();
switch (config.getClusterTarget()) {
case DIMENSION_CLUSTERING:
      result.setDimensionResult(data);
    break;
case RECORD_CLUSTERING:
  result.setRecordResult(data);
break;
}
return clusterResult;
}
 catch (final Exception e) {
log.error("String_Node_Str",e);
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){
@Override public void run(){
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){
  @Override public void run(){
    MessageBox messageBox=new MessageBox(new Shell(),SWT.ERROR);
    messageBox.setText("String_Node_Str");
    messageBox.setMessage("String_Node_Str");
    messageBox.open();
  }
}
);
}
}
);
}
 finally {
log.debug("String_Node_Str" + w);
}
return null;
}

Fixed version (ground truth):
public static ClusterResult cluster(ClusterConfiguration config){
  log.info("String_Node_Str" + config);
  Stopwatch w=new Stopwatch().start();
  try {
    SafeCallable<PerspectiveInitializationData> clusterer=createClusterer(config);
    if (clusterer == null) {
      log.error("String_Node_Str" + config);
      throw new IllegalStateException("String_Node_Str" + config);
    }
    PerspectiveInitializationData data=clusterer.call();
    ClusterResult result=new ClusterResult();
switch (config.getClusterTarget()) {
case DIMENSION_CLUSTERING:
      result.setDimensionResult(data);
    break;
case RECORD_CLUSTERING:
  result.setRecordResult(data);
break;
}
return result;
}
 catch (final Exception e) {
log.error("String_Node_Str",e);
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){
@Override public void run(){
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){
  @Override public void run(){
    MessageBox messageBox=new MessageBox(new Shell(),SWT.ERROR);
    messageBox.setText("String_Node_Str");
    messageBox.setMessage("String_Node_Str");
    messageBox.open();
  }
}
);
}
}
);
}
 finally {
log.debug("String_Node_Str" + w);
}
return null;
}
Program: 57109
Project: 57109
Buggy source:
private static Font advancedFeatures(Font base,boolean enable){
  HashMap<TextAttribute,Object> map=new HashMap<>(base.getAttributes());
  if (enable) {
    map.put(TextAttribute.KERNING,TextAttribute.KERNING_ON);
  }
 else {
    map.remove(TextAttribute.KERNING);
    map.put(TextAttribute.TRACKING,0.5);
  }
  return base.deriveFont(map);
}

Fixed version (ground truth):
private static Font advancedFeatures(Font base,boolean enable){
  HashMap<TextAttribute,Object> map=new HashMap<>(base.getAttributes());
  if (enable) {
    map.put(TextAttribute.KERNING,TextAttribute.KERNING_ON);
  }
 else {
    map.remove(TextAttribute.KERNING);
    map.remove(TextAttribute.LIGATURES);
    map.put(TextAttribute.TRACKING,0.3f);
  }
  return base.deriveFont(map);
}
Program: 57110
Project: 57110
Buggy source:
protected final float scale(float height){
  return height / (float)maxBounds.getHeight();
}

Fixed version (ground truth):
protected final double scale(float height){
  return height / (scaleByBaseLine ? baseLine : maxBounds.getHeight());
}
Program: 57111
Project: 57111
Buggy source:
/** 
 * @return the bounds, see {@link #bounds}
 */
public Rect getBounds(){
  return bounds;
}

Fixed version (ground truth):
/** 
 * @return the bounds, see {@link #bounds}
 */
public Rectangle2D getBounds(){
  return bounds;
}
Program: 57112
Project: 57112
Buggy source:
public final float getTextWidth(String text,float height){
  GlyphVector glyphVector=get(text);
  if (glyphVector == null)   return 0;
  return (float)glyphVector.getVisualBounds().getWidth() * scale(height);
}

Fixed version (ground truth):
public final float getTextWidth(String text,float height){
  GlyphVector glyphVector=get(text);
  if (glyphVector == null)   return 0;
  return (float)(glyphVector.getVisualBounds().getWidth() * scale(height));
}
Program: 57113
Project: 57113
Buggy source:
/** 
 * @param subSequence
 */
private void render(CharSequence csq){
  GlyphVector glyphVector=renderFont.createGlyphVector(frc,csq.toString());
  Rectangle bounds=glyphVector.getVisualBounds().getBounds();
  bounds.y+=baseLine;
  graphics.drawGlyphVector(glyphVector,pos.x(),pos.y());
  for (int i=0; i < csq.length(); ++i) {
    char c=csq.charAt(i);
    Rectangle gbounds=glyphVector.getGlyphPixelBounds(i,frc,pos.x(),pos.y());
    Rect r=new Rect(gbounds.x,gbounds.y,gbounds.width,gbounds.height);
    CharacterInfo info=new CharacterInfo(r);
    chars.put(c,info);
  }
  pos.setX(pos.x() + bounds.width);
  markDirty(bounds);
}

Fixed version (ground truth):
/** 
 * @param subSequence
 */
private void render(CharSequence csq){
  GlyphVector glyphVector=renderFont.createGlyphVector(frc,csq.toString());
  Rectangle bounds=glyphVector.getVisualBounds().getBounds();
  bounds.y+=baseLine;
  graphics.drawGlyphVector(glyphVector,pos.x(),pos.y());
  for (int i=0; i < csq.length(); ++i) {
    char c=csq.charAt(i);
    Rectangle gbounds=glyphVector.getGlyphPixelBounds(i,frc,pos.x(),pos.y());
    CharacterInfo info=new CharacterInfo(gbounds);
    chars.put(c,info);
  }
  pos.setX(pos.x() + bounds.width + 4);
  markDirty(bounds);
}
Program: 57114
Project: 57114
Buggy source:
public CharacterInfo(Rect bounds){
  this.bounds=bounds;
}

Fixed version (ground truth):
public CharacterInfo(Rectangle2D bounds){
  this.bounds=bounds;
}
Program: 57115
Project: 57115
Buggy source:
@Override protected void renderImpl(GLGraphics g,float w,float h){
  g.color(Color.RED).fillRect(0,0,200,200);
  g.drawText("String_Node_Str",10,10,100,40);
}

Fixed version (ground truth):
@Override protected void renderImpl(GLGraphics g,float w,float h){
  g.color(Color.RED).fillRect(10,10,500,18);
  g.drawText("String_Node_Str",10,10,500,18);
}
Program: 57116
Project: 57116
Buggy source:
@Override protected ITextRenderer createTextRenderer(){
  return new BitmapTextRenderer(new Font("String_Node_Str",Font.PLAIN,40));
}

Fixed version (ground truth):
@Override protected ITextRenderer createTextRenderer(){
  return new BitmapTextRenderer(new Font("String_Node_Str",Font.PLAIN,10));
}
Program: 57117
Project: 57117
Buggy source:
public Root(Shell parentShell){
  super(parentShell,"String_Node_Str",new GLElement(){
    @Override protected void renderImpl(    GLGraphics g,    float w,    float h){
      g.color(Color.RED).fillRect(0,0,200,200);
      g.drawText("String_Node_Str",10,10,100,40);
    }
  }
,GLPadding.ZERO,new Dimension(500,500));
}

Fixed version (ground truth):
public Root(Shell parentShell){
  super(parentShell,"String_Node_Str",new GLElement(){
    @Override protected void renderImpl(    GLGraphics g,    float w,    float h){
      g.color(Color.RED).fillRect(10,10,500,18);
      g.drawText("String_Node_Str",10,10,500,18);
    }
  }
,GLPadding.ZERO,new Dimension(500,500));
}
Program: 57118
Project: 57118
Buggy source:
/** 
 * @param bounds
 * @return
 */
private Rect toTextureCoordinates(Rect bounds){
  float iw=1.f / texture.getWidth();
  float ih=1.f / texture.getHeight();
  return new Rect(bounds.x() * iw,bounds.y() * ih,bounds.width() * iw,bounds.height() * ih);
}

Fixed version (ground truth):
/** 
 * @param bounds
 * @return
 */
private Rectangle2D toTextureCoordinates(Rectangle2D bounds){
  double iw=1. / texture.getWidth();
  double ih=1. / texture.getHeight();
  int p=PADDING;
  return new Rectangle2D.Double((bounds.getX() - p) * iw,(bounds.getY() - p) * ih,(bounds.getWidth() + p * 2) * iw,(bounds.getHeight() + p * 2) * ih);
}
Program: 57119
Project: 57119
Buggy source:
@Override public void renderTextInBounds(GL2 gl,String text,float x,float y,float z,float w,float h){
  GlyphVector glyphVector=get(text);
  if (glyphVector == null)   return;
  upload(text);
  Texture tex=texture.getTexture();
  tex.enable(gl);
  tex.bind(gl);
  gl.glPushMatrix();
  gl.glTranslatef(x,y,z);
  float s=scale(h);
  w/=s;
  gl.glScalef(s,s,1);
  GLGraphics.checkError(gl);
  gl.glBegin(GL2.GL_QUADS);
  gl.glColor4fv(color,0);
  for (int i=0; i < text.length(); ++i) {
    char c=text.charAt(i);
    if (filterChar(c))     continue;
    final CharacterInfo info=chars.get(c);
    Rect bounds=info.getBounds();
    Rect texCoords=toTextureCoordinates(bounds);
    Point2D pos=glyphVector.getGlyphPosition(i);
    if ((pos.getX() + bounds.width() >= w)) {
      break;
    }
    float xo=(float)pos.getX();
    float yo=(float)pos.getY();
    gl.glTexCoord2f(texCoords.x(),texCoords.y());
    gl.glVertex2f(xo,yo);
    gl.glTexCoord2f(texCoords.x2(),texCoords.y());
    gl.glVertex2f(xo + bounds.width(),yo);
    gl.glTexCoord2f(texCoords.x2(),texCoords.y2());
    gl.glVertex2f(xo + bounds.width(),yo + bounds.height());
    gl.glTexCoord2f(texCoords.x(),texCoords.y2());
    gl.glVertex2f(xo,yo + bounds.height());
  }
  gl.glEnd();
  gl.glPopMatrix();
  tex.disable(gl);
}

Fixed version (ground truth):
@Override public void renderTextInBounds(GL2 gl,String text,float x,float y,float z,float w,float h){
  GlyphVector glyphVector=get(text);
  if (glyphVector == null)   return;
  upload(text);
  Texture tex=texture.getTexture();
  tex.enable(gl);
  tex.bind(gl);
  gl.glPushMatrix();
  gl.glTranslatef(x,y,z);
  double s=scale(h);
  w/=s;
  gl.glScaled(s,s,s);
  gl.glTranslatef(0,baseLine,0);
  GLGraphics.checkError(gl);
  gl.glBegin(GL2.GL_QUADS);
  gl.glColor4fv(color,0);
  final int p=PADDING;
  for (int i=0; i < text.length(); ++i) {
    char c=text.charAt(i);
    if (filterChar(c))     continue;
    final CharacterInfo info=chars.get(c);
    Rectangle2D bounds=info.getBounds();
    Rectangle2D texCoords=toTextureCoordinates(bounds);
    Rectangle2D target=glyphVector.getGlyphVisualBounds(i).getBounds2D();
    if ((target.getMaxX() >= w)) {
      break;
    }
    gl.glTexCoord2d(texCoords.getX(),texCoords.getY());
    gl.glVertex2d(target.getX() - p,target.getY() - p);
    gl.glTexCoord2d(texCoords.getMaxX(),texCoords.getY());
    gl.glVertex2d(target.getMaxX() + p,target.getY() - p);
    gl.glTexCoord2d(texCoords.getMaxX(),texCoords.getMaxY());
    gl.glVertex2d(target.getMaxX() + p,target.getMaxY() + p);
    gl.glTexCoord2d(texCoords.getX(),texCoords.getMaxY());
    gl.glVertex2d(target.getX() - p,target.getMaxY() + p);
  }
  gl.glEnd();
  gl.glPopMatrix();
  tex.disable(gl);
}
Program: 57121
Project: 57121
Buggy source:
/** 
 * initial random create of clusters and cluster centers
 * @param nrSamples
 * @return
 */
private List<Cluster> createClusters(final int nrSamples){
  List<Cluster> clusters=new ArrayList<>(numberOfCluster);
  Random r=new Random();
  BitSet used=new BitSet();
  for (int i=0; i < numberOfCluster; ++i) {
    int p;
    do {
      p=r.nextInt(nrSamples);
    }
 while (used.get(p));
    used.set(p);
    clusters.add(new Cluster(i,fillVector(null,va.get(p))));
  }
  return clusters;
}

Fixed version (ground truth):
/** 
 * initial random create of clusters and cluster centers
 * @param nrSamples
 * @return
 */
private List<Cluster> createClusters(final int nrSamples){
  List<Cluster> clusters=new ArrayList<>(numberOfCluster);
  Random r=new Random();
  BitSet used=new BitSet();
  for (int i=0; i < numberOfCluster; ++i) {
    int p;
    do {
      p=r.nextInt(nrSamples - 1);
    }
 while (used.get(p));
    used.set(p);
    clusters.add(new Cluster(i,fillVector(null,va.get(p))));
  }
  return clusters;
}
Program: 57122
Project: 57122
Buggy source:
public KMeansClusterer(ClusterConfiguration config,int progressMultiplier,int progressOffset){
  super(config,progressMultiplier,progressOffset);
  KMeansClusterConfiguration kMeansClusterConfiguration=(KMeansClusterConfiguration)config.getClusterAlgorithmConfiguration();
  this.numberOfCluster=kMeansClusterConfiguration.getNumberOfClusters();
}

Fixed version (ground truth):
public KMeansClusterer(ClusterConfiguration config,int progressMultiplier,int progressOffset){
  super(config,progressMultiplier,progressOffset);
  KMeansClusterConfiguration kMeansClusterConfiguration=(KMeansClusterConfiguration)config.getClusterAlgorithmConfiguration();
  this.numberOfCluster=kMeansClusterConfiguration.getNumberOfClusters();
  if (kMeansClusterConfiguration.isCacheVectors())   cache=new IntObjectHashMap();
 else   cache=null;
}
Program: 57123
Project: 57123
Buggy source:
private void createTab(){
  clusterTab=new TabItem(tabFolder,SWT.NONE);
  clusterTab.setData(this);
  clusterTab.setText("String_Node_Str");
  Composite composite=new Composite(tabFolder,SWT.NONE);
  clusterTab.setControl(composite);
  composite.setLayout(new GridLayout(1,false));
  final Label clusterNumberLabel=new Label(composite,SWT.NONE);
  clusterNumberLabel.setText("String_Node_Str");
  clusterNumberLabel.setLayoutData(new GridData(SWT.LEFT,SWT.CENTER,false,false));
  final Text clusterNumberText=new Text(composite,SWT.BORDER);
  clusterNumberText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
  clusterNumberText.addModifyListener(new ModifyListener(){
    @Override public void modifyText(    ModifyEvent event){
      try {
        int temp=Integer.parseInt(clusterNumberText.getText());
        if (temp > 0) {
          nrClustersRecords=temp;
        }
 else {
          throw new NumberFormatException("String_Node_Str");
        }
      }
 catch (      NumberFormatException e) {
        Shell shell=new Shell();
        MessageBox messageBox=new MessageBox(shell,SWT.OK);
        messageBox.setText("String_Node_Str");
        messageBox.setMessage("String_Node_Str");
        messageBox.open();
        System.out.println("String_Node_Str");
      }
    }
  }
);
  clusterNumberText.setText("String_Node_Str");
  clusterNumberText.setToolTipText("String_Node_Str");
}

Fixed version (ground truth):
private void createTab(){
  clusterTab=new TabItem(tabFolder,SWT.NONE);
  clusterTab.setData(this);
  clusterTab.setText("String_Node_Str");
  Composite composite=new Composite(tabFolder,SWT.NONE);
  clusterTab.setControl(composite);
  composite.setLayout(new GridLayout(1,false));
  final Label clusterNumberLabel=new Label(composite,SWT.NONE);
  clusterNumberLabel.setText("String_Node_Str");
  clusterNumberLabel.setLayoutData(new GridData(SWT.LEFT,SWT.CENTER,false,false));
  final Text clusterNumberText=new Text(composite,SWT.BORDER);
  clusterNumberText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
  clusterNumberText.addModifyListener(new ModifyListener(){
    @Override public void modifyText(    ModifyEvent event){
      try {
        int temp=Integer.parseInt(clusterNumberText.getText());
        if (temp > 0) {
          nrClustersRecords=temp;
        }
 else {
          throw new NumberFormatException("String_Node_Str");
        }
      }
 catch (      NumberFormatException e) {
        Shell shell=new Shell();
        MessageBox messageBox=new MessageBox(shell,SWT.OK);
        messageBox.setText("String_Node_Str");
        messageBox.setMessage("String_Node_Str");
        messageBox.open();
        System.out.println("String_Node_Str");
      }
    }
  }
);
  clusterNumberText.setText("String_Node_Str");
  clusterNumberText.setToolTipText("String_Node_Str");
  cacheVectors=new Button(composite,SWT.CHECK);
  cacheVectors.setText("String_Node_Str");
  cacheVectors.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
}
Program: 57124
Project: 57124
Buggy source:
@Override public AClusterAlgorithmConfiguration getClusterConfiguration(){
  KMeansClusterConfiguration clusterConfiguration=new KMeansClusterConfiguration();
  clusterConfiguration.setNumberOfClusters(nrClustersRecords);
  return clusterConfiguration;
}

Fixed version (ground truth):
@Override public AClusterAlgorithmConfiguration getClusterConfiguration(){
  KMeansClusterConfiguration clusterConfiguration=new KMeansClusterConfiguration();
  clusterConfiguration.setNumberOfClusters(nrClustersRecords);
  clusterConfiguration.setCacheVectors(cacheVectors.getSelection());
  return clusterConfiguration;
}
Program: 57125
Project: 57125
Buggy source:
private void select(SelectionManager manager,Collection<Integer> positions,boolean row){
  manager.clearSelection(SelectionType.SELECTION);
  for (  Integer pos : positions) {
    int index=row ? table.getRowIndexByPosition(pos) : table.getColumnIndexByPosition(pos);
    int id=row ? data.getRowObject(index) : data.getColumnObject(index);
    manager.addToType(SelectionType.SELECTION,id);
  }
  selection.fireSelectionDelta(manager.getIDType());
}

Fixed version (ground truth):
private void select(SelectionManager manager,Collection<Integer> positions,boolean row){
  manager.clearSelection(SelectionType.SELECTION);
  for (  Integer pos : positions) {
    int index=row ? table.getRowIndexByPosition(pos) : table.getColumnIndexByPosition(pos);
    if (index < 0)     continue;
    int id=row ? data.getRowObject(index) : data.getColumnObject(index);
    manager.addToType(SelectionType.SELECTION,id);
  }
  selection.fireSelectionDelta(manager.getIDType());
}
Program: 57126
Project: 57126
Buggy source:
@Override public void handleLayerEvent(ILayerEvent event){
  if (event instanceof CellSelectionEvent || event instanceof RowSelectionEvent || event instanceof ColumnSelectionEvent) {
    ISelectionModel model=selectionLayer.getSelectionModel();
    Collection<Integer> columns=Ints.asList(model.getSelectedColumnPositions());
    Collection<Integer> rows=new TreeSet<>();
    for (    Range r : model.getSelectedRowPositions())     rows.addAll(r.getMembers());
    int columnCount=table.getColumnCount();
    int rowCount=table.getRowCount();
    boolean allColumnsSelected=columns.size() == columnCount;
    boolean allRowsSelected=rows.size() == rowCount;
    if (allColumnsSelected == allRowsSelected) {
      select(selection.getDimensionSelectionManager(),columns,false);
      select(selection.getRecordSelectionManager(),rows,true);
    }
 else     if (allColumnsSelected) {
      select(selection.getRecordSelectionManager(),rows,true);
    }
 else     if (allRowsSelected) {
      select(selection.getDimensionSelectionManager(),columns,false);
    }
  }
}

Fixed version (ground truth):
@Override public void handleLayerEvent(ILayerEvent event){
  if (event instanceof CellSelectionEvent || event instanceof RowSelectionEvent || event instanceof ColumnSelectionEvent) {
    ISelectionModel model=selectionLayer.getSelectionModel();
    Collection<Integer> columns=Ints.asList(model.getSelectedColumnPositions());
    Collection<Integer> rows=new TreeSet<>();
    for (    Range r : model.getSelectedRowPositions())     rows.addAll(r.getMembers());
    int columnCount=data.getColumnCount();
    int rowCount=data.getRowCount();
    boolean allColumnsSelected=columns.size() == columnCount;
    boolean allRowsSelected=rows.size() == rowCount;
    if (allColumnsSelected == allRowsSelected) {
      select(selection.getDimensionSelectionManager(),columns,false);
      select(selection.getRecordSelectionManager(),rows,true);
    }
 else     if (allColumnsSelected) {
      select(selection.getRecordSelectionManager(),rows,true);
    }
 else     if (allRowsSelected) {
      select(selection.getDimensionSelectionManager(),columns,false);
    }
  }
}
Program: 57127
Project: 57127
Buggy source:
/** 
 * @param content setter, see  {@link content}
 */
public void setContent(GLElement content){
  if (this.content == content)   return;
  if (this.content != null) {
    this.content.setParent(null);
    if (context != null)     content.takeDown();
  }
  this.content=content;
  if (this.content != null) {
    this.content.setParent(this);
    if (context != null)     this.content.init(context);
  }
}

Fixed version (ground truth):
/** 
 * @param content setter, see  {@link content}
 */
public void setContent(GLElement content){
  if (this.content == content)   return;
  if (this.content != null) {
    this.content.setParent(null);
    if (context != null)     content.takeDown();
  }
  this.content=content;
  if (this.content != null) {
    this.content.setParent(this);
    if (context != null)     this.content.init(context);
  }
  relayout();
}
Program: 57128
Project: 57128
Buggy source:
private void render(GLGraphics g,float w,float h,boolean doPicking){
  final VirtualArray recordVA=tablePerspective.getRecordPerspective().getVirtualArray();
  final VirtualArray dimensionVA=tablePerspective.getDimensionPerspective().getVirtualArray();
  final ATableBasedDataDomain dataDomain=tablePerspective.getDataDomain();
  float y=0;
  final float fieldWidth=recordSpacing.getFieldWidth();
  for (int i=0; i < recordVA.size(); ++i) {
    Integer recordID=recordVA.get(i);
    if (isHidden(recordID)) {
      continue;
    }
    float fieldHeight=recordSpacing.getFieldHeight(recordID);
    y+=fieldHeight;
    float x=0;
    for (    Integer dimensionID : dimensionVA) {
      if (doPicking) {
        g.pushName(dimensionPickingIds.get(dimensionID));
        g.pushName(recordPickingIds.get(recordID));
        g.fillRect(x,y,fieldWidth,fieldHeight);
        g.popName();
        g.popName();
      }
 else {
        boolean deSelected=isDeselected(recordID);
        blockRenderer.render(g,recordID,dimensionID,dataDomain,new Rect(x,y,fieldWidth,fieldHeight),deSelected);
      }
      x+=fieldWidth;
    }
  }
  g.incZ();
  recordSelectionRenderer.render(g,w,h,recordSpacing,doPicking);
  dimensionSelectionRenderer.render(g,w,h,recordSpacing,doPicking);
  g.decZ();
}

Fixed version (ground truth):
private void render(GLGraphics g,float w,float h,boolean doPicking){
  final VirtualArray recordVA=tablePerspective.getRecordPerspective().getVirtualArray();
  final VirtualArray dimensionVA=tablePerspective.getDimensionPerspective().getVirtualArray();
  final ATableBasedDataDomain dataDomain=tablePerspective.getDataDomain();
  final float fieldWidth=recordSpacing.getFieldWidth();
  for (int i=0; i < recordVA.size(); ++i) {
    Integer recordID=recordVA.get(i);
    if (isHidden(recordID)) {
      continue;
    }
    float y=recordSpacing.getYPosition(i);
    float fieldHeight=recordSpacing.getFieldHeight(recordID);
    float x=0;
    for (    Integer dimensionID : dimensionVA) {
      if (doPicking) {
        g.pushName(dimensionPickingIds.get(dimensionID));
        g.pushName(recordPickingIds.get(recordID));
        g.fillRect(x,y,fieldWidth,fieldHeight);
        g.popName();
        g.popName();
      }
 else {
        boolean deSelected=isDeselected(recordID);
        blockRenderer.render(g,recordID,dimensionID,dataDomain,new Rect(x,y,fieldWidth,fieldHeight),deSelected);
      }
      x+=fieldWidth;
    }
  }
  g.incZ();
  recordSelectionRenderer.render(g,w,h,recordSpacing,doPicking);
  dimensionSelectionRenderer.render(g,w,h,recordSpacing,doPicking);
  g.decZ();
}
Program: 57129
Project: 57129
Buggy source:
@ListenTo private void onSelectionCommand(SelectionCommandEvent event){
  IDCategory idCategory=event.getIdCategory();
  ATableBasedDataDomain dataDomain=getDataDomain();
  if (idCategory == dataDomain.getRecordIDCategory()) {
    recordSelectionManager.executeSelectionCommand(event.getSelectionCommand());
    callback.onSelectionUpdate(recordSelectionManager);
  }
 else   if (idCategory == dataDomain.getDimensionIDCategory()) {
    dimensionSelectionManager.executeSelectionCommand(event.getSelectionCommand());
    callback.onSelectionUpdate(dimensionSelectionManager);
  }
}

Fixed version (ground truth):
@ListenTo private void onSelectionCommand(SelectionCommandEvent event){
  if (event.getSender() == this)   return;
  IDCategory idCategory=event.getIdCategory();
  ATableBasedDataDomain dataDomain=getDataDomain();
  if (idCategory == dataDomain.getRecordIDCategory()) {
    recordSelectionManager.executeSelectionCommand(event.getSelectionCommand());
    callback.onSelectionUpdate(recordSelectionManager);
  }
 else   if (idCategory == dataDomain.getDimensionIDCategory()) {
    dimensionSelectionManager.executeSelectionCommand(event.getSelectionCommand());
    callback.onSelectionUpdate(dimensionSelectionManager);
  }
}
Program: 57130
Project: 57130
Buggy source:
@Override public Collection<TablePerspective> filter(Collection<TablePerspective> tablePerspectives){
  return Collections2.filter(tablePerspectives,asTablePerspectivePredicate());
}

Fixed version (ground truth):
@Override public List<TablePerspective> filter(Collection<TablePerspective> tablePerspectives){
  return new ArrayList<>(Collections2.filter(tablePerspectives,asTablePerspectivePredicate()));
}
Program: 57131
Project: 57131
Buggy source:
public Collection<TablePerspective> filter(Collection<TablePerspective> tablePerspectives);

Fixed version (ground truth):
public List<TablePerspective> filter(Collection<TablePerspective> tablePerspectives);
Program: 57132
Project: 57132
Buggy source:
@Override public void postWindowOpen(){
  IMenuManager menuManager=getWindowConfigurer().getActionBarConfigurer().getMenuManager();
  for (  IContributionItem item : menuManager.getItems()) {
    if (item.getId().contains("String_Node_Str")) {
      menuManager.remove(item);
    }
  }
}

Fixed version (ground truth):
@Override public void postWindowOpen(){
  IMenuManager menuManager=getWindowConfigurer().getActionBarConfigurer().getMenuManager();
  for (  IContributionItem item : menuManager.getItems()) {
    if (item.getId().contains("String_Node_Str") && !item.getId().contains("String_Node_Str")) {
      menuManager.remove(item);
    }
  }
}
Program: 57133
Project: 57133
Buggy source:
@Override protected void fillMenuBar(IMenuManager menuBar){
  super.fillMenuBar(menuBar);
  MenuManager menu2=new MenuManager("String_Node_Str","String_Node_Str");
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menuBar.add(menu2);
  menu2=new MenuManager("String_Node_Str","String_Node_Str");
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menuBar.add(menu2);
}

Fixed version (ground truth):
@Override protected void fillMenuBar(IMenuManager menuBar){
  super.fillMenuBar(menuBar);
  MenuManager menu2=new MenuManager("String_Node_Str","String_Node_Str");
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menuBar.add(menu2);
  menu2=new MenuManager("String_Node_Str","String_Node_Str");
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menu2.add(new ShowView("String_Node_Str","String_Node_Str"));
  menuBar.add(menu2);
}
Program: 57134
Project: 57134
Buggy source:
@Override protected void renderImpl(GLGraphics g,float w,float h){
  renderBackground(g,w,h);
  if (get(HIST).getParent() != null)   get(HIST).render(g);
}

Fixed version (ground truth):
@Override protected void renderImpl(GLGraphics g,float w,float h){
  if (AColumnHeaderUI.this.getParent() != null)   renderBackground(g,w,h);
  if (get(HIST).getParent() != null)   get(HIST).render(g);
}
Program: 57135
Project: 57135
Buggy source:
private void takeDown(ARankColumnModel col){
  col.removePropertyChangeListener(ARankColumnModel.PROP_WIDTH,resort);
  col.removePropertyChangeListener(IMappedColumnMixin.PROP_MAPPING,refilter);
  col.removePropertyChangeListener(IFilterColumnMixin.PROP_FILTER,refilter);
}

Fixed version (ground truth):
private void takeDown(ARankColumnModel col){
  col.removePropertyChangeListener(ARankColumnModel.PROP_WIDTH,resort);
  col.removePropertyChangeListener(StackedRankColumnModel.PROP_WEIGHTS,resort);
  col.removePropertyChangeListener(IMappedColumnMixin.PROP_MAPPING,refilter);
  col.removePropertyChangeListener(IFilterColumnMixin.PROP_FILTER,refilter);
}
Program: 57136
Project: 57136
Buggy source:
private void setup(ARankColumnModel col){
  col.addPropertyChangeListener(ARankColumnModel.PROP_WIDTH,resort);
  col.addPropertyChangeListener(IMappedColumnMixin.PROP_MAPPING,refilter);
  col.addPropertyChangeListener(IFilterColumnMixin.PROP_FILTER,refilter);
}

Fixed version (ground truth):
private void setup(ARankColumnModel col){
  col.addPropertyChangeListener(ARankColumnModel.PROP_WIDTH,resort);
  col.addPropertyChangeListener(StackedRankColumnModel.PROP_WEIGHTS,resort);
  col.addPropertyChangeListener(IMappedColumnMixin.PROP_MAPPING,refilter);
  col.addPropertyChangeListener(IFilterColumnMixin.PROP_FILTER,refilter);
}
Program: 57137
Project: 57137
Buggy source:
@ListenTo(restrictExclusiveToEventSpace=true) public void onShowNodeContext(ShowNodeContextEvent event){
  currentContextVertexRep=event.getVertexRep();
  for (  PathwayMultiFormInfo info : pathwayInfos) {
    if (hasPathwayCurrentContext(info.pathway) && info.getCurrentEmbeddingID() != EEmbeddingID.PATHWAY_LEVEL1 && info.multiFormRenderer != lastUsedRenderer) {
      info.multiFormRenderer.setActive(info.embeddingIDToRendererIDs.get(EEmbeddingID.PATHWAY_LEVEL2).get(0));
    }
  }
  rankingElement.setFilter(new PathwayFilters.CommonVertexFilter(currentContextVertexRep,false));
  rankingElement.setRanking(new PathwayRankings.CommonVerticesRanking(currentContextVertexRep.getPathway()));
  wasContextChanged=true;
  updatePathwayPortals();
}

Fixed version (ground truth):
@ListenTo(restrictExclusiveToEventSpace=true) public void onShowNodeContext(ShowNodeContextEvent event){
  currentContextVertexRep=event.getVertexRep();
  if (event.getSender() == GLSubGraph.this)   return;
  for (  PathwayMultiFormInfo info : pathwayInfos) {
    if (hasPathwayCurrentContext(info.pathway) && info.getCurrentEmbeddingID() != EEmbeddingID.PATHWAY_LEVEL1 && info.multiFormRenderer != lastUsedRenderer) {
      info.multiFormRenderer.setActive(info.embeddingIDToRendererIDs.get(EEmbeddingID.PATHWAY_LEVEL2).get(0));
    }
  }
  rankingElement.setFilter(new PathwayFilters.CommonVertexFilter(currentContextVertexRep,false));
  rankingElement.setRanking(new PathwayRankings.CommonVerticesRanking(currentContextVertexRep.getPathway()));
  wasContextChanged=true;
  updatePathwayPortals();
}
Program: 57138
Project: 57138
Buggy source:
@Override public void display(GL2 gl){
  clearWindowStubSets();
  if (windowToSetActive != null) {
    windowToSetActive.setActive(true);
    windowToSetActive=null;
  }
  boolean updateAugmentation=false;
  if (isLayoutDirty)   updateAugmentation=true;
  super.display(gl);
  if (wasPathwayAdded) {
    EnablePathSelectionEvent event=new EnablePathSelectionEvent(isPathSelectionMode);
    event.setEventSpace(pathEventSpace);
    eventPublisher.triggerEvent(event);
    wasPathwayAdded=false;
  }
  if (updateAugmentation) {
    updateAugmentation();
  }
  dndController.handleDragging(gl,glMouseListener);
  contextMenuItemsToShow.clear();
}

Fixed version (ground truth):
@Override public void display(GL2 gl){
  clearWindowStubSets();
  if (windowToSetActive != null) {
    windowToSetActive.setActive(true);
    windowToSetActive=null;
  }
  boolean updateAugmentation=false;
  if (isLayoutDirty)   updateAugmentation=true;
  super.display(gl);
  if (wasPathwayAdded) {
    EnablePathSelectionEvent event=new EnablePathSelectionEvent(isPathSelectionMode);
    event.setEventSpace(pathEventSpace);
    eventPublisher.triggerEvent(event);
    if (currentContextVertexRep != null) {
      ShowNodeContextEvent e=new ShowNodeContextEvent(currentContextVertexRep);
      e.setEventSpace(pathEventSpace);
      e.setSender(this);
      eventPublisher.triggerEvent(e);
    }
    wasPathwayAdded=false;
  }
  if (updateAugmentation) {
    updateAugmentation();
  }
  dndController.handleDragging(gl,glMouseListener);
  contextMenuItemsToShow.clear();
}
Program: 57141
Project: 57141
Buggy source:
@Override public void propertyChange(PropertyChangeEvent evt){
  if (window == null)   return;
  if (table.getColumns().size() > 1) {
    if (window.getSize().x() != 200)     window.setSize(200,Float.NaN);
  }
 else {
    if (window.getSize().y() != 150)     window.setSize(150,Float.NaN);
    setFilter(PathwayFilters.NONE);
  }
}

Fixed version (ground truth):
@Override public void propertyChange(PropertyChangeEvent evt){
  if (window == null || window.getSize().x() < 2)   return;
  if (table.getColumns().size() > 1) {
    if (window.getSize().x() != 200)     window.setSize(200,Float.NaN);
  }
 else {
    if (window.getSize().y() != 150)     window.setSize(150,Float.NaN);
    setFilter(PathwayFilters.NONE);
  }
}
Program: 57142
Project: 57142
Buggy source:
private static boolean combine(ARankColumnModel model,ARankColumnModel with,boolean clone,int combineMode){
  final RankTableModel table=model.getTable();
  model.setCollapsed(false);
  with.setCollapsed(false);
  boolean isWithComposite=with instanceof ACompositeRankColumnModel;
  boolean isModelComposite=model instanceof ACompositeRankColumnModel;
  if (isModelComposite) {
    ACompositeRankColumnModel t=(ACompositeRankColumnModel)model;
    if (table.getConfig().canBeReusedForCombining(t,combineMode)) {
      addAll(with,clone,table,t);
    }
 else {
      createNewCombined(model,with,clone,combineMode,table);
    }
  }
 else {
    if (isWithComposite) {
      ACompositeRankColumnModel w=(ACompositeRankColumnModel)with;
      if (!clone && table.getConfig().canBeReusedForCombining(w,combineMode)) {
        model.getParent().replace(model,w);
        w.add(0,model);
      }
      createNewCombined(model,with,clone,combineMode,table);
    }
 else {
      createNewCombined(model,with,clone,combineMode,table);
    }
  }
  return true;
}

Fixed version (ground truth):
private static boolean combine(ARankColumnModel model,ARankColumnModel with,boolean clone,int combineMode){
  final RankTableModel table=model.getTable();
  model.setCollapsed(false);
  with.setCollapsed(false);
  boolean isWithComposite=with instanceof ACompositeRankColumnModel;
  boolean isModelComposite=model instanceof ACompositeRankColumnModel;
  if (isModelComposite) {
    ACompositeRankColumnModel t=(ACompositeRankColumnModel)model;
    if (table.getConfig().canBeReusedForCombining(t,combineMode)) {
      addAll(with,clone,table,t);
    }
 else {
      createNewCombined(model,with,clone,combineMode,table);
    }
  }
 else {
    if (isWithComposite) {
      ACompositeRankColumnModel w=(ACompositeRankColumnModel)with;
      if (!clone && table.getConfig().canBeReusedForCombining(w,combineMode)) {
        w.getParent().remove(w);
        model.getParent().replace(model,w);
        w.add(0,model);
      }
 else       createNewCombined(model,with,clone,combineMode,table);
    }
 else {
      createNewCombined(model,with,clone,combineMode,table);
    }
  }
  return true;
}
Program: 57143
Project: 57143
Buggy source:
private static void addAll(ARankColumnModel with,boolean clone,final RankTableModel table,ACompositeRankColumnModel model){
  boolean isWithComposite=with instanceof ACompositeRankColumnModel;
  if (isWithComposite && model.isFlatAdding((ACompositeRankColumnModel)with)) {
    if (with.getParent() != null)     with.getParent().remove(with);
    ACompositeRankColumnModel w=(ACompositeRankColumnModel)with;
    Collection<ARankColumnModel> tmp=new ArrayList<>(w.getChildren());
    if (clone) {
      for (      ARankColumnModel wi : tmp)       model.add(wi.clone());
    }
 else {
      for (      ARankColumnModel wi : tmp) {
        w.remove(wi);
        model.add(wi);
      }
    }
  }
 else   if (clone)   model.add(with.clone());
 else {
    if (with.getParent() != null)     with.getParent().remove(with);
    model.add(with);
  }
}

Fixed version (ground truth):
private static void addAll(ARankColumnModel with,boolean clone,final RankTableModel table,ACompositeRankColumnModel model){
  boolean isWithComposite=with instanceof ACompositeRankColumnModel;
  if (isWithComposite && model.isFlatAdding((ACompositeRankColumnModel)with)) {
    ACompositeRankColumnModel w=(ACompositeRankColumnModel)with;
    Collection<ARankColumnModel> tmp=new ArrayList<>(w.getChildren());
    if (clone) {
      for (      ARankColumnModel wi : tmp)       model.add(wi.clone());
    }
 else {
      for (      ARankColumnModel wi : tmp) {
        w.remove(wi);
        model.add(wi);
      }
    }
    if (with.getParent() != null)     with.getParent().remove(with);
  }
 else   if (clone)   model.add(with.clone());
 else {
    if (with.getParent() != null)     with.getParent().remove(with);
    model.add(with);
  }
}
Program: 57144
Project: 57144
Buggy source:
private void overlayBubbleSets(GL2 gl){
  if (isBubbleTextureDirty) {
    this.bubbleSet.clear();
    this.alternativeBubbleSet.clear();
    this.bubbleSet.setPathwayGraph(pathway);
    this.alternativeBubbleSet.setPathwayGraph(pathway);
    for (    Pair<List<GraphPath<PathwayVertexRep,DefaultEdge>>,Integer> pathsPair : allPathsList) {
      List<GraphPath<PathwayVertexRep,DefaultEdge>> paths=pathsPair.getFirst();
      this.alternativeBubbleSet.addAllPaths(paths,pathsPair.getSecond());
    }
    this.bubbleSet.addPathSegements(pathSegments);
    this.bubbleSet.addPathSegements(pathSegments);
    this.bubbleSet.getBubbleSetGLRenderer().setSize(pathway.getWidth(),pathway.getHeight());
    this.bubbleSet.getBubbleSetGLRenderer().update(gl,null,0);
    alternativeBubbleSet.getBubbleSetGLRenderer().setSize(pathway.getWidth(),pathway.getHeight());
    alternativeBubbleSet.getBubbleSetGLRenderer().update(gl,null,0);
    isBubbleTextureDirty=false;
  }
  gl.glPushName(generalManager.getViewManager().getPickingManager().getPickingID(uniqueID,EPickingType.PATHWAY_TEXTURE_SELECTION.name(),0));
  this.alternativeBubbleSet.getBubbleSetGLRenderer().render(gl,pixelGLConverter.getGLWidthForPixelWidth(pathway.getWidth()),pixelGLConverter.getGLHeightForPixelHeight(pathway.getHeight()),0.25f);
  this.bubbleSet.getBubbleSetGLRenderer().render(gl,pixelGLConverter.getGLWidthForPixelWidth(pathway.getWidth()),pixelGLConverter.getGLHeightForPixelHeight(pathway.getHeight()));
  gl.glPopName();
}

Fixed version (ground truth):
private void overlayBubbleSets(GL2 gl){
  if (isBubbleTextureDirty) {
    this.bubbleSet.clear();
    this.alternativeBubbleSet.clear();
    this.bubbleSet.setPathwayGraph(pathway);
    this.alternativeBubbleSet.setPathwayGraph(pathway);
    if (pathSegments.size() == 0) {
      allPathsList.clear();
    }
    for (    Pair<List<GraphPath<PathwayVertexRep,DefaultEdge>>,Integer> pathsPair : allPathsList) {
      List<GraphPath<PathwayVertexRep,DefaultEdge>> paths=pathsPair.getFirst();
      this.alternativeBubbleSet.addAllPaths(paths,pathsPair.getSecond());
    }
    this.bubbleSet.addPathSegements(pathSegments);
    this.bubbleSet.addPathSegements(pathSegments);
    this.bubbleSet.getBubbleSetGLRenderer().setSize(pathway.getWidth(),pathway.getHeight());
    this.bubbleSet.getBubbleSetGLRenderer().update(gl,null,0);
    alternativeBubbleSet.getBubbleSetGLRenderer().setSize(pathway.getWidth(),pathway.getHeight());
    alternativeBubbleSet.getBubbleSetGLRenderer().update(gl,null,0);
    isBubbleTextureDirty=false;
  }
  gl.glPushName(generalManager.getViewManager().getPickingManager().getPickingID(uniqueID,EPickingType.PATHWAY_TEXTURE_SELECTION.name(),0));
  this.alternativeBubbleSet.getBubbleSetGLRenderer().render(gl,pixelGLConverter.getGLWidthForPixelWidth(pathway.getWidth()),pixelGLConverter.getGLHeightForPixelHeight(pathway.getHeight()),0.25f);
  this.bubbleSet.getBubbleSetGLRenderer().render(gl,pixelGLConverter.getGLWidthForPixelWidth(pathway.getWidth()),pixelGLConverter.getGLHeightForPixelHeight(pathway.getHeight()));
  gl.glPopName();
}
Program: 57145
Project: 57145
Buggy source:
@ListenTo(restrictExclusiveToEventSpace=true) public void onPathSelection(PathwayPathSelectionEvent event){
  pathSegments=event.getPathSegments();
  if (pathSegments.size() > 0) {
    PathwayPath segment=pathSegments.get(pathSegments.size() - 1);
    PathwayMultiFormInfo info=getPathwayMultiFormInfo(segment.getPathway());
    if (info != null) {
      lastUsedRenderer=info.multiFormRenderer;
    }
  }
  updatePathLinks();
}

Fixed version (ground truth):
@ListenTo(restrictExclusiveToEventSpace=true) public void onPathSelection(PathwayPathSelectionEvent event){
  pathSegments=event.getPathSegments();
  if (pathSegments.size() > 0) {
    PathwayPath segment=pathSegments.get(pathSegments.size() - 1);
    PathwayMultiFormInfo info=getPathwayMultiFormInfo(segment.getPathway());
    if (info != null) {
      lastUsedRenderer=info.multiFormRenderer;
    }
  }
  updatePathwayPortals();
  updatePathLinks();
}
Program: 57146
Project: 57146
Buggy source:
protected void updatePathLinks(){
  clearWindowStubSets();
  augmentation.isDirty=true;
  augmentation.setPxlSize(this.getParentGLCanvas().getWidth(),this.getParentGLCanvas().getHeight());
  List<Rectangle2D> path=new ArrayList<>();
  IPathwayRepresentation pathwayRepresentation=null;
  PathwayMultiFormInfo pwInfo=null;
  for (  PathwayPath segment : pathSegments) {
    if (segment == null) {
      System.out.println("String_Node_Str");
      break;
    }
    for (    PathwayMultiFormInfo info : pathwayInfos) {
      pathwayRepresentation=getPathwayRepresentation(info.multiFormRenderer,info.multiFormRenderer.getActiveRendererID());
      if (pathwayRepresentation != null && (segment.getPathway() == pathwayRepresentation.getPathway())) {
        pwInfo=info;
        break;
      }
    }
    if (pathwayRepresentation != null && pwInfo != null) {
      for (      PathwayVertexRep v : segment.getNodes()) {
        Rectangle2D rect=getAbsoluteVertexLocation(pathwayRepresentation,v,pwInfo.container);
        if (rect != null)         path.add(rect);
      }
    }
  }
  augmentation.setPath(path);
}

Fixed version (ground truth):
protected void updatePathLinks(){
}