nus-yam/ex-repair huggingface dataset:
Program: 57808
Project: 57808
Buggy source:
public void handleDragging(GL2 gl,GLMouseListener glMouseListener){
  if (isDragging) {
    Point mouseWinCoords=glMouseListener.getPickedPoint();
    float[] fArTargetWorldCoordinates=GLCoordinateUtils.convertWindowCoordinatesToWorldCoordinates(gl,mouseWinCoords.x,mouseWinCoords.y);
    if (dropArea != null) {
      dropArea.handleDragOver(gl,draggables,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1]);
    }
    for (    IDraggable draggable : draggables) {
      if (isDraggingFirstTime) {
        float[] fArStartDraggingWorldCoordinates=GLCoordinateUtils.convertWindowCoordinatesToWorldCoordinates(gl,startDraggingWindowCoords.x,startDraggingWindowCoords.y);
        draggable.setDraggingStartPoint(fArStartDraggingWorldCoordinates[0],fArStartDraggingWorldCoordinates[1]);
      }
      draggable.handleDragging(gl,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1]);
    }
    if (glMouseListener.wasMouseReleased()) {
      isDragging=false;
      for (      IDraggable draggable : draggables) {
        draggable.handleDrop(gl,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1]);
      }
      if (dropArea != null) {
        dropArea.handleDrop(gl,draggables,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1],this);
      }
      draggingMode=null;
      view.setDisplayListDirty();
    }
    isDraggingFirstTime=false;
  }
}

Fixed version (ground truth):
public void handleDragging(GL2 gl,GLMouseListener glMouseListener){
  if (isDragging) {
    Point mouseWinCoords=glMouseListener.getPickedPoint();
    float[] fArTargetWorldCoordinates=new float[]{0,0};
    PixelGLConverter pixelGLConverter=view.getPixelGLConverter();
    fArTargetWorldCoordinates[0]=pixelGLConverter.getGLWidthForPixelWidth(mouseWinCoords.x);
    fArTargetWorldCoordinates[1]=pixelGLConverter.getGLHeightForPixelHeight(view.getParentGLCanvas().getHeight() - mouseWinCoords.y);
    if (dropArea != null) {
      dropArea.handleDragOver(gl,draggables,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1]);
    }
    for (    IDraggable draggable : draggables) {
      if (isDraggingFirstTime) {
        float[] fArStartDraggingWorldCoordinates=new float[]{0,0};
        fArStartDraggingWorldCoordinates[0]=pixelGLConverter.getGLWidthForPixelWidth(startDraggingWindowCoords.x);
        fArStartDraggingWorldCoordinates[1]=pixelGLConverter.getGLHeightForPixelHeight(view.getParentGLCanvas().getHeight() - startDraggingWindowCoords.y);
        draggable.setDraggingStartPoint(fArStartDraggingWorldCoordinates[0],fArStartDraggingWorldCoordinates[1]);
      }
      draggable.handleDragging(gl,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1]);
    }
    if (glMouseListener.wasMouseReleased()) {
      isDragging=false;
      for (      IDraggable draggable : draggables) {
        draggable.handleDrop(gl,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1]);
      }
      if (dropArea != null) {
        dropArea.handleDrop(gl,draggables,fArTargetWorldCoordinates[0],fArTargetWorldCoordinates[1],this);
      }
      draggingMode=null;
      view.setDisplayListDirty();
    }
    isDraggingFirstTime=false;
  }
}
Program: 57809
Project: 57809
Buggy source:
/** 
 * Constructor.
 */
public ViewManager(){
  registerEventListeners();
  try {
    UIManager.setLookAndFeel("String_Node_Str");
  }
 catch (  ClassNotFoundException e) {
    e.printStackTrace();
  }
catch (  InstantiationException e) {
    e.printStackTrace();
  }
catch (  IllegalAccessException e) {
    e.printStackTrace();
  }
catch (  UnsupportedLookAndFeelException e) {
    e.printStackTrace();
  }
}

Fixed version (ground truth):
/** 
 * Constructor.
 */
public ViewManager(){
  registerEventListeners();
}
Program: 57810
Project: 57810
Buggy source:
/** 
 * Creates a default tree of depth 1 and a   {@link GroupList} with one group 
 */
private void createDefaultTreeAndGroupList(){
  isTreeDefaultTree=true;
  tree=new ClusterTree(idType,virtualArray.size());
  ClusterNode root=new ClusterNode(tree,"String_Node_Str",0,true,-1);
  tree.setRootNode(root);
  for (  Integer id : virtualArray) {
    tree.addChild(root,new ClusterNode(tree,getElementLabel(id),id,false,id));
  }
  GroupType groupList=createGroupList();
  Group group=new Group(virtualArray.size(),0);
  groupList.add(0,group);
  virtualArray.setGroupList(groupList);
}

Fixed version (ground truth):
/** 
 * Creates a default tree of depth 1 and a   {@link GroupList} with one group 
 */
private void createDefaultTreeAndGroupList(){
  isTreeDefaultTree=true;
  tree=new ClusterTree(idType,virtualArray.size());
  ClusterNode root=new ClusterNode(tree,"String_Node_Str",0,true,-1);
  tree.setRootNode(root);
  for (  Integer id : virtualArray) {
    tree.addChild(root,new ClusterNode(tree,getElementLabel(id),id,false,id));
  }
  GroupType groupList=createGroupList();
  Group group=new Group(virtualArray.size(),0,root);
  groupList.append(group);
  virtualArray.setGroupList(groupList);
}
Program: 57811
Project: 57811
Buggy source:
private void createGroupListAndDefaultTreeFromClusterSizes(PerspectiveInitializationData data){
  GroupType groupList=createGroupList();
  int groupCounter=0;
  isTreeDefaultTree=true;
  tree=new ClusterTree(idType,data.getIndices().size());
  int clusterNr=0;
  ClusterNode root=new ClusterNode(tree,"String_Node_Str",clusterNr++,true,-1);
  tree.setRootNode(root);
  ClusterNode node;
  int from=0;
  int to=0;
  for (  Integer clusterSize : data.getClusterSizes()) {
    node=new ClusterNode(tree,"String_Node_Str" + clusterNr,clusterNr++,true,-1);
    Group temp=new Group(clusterSize,data.getSampleElements().get(groupCounter),node);
    tree.addChild(root,node);
    groupList.append(temp);
    groupCounter++;
    to+=clusterSize;
    ClusterNode leaf;
    for (int vaIndex=from; vaIndex < to; vaIndex++) {
      Integer id=virtualArray.get(vaIndex);
      leaf=new ClusterNode(tree,"String_Node_Str" + id,clusterNr++,true,id);
      tree.addChild(node,leaf);
    }
    from=to;
  }
  virtualArray.setGroupList(groupList);
}

