nus-yam/ex-repair huggingface dataset:
Program: 57241
Project: 57241
Buggy source:
/** 
 * @param initializer
 */
public AContentPreviewRenderer(int davidID,TablePerspective tablePerspective,EventBasedSelectionManager geneSelectionManager,EventBasedSelectionManager sampleSelectionManager){
  this.tablePerspective=tablePerspective;
  this.davidID=davidID;
  this.geneSelectionManager=geneSelectionManager;
  this.sampleSelectionManager=sampleSelectionManager;
  dataDomain=(GeneticDataDomain)tablePerspective.getDataDomain();
  if (dataDomain.isGeneRecord()) {
    experimentPerspective=tablePerspective.getDimensionPerspective();
  }
 else {
    experimentPerspective=tablePerspective.getRecordPerspective();
  }
  IDType geneIDTYpe=dataDomain.getGeneIDType();
  Set<Integer> geneIDs=dataDomain.getGeneIDMappingManager().getIDAsSet(IDType.getIDType("String_Node_Str"),geneIDTYpe,davidID);
  if (geneIDs == null) {
    geneID=null;
  }
 else {
    geneID=geneIDs.iterator().next();
    if (geneIDs.size() > 1) {
      Set<String> names=dataDomain.getGeneIDMappingManager().getIDAsSet(IDType.getIDType("String_Node_Str"),IDCategory.getIDCategory(EGeneIDTypes.GENE.name()).getHumanReadableIDType(),davidID);
      System.out.println("String_Node_Str" + names + "String_Node_Str"+ geneIDs);
    }
  }
}

Fixed version (ground truth):
public AContentPreviewRenderer(int rowID,TablePerspective tablePerspective,EventBasedSelectionManager geneSelectionManager,EventBasedSelectionManager sampleSelectionManager){
  this.tablePerspective=tablePerspective;
  this.rowID=rowID;
  this.rowIDType=IDType.getIDType("String_Node_Str");
  this.geneSelectionManager=geneSelectionManager;
  this.sampleSelectionManager=sampleSelectionManager;
  dataDomain=(GeneticDataDomain)tablePerspective.getDataDomain();
  if (dataDomain.isGeneRecord()) {
    experimentPerspective=tablePerspective.getDimensionPerspective();
  }
 else {
    experimentPerspective=tablePerspective.getRecordPerspective();
  }
  resolvedRowIDType=dataDomain.getGeneIDType();
  Set<Integer> geneIDs=dataDomain.getGeneIDMappingManager().getIDAsSet(rowIDType,resolvedRowIDType,rowID);
  if (geneIDs == null) {
    resolvedRowID=null;
  }
 else {
    resolvedRowID=geneIDs.iterator().next();
    if (geneIDs.size() > 1) {
      Set<String> names=dataDomain.getGeneIDMappingManager().getIDAsSet(rowIDType,IDCategory.getIDCategory(EGeneIDTypes.GENE.name()).getHumanReadableIDType(),rowID);
      System.out.println("String_Node_Str" + names + "String_Node_Str"+ geneIDs);
    }
  }
}
Program: 57243
Project: 57243
Buggy source:
/** 
 * @param initializor
 */
public CategoricalContentPreviewRenderer(int davidID,TablePerspective tablePerspective,EventBasedSelectionManager geneSelectionManager,EventBasedSelectionManager sampleSelectionManager){
  super(davidID,tablePerspective,geneSelectionManager,sampleSelectionManager);
  if (geneID == null)   return;
  VirtualArray geneVA=new VirtualArray(dataDomain.getGeneIDType());
  geneVA.append(geneID);
  histogram=TablePerspectiveStatistics.calculateHistogram(dataDomain.getTable(),experimentPerspective.getVirtualArray(),geneVA,dataDomain.getLabel().toLowerCase().contains("String_Node_Str") ? 5 : 2);
}

Fixed version (ground truth):
/** 
 * @param initializor
 */
public CategoricalContentPreviewRenderer(int davidID,TablePerspective tablePerspective,EventBasedSelectionManager geneSelectionManager,EventBasedSelectionManager sampleSelectionManager){
  super(davidID,tablePerspective,geneSelectionManager,sampleSelectionManager);
  if (resolvedRowID == null)   return;
  VirtualArray geneVA=new VirtualArray(dataDomain.getGeneIDType());
  geneVA.append(resolvedRowID);
  histogram=TablePerspectiveStatistics.calculateHistogram(dataDomain.getTable(),experimentPerspective.getVirtualArray(),geneVA,dataDomain.getLabel().toLowerCase().contains("String_Node_Str") ? 5 : 2);
}
Program: 57244
Project: 57244
Buggy source:
/** 
 * @param initializer
 */
public ContinuousContentPreviewRenderer(int davidID,TablePerspective tablePerspective,EventBasedSelectionManager geneSelectionManager,EventBasedSelectionManager sampleSelectionManager){
  super(davidID,tablePerspective,geneSelectionManager,sampleSelectionManager);
  colorCalculator.setBaseColor(new Color(MappedDataRenderer.SUMMARY_BAR_COLOR));
  if (geneID == null)   return;
  average=TablePerspectiveStatistics.calculateAverage(experimentPerspective.getVirtualArray(),dataDomain.getTable(),IDType.getIDType("String_Node_Str"),geneID);
}

Fixed version (ground truth):
/** 
 * @param initializer
 */
public ContinuousContentPreviewRenderer(int rowID,TablePerspective tablePerspective,EventBasedSelectionManager geneSelectionManager,EventBasedSelectionManager sampleSelectionManager){
  super(rowID,tablePerspective,geneSelectionManager,sampleSelectionManager);
  colorCalculator.setBaseColor(new Color(MappedDataRenderer.SUMMARY_BAR_COLOR));
  if (resolvedRowID == null)   return;
  average=TablePerspectiveStatistics.calculateAverage(experimentPerspective.getVirtualArray(),dataDomain.getTable(),resolvedRowIDType,resolvedRowID);
}
Program: 57247
Project: 57247
Buggy source:
@Override public void init(){
  if (rowID == null)   return;
  VirtualArray dimensionVirtualArray=new VirtualArray(dataDomain.getPrimaryIDType(rowIDType));
  dimensionVirtualArray.append(rowID);
  histogram=TablePerspectiveStatistics.calculateHistogram(dataDomain.getTable(),columnPerspective.getVirtualArray(),dimensionVirtualArray,5);
  registerPickingListener();
}

Fixed version (ground truth):
@Override public void init(){
  if (resolvedRowID == null)   return;
  VirtualArray dimensionVirtualArray=new VirtualArray(resolvedRowIDType);
  dimensionVirtualArray.append(resolvedRowID);
  histogram=TablePerspectiveStatistics.calculateHistogram(dataDomain.getTable(),columnPerspective.getVirtualArray(),dimensionVirtualArray,5);
  registerPickingListener();
}
Program: 57248
Project: 57248
Buggy source:
/** 
 * Constructor
 * @param textRenderer the <code>CaleydoTextRenderer</code> of the parent GL view
 * @param pixelGLConverter the <code>PixelGLConverter</code> of the parent GL view
 * @param davidID the id used for the resolution of the human readable id type that is rendered
 * @param backgroundColor RGBA value of the background color.
 */