Fixed version (ground truth):
private void createGroupListAndDefaultTreeFromClusterSizes(PerspectiveInitializationData data){
  GroupType groupList=createGroupList();
  int groupCounter=0;
  isTreeDefaultTree=true;
  tree=new ClusterTree(idType,data.getIndices().size());
  int clusterNr=0;
  ClusterNode root=new ClusterNode(tree,"String_Node_Str",clusterNr++,true,-1);
  tree.setRootNode(root);
  ClusterNode node;
  int from=0;
  int to=0;
  for (  Integer clusterSize : data.getClusterSizes()) {
    node=new ClusterNode(tree,"String_Node_Str" + clusterNr,clusterNr++,false,-1);
    Group temp=new Group(clusterSize,data.getSampleElements().get(groupCounter),node);
    tree.addChild(root,node);
    groupList.append(temp);
    groupCounter++;
    to+=clusterSize;
    ClusterNode leaf;
    for (int vaIndex=from; vaIndex < to; vaIndex++) {
      Integer id=virtualArray.get(vaIndex);
      leaf=new ClusterNode(tree,"String_Node_Str" + id,clusterNr++,false,id);
      tree.addChild(node,leaf);
    }
    from=to;
  }
  virtualArray.setGroupList(groupList);
}
Program: 57812
Project: 57812
Buggy source:
public void setGroupID(Integer groupID){
  this.groupID=groupID;
}

Fixed version (ground truth):
/** 
 * @param groupID setter, see {@link #groupID}
 */
public void setGroupID(Integer groupID){
  this.groupID=groupID;
}
Program: 57813
Project: 57813
Buggy source:
/** 
 * Returns the groupID of this group, which is equivalent to the index of this group in the  {@link GroupList}. For a unique ID of the group see the   {@link #getID()} method.
 */
public int getGroupID(){
  return groupID;
}

Fixed version (ground truth):
/** 
 * @return the groupID, see {@link #groupID}
 */
public Integer getGroupID(){
  return groupID;
}
Program: 57814
Project: 57814
Buggy source:
/** 
 * Constructor
 * @param groupList the group list on which the iterator is executed
 */
public GroupIterator(GroupList groupList){
  this.groupList=groupList;
}

Fixed version (ground truth):
/** 
 * Constructor
 * @param groupList the group list on which the iterator is executed
 */
public GroupIterator(GroupType groupList){
  this.groupList=groupList;
}
Program: 57815
Project: 57815
Buggy source:
/** 
 * Returns an Iterator<Group> of type GroupIterator, which allows to iterate over the group list
 */
@Override public GroupIterator iterator(){
  return new GroupIterator(this);
}

Fixed version (ground truth):
/** 
 * Returns an Iterator<Group> of type GroupIterator, which allows to iterate over the group list
 */
@Override @SuppressWarnings({"String_Node_Str","String_Node_Str"}) public GroupIterator<ConcreteType> iterator(){
  return new GroupIterator(this);
}
Program: 57817
Project: 57817
Buggy source:
public abstract void createDefaultConfiguration();

Fixed version (ground truth):
/** 
 * Create a default   {@link DataDomainConfiguration} where the columns are the dimensions 
 */
public abstract void createDefaultConfiguration();
Program: 57818
Project: 57818
Buggy source:
/** 
 * Register a new IDType. Checks whether whether the columnType is legal. If the typeName is already registered, it is replaced with the newly created one.
 * @param typeName see  {@link #typeName}
 * @param idCategory see  {@link #idCategory}
 * @param columnType see  {@link #columnType}
 * @return the created ID Type
 */
public static IDType registerType(String typeName,IDCategory idCategory,EColumnType columnType){
  if (!(columnType == EColumnType.STRING || columnType == EColumnType.INT))   throw new IllegalStateException("String_Node_Str" + columnType);
  IDType idType=new IDType(typeName,idCategory,columnType);
  registeredTypes.put(typeName,idType);
  Logger.log(new Status(Status.INFO,"String_Node_Str","String_Node_Str" + typeName));
  return idType;
}

Fixed version (ground truth):
/** 
 * Register a new IDType. Checks whether whether the columnType is legal. If the typeName is already registered, it is replaced with the newly created one.
 * @param typeName see  {@link #typeName}
 * @param idCategory see  {@link #idCategory}
 * @param columnType see  {@link #columnType}
 * @return the created ID Type
 */
public static IDType registerType(String typeName,IDCategory idCategory,EColumnType columnType){
  if (!(columnType == EColumnType.STRING || columnType == EColumnType.INT))   throw new IllegalStateException("String_Node_Str" + columnType);
  IDType idType=registeredTypes.get(typeName);
  if (idType != null) {
    if (!idType.getIDCategory().equals(idCategory) || !idType.getColumnType().equals(columnType))     throw new IllegalStateException("String_Node_Str" + typeName + "String_Node_Str"+ idType+ "String_Node_Str"+ idCategory+ "String_Node_Str"+ columnType);
  }
 else {
    idType=new IDType(typeName,idCategory,columnType);
    registeredTypes.put(typeName,idType);
    Logger.log(new Status(Status.INFO,"String_Node_Str","String_Node_Str" + typeName));
  }
  return idType;
}
Program: 57819
Project: 57819
Buggy source:
public static ColorMapper createDefaultMapper(EDefaultColorSchemes colorSchema){
  return colorSchema.getDefaultColorMapper();
}

Fixed version (ground truth):
/** 
 * Returns a new   {@link ColorMapper} for the schema specified
 * @param colorSchema
 * @return
 */
public static ColorMapper createDefaultMapper(EDefaultColorSchemes colorSchema){
  return colorSchema.getDefaultColorMapper();
}
Program: 57820
Project: 57820
Buggy source:
@Override public void createDefaultConfiguration(){
  configuration=new DataDomainConfiguration();
  configuration.setRecordIDCategory("String_Node_Str");
  configuration.setDimensionIDCategory("String_Node_Str");
  configuration.setHumanReadableRecordIDType("String_Node_Str");
  configuration.setHumanReadableDimensionIDType("String_Node_Str");
  configuration.setRecordDenominationPlural("String_Node_Str");
  configuration.setRecordDenominationSingular("String_Node_Str");
  configuration.setDimensionDenominationPlural("String_Node_Str");
  configuration.setDimensionDenominationSingular("String_Node_Str");
}

Fixed version (ground truth):
@Override public void createDefaultConfiguration(){
  configuration=new DataDomainConfiguration();
  configuration.setDefaultConfiguration(true);
  configuration.setRecordIDCategory("String_Node_Str");
  configuration.setDimensionIDCategory("String_Node_Str");
  configuration.setHumanReadableRecordIDType("String_Node_Str");
  configuration.setHumanReadableDimensionIDType("String_Node_Str");
  configuration.setRecordDenominationPlural("String_Node_Str");
  configuration.setRecordDenominationSingular("String_Node_Str");
  configuration.setDimensionDenominationPlural("String_Node_Str");
  configuration.setDimensionDenominationSingular("String_Node_Str");
}
Program: 57821
Project: 57821
Buggy source:
public void createDefaultConfiguration(){
  configuration=new DataDomainConfiguration();
  configuration.setMappingFile("String_Node_Str");
  configuration.setRecordIDCategory("String_Node_Str");
  configuration.setDimensionIDCategory("String_Node_Str");
  configuration.setPrimaryRecordMappingType("String_Node_Str");
  configuration.setPrimaryDimensionMappingType("String_Node_Str");
  configuration.setHumanReadableRecordIDType("String_Node_Str");
  configuration.setHumanReadableDimensionIDType("String_Node_Str");
  configuration.setRecordDenominationPlural("String_Node_Str");
  configuration.setRecordDenominationSingular("String_Node_Str");
  configuration.setDimensionDenominationPlural("String_Node_Str");
  configuration.setDimensionDenominationSingular("String_Node_Str");
  pathwayViewerMode=false;
}

Fixed version (ground truth):
@Override public void createDefaultConfiguration(){
  configuration=new DataDomainConfiguration();
  configuration.setDefaultConfiguration(true);
  configuration.setMappingFile("String_Node_Str");
  configuration.setRecordIDCategory("String_Node_Str");
  configuration.setDimensionIDCategory("String_Node_Str");
  configuration.setPrimaryRecordMappingType("String_Node_Str");
  configuration.setPrimaryDimensionMappingType("String_Node_Str");
  configuration.setHumanReadableRecordIDType("String_Node_Str");
  configuration.setHumanReadableDimensionIDType("String_Node_Str");
  configuration.setRecordDenominationPlural("String_Node_Str");
  configuration.setRecordDenominationSingular("String_Node_Str");
  configuration.setDimensionDenominationPlural("String_Node_Str");
  configuration.setDimensionDenominationSingular("String_Node_Str");
  pathwayViewerMode=false;
}
Program: 57822
Project: 57822
Buggy source:
/** 
 * Returns the   {@link DataContainer} for the {@link RecordPerspective} and the{@link DimensionPerspective} specified. </p><p> If such a container exists already, the existing container is returned. If not, a new container is created. </p>
 * @param recordPerspectiveID
 * @param dimensionPerspectiveID
 * @return
 */
public DataContainer getDataContainer(String recordPerspectiveID,String dimensionPerspectiveID){
  DataContainer container=dataContainers.get(createKey(recordPerspectiveID,dimensionPerspectiveID));
  if (container == null) {
    RecordPerspective recordPerspective=table.getRecordPerspective(recordPerspectiveID);
    if (recordPerspective == null)     throw new IllegalArgumentException("String_Node_Str" + recordPerspectiveID);
    DimensionPerspective dimensionPerspective=table.getDimensionPerspective(dimensionPerspectiveID);
    if (dimensionPerspective == null)     throw new IllegalArgumentException("String_Node_Str" + dimensionPerspectiveID);
    container=new DataContainer(this,recordPerspective,dimensionPerspective);
    dataContainers.put(createKey(recordPerspectiveID,dimensionPerspectiveID),container);
  }
  return container;
}

Fixed version (ground truth):
/** 
 * Returns the   {@link DataContainer} for the {@link RecordPerspective} and the{@link DimensionPerspective} specified. </p><p> If such a container exists already, the existing container is returned. If not, a new container is created. </p>
 * @param recordPerspectiveID
 * @param dimensionPerspectiveID
 * @return
 */
public DataContainer getDataContainer(String recordPerspectiveID,String dimensionPerspectiveID){
  DataContainer container=dataContainers.get(createKey(recordPerspectiveID,dimensionPerspectiveID));
  if (container == null) {
    RecordPerspective recordPerspective=table.getRecordPerspective(recordPerspectiveID);
    if (recordPerspective == null)     throw new IllegalArgumentException("String_Node_Str" + recordPerspectiveID);
    DimensionPerspective dimensionPerspective=table.getDimensionPerspective(dimensionPerspectiveID);
    if (dimensionPerspective == null)     throw new IllegalArgumentException("String_Node_Str" + dimensionPerspectiveID);
    container=new DataContainer(this,recordPerspective,dimensionPerspective);
    dataContainers.put(createKey(recordPerspectiveID,dimensionPerspectiveID),container);
    DimensionGroupsChangedEvent event=new DimensionGroupsChangedEvent(this);
    event.setSender(this);
    GeneralManager.get().getEventPublisher().triggerEvent(event);
  }
  return container;
}
Program: 57824
Project: 57824
Buggy source:
public Set<IDataDomain> getNeighboursOf(IDataDomain vertex){
  Set<Edge> edges=dataDomainGraph.edgesOf(vertex);
  Set<IDataDomain> vertices=new HashSet<IDataDomain>();
  for (  Edge edge : edges) {
    vertices.add(edge.getOtherSideOf(vertex));
  }
  return vertices;
}

Fixed version (ground truth):
public synchronized Set<IDataDomain> getNeighboursOf(IDataDomain vertex){
  Set<Edge> edges=dataDomainGraph.edgesOf(vertex);
  Set<IDataDomain> vertices=new HashSet<IDataDomain>();
  for (  Edge edge : edges) {
    vertices.add(edge.getOtherSideOf(vertex));
  }
  return vertices;
}
Program: 57825
Project: 57825
Buggy source:
public Multigraph<IDataDomain,Edge> getGraph(){
  return dataDomainGraph;
}

Fixed version (ground truth):
public synchronized Multigraph<IDataDomain,Edge> getGraph(){
  return dataDomainGraph;
}
Program: 57826
Project: 57826
Buggy source:
public Set<Edge> getEdges(IDataDomain dataDomain1,IDataDomain dataDomain2){
  return dataDomainGraph.getAllEdges(dataDomain1,dataDomain2);
}