public RowCaptionRenderer(Integer davidID,AGLView parentView,MappedDataRenderer parent,float[] backgroundColor){
  super(parentView,new Color(backgroundColor));
  this.davidID=davidID;
  this.parent=parent;
  textRenderer=parentView.getTextRenderer();
  pixelGLConverter=parentView.getPixelGLConverter();
}

Fixed version (ground truth):
/** 
 * Constructor
 * @param textRenderer the <code>CaleydoTextRenderer</code> of the parent GL view
 * @param pixelGLConverter the <code>PixelGLConverter</code> of the parent GL view
 * @param rowID the id used for the resolution of the human readable id type that is rendered
 * @param backgroundColor RGBA value of the background color.
 */
public RowCaptionRenderer(Integer davidID,AGLView parentView,MappedDataRenderer parent,float[] backgroundColor){
  super(parentView,new Color(backgroundColor));
  this.davidID=davidID;
  this.parent=parent;
  textRenderer=parentView.getTextRenderer();
  pixelGLConverter=parentView.getPixelGLConverter();
}
Program: 57249
Project: 57249
Buggy source:
private void calcMinWidthPixels(){
  minWidthPixels=0;
  for (int i=0; i < geneTablePerspectives.size(); i++) {
    TablePerspective tablePerspective=geneTablePerspectives.get(i);
    Perspective experimentPerspective;
    GeneticDataDomain dataDomain=(GeneticDataDomain)tablePerspective.getDataDomain();
    Group group=null;
    if (dataDomain.isGeneRecord()) {
      experimentPerspective=tablePerspective.getDimensionPerspective();
      group=tablePerspective.getDimensionGroup();
    }
 else {
      experimentPerspective=tablePerspective.getRecordPerspective();
      group=tablePerspective.getRecordGroup();
    }
    if (sampleGroupSelectionManager.checkStatus(abstractGroupType,group.getID())) {
      minWidthPixels+=ABSTRACT_GROUP_PIXEL_WIDTH;
    }
 else {
      minWidthPixels+=experimentPerspective.getVirtualArray().size() * MIN_SAMPLE_PIXEL_WIDTH;
    }
  }
  minWidthPixels+=(geneTablePerspectives.size() - 1) * SPACING_PIXEL_WIDTH;
  minWidthPixels+=CAPTION_COLUMN_PIXEL_WIDTH;
}

Fixed version (ground truth):
private void calcMinWidthPixels(){
  minWidthPixels=0;
  for (int i=0; i < geneTablePerspectives.size(); i++) {
    TablePerspective tablePerspective=geneTablePerspectives.get(i);
    Perspective experimentPerspective;
    GeneticDataDomain dataDomain=(GeneticDataDomain)tablePerspective.getDataDomain();
    Group group=null;
    if (dataDomain.isGeneRecord()) {
      experimentPerspective=tablePerspective.getDimensionPerspective();
      group=tablePerspective.getDimensionGroup();
    }
 else {
      experimentPerspective=tablePerspective.getRecordPerspective();
      group=tablePerspective.getRecordGroup();
    }
    if (group == null)     continue;
    if (sampleGroupSelectionManager.checkStatus(abstractGroupType,group.getID())) {
      minWidthPixels+=ABSTRACT_GROUP_PIXEL_WIDTH;
    }
 else {
      minWidthPixels+=experimentPerspective.getVirtualArray().size() * MIN_SAMPLE_PIXEL_WIDTH;
    }
  }
  minWidthPixels+=(geneTablePerspectives.size() - 1) * SPACING_PIXEL_WIDTH;
  minWidthPixels+=CAPTION_COLUMN_PIXEL_WIDTH;
}
Program: 57250
Project: 57250
Buggy source:
@Override public void setLimits(float x,float y){
  super.setLimits(x,y);
  PixelGLConverter pixelGLConverter=view.getPixelGLConverter();
  ViewFrustum viewFrustum=view.getViewFrustum();
  if (viewFrustum == null) {
    viewFrustum=new ViewFrustum();
    viewFrustum.setProjectionMode(CameraProjectionMode.ORTHOGRAPHIC);
  }
  viewFrustum.setLeft(0);
  viewFrustum.setBottom(0);
  viewFrustum.setRight(x);
  viewFrustum.setTop(y);
  view.setFrustum(viewFrustum);
  view.setDisplayListDirty();
}

Fixed version (ground truth):
@Override public void setLimits(float x,float y){
  if (Float.compare(this.x,x) == 0 && Float.compare(this.y,y) == 0)   return;
  super.setLimits(x,y);
  PixelGLConverter pixelGLConverter=view.getPixelGLConverter();
  ViewFrustum viewFrustum=view.getViewFrustum();
  if (viewFrustum == null) {
    viewFrustum=new ViewFrustum();
    viewFrustum.setProjectionMode(CameraProjectionMode.ORTHOGRAPHIC);
  }
  viewFrustum.setLeft(0);
  viewFrustum.setBottom(0);
  viewFrustum.setRight(x);
  viewFrustum.setTop(y);
  view.setFrustum(viewFrustum);
  view.setDisplayListDirty();
}
Program: 57251
Project: 57251
Buggy source:
@Override protected void prepare(){
  updateStrategy.processEvents();
}

Fixed version (ground truth):
@Override protected void prepare(){
  updateStrategy.processEvents();
  if (isDisplayListDirty()) {
    updateLayout();
  }
}
Program: 57252
Project: 57252
Buggy source:
@Override protected void prepare(){
  processEvents();
  if (isDisplayListDirty()) {
    layout.updateLayout();
  }
}