Fixed version (ground truth):
public Set<Edge> getEdges(IDataDomain dataDomain1,IDataDomain dataDomain2){
  return new HashSet<Edge>(dataDomainGraph.getAllEdges(dataDomain1,dataDomain2));
}
Program: 57827
Project: 57827
Buggy source:
public void removeDataDomain(IDataDomain dataDomain){
  if (dataDomainGraph.containsVertex(dataDomain)) {
    dataDomainGraph.removeAllEdges(dataDomainGraph.edgesOf(dataDomain));
    dataDomainGraph.removeVertex(dataDomain);
  }
}

Fixed version (ground truth):
public synchronized void removeDataDomain(IDataDomain dataDomain){
  if (dataDomainGraph.containsVertex(dataDomain)) {
    dataDomainGraph.removeAllEdges(dataDomainGraph.edgesOf(dataDomain));
    dataDomainGraph.removeVertex(dataDomain);
  }
}
Program: 57828
Project: 57828
Buggy source:
public Set<IDataDomain> getDataDomains(){
  return dataDomainGraph.vertexSet();
}

Fixed version (ground truth):
public Set<IDataDomain> getDataDomains(){
  return new HashSet<IDataDomain>(dataDomainGraph.vertexSet());
}
Program: 57832
Project: 57832
Buggy source:
/** 
 * Constructor for uncertainty heat map where no GLHeatMap parent exists.
 */
public HeatMapTextureRenderer(GLUncertaintyHeatMap uncertaintyHeatMap){
  super(null);
  viewID=uncertaintyHeatMap.getID();
}

Fixed version (ground truth):
/** 
 * Constructor for uncertainty heat map where no GLHeatMap parent exists.
 */
public HeatMapTextureRenderer(GLUncertaintyHeatMap uncertaintyHeatMap){
  super(null);
  colorMapper=uncertaintyHeatMap.getColorMapper();
  viewID=uncertaintyHeatMap.getID();
}
Program: 57833
Project: 57833
Buggy source:
@Override public void destroy(){
  selectionTransformer.destroy();
  super.destroy();
}

Fixed version (ground truth):
@Override public void destroy(){
  super.destroy();
}
Program: 57834
Project: 57834
Buggy source:
/** 
 * Constructor. Pass the length of the managed collection and a predefined array list of indices on the collection. This will serve as the starting point for the virtual array.
 * @param initialList
 */
public VirtualArray(String vaType,List<Integer> initialList){
  super(GeneralManager.get().getIDCreator().createID(ManagedObjectType.VIRTUAL_ARRAY));
  this.vaType=vaType;
  virtualArrayList.addAll(initialList);
}

Fixed version (ground truth):
/** 
 * Constructor. Pass the length of the managed collection and a predefined array list of indices on the collection. This will serve as the starting point for the virtual array.
 * @param initialList
 */
public VirtualArray(String vaType,List<Integer> initialList){
  super(GeneralManager.get().getIDCreator().createID(ManagedObjectType.VIRTUAL_ARRAY));
  this.vaType=vaType;
  if (initialList != null)   virtualArrayList.addAll(initialList);
}
Program: 57836
Project: 57836
Buggy source:
@Override public void setParameterHandler(final ParameterHandler parameterHandler){
  super.setParameterHandler(parameterHandler);
  typeName=detail;
  idCategory=IDCategory.getIDCategory(attrib1);
  dimensionType=EDimensionType.valueOf(attrib2);
}

Fixed version (ground truth):
@Override public void setParameterHandler(final ParameterHandler parameterHandler){
  super.setParameterHandler(parameterHandler);
  typeName=detail;
  idCategory=IDCategory.getIDCategory(attrib1);
  dimensionType=EColumnType.valueOf(attrib2);
}
Program: 57837
Project: 57837
Buggy source:
public void setAttributes(String typeName,IDCategory idCategory,EDimensionType dimensionType){
  this.typeName=typeName;
  this.idCategory=idCategory;
  this.dimensionType=dimensionType;
}

Fixed version (ground truth):
public void setAttributes(String typeName,IDCategory idCategory,EColumnType dimensionType){
  this.typeName=typeName;
  this.idCategory=idCategory;
  this.dimensionType=dimensionType;
}
Program: 57840
Project: 57840
Buggy source:
private final void initDataPerspectiveChoosers(Composite parent){
  if (dataDomain != null) {
    possibleRecordPerspectives=dataDomain.getRecordPerspectiveIDs().toArray(new String[0]);
    possibleDimensionPerspectives=dataDomain.getDimensionPerspectiveIDs().toArray(new String[0]);
  }
 else {
    possibleRecordPerspectives=new String[]{"String_Node_Str"};
    possibleDimensionPerspectives=new String[]{"String_Node_Str"};
  }
  recordPerspectiveChooser.removeAll();
  for (int index=0; index < possibleRecordPerspectives.length; index++) {
    String possibleDataPerspective=possibleRecordPerspectives[index];
    recordPerspectiveChooser.add(possibleDataPerspective,index);
  }
  dimensionPerspectiveChooser.removeAll();
  for (int index=0; index < possibleDimensionPerspectives.length; index++) {
    String possibleDataPerspective=possibleDimensionPerspectives[index];
    dimensionPerspectiveChooser.add(possibleDataPerspective,index);
  }
  if (dataDomain == null) {
    recordPerspectiveChooser.setEnabled(false);
    dimensionPerspectiveChooser.setEnabled(false);
  }
 else {
    selectRecordPerspective(0);
    recordPerspectiveChooser.select(0);
    selectDimensionPerspective(0);
    dimensionPerspectiveChooser.select(0);
    recordPerspectiveChooser.setEnabled(true);
    dimensionPerspectiveChooser.setEnabled(true);
  }
}

Fixed version (ground truth):
private final void initDataPerspectiveChoosers(Composite parent){
  if (dataDomain != null) {
    possibleRecordPerspectives=dataDomain.getRecordPerspectiveIDs().toArray(new String[0]);
    possibleDimensionPerspectives=dataDomain.getDimensionPerspectiveIDs().toArray(new String[0]);
  }
 else {
    possibleRecordPerspectives=new String[]{"String_Node_Str"};
    possibleDimensionPerspectives=new String[]{"String_Node_Str"};
  }
  recordPerspectiveChooser.removeAll();
  for (int index=0; index < possibleRecordPerspectives.length; index++) {
    String possibleDataPerspective=possibleRecordPerspectives[index];
    String recordPerspectiveLabel=dataDomain.getTable().getRecordPerspective(possibleDataPerspective).getLabel();
    recordPerspectiveChooser.add(recordPerspectiveLabel,index);
  }
  dimensionPerspectiveChooser.removeAll();
  for (int index=0; index < possibleDimensionPerspectives.length; index++) {
    String possibleDataPerspective=possibleDimensionPerspectives[index];
    String dimensionPerspectiveLabel=dataDomain.getTable().getDimensionPerspective(possibleDataPerspective).getLabel();
    dimensionPerspectiveChooser.add(dimensionPerspectiveLabel,index);
  }
  if (dataDomain == null) {
    recordPerspectiveChooser.setEnabled(false);
    dimensionPerspectiveChooser.setEnabled(false);
  }
 else {
    selectRecordPerspective(0);
    recordPerspectiveChooser.select(0);
    selectDimensionPerspective(0);
    dimensionPerspectiveChooser.select(0);
    recordPerspectiveChooser.setEnabled(true);
    dimensionPerspectiveChooser.setEnabled(true);
  }
}
Program: 57841
Project: 57841
Buggy source:
protected abstract void initIDMappings();

Fixed version (ground truth):
/** 
 * Load ID mappings in concrete implementing classes. This is called by   {@link #init()}.
 */
protected abstract void initIDMappings();
Program: 57842
Project: 57842
Buggy source:
public ADataDomain(String dataDomainType,String dataDomainID){
  this.dataDomainType=dataDomainType;
  this.dataDomainID=dataDomainID;
  initIDMappings();
}

Fixed version (ground truth):
public ADataDomain(String dataDomainType,String dataDomainID){
  this.dataDomainType=dataDomainType;
  this.dataDomainID=dataDomainID;
}
Program: 57843
Project: 57843
Buggy source:
public String getDimensionLabel(IDType idType,Object id){
  String label=dimensionIDMappingManager.getID(idType,humanReadableDimensionIDType,id);
  if (label == null)   label="String_Node_Str";
  return label;
}

Fixed version (ground truth):
public String getDimensionLabel(IDType idType,Object id){
  Set<String> ids=dimensionIDMappingManager.getIDAsSet(idType,humanReadableDimensionIDType,id);
  String label="String_Node_Str";
  if (ids != null && ids.size() > 0) {
    label=ids.iterator().next();
  }
  return label;
}
Program: 57844
Project: 57844
Buggy source:
private void init(){
  assignIDCategories();
  if (recordIDCategory == null || dimensionIDCategory == null) {
    throw new IllegalStateException("String_Node_Str" + toString() + "String_Node_Str"+ recordIDCategory+ "String_Node_Str"+ dimensionIDCategory);
  }
  recordIDMappingManager=IDMappingManagerRegistry.get().getIDMappingManager(recordIDCategory);
  dimensionIDMappingManager=IDMappingManagerRegistry.get().getIDMappingManager(dimensionIDCategory);
  recordIDType=IDType.registerType("String_Node_Str" + dataDomainID + "String_Node_Str"+ hashCode(),recordIDCategory,EDimensionType.INT);
  dimensionIDType=IDType.registerType("String_Node_Str" + dataDomainID + "String_Node_Str"+ hashCode(),dimensionIDCategory,EDimensionType.INT);
  recordGroupIDType=IDType.registerType("String_Node_Str" + dataDomainID + "String_Node_Str"+ hashCode(),recordIDCategory,EDimensionType.INT);
  recordSelectionManager=new RecordSelectionManager(recordIDMappingManager,recordIDType);
  dimensionSelectionManager=new DimensionSelectionManager(dimensionIDMappingManager,dimensionIDType);
  recordGroupSelectionManager=new SelectionManager(recordGroupIDType);
}

Fixed version (ground truth):
@Override public void init(){
  super.init();
  assignIDCategories();
  if (recordIDCategory == null || dimensionIDCategory == null) {
    throw new IllegalStateException("String_Node_Str" + toString() + "String_Node_Str"+ recordIDCategory+ "String_Node_Str"+ dimensionIDCategory);
  }
  recordIDMappingManager=IDMappingManagerRegistry.get().getIDMappingManager(recordIDCategory);
  dimensionIDMappingManager=IDMappingManagerRegistry.get().getIDMappingManager(dimensionIDCategory);
  recordIDType=IDType.registerType("String_Node_Str" + dataDomainID + "String_Node_Str"+ hashCode(),recordIDCategory,EColumnType.INT);
  recordIDType.setInternalType(true);
  dimensionIDType=IDType.registerType("String_Node_Str" + dataDomainID + "String_Node_Str"+ hashCode(),dimensionIDCategory,EColumnType.INT);
  dimensionIDType.setInternalType(true);
  recordGroupIDType=IDType.registerType("String_Node_Str" + dataDomainID + "String_Node_Str"+ hashCode(),recordIDCategory,EColumnType.INT);
  recordGroupIDType.setInternalType(true);
  recordSelectionManager=new RecordSelectionManager(recordIDMappingManager,recordIDType);
  dimensionSelectionManager=new DimensionSelectionManager(dimensionIDMappingManager,dimensionIDType);
  recordGroupSelectionManager=new SelectionManager(recordGroupIDType);
}
Program: 57845
Project: 57845
Buggy source:
public String getRecordLabel(IDType idType,Object id){
  Set<String> ids=recordIDMappingManager.getIDAsSet(idType,humanReadableRecordIDType,id);
  String resolvedID="String_Node_Str";
  if (ids != null && ids.size() > 0) {
    resolvedID=ids.iterator().next();
  }
  return resolvedID;
}

Fixed version (ground truth):
public String getRecordLabel(IDType idType,Object id){
  Set<String> ids=recordIDMappingManager.getIDAsSet(idType,humanReadableRecordIDType,id);
  String label="String_Node_Str";
  if (ids != null && ids.size() > 0) {
    label=ids.iterator().next();
  }
  return label;
}
Program: 57846
Project: 57846
Buggy source:
public ATableBasedDataDomain(String dataDomainType,String dataDomainID){
  super(dataDomainType,dataDomainID);
  init();
}

Fixed version (ground truth):
public ATableBasedDataDomain(String dataDomainType,String dataDomainID){
  super(dataDomainType,dataDomainID);
}
Program: 57847
Project: 57847
Buggy source:
/** 
 * Initiates clustering based on the parameters passed. Sends out an event to all affected views upon positive completion to replace their VA.
 * @param tableID ID of the set to cluster
 * @param clusterState
 */