Fixed version (ground truth):
@Override protected void prepare(){
  processEvents();
}
Program: 57253
Project: 57253
Buggy source:
@Override public boolean isDisplayListDirty(){
  if (super.isDisplayListDirty())   return true;
  for (  APathwayPathRenderer renderer : renderers.keySet()) {
    if (renderer.isDisplayListDirty())     return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean isDisplayListDirty(){
  for (  APathwayPathRenderer renderer : renderers.keySet()) {
    if (renderer.isDisplayListDirty())     return true;
  }
  return false;
}
Program: 57255
Project: 57255
Buggy source:
private void updateChildrenOf(ColumnRanker ranker){
  boolean started=false;
  for (  ITableColumnUI r : Iterables.filter(this,ITableColumnUI.class)) {
    if (r instanceof OrderColumnUI) {
      OrderColumnUI cr=(OrderColumnUI)r;
      if (ranker != cr.getRanker())       continue;
      if (started)       break;
      started=true;
    }
    if (started)     r.update();
  }
  relayout();
}

Fixed version (ground truth):
private void updateChildrenOf(ColumnRanker ranker){
  boolean started=false;
  for (  ITableColumnUI r : Iterables.filter(this,ITableColumnUI.class)) {
    if (r instanceof OrderColumnUI) {
      OrderColumnUI cr=(OrderColumnUI)r;
      if (started) {
        ((OrderColumnUI)r).repaintAll();
        break;
      }
      if (ranker != cr.getRanker())       continue;
      started=true;
    }
    if (started)     r.update();
  }
  relayout();
}
Program: 57256
Project: 57256
Buggy source:
public void init(RankTableModel table,boolean interactive,IRowHeightLayout... layouts){
  setLayout(new TableLayout(layouts.length > 1));
  if (layouts.length > 1) {
    ButtonBar buttons=new ButtonBar();
    buttons.setzDelta(0.5f);
    RadioController radio=new RadioController(this);
    for (int i=0; i < layouts.length; ++i) {
      GLButton b=new GLButton();
      b.setLayoutData(layouts[i]);
      b.setRenderer(renderer);
      radio.add(b);
      buttons.addButton(b);
    }
    this.add(buttons);
  }
  this.add(new TableHeaderUI(table,interactive));
  this.add(new TableBodyUI(table,layouts.length == 0 ? RowHeightLayouts.UNIFORM : layouts[0]));
  if (interactive && !table.getConfig().isDestroyOnHide())   this.add(new ColumnPoolUI(table));
}

Fixed version (ground truth):
public void init(RankTableModel table,boolean interactive,IRowHeightLayout... layouts){
  setLayout(GLLayouts.flowVertical(0));
  if (layouts.length > 1) {
    ButtonBar buttons=new ButtonBar();
    buttons.setzDelta(0.5f);
    RadioController radio=new RadioController(this);
    for (int i=0; i < layouts.length; ++i) {
      GLButton b=new GLButton();
      b.setLayoutData(layouts[i]);
      b.setRenderer(renderer);
      radio.add(b);
      buttons.addButton(b);
    }
    this.add(buttons);
  }
  this.add(new TableHeaderUI(table,interactive));
  this.add(new TableBodyUI(table,layouts.length == 0 ? RowHeightLayouts.UNIFORM : layouts[0]));
  if (interactive && !table.getConfig().isDestroyOnHide())   this.add(new ColumnPoolUI(table));
}
Program: 57257
Project: 57257
Buggy source:
@Override protected void prepare(){
  currentRenderer.prepare();
  if (currentRenderer.isDisplayListDirty())   super.setDisplayListDirty();
}

Fixed version (ground truth):
@Override protected void prepare(){
  currentRenderer.prepare();
  super.setDisplayListDirty(currentRenderer.isDisplayListDirty());
}
Program: 57258
Project: 57258
Buggy source:
@Override public void setDisplayListDirty(){
  super.setDisplayListDirty();
  currentRenderer.setDisplayListDirty();
}

Fixed version (ground truth):
@Override public void setDisplayListDirty(boolean isDisplayListDirty){
  super.setDisplayListDirty(isDisplayListDirty);
  currentRenderer.setDisplayListDirty(isDisplayListDirty);
}
Program: 57259
Project: 57259
Buggy source:
/** 
 * Set the limits of this renderer. The view must render within only these limits.
 * @param x
 * @param y
 */
public void setLimits(float x,float y){
  this.x=x;
  this.y=y;
  setDisplayListDirty();
}

Fixed version (ground truth):
/** 
 * Set the limits of this renderer. The view must render within only these limits.
 * @param x
 * @param y
 */
public void setLimits(float x,float y){
  this.x=x;
  this.y=y;
  setDisplayListDirty(true);
}
Program: 57260
Project: 57260
Buggy source:
/** 
 * Sets the display list of this renderer dirty.
 */
public void setDisplayListDirty(){
  this.isDisplayListDirty=true;
}

Fixed version (ground truth):
/** 
 * Sets   {@link #isDisplayListDirty()}
 */
public void setDisplayListDirty(boolean isDisplayListDirty){
  this.isDisplayListDirty=isDisplayListDirty;
}
Program: 57261
Project: 57261
Buggy source:
/** 
 * Rendering method.
 * @param gl
 */
public final void render(GL2 gl){
  boolean displayListsAllowedByLayoutManager=false;
  if (layoutManager != null) {
    displayListsAllowedByLayoutManager=layoutManager.isUseDisplayLists();
  }
  if (displayListsAllowedByLayoutManager && !hasDisplayListIndex && permitsWrappingDisplayLists()) {
    displayListIndex=gl.glGenLists(1);
    hasDisplayListIndex=true;
  }
  prepare();
  if (isDisplayListDirty() && permitsWrappingDisplayLists() && displayListsAllowedByLayoutManager) {
    gl.glNewList(displayListIndex,GL2.GL_COMPILE);
    renderContent(gl);
    gl.glEndList();
    isDisplayListDirty=false;
  }
  if (permitsWrappingDisplayLists() && displayListsAllowedByLayoutManager) {
    gl.glCallList(displayListIndex);
  }
 else {
    renderContent(gl);
  }
}

Fixed version (ground truth):
/** 
 * Rendering method.
 * @param gl
 */
public final void render(GL2 gl){
  boolean displayListsAllowedByLayoutManager=false;
  if (layoutManager != null) {
    displayListsAllowedByLayoutManager=layoutManager.isUseDisplayLists();
  }
  if (displayListsAllowedByLayoutManager && !hasDisplayListIndex && permitsWrappingDisplayLists()) {
    displayListIndex=gl.glGenLists(1);
    hasDisplayListIndex=true;
  }
  prepare();
  if (isDisplayListDirty() && permitsWrappingDisplayLists() && displayListsAllowedByLayoutManager) {
    gl.glNewList(displayListIndex,GL2.GL_COMPILE);
    renderContent(gl);
    gl.glEndList();
    setDisplayListDirty(false);
  }
  if (permitsWrappingDisplayLists() && displayListsAllowedByLayoutManager) {
    gl.glCallList(displayListIndex);
  }
 else {
    renderContent(gl);
  }
}
Program: 57262
Project: 57262
Buggy source:
/** 
 * Sets the display lists of all renderers of this layout dirty.
 */
void setRenderingDirty(){
  if (isHidden)   return;
  if (foregroundRenderers != null) {
    for (    ALayoutRenderer renderer : foregroundRenderers) {
      renderer.setDisplayListDirty();
    }
  }
  if (backgroundRenderers != null) {
    for (    ALayoutRenderer renderer : backgroundRenderers) {
      renderer.setDisplayListDirty();
    }
  }
  if (renderer != null) {
    renderer.setDisplayListDirty();
  }
}

Fixed version (ground truth):
/** 
 * Sets the display lists of all renderers of this layout dirty.
 */
void setRenderingDirty(){
  if (isHidden)   return;
  if (foregroundRenderers != null) {
    for (    ALayoutRenderer renderer : foregroundRenderers) {
      renderer.setDisplayListDirty(true);
    }
  }
  if (backgroundRenderers != null) {
    for (    ALayoutRenderer renderer : backgroundRenderers) {
      renderer.setDisplayListDirty(true);
    }
  }
  if (renderer != null) {
    renderer.setDisplayListDirty(true);
  }
}
Program: 57263
Project: 57263
Buggy source:
/** 
 * @param color Color with rgba values.
 */
public void setColor(float[] color){
  this.color=color;
  setDisplayListDirty();
}

Fixed version (ground truth):
/** 
 * @param color Color with rgba values.
 */
public void setColor(float[] color){
  this.color=color;
  setDisplayListDirty(true);
}
Program: 57264
Project: 57264
Buggy source:
public void setBorderColor(float[] borderColor){
  this.borderColor=borderColor;
  setDisplayListDirty();
}

Fixed version (ground truth):
public void setBorderColor(float[] borderColor){
  this.borderColor=borderColor;
  setDisplayListDirty(true);
}
Program: 57265
Project: 57265
Buggy source:
/** 
 * @param showGradient setter, see  {@link #useGradient}
 */
public void setUseGradient(boolean useGradient){
  this.useGradient=useGradient;
  setDisplayListDirty();
}

Fixed version (ground truth):
/** 
 * @param showGradient setter, see  {@link #useGradient}
 */
public void setUseGradient(boolean useGradient){
  this.useGradient=useGradient;
  setDisplayListDirty(true);
}
Program: 57266
Project: 57266
Buggy source:
public void setDrawBorder(boolean drawBorder){
  this.drawBorder=drawBorder;
  setDisplayListDirty();
}

Fixed version (ground truth):
public void setDrawBorder(boolean drawBorder){
  this.drawBorder=drawBorder;
  setDisplayListDirty(true);
}
Program: 57267
Project: 57267
Buggy source:
public void setBorderWidth(int borderWidth){
  this.borderWidth=borderWidth;
  setDisplayListDirty();
}

Fixed version (ground truth):
public void setBorderWidth(int borderWidth){
  this.borderWidth=borderWidth;
  setDisplayListDirty(true);
}
Program: 57268
Project: 57268
Buggy source:
public void setColor(float[] color){
  this.color=color;
  setDisplayListDirty();
}

Fixed version (ground truth):
public void setColor(float[] color){
  this.color=color;
  setDisplayListDirty(true);
}
Program: 57269
Project: 57269
Buggy source:
/** 
 * @param isHorizontalGradient setter, see  {@link #isHorizontalGradient}
 */
public void setHorizontalGradient(boolean isHorizontalGradient){
  this.isHorizontalGradient=isHorizontalGradient;
  setDisplayListDirty();
}

Fixed version (ground truth):
/** 
 * @param isHorizontalGradient setter, see  {@link #isHorizontalGradient}
 */
public void setHorizontalGradient(boolean isHorizontalGradient){
  this.isHorizontalGradient=isHorizontalGradient;
  setDisplayListDirty(true);
}
Program: 57270
Project: 57270
Buggy source:
/** 
 * @param gradientColor setter, see  {@link #gradientColor}
 */
public void setGradientColor(float[] gradientColor){
  this.gradientColor=gradientColor;
  setDisplayListDirty();
}

Fixed version (ground truth):
/** 
 * @param gradientColor setter, see  {@link #gradientColor}
 */
public void setGradientColor(float[] gradientColor){
  this.gradientColor=gradientColor;
  setDisplayListDirty(true);
}
Program: 57271
Project: 57271
Buggy source:
@Override protected void prepare(){
  if (labelProvider != null)   label=labelProvider.getLabel();
  if (!prevLabel.equals(label)) {
    setDisplayListDirty();
  }
  prevLabel=label;
}

Fixed version (ground truth):
@Override protected void prepare(){
  if (labelProvider != null)   label=labelProvider.getLabel();
  if (!prevLabel.equals(label)) {
    setDisplayListDirty(true);
  }
  prevLabel=label;
}
Program: 57272
Project: 57272
Buggy source:
/** 
 * @param lineWidth setter, see  {@link lineWidth}
 */
public void setLineWidth(float lineWidth){
  if (lineWidth == this.lineWidth)   return;
  this.lineWidth=lineWidth;
  setDisplayListDirty();
}

Fixed version (ground truth):
/** 
 * @param lineWidth setter, see  {@link lineWidth}
 */
public void setLineWidth(float lineWidth){
  if (lineWidth == this.lineWidth)   return;
  this.lineWidth=lineWidth;
  setDisplayListDirty(true);
}
Program: 57273
Project: 57273
Buggy source:
@Override public void setDisplayListDirty(){
  if (!ensureValidRenderer())   return;
  super.setDisplayListDirty();
}

Fixed version (ground truth):
@Override public void setDisplayListDirty(boolean isDisplayListDiry){
  if (!ensureValidRenderer())   return;
  super.setDisplayListDirty(isDisplayListDiry);
}
Program: 57274
Project: 57274
Buggy source:
@Override public void repaintPick(){
  setDisplayListDirty();
}

Fixed version (ground truth):
@Override public void repaintPick(){
  setDisplayListDirty(true);
}
Program: 57275
Project: 57275
Buggy source:
@Override public void repaint(){
  setDisplayListDirty();
}

Fixed version (ground truth):
@Override public void repaint(){
  setDisplayListDirty(true);
}
Program: 57276
Project: 57276
Buggy source:
/** 
 * @param zCoordinate setter, see  {@link #zCoordinate}
 */
public ButtonRenderer setZCoordinate(float zCoordinate){
  this.zCoordinate=zCoordinate;
  setDisplayListDirty();
  return this;
}

Fixed version (ground truth):
/** 
 * @param zCoordinate setter, see  {@link #zCoordinate}
 */
public ButtonRenderer setZCoordinate(float zCoordinate){
  this.zCoordinate=zCoordinate;
  setDisplayListDirty(true);
  return this;
}
Program: 57277
Project: 57277
Buggy source:
public void setTextureRotation(ETextureRotation textureRotation){
  this.textureRotation=textureRotation;
  setDisplayListDirty();
}

Fixed version (ground truth):
public void setTextureRotation(ETextureRotation textureRotation){
  this.textureRotation=textureRotation;
  setDisplayListDirty(true);
}
Program: 57278
Project: 57278
Buggy source:
@Override protected void prepare(){
  updateStrategy.processEvents();
  if (isDisplayListDirty()) {
    updateLayout();
  }
}

Fixed version (ground truth):
@Override protected void prepare(){
  updateStrategy.processEvents();
}
Program: 57279
Project: 57279
Buggy source:
/** 
 * @param currentExpandedBranchNode setter, see  {@link #expandedBranchSummaryNode}
 */
public void setExpandedBranchSummaryNode(BranchSummaryNode expandedBranchSummaryNode){
  if (this.expandedBranchSummaryNode != expandedBranchSummaryNode) {
    this.expandedBranchSummaryNode=expandedBranchSummaryNode;
    for (    ALinearizableNode node : pathNodes) {
      node.setPickable(expandedBranchSummaryNode == null);
    }
    PathRendererChangedEvent event=new PathRendererChangedEvent(this);
    event.setSender(this);
    GeneralManager.get().getEventPublisher().triggerEvent(event);
    updateLayout();
  }
}

Fixed version (ground truth):
/** 
 * @param currentExpandedBranchNode setter, see  {@link #expandedBranchSummaryNode}
 */
public void setExpandedBranchSummaryNode(BranchSummaryNode expandedBranchSummaryNode){
  if (this.expandedBranchSummaryNode != expandedBranchSummaryNode) {
    this.expandedBranchSummaryNode=expandedBranchSummaryNode;
    PathRendererChangedEvent event=new PathRendererChangedEvent(this);
    event.setSender(this);
    GeneralManager.get().getEventPublisher().triggerEvent(event);
    updateLayout();
    setDisplayListDirty(true);
  }
}
Program: 57280
Project: 57280
Buggy source:
/** 
 * Selects a branch node to be linearized.
 * @param node
 */
public void selectBranch(ALinearizableNode node){
  List<List<PathwayVertexRep>> newPathSegments=getBranchPath(node);
  if (updateStrategy.isPathChangePermitted(newPathSegments)) {
    setExpandedBranchSummaryNode(null);
    setPath(newPathSegments);
    updateStrategy.triggerPathUpdate();
  }
}

Fixed version (ground truth):
/** 
 * Selects a branch node to be linearized.
 * @param node
 */
public void selectBranch(ALinearizableNode node){
  List<List<PathwayVertexRep>> newPathSegments=getBranchPath(node);
  if (updateStrategy.isPathChangePermitted(newPathSegments)) {
    setExpandedBranchSummaryNode(null);
    setPath(newPathSegments);
    updateStrategy.triggerPathUpdate();
    setDisplayListDirty(true);
  }
}
Program: 57281
Project: 57281
Buggy source:
@Override public void notifyOfSelectionChange(EventBasedSelectionManager selectionManager){
  setDisplayListDirty();
}

Fixed version (ground truth):
@Override public void notifyOfSelectionChange(EventBasedSelectionManager selectionManager){
  setDisplayListDirty(true);
}
Program: 57282
Project: 57282
Buggy source:
@ListenTo(restrictExclusiveToEventSpace=true) public void onShowPortalNodes(ShowPortalNodesEvent event){
  Set<PathwayVertexRep> vertexReps=PathwayManager.get().getEquivalentVertexRepsInPathway(event.getVertexRep(),pathway);
  if (event.getVertexRep().getPathway() == pathway) {
    vertexReps.add(event.getVertexRep());
  }
  Set<APathwayPathRenderer> renderersToRemove=new HashSet<>(renderers.keySet());
  renderersToRemove.remove(selectedPathRenderer);
  for (  PathwayVertexRep vertexRep : vertexReps) {
    boolean createNewPath=true;
    for (    APathwayPathRenderer renderer : renderers.keySet()) {
      if (PathUtility.containsVertexRep(renderer.pathSegments,vertexRep)) {
        renderersToRemove.remove(renderer);
        createNewPath=false;
        break;
      }
    }
    if (createNewPath) {
      List<PathwayVertexRep> segment=PathwayManager.get().determineDirectionalPath(vertexRep,false,5);
      segment.remove(0);
      Collections.reverse(segment);
      segment.addAll(PathwayManager.get().determineDirectionalPath(vertexRep,true,5));
      List<List<PathwayVertexRep>> pathSegments=new ArrayList<>(1);
      pathSegments.add(segment);
      addPath(pathSegments);
    }
  }
  for (  APathwayPathRenderer renderer : renderersToRemove) {
    removePath(renderer);
  }
  setDisplayListDirty();
  layout.updateLayout();
  triggerMinSizeUpdate();
}

Fixed version (ground truth):
@ListenTo(restrictExclusiveToEventSpace=true) public void onShowPortalNodes(ShowPortalNodesEvent event){
  Set<PathwayVertexRep> vertexReps=PathwayManager.get().getEquivalentVertexRepsInPathway(event.getVertexRep(),pathway);
  if (event.getVertexRep().getPathway() == pathway) {
    vertexReps.add(event.getVertexRep());
  }
  Set<APathwayPathRenderer> renderersToRemove=new HashSet<>(renderers.keySet());
  renderersToRemove.remove(selectedPathRenderer);
  for (  PathwayVertexRep vertexRep : vertexReps) {
    boolean createNewPath=true;
    for (    APathwayPathRenderer renderer : renderers.keySet()) {
      if (PathUtility.containsVertexRep(renderer.pathSegments,vertexRep)) {
        renderersToRemove.remove(renderer);
        createNewPath=false;
        break;
      }
    }
    if (createNewPath) {
      List<PathwayVertexRep> segment=PathwayManager.get().determineDirectionalPath(vertexRep,false,5);
      segment.remove(0);
      Collections.reverse(segment);
      segment.addAll(PathwayManager.get().determineDirectionalPath(vertexRep,true,5));
      List<List<PathwayVertexRep>> pathSegments=new ArrayList<>(1);
      pathSegments.add(segment);
      addPath(pathSegments);
    }
  }
  for (  APathwayPathRenderer renderer : renderersToRemove) {
    removePath(renderer);
  }
  setDisplayListDirty(true);
  layout.updateLayout();
  triggerMinSizeUpdate();
}
Program: 57283
Project: 57283
Buggy source:
@Override public boolean isDisplayListDirty(){
  if (isDisplayListDirty)   return true;
  for (  APathwayPathRenderer renderer : renderers.keySet()) {
    if (renderer.isDisplayListDirty())     return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean isDisplayListDirty(){
  if (super.isDisplayListDirty())   return true;
  for (  APathwayPathRenderer renderer : renderers.keySet()) {
    if (renderer.isDisplayListDirty())     return true;
  }
  return false;
}
Program: 57284
Project: 57284
Buggy source:
@Override public void registerPickingListeners(){
  for (  Integer nodeId : nodeIds) {
    showButtonPickingListener=new ATimedMouseOutPickingListener(){
      @Override protected void timedMouseOut(      Pick pick){
        showRemoveButton=false;
        pathwayPathRenderer.setDisplayListDirty();
      }
      @Override public void mouseOver(      Pick pick){
        if (!node.isPickable())         return;
        if (pathwayPathRenderer.isFirstNode((ALinearizableNode)node) || pathwayPathRenderer.isLastNode((ALinearizableNode)node)) {
          super.mouseOver(pick);
          showRemoveButton=true;
          pathwayPathRenderer.setDisplayListDirty();
        }
      }
    }
;
    view.addIDPickingListener(showButtonPickingListener,EPickingType.LINEARIZABLE_NODE.name(),nodeId);
    view.addIDPickingListener(showButtonPickingListener,EPickingType.REMOVABLE_NODE.name(),nodeId);
    buttonPickingListener=new APickingListener(){
      @Override public void clicked(      Pick pick){
        if (!node.isPickable())         return;
        RemoveEnRouteNodeEvent event=new RemoveEnRouteNodeEvent((ALinearizableNode)node);
        event.setSender(this);
        GeneralManager.get().getEventPublisher().triggerEvent(event);
        pathwayPathRenderer.removeNodeFromPath((ALinearizableNode)node);
      }
    }
;
    view.addIDPickingListener(buttonPickingListener,EPickingType.REMOVE_NODE_BUTTON.name(),nodeId);
  }
}

Fixed version (ground truth):
@Override public void registerPickingListeners(){
  for (  Integer nodeId : nodeIds) {
    showButtonPickingListener=new ATimedMouseOutPickingListener(){
      @Override protected void timedMouseOut(      Pick pick){
        showRemoveButton=false;
        pathwayPathRenderer.setDisplayListDirty(true);
      }
      @Override public void mouseOver(      Pick pick){
        if (!node.isPickable())         return;
        if (pathwayPathRenderer.isFirstNode((ALinearizableNode)node) || pathwayPathRenderer.isLastNode((ALinearizableNode)node)) {
          super.mouseOver(pick);
          showRemoveButton=true;
          pathwayPathRenderer.setDisplayListDirty(true);
        }
      }
    }
;
    view.addIDPickingListener(showButtonPickingListener,EPickingType.LINEARIZABLE_NODE.name(),nodeId);
    view.addIDPickingListener(showButtonPickingListener,EPickingType.REMOVABLE_NODE.name(),nodeId);
    buttonPickingListener=new APickingListener(){
      @Override public void clicked(      Pick pick){
        if (!node.isPickable())         return;
        RemoveEnRouteNodeEvent event=new RemoveEnRouteNodeEvent((ALinearizableNode)node);
        event.setSender(this);
        GeneralManager.get().getEventPublisher().triggerEvent(event);
        pathwayPathRenderer.removeNodeFromPath((ALinearizableNode)node);
      }
    }
;
    view.addIDPickingListener(buttonPickingListener,EPickingType.REMOVE_NODE_BUTTON.name(),nodeId);
  }
}
Program: 57285
Project: 57285
Buggy source:
@Override public void mouseOver(Pick pick){
  if (!node.isPickable())   return;
  if (pathwayPathRenderer.isFirstNode((ALinearizableNode)node) || pathwayPathRenderer.isLastNode((ALinearizableNode)node)) {
    super.mouseOver(pick);
    showRemoveButton=true;
    pathwayPathRenderer.setDisplayListDirty();
  }
}

Fixed version (ground truth):
@Override public void mouseOver(Pick pick){
  if (!node.isPickable())   return;
  if (pathwayPathRenderer.isFirstNode((ALinearizableNode)node) || pathwayPathRenderer.isLastNode((ALinearizableNode)node)) {
    super.mouseOver(pick);
    showRemoveButton=true;
    pathwayPathRenderer.setDisplayListDirty(true);
  }
}
Program: 57286
Project: 57286
Buggy source:
@Override protected void timedMouseOut(Pick pick){
  showRemoveButton=false;
  pathwayPathRenderer.setDisplayListDirty();
}

Fixed version (ground truth):
@Override protected void timedMouseOut(Pick pick){
  showRemoveButton=false;
  pathwayPathRenderer.setDisplayListDirty(true);
}
Program: 57287
Project: 57287
Buggy source:
@Override protected void determineBackgroundColor(EventBasedSelectionManager selectionManager){
  List<SelectionType> selectionTypes=selectionManager.getSelectionTypes(node.getPrimaryPathwayVertexRep().getName().hashCode());
  Collections.sort(selectionTypes);
  Collections.reverse(selectionTypes);
  colorCalculator.calculateColors(selectionTypes);
  backgroundColor=colorCalculator.getPrimaryColor().getRGB();
}

Fixed version (ground truth):
@Override protected void determineBackgroundColor(EventBasedSelectionManager selectionManager){
  List<SelectionType> selectionTypes=selectionManager.getSelectionTypes(node.getPrimaryPathwayVertexRep().getName().hashCode());
  Collections.sort(selectionTypes);
  Collections.reverse(selectionTypes);
  colorCalculator.calculateColors(selectionTypes);
  backgroundColor=colorCalculator.getPrimaryColor().getRGBA();
}
Program: 57288
Project: 57288
Buggy source:
protected void renderCircle(GL2 gl,GLU glu,Vec3f position,float radius){
  gl.glPushName(pickingManager.getPickingID(view.getID(),EPickingType.LINEARIZABLE_NODE.name(),node.hashCode()));
  gl.glPushMatrix();
  gl.glTranslatef(position.x(),position.y(),position.z());
  gl.glColor4f(backgroundColor[0],backgroundColor[1],backgroundColor[2],pathwayPathRenderer.getNodeAlpha());
  gl.glColor4fv(backgroundColor,0);
  GLPrimitives.renderCircle(glu,radius / 2.0f,16);
  gl.glColor4f(0,0,0,1);
  GLPrimitives.renderCircleBorder(gl,glu,radius / 2.0f,16,0.1f);
  gl.glPopMatrix();
  gl.glPopName();
}

Fixed version (ground truth):
protected void renderCircle(GL2 gl,GLU glu,Vec3f position,float radius){
  gl.glPushName(pickingManager.getPickingID(view.getID(),EPickingType.LINEARIZABLE_NODE.name(),node.hashCode()));
  gl.glPushMatrix();
  gl.glTranslatef(position.x(),position.y(),position.z());
  gl.glColor4fv(backgroundColor,0);
  GLPrimitives.renderCircle(glu,radius / 2.0f,16);
  gl.glColor4f(0,0,0,1);
  GLPrimitives.renderCircleBorder(gl,glu,radius / 2.0f,16,0.1f);
  gl.glPopMatrix();
  gl.glPopName();
}
Program: 57289
Project: 57289
Buggy source:
private void createRemoteRenderedViews(){
  if (remoteRenderedPathwayMultiformViewIDs == null) {
    pathInfo=new MultiFormInfo();
    createMultiformRenderer(tablePerspectives,EnumSet.of(EEmbeddingID.PATH_LEVEL1,EEmbeddingID.PATH_LEVEL2),baseContainer,0.3f,pathInfo);
    int rendererID=pathInfo.embeddingIDToRendererIDs.get(EEmbeddingID.PATH_LEVEL2).get(0);
    if (pathInfo.multiFormRenderer.getActiveRendererID() != rendererID) {
      pathInfo.multiFormRenderer.setActive(rendererID);
    }
 else {
      setPathLevel(EEmbeddingID.PATH_LEVEL2);
    }
  }
}

Fixed version (ground truth):
private void createRemoteRenderedViews(){
  if (remoteRenderedPathwayMultiformViewIDs == null) {
    addPathway(PathwayManager.get().getPathwayByTitle("String_Node_Str",EPathwayDatabaseType.KEGG));
  }
}
Program: 57290
Project: 57290
Buggy source:
@Override protected void onMouseOver(Pick pick){
  GLPathwayBackground currentActiveBackground=view.getCurrentActiveBackground();
  if (currentActiveBackground != null && currentActiveBackground != this) {
    currentActiveBackground.hovered=false;
    currentActiveBackground.repaint();
  }
  view.setCurrentActiveBackground(this);
  hovered=true;
  repaint();
}

Fixed version (ground truth):
@Override protected void onMouseOver(Pick pick){
  parentWindow.setActive(true);
}
Program: 57291
Project: 57291
Buggy source:
public GLPathwayBackground(GLSubGraph view){
  this.view=view;
}

Fixed version (ground truth):
public GLPathwayBackground(GLPathwayWindow parentWindow){
  this.parentWindow=parentWindow;
}
Program: 57292
Project: 57292
Buggy source:
private boolean demote(MultiFormInfo info){
  if (info.multiFormRenderer != view.lastUsedRenderer) {
    EEmbeddingID level=info.getEmbeddingIDFromRendererID(info.multiFormRenderer.getActiveRendererID());
    EEmbeddingID levelDown=EEmbeddingID.levelDown(level);
    if (levelDown != level) {
      int rendererID=info.embeddingIDToRendererIDs.get(levelDown).get(0);
      info.multiFormRenderer.setActive(rendererID);
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
private boolean demote(MultiFormInfo info){
  if (info.multiFormRenderer != view.lastUsedRenderer && info.multiFormRenderer != view.lastUsedLevel1Renderer) {
    EEmbeddingID level=info.getEmbeddingIDFromRendererID(info.multiFormRenderer.getActiveRendererID());
    EEmbeddingID levelDown=EEmbeddingID.levelDown(level);
    if (levelDown != level) {
      int rendererID=info.embeddingIDToRendererIDs.get(levelDown).get(0);
      info.multiFormRenderer.setActive(rendererID);
      return true;
    }
  }
  return false;
}
Program: 57293
Project: 57293
Buggy source:
public GLPathwayWindow(PathwayGraph pathway,GLSubGraph view,final MultiFormInfo info){
  setLayout(GLLayouts.LAYERS);
  this.info=info;
  GLElementContainer multiFormContainer=new GLElementContainer(new GLSizeRestrictiveFlowLayout(false,1,GLPadding.ZERO));
  GLTitleBar titleBar=new GLTitleBar(pathway == null ? "String_Node_Str" : pathway.getTitle());
  multiFormContainer.add(titleBar);
  GLElementAdapter container=new GLElementAdapter(view,info.multiFormRenderer,true);
  multiFormContainer.add(container);
  info.container=container;
  GLElementViewSwitchingBar viewSwitchingBar=new GLElementViewSwitchingBar(info.multiFormRenderer);
  GLPathwayBackground bg=new GLPathwayBackground(view);
  titleBar.add(viewSwitchingBar);
  add(bg);
  add(multiFormContainer);
}

Fixed version (ground truth):
public GLPathwayWindow(PathwayGraph pathway,GLSubGraph view,final MultiFormInfo info){
  setLayout(GLLayouts.LAYERS);
  this.info=info;
  this.view=view;
  GLElementContainer multiFormContainer=new GLElementContainer(new GLSizeRestrictiveFlowLayout(false,1,GLPadding.ZERO));
  GLTitleBar titleBar=new GLTitleBar(pathway == null ? "String_Node_Str" : pathway.getTitle());
  multiFormContainer.add(titleBar);
  GLElementAdapter container=new GLElementAdapter(view,info.multiFormRenderer,true);
  multiFormContainer.add(container);
  info.container=container;
  viewSwitchingBar=new GLElementViewSwitchingBar(info.multiFormRenderer);
  background=new GLPathwayBackground(this);
  titleBar.add(viewSwitchingBar);
  viewSwitchingBar.setVisibility(EVisibility.NONE);
  add(background);
  add(multiFormContainer);
}
Program: 57296
Project: 57296
Buggy source:
@Override public void activeRendererChanged(MultiFormRenderer multiFormRenderer,int rendererID,int previousRendererID,boolean wasTriggeredByUser){
  if (pathInfo == null || !pathInfo.isInitialized())   return;
  if (multiFormRenderer == pathInfo.multiFormRenderer) {
    EEmbeddingID embeddingID=pathInfo.getEmbeddingIDFromRendererID(rendererID);
    setPathLevel(embeddingID);
  }
  if (wasTriggeredByUser && rendererID != previousRendererID) {
    for (    PathwayMultiFormInfo info : pathwayInfos) {
      if (info.multiFormRenderer == multiFormRenderer) {
        if (info.getEmbeddingIDFromRendererID(rendererID) == EEmbeddingID.PATHWAY_LEVEL1) {
          pathwayLayout.setLevel1(info.window);
          info.age=currentPathwayAge--;
          lastUsedRenderer=info.multiFormRenderer;
          break;
        }
      }
    }
    pathwayRow.relayout();
  }
}

Fixed version (ground truth):
@Override public void activeRendererChanged(MultiFormRenderer multiFormRenderer,int rendererID,int previousRendererID,boolean wasTriggeredByUser){
  if (pathInfo == null || !pathInfo.isInitialized())   return;
  if (multiFormRenderer == pathInfo.multiFormRenderer) {
    EEmbeddingID embeddingID=pathInfo.getEmbeddingIDFromRendererID(rendererID);
    setPathLevel(embeddingID);
  }
  if (wasTriggeredByUser && rendererID != previousRendererID) {
    for (    PathwayMultiFormInfo info : pathwayInfos) {
      if (info.multiFormRenderer == multiFormRenderer) {
        if (info.getEmbeddingIDFromRendererID(rendererID) == EEmbeddingID.PATHWAY_LEVEL1) {
          pathwayLayout.setLevel1(info.window);
          lastUsedLevel1Renderer=info.multiFormRenderer;
        }
        info.age=currentPathwayAge--;
        lastUsedRenderer=info.multiFormRenderer;
        break;
      }
    }
    pathwayRow.relayout();
  }
}
Program: 57297
Project: 57297
Buggy source:
private void createRemoteRenderedViews(){
  if (remoteRenderedPathwayMultiformViewIDs == null) {
    addPathway(PathwayManager.get().getPathwayByTitle("String_Node_Str",EPathwayDatabaseType.KEGG));
  }
}

Fixed version (ground truth):
private void createRemoteRenderedViews(){
  if (remoteRenderedPathwayMultiformViewIDs == null) {
    pathInfo=new MultiFormInfo();
    createMultiformRenderer(tablePerspectives,EnumSet.of(EEmbeddingID.PATH_LEVEL1,EEmbeddingID.PATH_LEVEL2),baseContainer,0.3f,pathInfo);
    int rendererID=pathInfo.embeddingIDToRendererIDs.get(EEmbeddingID.PATH_LEVEL2).get(0);
    if (pathInfo.multiFormRenderer.getActiveRendererID() != rendererID) {
      pathInfo.multiFormRenderer.setActive(rendererID);
    }
 else {
      setPathLevel(EEmbeddingID.PATH_LEVEL2);
    }
  }
}
Program: 57298
Project: 57298
Buggy source:
@Override public void activeRendererChanged(MultiFormRenderer multiFormRenderer,int rendererID,int previousRendererID,boolean wasTriggeredByUser){
  if (pathInfo == null || !pathInfo.isInitialized())   return;
  if (multiFormRenderer == pathInfo.multiFormRenderer) {
    EEmbeddingID embeddingID=pathInfo.getEmbeddingIDFromRendererID(rendererID);
    setPathLevel(embeddingID);
  }
  if (wasTriggeredByUser && rendererID != previousRendererID) {
    for (    PathwayMultiFormInfo info : pathwayInfos) {
      if (info.multiFormRenderer == multiFormRenderer) {
        if (info.getEmbeddingIDFromRendererID(rendererID) == EEmbeddingID.PATHWAY_LEVEL1) {
          pathwayLayout.setLevel1(info.window);
          lastUsedLevel1Renderer=info.multiFormRenderer;
        }
        info.age=currentPathwayAge--;
        lastUsedRenderer=info.multiFormRenderer;
        break;
      }
    }
    pathwayRow.relayout();
  }
}

Fixed version (ground truth):
@Override public void activeRendererChanged(MultiFormRenderer multiFormRenderer,int rendererID,int previousRendererID,boolean wasTriggeredByUser){
  if (pathInfo != null && pathInfo.isInitialized()) {
    if (multiFormRenderer == pathInfo.multiFormRenderer) {
      EEmbeddingID embeddingID=pathInfo.getEmbeddingIDFromRendererID(rendererID);
      setPathLevel(embeddingID);
    }
  }
  if (wasTriggeredByUser && rendererID != previousRendererID) {
    for (    PathwayMultiFormInfo info : pathwayInfos) {
      if (info.multiFormRenderer == multiFormRenderer) {
        if (info.getEmbeddingIDFromRendererID(rendererID) == EEmbeddingID.PATHWAY_LEVEL1) {
          pathwayLayout.setLevel1(info.window);
          lastUsedLevel1Renderer=info.multiFormRenderer;
        }
        info.age=currentPathwayAge--;
        lastUsedRenderer=info.multiFormRenderer;
        break;
      }
    }
    pathwayRow.relayout();
  }
}
Program: 57299
Project: 57299
Buggy source:
protected void handlePicking(String pickingType,PickingMode pickingMode,int pickedObjectID,Pick pick){
  Set<IPickingListener> pickingListeners=typePickingListeners.get(pickingType);
  if (pickingListeners != null) {
    for (    IPickingListener pickingListener : pickingListeners) {
      notifyPickingListener(pickingListener,pickingMode,pick);
    }
  }
  HashMap<Integer,Set<IPickingListener>> map=idPickingListeners.get(pickingType);
  if (map == null)   return;
  pickingListeners=map.get(pickedObjectID);
  if (pickingListeners != null) {
    for (    IPickingListener pickingListener : pickingListeners) {
      notifyPickingListener(pickingListener,pickingMode,pick);
    }
  }
}

Fixed version (ground truth):
protected void handlePicking(String pickingType,PickingMode pickingMode,int pickedObjectID,Pick pick){
  Set<IPickingListener> pickingListeners=typePickingListeners.get(pickingType);
  if (pickingListeners != null) {
    for (    IPickingListener pickingListener : new HashSet<>(pickingListeners)) {
      notifyPickingListener(pickingListener,pickingMode,pick);
    }
  }
  HashMap<Integer,Set<IPickingListener>> map=idPickingListeners.get(pickingType);
  if (map == null)   return;
  pickingListeners=map.get(pickedObjectID);
  if (pickingListeners != null) {
    for (    IPickingListener pickingListener : new HashSet<>(pickingListeners)) {
      notifyPickingListener(pickingListener,pickingMode,pick);
    }
  }
}
Program: 57300
Project: 57300
Buggy source:
@Override protected void rightClicked(Pick pick){
  addContextMenuItems(nodeContextMenuItems);
  if (allowBranchPathExtraction && branchNodesToLinearizedNodesMap.keySet().contains(node)) {
    ShowPathEvent event=new ShowPathEvent(getBranchPath(node));
    event.setEventSpace(branchPathExtractionEventSpace);
    view.getContextMenuCreator().addContextMenuItem(new GenericContextMenuItem("String_Node_Str",event));
  }
}

Fixed version (ground truth):
@Override protected void rightClicked(Pick pick){
  if (!node.isPickable())   return;
  addContextMenuItems(nodeContextMenuItems);
  if (allowBranchPathExtraction && branchNodesToLinearizedNodesMap.keySet().contains(node)) {
    ShowPathEvent event=new ShowPathEvent(getBranchPath(node));
    event.setEventSpace(branchPathExtractionEventSpace);
    view.getContextMenuCreator().addContextMenuItem(new GenericContextMenuItem("String_Node_Str",event));
  }
}
Program: 57301
Project: 57301
Buggy source:
/** 
 * @param currentExpandedBranchNode setter, see  {@link #expandedBranchSummaryNode}
 */
public void setExpandedBranchSummaryNode(BranchSummaryNode expandedBranchSummaryNode){
  if (this.expandedBranchSummaryNode != expandedBranchSummaryNode) {
    this.expandedBranchSummaryNode=expandedBranchSummaryNode;
    PathRendererChangedEvent event=new PathRendererChangedEvent(this);
    event.setSender(this);
    GeneralManager.get().getEventPublisher().triggerEvent(event);
    updateLayout();
  }
}

Fixed version (ground truth):
/** 
 * @param currentExpandedBranchNode setter, see  {@link #expandedBranchSummaryNode}
 */
public void setExpandedBranchSummaryNode(BranchSummaryNode expandedBranchSummaryNode){
  if (this.expandedBranchSummaryNode != expandedBranchSummaryNode) {
    this.expandedBranchSummaryNode=expandedBranchSummaryNode;
    for (    ALinearizableNode node : pathNodes) {
      node.setPickable(expandedBranchSummaryNode == null);
    }
    PathRendererChangedEvent event=new PathRendererChangedEvent(this);
    event.setSender(this);
    GeneralManager.get().getEventPublisher().triggerEvent(event);
    updateLayout();
  }
}