public void startClustering(ClusterConfiguration clusterState){
  ClusterManager clusterManager=new ClusterManager(this);
  ClusterResult result=clusterManager.cluster(clusterState);
  if (clusterState.getClustererType() == ClustererType.DIMENSION_CLUSTERING || clusterState.getClustererType() == ClustererType.BI_CLUSTERING) {
    PerspectiveInitializationData dimensionResult=result.getDimensionResult();
    DimensionPerspective dimensionPerspective=clusterState.getTargetDimensionPerspective();
    dimensionPerspective.init(dimensionResult);
    eventPublisher.triggerEvent(new DimensionVAUpdateEvent(dataDomainID,dimensionPerspective.getPerspectiveID(),this));
  }
  if (clusterState.getClustererType() == ClustererType.RECORD_CLUSTERING || clusterState.getClustererType() == ClustererType.BI_CLUSTERING) {
    PerspectiveInitializationData recordResult=result.getRecordResult();
    RecordPerspective recordPerspective=clusterState.getTargetRecordPerspective();
    recordPerspective.init(recordResult);
    eventPublisher.triggerEvent(new RecordVAUpdateEvent(dataDomainID,recordPerspective.getPerspectiveID(),this));
  }
}

Fixed version (ground truth):
/** 
 * Initiates clustering based on the parameters passed. Sends out an event to all affected views upon positive completion to replace their VA.
 * @param tableID ID of the set to cluster
 * @param clusterState
 */
public void startClustering(ClusterConfiguration clusterState){
  ClusterManager clusterManager=new ClusterManager(this);
  ClusterResult result=clusterManager.cluster(clusterState);
  if (result == null)   return;
  if (clusterState.getClustererType() == ClustererType.DIMENSION_CLUSTERING || clusterState.getClustererType() == ClustererType.BI_CLUSTERING) {
    PerspectiveInitializationData dimensionResult=result.getDimensionResult();
    DimensionPerspective dimensionPerspective=clusterState.getTargetDimensionPerspective();
    dimensionPerspective.init(dimensionResult);
    eventPublisher.triggerEvent(new DimensionVAUpdateEvent(dataDomainID,dimensionPerspective.getPerspectiveID(),this));
  }
  if (clusterState.getClustererType() == ClustererType.RECORD_CLUSTERING || clusterState.getClustererType() == ClustererType.BI_CLUSTERING) {
    PerspectiveInitializationData recordResult=result.getRecordResult();
    RecordPerspective recordPerspective=clusterState.getTargetRecordPerspective();
    recordPerspective.init(recordResult);
    eventPublisher.triggerEvent(new RecordVAUpdateEvent(dataDomainID,recordPerspective.getPerspectiveID(),this));
  }
}
Program: 57848
Project: 57848
Buggy source:
private void loadPluginData(String dirName) throws JAXBException, BundleException {
  JAXBContext context;
  PlugInList plugInList=null;
  context=JAXBContext.newInstance(PlugInList.class);
  Unmarshaller unmarshaller=context.createUnmarshaller();
  File pluginFile=new File(dirName + ProjectSaver.PLUG_IN_LIST_FILE);
  if (!pluginFile.exists()) {
    Logger.log(new Status(Status.INFO,this.toString(),"String_Node_Str" + pluginFile));
    return;
  }
  plugInList=(PlugInList)unmarshaller.unmarshal(pluginFile);
  ArrayList<String> plugIns=plugInList.plugIns;
  for (  String plugIn : plugIns) {
    Bundle bundle=Platform.getBundle(plugIn);
    if (bundle == null) {
      Logger.log(new Status(IStatus.WARNING,toString(),"String_Node_Str" + bundle));
      continue;
    }
    bundle.start();
  }
}

Fixed version (ground truth):
private void loadPluginData(String dirName) throws JAXBException, BundleException {
  JAXBContext context;
  PlugInList plugInList=null;
  context=JAXBContext.newInstance(PlugInList.class);
  Unmarshaller unmarshaller=context.createUnmarshaller();
  File pluginFile=new File(dirName + ProjectSaver.PLUG_IN_LIST_FILE);
  if (!pluginFile.exists()) {
    Logger.log(new Status(Status.INFO,this.toString(),"String_Node_Str" + pluginFile));
    return;
  }
  plugInList=(PlugInList)unmarshaller.unmarshal(pluginFile);
  ArrayList<String> plugIns=plugInList.plugIns;
  for (  String plugIn : plugIns) {
    Bundle bundle=Platform.getBundle(plugIn);
    if (bundle == null) {
      Logger.log(new Status(IStatus.WARNING,toString(),"String_Node_Str" + plugIn));
      continue;
    }
    bundle.start();
  }
}
Program: 57849
Project: 57849
Buggy source:
public ADataDomain(String dataDomainType,String dataDomainID){
  this.dataDomainType=dataDomainType;
  this.dataDomainID=dataDomainID;
}

Fixed version (ground truth):
public ADataDomain(String dataDomainType,String dataDomainID){
  this.dataDomainType=dataDomainType;
  this.dataDomainID=dataDomainID;
  System.out.println("String_Node_Str" + this);
}
Program: 57850
Project: 57850
Buggy source:
/** 
 * Returns the IDType for the typeName specified, or null if no such type is registered 
 */
public static IDType getIDType(String typeName){
  return registeredTypes.get(typeName);
}

Fixed version (ground truth):
/** 
 * Returns the IDType for the typeName specified, or null if no such type is registered 
 */
public static IDType getIDType(String typeName){
  IDType requestedType=registeredTypes.get(typeName);
  if (requestedType == null)   throw new IllegalStateException("String_Node_Str" + typeName + "String_Node_Str");
  return requestedType;
}
Program: 57851
Project: 57851
Buggy source:
/** 
 * Returns the   {@link IDMappingManager} for the {@link IDCategory} specified. If no such{@link IDMappingManager} exists, a new one is created and registered.
 * @param idCategory
 * @return
 */
public IDMappingManager getIDMappingManager(IDCategory idCategory){
  if (!hashIDMappingManagers.containsKey(idCategory)) {
    hashIDMappingManagers.put(idCategory,new IDMappingManager(idCategory));
  }
  return hashIDMappingManagers.get(idCategory);
}

Fixed version (ground truth):
/** 
 * Returns the   {@link IDMappingManager} for the {@link IDCategory} specified. If no such{@link IDMappingManager} exists, a new one is created and registered.
 * @param idCategory
 * @return
 */
public IDMappingManager getIDMappingManager(IDCategory idCategory){
  if (idCategory == null)   throw new IllegalArgumentException("String_Node_Str");
  if (!hashIDMappingManagers.containsKey(idCategory)) {
    hashIDMappingManagers.put(idCategory,new IDMappingManager(idCategory));
  }
  return hashIDMappingManagers.get(idCategory);
}
Program: 57852
Project: 57852
Buggy source:
/** 
 * <p> Returns the cluster tree showing the relations between the elements indexed by the virtual array. </p> <p> Depending on whether or not a cluster tree has been set, this method either returns a tree with real relations, or a tree with one root and all leafs as children of the root (the default tree). You can check whether the tree is the default tree using   {@link #isTreeDefaultTree()}. </p>
 * @return
 */
@XmlTransient public ClusterTree getTree(){
  return tree;
}

Fixed version (ground truth):
/** 
 * <p> Returns the cluster tree showing the relations between the elements indexed by the virtual array. </p> <p> Depending on whether or not a cluster tree has been set, this method either returns a tree with real relations, or a tree with one root and all leafs as children of the root (the default tree). You can check whether the tree is the default tree using   {@link #isTreeDefaultTree()}. </p>
 * @return
 */
@XmlTransient public ClusterTree getTree(){
  if (tree == null)   createDefaultTree();
  return tree;
}
Program: 57854
Project: 57854
Buggy source:
public String getRecordLabel(IDType idType,Object id){
  String resolvedID=recordIDMappingManager.getID(idType,humanReadableRecordIDType,id);
  return resolvedID;
}

Fixed version (ground truth):
public String getRecordLabel(IDType idType,Object id){
  Set<String> ids=recordIDMappingManager.getIDAsSet(idType,humanReadableRecordIDType,id);
  String resolvedID="String_Node_Str";
  if (ids != null && ids.size() > 0) {
    resolvedID=ids.iterator().next();
  }
  return resolvedID;
}
Program: 57855
Project: 57855
Buggy source:
/** 
 * @param isColumnDimension setter, see {@link #isColumnDimension}
 */
public void setColumnDimension(boolean isColumnDimension){
  this.isColumnDimension=isColumnDimension;
}

Fixed version (ground truth):
/** 
 * @param isColumnDimension setter, see  {@link #isColumnDimension}
 */
public void setColumnDimension(boolean isColumnDimension){
  this.isColumnDimension=isColumnDimension;
}
Program: 57857
Project: 57857
Buggy source:
/** 
 * Generic method for   {@link #getRecordPerspectiveCandidates(DataTable,boolean)} and{@link #getDimensionPerspectiveCandidates(DataTable,boolean)}
 * @param table
 * @param considerOnlyPublic
 * @param isRecord
 * @return
 */
private static ArrayList<String> getPerspectiveCandidates(DataTable table,boolean considerOnlyPublic,boolean isRecord){
  Set<String> dataPerspectiveIDs;
  if (isRecord)   dataPerspectiveIDs=table.getRecordPerspectiveIDs();
 else   dataPerspectiveIDs=table.getDimensionPerspectiveIDs();
  ArrayList<String> candidates=new ArrayList<String>(dataPerspectiveIDs);
  if (!considerOnlyPublic)   return candidates;
 else {
    Iterator<String> iterator=candidates.iterator();
    while (iterator.hasNext()) {
      String tempPerspectiveID=iterator.next();
      DataPerspective<?,?,?,?> perspective;
      if (isRecord)       perspective=table.getRecordPerspective(tempPerspectiveID);
 else       perspective=table.getDimensionPerspective(tempPerspectiveID);
      if (!perspective.isPrivate()) {
        iterator.remove();
      }
    }
    return candidates;
  }
}

Fixed version (ground truth):
/** 
 * Generic method for   {@link #getRecordPerspectiveCandidates(DataTable,boolean)} and{@link #getDimensionPerspectiveCandidates(DataTable,boolean)}
 * @param table
 * @param considerOnlyPublic
 * @param isRecord
 * @return
 */
private static ArrayList<String> getPerspectiveCandidates(DataTable table,boolean considerOnlyPublic,boolean isRecord){
  Set<String> dataPerspectiveIDs;
  if (isRecord)   dataPerspectiveIDs=table.getRecordPerspectiveIDs();
 else   dataPerspectiveIDs=table.getDimensionPerspectiveIDs();
  ArrayList<String> candidates=new ArrayList<String>(dataPerspectiveIDs);
  if (!considerOnlyPublic)   return candidates;
 else {
    Iterator<String> iterator=candidates.iterator();
    while (iterator.hasNext()) {
      String tempPerspectiveID=iterator.next();
      ADataPerspective<?,?,?,?> perspective;
      if (isRecord)       perspective=table.getRecordPerspective(tempPerspectiveID);
 else       perspective=table.getDimensionPerspective(tempPerspectiveID);
      if (!perspective.isPrivate()) {
        iterator.remove();
      }
    }
    return candidates;
  }
}
Program: 57858
Project: 57858
Buggy source:
/** 
 * <p> Checks if there is only one   {@link RecordPerspective} from those registered with the {@link DataTable}a possible match considering the parameters. If so, this one match is returned, else null is returned. </p> <p> As   {@link DataPerspective}s can be either private or public (see  {@link DataPerspective#setIsPrivate(boolean)}, it is possible to let the chooser only chose from those that are public. </p>
 * @param table the data table from which to choose the available perspectives
 * @param considerOnlyPublic whether only public perspectives shall be used (true) or whether to also include private perspectives
 * @return the chosen perspectiveID if a unique ID could be identified, or null
 */
private static Collection<String> getRecordPerspectiveCandidates(DataTable table,boolean considerOnlyPublic){
  return getPerspectiveCandidates(table,considerOnlyPublic,true);
}

Fixed version (ground truth):
/** 
 * <p> Checks if there is only one   {@link RecordPerspective} from those registered with the {@link DataTable}a possible match considering the parameters. If so, this one match is returned, else null is returned. </p> <p> As   {@link ADataPerspective}s can be either private or public (see  {@link ADataPerspective#setIsPrivate(boolean)}, it is possible to let the chooser only chose from those that are public. </p>
 * @param table the data table from which to choose the available perspectives
 * @param considerOnlyPublic whether only public perspectives shall be used (true) or whether to also include private perspectives
 * @return the chosen perspectiveID if a unique ID could be identified, or null
 */
private static Collection<String> getRecordPerspectiveCandidates(DataTable table,boolean considerOnlyPublic){
  return getPerspectiveCandidates(table,considerOnlyPublic,true);
}
Program: 57861
Project: 57861
Buggy source:
/** 
 * Creates a meta-set for this node
 * @param set
 */
public void fillDataPerspective(DataPerspective<?,?,?,?> dataPerspective){
  dataPerspective.createVA(getLeaveIds());
  dataPerspective.setTreeRoot(this);
  dataPerspective.setTree((ClusterTree)tree);
  this.dataPerspective=dataPerspective;
}

Fixed version (ground truth):
/** 
 * Creates a meta-set for this node
 * @param set
 */
public void fillDataPerspective(ADataPerspective<?,?,?,?> dataPerspective){
  dataPerspective.createVA(getLeaveIds());
  dataPerspective.setTreeRoot(this);
  dataPerspective.setTree((ClusterTree)tree);
  this.dataPerspective=dataPerspective;
}
Program: 57862
Project: 57862
Buggy source:
public DataPerspective<?,?,?,?> getPerspective(){
  return dataPerspective;
}

Fixed version (ground truth):
public ADataPerspective<?,?,?,?> getPerspective(){
  return dataPerspective;
}
Program: 57863
Project: 57863
Buggy source:
/** 
 * Set the ID of the   {@link DataPerspective} the virtual array to be updated is associated with
 * @param perspectiveID
 */
public void setPerspectiveID(String perspectiveID){
  this.perspectiveID=perspectiveID;
}

Fixed version (ground truth):
/** 
 * Set the ID of the   {@link ADataPerspective} the virtual array to be updated is associated with
 * @param perspectiveID
 */
public void setPerspectiveID(String perspectiveID){
  this.perspectiveID=perspectiveID;
}
Program: 57864
Project: 57864
Buggy source:
/** 
 * Saves the   {@link VirtualArray} of the given type. The filename is created from the type.
 * @param dir directory to save the  {@link VirtualArray} in.
 * @param useCase {@link IDataDomain} to retrieve the {@link VirtualArray} from.
 * @param perspectiveID type of the virtual array within the given  {@link IDataDomain}.
 */
private void saveDataPerspective(Marshaller marshaller,String dir,String perspectiveID,DataPerspective<?,?,?,?> perspective) throws JAXBException, IOException {
  String fileName=dir + perspectiveID + "String_Node_Str";
  marshaller.marshal(perspective,new File(fileName));
  if (!perspective.isTreeDefaultTree()) {
    TreePorter treePorter=new TreePorter();
    Tree<ClusterNode> tree=perspective.getTree();
    if (tree != null) {
      treePorter.exportTree(dir + perspectiveID + "String_Node_Str",tree);
    }
  }
}

Fixed version (ground truth):
/** 
 * Saves the   {@link VirtualArray} of the given type. The filename is created from the type.
 * @param dir directory to save the  {@link VirtualArray} in.
 * @param useCase {@link IDataDomain} to retrieve the {@link VirtualArray} from.
 * @param perspectiveID type of the virtual array within the given  {@link IDataDomain}.
 */
private void saveDataPerspective(Marshaller marshaller,String dir,String perspectiveID,ADataPerspective<?,?,?,?> perspective) throws JAXBException, IOException {
  String fileName=dir + perspectiveID + "String_Node_Str";
  marshaller.marshal(perspective,new File(fileName));
  if (!perspective.isTreeDefaultTree()) {
    TreePorter treePorter=new TreePorter();
    Tree<ClusterNode> tree=perspective.getTree();
    if (tree != null) {
      treePorter.exportTree(dir + perspectiveID + "String_Node_Str",tree);
    }
  }
}
Program: 57865
Project: 57865
Buggy source:
private void runContentClustering(AClusterer clusterer,ClusterConfiguration clusterState,ClusterResult result,int progressBarOffset,int progressBarMulti){
  clusterer.setClusterState(clusterState);
  TempResult tempResult=clusterer.getSortedVA(dataDomain,clusterState,progressBarOffset,progressBarMulti);
  if (tempResult == null) {
    Logger.log(new Status(IStatus.ERROR,toString(),"String_Node_Str" + clusterer.toString()));
    return;
  }
  result.setRecordResult(tempResult);
}

Fixed version (ground truth):
private void runContentClustering(AClusterer clusterer,ClusterConfiguration clusterState,ClusterResult result,int progressBarOffset,int progressBarMulti){
  clusterer.setClusterState(clusterState);
  PerspectiveInitializationData tempResult=clusterer.getSortedVA(dataDomain,clusterState,progressBarOffset,progressBarMulti);
  if (tempResult == null) {
    Logger.log(new Status(IStatus.ERROR,toString(),"String_Node_Str" + clusterer.toString()));
    return;
  }
  result.setRecordResult(tempResult);
}
Program: 57866
Project: 57866
Buggy source:
private void runDimensionClustering(AClusterer clusterer,ClusterConfiguration clusterState,ClusterResult result,int progressBarOffset,int progressBarMulti){
  clusterer.setClusterState(clusterState);
  TempResult tempResult=clusterer.getSortedVA(dataDomain,clusterState,progressBarOffset,progressBarMulti);
  result.setDimensionResult(tempResult);
}

Fixed version (ground truth):
private void runDimensionClustering(AClusterer clusterer,ClusterConfiguration clusterState,ClusterResult result,int progressBarOffset,int progressBarMulti){
  clusterer.setClusterState(clusterState);
  PerspectiveInitializationData tempResult=clusterer.getSortedVA(dataDomain,clusterState,progressBarOffset,progressBarMulti);
  result.setDimensionResult(tempResult);
}
Program: 57867
Project: 57867
Buggy source:
@Override public void display(GL2 gl){
  templateRenderer.render(gl);
  if (updateVisualUncertainty) {
    for (    ClusterRenderer clusterRenderer : overviewHeatMap.getClusterRendererList()) {
      if (clusterRenderer.textureRenderer != null && clusterRenderer.textureRenderer.heatmapLayout != null && clusterRenderer.visUncBarTextureRenderer != null) {
        clusterRenderer.visUncBarTextureRenderer.initTextures(VisualUncertaintyUtil.calcVisualUncertainty(gl,pixelGLConverter,clusterRenderer.textureRenderer.heatmapLayout,clusterRenderer.textureRenderer));
      }
    }
    updateVisualUncertainty=false;
  }
}

Fixed version (ground truth):
@Override public void display(GL2 gl){
  templateRenderer.render(gl);
  if (updateVisualUncertainty) {
    for (    ClusterRenderer clusterRenderer : overviewHeatMap.getClusterRendererList()) {
      clusterRenderer.updateVisualUncertainty(gl,pixelGLConverter);
    }
    updateVisualUncertainty=false;
  }
}
Program: 57868
Project: 57868
Buggy source:
@Override protected void reactOnRecordVAChanges(){
  super.reactOnRecordVAChanges();
  setDisplayListDirty();
  initMultiLevelUncertainty();
  overviewHeatMap.init();
}

Fixed version (ground truth):
@Override protected void reactOnRecordVAChanges(){
  super.reactOnRecordVAChanges();
  setDisplayListDirty();
  initMultiLevelUncertainty();
  updateVisualUncertainty=true;
  overviewHeatMap.init();
}