nus-yam/ex-repair huggingface dataset:
Program: 108338
Project: 108338
Buggy source:
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  weights=new double[hierarchies.length];
  double total=0d;
  for (int i=0; i < hierarchies.length; i++) {
    String attribute=hierarchies[i].getName();
    double weight=config.getAttributeWeight(attribute);
    weights[i]=weight;
    total+=weight;
  }
  if (total == 0d) {
    Arrays.fill(weights,1d);
  }
 else {
    for (int i=0; i < weights.length; i++) {
      weights[i]/=total;
    }
  }
  dimensions=hierarchies.length;
  this.min=new double[hierarchies.length];
  Arrays.fill(min,0d);
  this.max=new double[min.length];
  Arrays.fill(max,Double.MAX_VALUE);
}

Fixed version (ground truth):
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  weights=new double[hierarchies.length];
  double maximum=0d;
  for (int i=0; i < hierarchies.length; i++) {
    String attribute=hierarchies[i].getName();
    double weight=config.getAttributeWeight(attribute);
    weights[i]=weight;
    maximum=Math.max(maximum,weight);
  }
  if (maximum == 0d) {
    Arrays.fill(weights,1d);
  }
 else {
    for (int i=0; i < weights.length; i++) {
      weights[i]/=maximum;
    }
  }
  dimensions=hierarchies.length;
  this.min=new double[hierarchies.length];
  Arrays.fill(min,0d);
  this.max=new double[min.length];
  Arrays.fill(max,Double.MAX_VALUE);
}
Program: 108341
Project: 108341
Buggy source:
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(final Node node,final IHashGroupify g){
  double[] result=super.getInformationLossInternalRaw(node,g);
  double suppressed=0;
  final IntIntOpenHashMap[] original=new IntIntOpenHashMap[node.getTransformation().length];
  for (int i=0; i < original.length; i++) {
    original[i]=new IntIntOpenHashMap();
  }
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!m.isNotOutlier && m.count > 0) {
      suppressed+=m.count;
      for (int i=0; i < original.length; i++) {
        original[i].putOrAdd(m.key[i],m.count,m.count);
      }
    }
    m=m.nextOrdered;
  }
  if (suppressed != 0) {
    for (int i=0; i < original.length; i++) {
      IntIntOpenHashMap map=original[i];
      for (int j=0; j < map.allocated.length; j++) {
        if (map.allocated[j]) {
          double count=map.values[j];
          result[i]+=count * log2(count / suppressed);
        }
      }
    }
  }
  for (int column=0; column < result.length; column++) {
    result[column]=round(result[column] == 0.0d ? result[column] : -result[column]);
  }
  return new ILMultiDimensionalWithBound(createInformationLoss(result),createInformationLoss(result));
}

Fixed version (ground truth):
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(final Node node,final IHashGroupify g){
  double[] result=super.getInformationLossInternalRaw(node,g);
  double[] bound=new double[result.length];
  System.arraycopy(result,0,bound,0,result.length);
  double suppressed=0;
  final IntIntOpenHashMap[] original=new IntIntOpenHashMap[node.getTransformation().length];
  for (int i=0; i < original.length; i++) {
    original[i]=new IntIntOpenHashMap();
  }
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!m.isNotOutlier && m.count > 0) {
      suppressed+=m.count;
      for (int i=0; i < original.length; i++) {
        original[i].putOrAdd(m.key[i],m.count,m.count);
      }
    }
    m=m.nextOrdered;
  }
  if (suppressed != 0) {
    for (int i=0; i < original.length; i++) {
      IntIntOpenHashMap map=original[i];
      for (int j=0; j < map.allocated.length; j++) {
        if (map.allocated[j]) {
          double count=map.values[j];
          result[i]+=count * log2(count / suppressed);
        }
      }
    }
  }
  for (int column=0; column < result.length; column++) {
    result[column]=round(result[column] == 0.0d ? result[column] : -result[column]);
  }
  return new ILMultiDimensionalWithBound(createInformationLoss(result),createInformationLoss(bound));
}
Program: 108344
Project: 108344
Buggy source:
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  super.initializeInternal(definition,input,hierarchies,config);
  this.shares=new DomainShare[hierarchies.length];
  for (int i=0; i < shares.length; i++) {
    shares[i]=new DomainShare(hierarchies[i],input.getDictionary().getMapping()[i]);
  }
  this.tuples=input.getDataLength();
  if (config.containsCriterion(DPresence.class)) {
    Set<DPresence> criteria=config.getCriteria(DPresence.class);
    if (criteria.size() > 1) {
      throw new IllegalStateException("String_Node_Str");
    }
    this.tuples=criteria.iterator().next().getSubset().getArray().length;
  }
  double[] min=new double[shares.length];
  Arrays.fill(min,0d);
  double[] max=new double[shares.length];
  Arrays.fill(max,1d);
  super.setMin(min);
  super.setMax(max);
}

Fixed version (ground truth):
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  super.initializeInternal(definition,input,hierarchies,config);
  this.shares=new DomainShare[hierarchies.length];
  for (int i=0; i < shares.length; i++) {
    shares[i]=new DomainShare(definition.getHierarchy(input.getHeader()[i]),input.getDictionary().getMapping()[i]);
  }
  this.tuples=input.getDataLength();
  if (config.containsCriterion(DPresence.class)) {
    Set<DPresence> criteria=config.getCriteria(DPresence.class);
    if (criteria.size() > 1) {
      throw new IllegalStateException("String_Node_Str");
    }
    this.tuples=criteria.iterator().next().getSubset().getArray().length;
  }
  double[] min=new double[shares.length];
  Arrays.fill(min,0d);
  double[] max=new double[shares.length];
  Arrays.fill(max,1d);
  super.setMin(min);
  super.setMax(max);
}
Program: 108345
Project: 108345
Buggy source:
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(final Node node,final IHashGroupify g){
  ILMultiDimensionalWithBound loss=super.getInformationLossInternal(node,g);
  double[] result=loss.getInformationLoss().getValue();
  double suppressed=0;
  final IntIntOpenHashMap[] original=new IntIntOpenHashMap[node.getTransformation().length];
  for (int i=0; i < original.length; i++) {
    original[i]=new IntIntOpenHashMap();
  }
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!m.isNotOutlier && m.count > 0) {
      suppressed+=m.count;
      for (int i=0; i < original.length; i++) {
        original[i].putOrAdd(m.key[i],m.count,m.count);
      }
    }
    m=m.nextOrdered;
  }
  if (suppressed != 0) {
    for (int i=0; i < original.length; i++) {
      IntIntOpenHashMap map=original[i];
      for (int j=0; j < map.allocated.length; j++) {
        if (map.allocated[j]) {
          double count=map.values[j];
          result[i]-=count * log2(count / suppressed);
        }
      }
    }
  }
  return new ILMultiDimensionalWithBound(createInformationLoss(result),createInformationLoss(result));
}

Fixed version (ground truth):
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(final Node node,final IHashGroupify g){
  ILMultiDimensionalWithBound loss=super.getInformationLossInternal(node,g);
  double[] result=loss.getInformationLoss().getValue();
  double suppressed=0;
  final IntIntOpenHashMap[] original=new IntIntOpenHashMap[node.getTransformation().length];
  for (int i=0; i < original.length; i++) {
    original[i]=new IntIntOpenHashMap();
  }
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!m.isNotOutlier && m.count > 0) {
      suppressed+=m.count;
      for (int i=0; i < original.length; i++) {
        original[i].putOrAdd(m.key[i],m.count,m.count);
      }
    }
    m=m.nextOrdered;
  }
  if (suppressed != 0) {
    for (int i=0; i < original.length; i++) {
      IntIntOpenHashMap map=original[i];
      for (int j=0; j < map.allocated.length; j++) {
        if (map.allocated[j]) {
          double count=map.values[j];
          result[i]-=count * log2(count / suppressed);
        }
      }
    }
  }
  return new ILMultiDimensionalWithBound(createInformationLoss(result),loss.getLowerBound());
}
Program: 108346
Project: 108346
Buggy source:
/** 
 * Compares double for "equality" with a tolerance of 1 ulp
 * @param d1
 * @param d2
 * @return
 */
private boolean closeEnough(double d1,double d2){
  return Math.abs(d2 - d1) <= Math.max(Math.ulp(d1),Math.ulp(d2));
}

Fixed version (ground truth):
/** 
 * Compares double for "equality" with a tolerance of 5 ulps
 * @param d1
 * @param d2
 * @return
 */
private boolean closeEnough(double d1,double d2){
  return Math.abs(d2 - d1) <= 5 * Math.max(Math.ulp(d1),Math.ulp(d2));
}
Program: 108347
Project: 108347
Buggy source:
/** 
 * Normalizes the aggregate
 * @param aggregate
 * @param dimension
 * @return
 */
private double normalize(double aggregate,int dimension){
  double min=datasetSize / domainSizes[dimension];
  double max=datasetSize;
  double result=(aggregate - min) / (max - min);
  return result >= 0d ? result : 0d;
}

Fixed version (ground truth):
/** 
 * Normalizes the aggregate
 * @param aggregate
 * @param dimension
 * @return
 */
private double normalize(double aggregate,int dimension){
  double min=gWeight * datasetSize / domainSizes[dimension];
  double max=datasetSize;
  double result=(aggregate - min) / (max - min);
  return result >= 0d ? result : 0d;
}
Program: 108348
Project: 108348
Buggy source:
/** 
 * Normalizes the aggregate
 * @param aggregate
 * @param dimension
 * @return
 */
protected double normalize(double aggregate,int dimension){
  double min=tuples / shares[dimension].getDomainSize();
  double max=tuples;
  double result=(aggregate - min) / (max - min);
  return result >= 0d ? result : 0d;
}

Fixed version (ground truth):
/** 
 * Normalizes the aggregate
 * @param aggregate
 * @param dimension
 * @return
 */
protected double normalize(double aggregate,int dimension){
  double min=gFactor * tuples / shares[dimension].getDomainSize();
  double max=tuples;
  double result=(aggregate - min) / (max - min);
  return result >= 0d ? result : 0d;
}
Program: 108349
Project: 108349
Buggy source:
/** 
 * Utility method that helps with the conversion from metrics v1 to metrics v2
 * @param node
 * @return
 */
private String getInformationLoss(ARXNode node){
  InformationLoss<?> loss=node.getMaximumInformationLoss();
  if (loss instanceof ILMultiDimensionalRank) {
    @SuppressWarnings("String_Node_Str") double[] value=((InformationLoss<double[]>)loss).getValue().clone();
    sortDescending(value);
    int[] result=new int[value.length];
    for (int i=0; i < value.length; i++) {
      result[i]=(int)Math.round(value[i] * 100d);
    }
    return Arrays.toString(result);
  }
 else {
    return loss.toString();
  }
}

Fixed version (ground truth):
/** 
 * Utility method that helps with the conversion from metrics v1 to metrics v2
 * @param node
 * @return
 */
private String getInformationLoss(ARXNode node){
  InformationLoss<?> loss=node.getMaximumInformationLoss();
  if (loss instanceof ILMultiDimensionalRank) {
    @SuppressWarnings("String_Node_Str") double[] value=((InformationLoss<double[]>)loss).getValue().clone();
    sortDescending(value);
    int[] result=new int[value.length];
    for (int i=0; i < value.length; i++) {
      result[i]=(int)Math.round(value[i] * 100d);
    }
    return Arrays.toString(result).replace("String_Node_Str","String_Node_Str");
  }
 else {
    return loss.toString();
  }
}
Program: 108350
Project: 108350
Buggy source:
@Override public Object getDataValue(int col,int row){
  try {
    return provider.getDataValue(col,row);
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str" + e.getClass().getSimpleName());
    return "String_Node_Str";
  }
}

Fixed version (ground truth):
@Override public Object getDataValue(int col,int row){
  if (col == -1 || row == -1)   return "String_Node_Str";
  try {
    return provider.getDataValue(col,row);
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str" + e.getClass().getSimpleName());
    return "String_Node_Str";
  }
}
Program: 108351
Project: 108351
Buggy source:
/** 
 * Estimate maximum information loss
 */
private void estimateMax(){
  initializeTopDown(lattice.getTop());
  setMaximum(lattice.getTop());
  this.globalMaximum=null;
  ARXNode[][] levels=lattice.getLevels();
  for (int i=levels.length - 2; i >= 0; i--) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      pullTopDown(node);
      setMaximum(node);
      this.globalMaximum=max(this.globalMaximum,node.getMaximumInformationLoss());
    }
  }
}

Fixed version (ground truth):
/** 
 * Estimate maximum information loss
 */
private void estimateMax(){
  initializeTopDown(lattice.getTop());
  setMaximum(lattice.getTop());
  this.globalMaximum=lattice.getTop().getMaximumInformationLoss();
  ARXNode[][] levels=lattice.getLevels();
  for (int i=levels.length - 2; i >= 0; i--) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      pullTopDown(node);
      setMaximum(node);
      this.globalMaximum=max(this.globalMaximum,node.getMaximumInformationLoss());
    }
  }
}
Program: 108352
Project: 108352
Buggy source:
/** 
 * Estimate minimum information loss
 */
private void estimateMin(){
  initializeBottomUp(lattice.getBottom());
  setMinimum(lattice.getBottom());
  this.globalMinimum=null;
  ARXNode[][] levels=lattice.getLevels();
  for (int i=1; i < levels.length; i++) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      pullBottomUp(node);
      setMinimum(node);
      this.globalMinimum=min(this.globalMinimum,node.getMinimumInformationLoss());
    }
  }
}

Fixed version (ground truth):
/** 
 * Estimate minimum information loss
 */
private void estimateMin(){
  initializeBottomUp(lattice.getBottom());
  setMinimum(lattice.getBottom());
  this.globalMinimum=lattice.getBottom().getMinimumInformationLoss();
  ARXNode[][] levels=lattice.getLevels();
  for (int i=1; i < levels.length; i++) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      pullBottomUp(node);
      setMinimum(node);
      this.globalMinimum=min(this.globalMinimum,node.getMinimumInformationLoss());
    }
  }
}
Program: 108353
Project: 108353
Buggy source:
@Override protected InformationLossWithBound<InformationLossRCE> getInformationLossInternal(Node node,IHashGroupify g){
  int[] transformation=node.getTransformation();
  int dimensions=transformation.length;
  double[] scores=new double[dimensions];
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (m.count > 0) {
      if (m.isNotOutlier) {
        for (int dimension=0; dimension < dimensions; dimension++) {
          int value=m.key[dimension];
          double share=(double)m.count * frequencies[dimension][transformation[dimension]][value];
          scores[dimension]+=share * gWeight;
        }
      }
 else {
        for (int dimension=0; dimension < dimensions; dimension++) {
          if (sWeight == 1d) {
            double share=(double)m.count;
            scores[dimension]+=share;
          }
 else {
            int value=m.key[dimension];
            double share=(double)m.count * frequencies[dimension][transformation[dimension]][value];
            scores[dimension]+=share + sWeight * (1d - share);
          }
        }
      }
    }
    m=m.nextOrdered;
  }
  for (int dimension=0; dimension < dimensions; dimension++) {
    scores[dimension]=normalize(scores[dimension],dimension);
  }
  return new InformationLossWithBound<InformationLossRCE>(new InformationLossRCE(scores,weights));
}

Fixed version (ground truth):
@Override protected InformationLossWithBound<InformationLossRCE> getInformationLossInternal(Node node,IHashGroupify g){
  int[] transformation=node.getTransformation();
  int dimensions=transformation.length;
  double[] scores=new double[dimensions];
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (m.count > 0) {
      if (m.isNotOutlier) {
        for (int dimension=0; dimension < dimensions; dimension++) {
          int value=m.key[dimension];
          double share=(double)m.count * frequencies[dimension][transformation[dimension]][value];
          scores[dimension]+=share * gWeight;
        }
      }
 else {
        for (int dimension=0; dimension < dimensions; dimension++) {
          if (sWeight == 1d) {
            double share=(double)m.count;
            scores[dimension]+=share;
          }
 else {
            int value=m.key[dimension];
            double share=(double)m.count * frequencies[dimension][transformation[dimension]][value];
            scores[dimension]+=share + sWeight * ((double)m.count - share);
          }
        }
      }
    }
    m=m.nextOrdered;
  }
  for (int dimension=0; dimension < dimensions; dimension++) {
    scores[dimension]=normalize(scores[dimension],dimension);
  }
  return new InformationLossWithBound<InformationLossRCE>(new InformationLossRCE(scores,weights));
}
Program: 108354
Project: 108354
Buggy source:
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(Node node,IHashGroupify g){
  int[] transformation=node.getTransformation();
  int dimensions=transformation.length;
  double[] result=new double[dimensions];
  double[] bound=new double[dimensions];
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (m.count > 0) {
      for (int dimension=0; dimension < dimensions; dimension++) {
        int value=m.key[dimension];
        int level=transformation[dimension];
        double share=(double)m.count * shares[dimension].getShare(value,level);
        result[dimension]+=m.isNotOutlier ? share * gFactor : (sFactor == 1d ? m.count : share + sFactor * (1d - share));
        bound[dimension]+=share * gFactor;
      }
    }
    m=m.nextOrdered;
  }
  for (int dimension=0; dimension < dimensions; dimension++) {
    result[dimension]=normalize(result[dimension],dimension);
    bound[dimension]=normalize(bound[dimension],dimension);
  }
  return new ILMultiDimensionalWithBound(super.createInformationLoss(result),super.createInformationLoss(bound));
}

Fixed version (ground truth):
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(Node node,IHashGroupify g){
  int[] transformation=node.getTransformation();
  int dimensions=transformation.length;
  double[] result=new double[dimensions];
  double[] bound=new double[dimensions];
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (m.count > 0) {
      for (int dimension=0; dimension < dimensions; dimension++) {
        int value=m.key[dimension];
        int level=transformation[dimension];
        double share=(double)m.count * shares[dimension].getShare(value,level);
        result[dimension]+=m.isNotOutlier ? share * gFactor : (sFactor == 1d ? m.count : share + sFactor * ((double)m.count - share));
        bound[dimension]+=share * gFactor;
      }
    }
    m=m.nextOrdered;
  }
  for (int dimension=0; dimension < dimensions; dimension++) {
    result[dimension]=normalize(result[dimension],dimension);
    bound[dimension]=normalize(bound[dimension],dimension);
  }
  return new ILMultiDimensionalWithBound(super.createInformationLoss(result),super.createInformationLoss(bound));
}
Program: 108355
Project: 108355
Buggy source:
/** 
 * Creates a new set of domain shares derived from the given attribute
 * @param hierarchy
 */
public DomainShare(GeneralizationHierarchy hierarchy,String[] dictvalues){
  int[][] array=hierarchy.getArray();
  this.size=dictvalues.length;
  this.duplicates=new LongDoubleOpenHashMap();
  this.shares=new double[dictvalues.length];
  Arrays.fill(shares,NOT_AVAILABLE);
  IntIntOpenHashMap[] maps=new IntIntOpenHashMap[array[0].length];
  for (int level=0; level < maps.length; level++) {
    maps[level]=new IntIntOpenHashMap(hierarchy.getDistinctValues()[level]);
  }
  for (int value=0; value < array.length; value++) {
    int[] transformation=array[value];
    for (int level=0; level < transformation.length; level++) {
      maps[level].putOrAdd(transformation[level],1,1);
    }
  }
  for (int level=0; level < maps.length; level++) {
    IntIntOpenHashMap map=maps[level];
    boolean[] allocated=map.allocated;
    int[] keys=map.keys;
    int[] values=map.values;
    for (int index=0; index < allocated.length; index++) {
      if (allocated[index]) {
        int key=keys[index];
        double share=(double)values[index] / size;
        double stored=shares[key];
        if (stored != NOT_AVAILABLE) {
          if (stored == share) {
            continue;
          }
          if (stored >= 0d) {
            shares[key]=-shares[key];
          }
          long dkey=(((long)key) << 32) | (level & 0xffffffffL);
          duplicates.put(dkey,share);
        }
 else {
          shares[key]=share;
        }
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * Creates a new set of domain shares derived from the given attribute
 * @param hierarchy
 */
public DomainShare(GeneralizationHierarchy hierarchy,String[] dictvalues){
  int[][] array=hierarchy.getArray();
  this.size=array.length;
  this.duplicates=new LongDoubleOpenHashMap();
  this.shares=new double[dictvalues.length];
  Arrays.fill(shares,NOT_AVAILABLE);
  IntIntOpenHashMap[] maps=new IntIntOpenHashMap[array[0].length];
  for (int level=0; level < maps.length; level++) {
    maps[level]=new IntIntOpenHashMap(hierarchy.getDistinctValues()[level]);
  }
  for (int value=0; value < array.length; value++) {
    int[] transformation=array[value];
    for (int level=0; level < transformation.length; level++) {
      maps[level].putOrAdd(transformation[level],1,1);
    }
  }
  for (int level=0; level < maps.length; level++) {
    IntIntOpenHashMap map=maps[level];
    boolean[] allocated=map.allocated;
    int[] keys=map.keys;
    int[] values=map.values;
    for (int index=0; index < allocated.length; index++) {
      if (allocated[index]) {
        int key=keys[index];
        double share=(double)values[index] / size;
        double stored=shares[key];
        if (stored != NOT_AVAILABLE) {
          if (stored == share) {
            continue;
          }
          if (stored >= 0d) {
            shares[key]=-shares[key];
          }
          long dkey=(((long)key) << 32) | (level & 0xffffffffL);
          duplicates.put(dkey,share);
        }
 else {
          shares[key]=share;
        }
      }
    }
  }
}
Program: 108356
Project: 108356
Buggy source:
@Override public int compareTo(InformationLoss<?> other){
  if (other == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else {
    double[] otherValue=convert(other).aggregate;
    double[] thisValue=aggregate;
    for (int i=0; i < otherValue.length; i++) {
      if (thisValue[i] < otherValue[i])       return -1;
 else       if (thisValue[i] > otherValue[i])       return +1;
    }
    return 0;
  }
}

Fixed version (ground truth):
@Override public int compareTo(InformationLoss<?> other){
  if (other == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else {
    double[] otherValue=convert(other).aggregate;
    double[] thisValue=aggregate;
    for (int i=0; i < otherValue.length; i++) {
      int cmp=compareWithTolerance(thisValue[i],otherValue[i]);
      if (cmp != 0)       return cmp;
    }
    return 0;
  }
}
Program: 108357
Project: 108357
Buggy source:
/** 
 * This method triggers the estimation of the information loss of all nodes in the lattice regardless of whether they have been checked for anonymity or not
 */
protected void estimateInformationLoss(){
  if (metric.isMonotonic() || (maxAbsoluteOutliers == 0)) {
    estimateMonotonicMinLoss();
    estimateMonotonicMaxLoss();
  }
 else {
    estimateNonMonotonicLoss();
  }
}

Fixed version (ground truth):
/** 
 * This method triggers the estimation of the information loss of all nodes in the lattice regardless of whether they have been checked for anonymity or not
 */
protected void estimateInformationLoss(){
  estimateNonMonotonicLoss();
}
Program: 108358
Project: 108358
Buggy source:
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  super.initializeInternal(definition,input,hierarchies,config);
  Set<String> qis=definition.getQuasiIdentifyingAttributes();
  for (  String qi : qis) {
    minHeight+=definition.getMinimumGeneralization(qi);
    maxHeight+=definition.getMaximumGeneralization(qi);
  }
}

Fixed version (ground truth):
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  super.initializeInternal(definition,input,hierarchies,config);
  minHeight=0;
  maxHeight=0;
  Set<String> qis=definition.getQuasiIdentifyingAttributes();
  for (  String qi : qis) {
    minHeight+=definition.getMinimumGeneralization(qi);
    maxHeight+=definition.getMaximumGeneralization(qi);
  }
}
Program: 108359
Project: 108359
Buggy source:
/** 
 * Creates a tooltip text
 * @param node
 */
private String getTooltipText(final ARXNode node){
  final StringBuffer b=new StringBuffer();
  b.append(Resources.getMessage("String_Node_Str"));
  b.append(format.format(asRelativeValue(node.getMinimumInformationLoss())));
  b.append("String_Node_Str");
  b.append(format.format(asRelativeValue(node.getMaximumInformationLoss())));
  b.append("String_Node_Str");
  for (  final String qi : node.getQuasiIdentifyingAttributes()) {
    int height=model.getOutputDefinition().isHierarchyAvailable(qi) ? model.getOutputDefinition().getHierarchy(qi)[0].length : 0;
    b.append("String_Node_Str");
    b.append(qi);
    b.append("String_Node_Str");
    b.append(format.format(asRelativeValue(node.getGeneralization(qi),height - 1)));
    b.append("String_Node_Str");
  }
  b.setLength(b.length() - 1);
  return b.toString();
}

Fixed version (ground truth):
/** 
 * Creates a tooltip text
 * @param node
 */
private String getTooltipText(final ARXNode node){
  final StringBuffer b=new StringBuffer();
  b.append(Resources.getMessage("String_Node_Str"));
  b.append(format.format(asRelativeValue(node.getMinimumInformationLoss())));
  b.append("String_Node_Str");
  b.append(format.format(asRelativeValue(node.getMaximumInformationLoss())));
  b.append("String_Node_Str");
  if (model.getOutputDefinition() != null) {
    for (    final String qi : node.getQuasiIdentifyingAttributes()) {
      int height=model.getOutputDefinition().isHierarchyAvailable(qi) ? model.getOutputDefinition().getHierarchy(qi)[0].length : 0;
      b.append("String_Node_Str");
      b.append(qi);
      b.append("String_Node_Str");
      b.append(format.format(asRelativeValue(node.getGeneralization(qi),height - 1)));
      b.append("String_Node_Str");
    }
  }
  b.setLength(b.length() - 1);
  return b.toString();
}
Program: 108360
Project: 108360
Buggy source:
@Override public void traverse(){
  FLASHPhaseConfiguration outerLoopConfiguration;
  if (config.isBinaryPhaseRequired()) {
    outerLoopConfiguration=config.getBinaryPhaseConfiguration();
  }
 else {
    outerLoopConfiguration=config.getLinearPhaseConfiguration();
  }
  lattice.setTagTrigger(config.getTriggerTagEvent());
  checker.getHistory().setStorageTrigger(config.getTriggerSnapshotStore());
  PriorityQueue<Node> queue=new PriorityQueue<Node>(lattice.getLevels().length,strategy);
  Node bottom=lattice.getBottom();
  INodeChecker.Result result=checker.check(bottom);
  lattice.setProperty(bottom,Node.PROPERTY_FORCE_SNAPSHOT);
  bottom.setData(result);
  int length=lattice.getLevels().length;
  for (int i=0; i < length; i++) {
    for (    Node node : getUnsetNodesAndSort(i,outerLoopConfiguration.getTriggerSkip())) {
      if (config.isBinaryPhaseRequired()) {
        binarySearch(node,queue);
      }
 else {
        linearSearch(node);
      }
    }
  }
  computeUtilityForMonotonicMetrics(lattice.getBottom());
  computeUtilityForMonotonicMetrics(lattice.getTop());
  lattice.getBottom().setData(null);
  potentiallyInsufficientUtility.clear();
}

Fixed version (ground truth):
@Override public void traverse(){
  FLASHPhaseConfiguration outerLoopConfiguration;
  if (config.isBinaryPhaseRequired()) {
    outerLoopConfiguration=config.getBinaryPhaseConfiguration();
  }
 else {
    outerLoopConfiguration=config.getLinearPhaseConfiguration();
  }
  lattice.setTagTrigger(config.getTriggerTagEvent());
  checker.getHistory().setStorageTrigger(config.getTriggerSnapshotStore());
  PriorityQueue<Node> queue=new PriorityQueue<Node>(lattice.getLevels().length,strategy);
  Node bottom=lattice.getBottom();
  INodeChecker.Result result=checker.check(bottom);
  lattice.setProperty(bottom,Node.PROPERTY_FORCE_SNAPSHOT);
  bottom.setData(result);
  int length=lattice.getLevels().length;
  for (int i=0; i < length; i++) {
    for (    Node node : getUnsetNodesAndSort(i,outerLoopConfiguration.getTriggerSkip())) {
      if (config.isBinaryPhaseRequired()) {
        binarySearch(node,queue);
      }
 else {
        linearSearch(node);
      }
    }
  }
  computeUtilityForMonotonicMetrics(lattice.getBottom());
  computeUtilityForMonotonicMetrics(lattice.getTop());
  lattice.getBottom().setData(null);
  if (potentiallyInsufficientUtility != null) {
    potentiallyInsufficientUtility.clear();
  }
}
Program: 108361
Project: 108361
Buggy source:
/** 
 * Creates a new instance for the given data set
 * @param hierarchy
 */
public Cardinalities(Data data,RowSet subset,GeneralizationHierarchy[] hierarchies){
  int[][] array=data.getArray();
  Dictionary dictionary=data.getDictionary();
  this.size=subset.size();
  cardinalities=new int[array[0].length][][];
  for (int i=0; i < cardinalities.length; i++) {
    cardinalities[i]=new int[dictionary.getMapping()[i].length][hierarchies[i].getArray()[0].length];
  }
  for (int i=0; i < array.length; i++) {
    if (subset == null || subset.contains(i)) {
      final int[] row=array[i];
      for (int column=0; column < row.length; column++) {
        cardinalities[column][row[column]][0]++;
      }
    }
  }
  for (int column=0; column < hierarchies.length; column++) {
    final int[][] hierarchy=hierarchies[column].getArray();
    for (int in=0; in < hierarchy.length; in++) {
      final int cardinality=cardinalities[column][in][0];
      for (int level=1; level < hierarchy[in].length; level++) {
        final int out=hierarchy[in][level];
        cardinalities[column][out][level]+=cardinality;
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * Creates a new instance for the given data set
 * @param hierarchy
 */
public Cardinalities(Data data,RowSet subset,GeneralizationHierarchy[] hierarchies){
  int[][] array=data.getArray();
  Dictionary dictionary=data.getDictionary();
  this.size=subset == null ? data.getDataLength() : subset.size();
  cardinalities=new int[array[0].length][][];
  for (int i=0; i < cardinalities.length; i++) {
    cardinalities[i]=new int[dictionary.getMapping()[i].length][hierarchies[i].getArray()[0].length];
  }
  for (int i=0; i < array.length; i++) {
    if (subset == null || subset.contains(i)) {
      final int[] row=array[i];
      for (int column=0; column < row.length; column++) {
        cardinalities[column][row[column]][0]++;
      }
    }
  }
  for (int column=0; column < hierarchies.length; column++) {
    final int[][] hierarchy=hierarchies[column].getArray();
    for (int in=0; in < hierarchy.length; in++) {
      final int cardinality=cardinalities[column][in][0];
      for (int level=1; level < hierarchy[in].length; level++) {
        final int out=hierarchy[in][level];
        cardinalities[column][out][level]+=cardinality;
      }
    }
  }
}
Program: 108362
Project: 108362
Buggy source:
/** 
 * Creates a new set of domain shares derived from the given attribute
 * @param hierarchy
 */
public DomainShare(GeneralizationHierarchy hierarchy){
  int[][] array=hierarchy.getArray();
  this.size=array.length;
  this.duplicates=new LongDoubleOpenHashMap();
  this.shares=new double[array.length];
  Arrays.fill(shares,NOT_AVAILABLE);
  IntIntOpenHashMap[] maps=new IntIntOpenHashMap[array[0].length];
  for (int level=0; level < maps.length; level++) {
    maps[level]=new IntIntOpenHashMap(hierarchy.getDistinctValues()[level]);
  }
  for (int value=0; value < array.length; value++) {
    int[] transformation=array[value];
    for (int level=0; level < transformation.length; level++) {
      maps[level].putOrAdd(transformation[level],1,1);
    }
  }
  for (int level=0; level < maps.length; level++) {
    IntIntOpenHashMap map=maps[level];
    boolean[] allocated=map.allocated;
    int[] keys=map.keys;
    int[] values=map.values;
    for (int index=0; index < allocated.length; index++) {
      if (allocated[index]) {
        int key=keys[index];
        double share=(double)values[index] / size;
        double stored=shares[key];
        if (stored != NOT_AVAILABLE) {
          if (stored == share) {
            continue;
          }
          if (stored >= 0d) {
            shares[key]=-shares[key];
          }
          long dkey=(((long)key) << 32) | (level & 0xffffffffL);
          duplicates.put(dkey,share);
        }
 else {
          shares[key]=share;
        }
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * Creates a new set of domain shares derived from the given attribute
 * @param hierarchy
 */
public DomainShare(GeneralizationHierarchy hierarchy,String[] dictvalues){
  int[][] array=hierarchy.getArray();
  this.size=dictvalues.length;
  this.duplicates=new LongDoubleOpenHashMap();
  this.shares=new double[dictvalues.length];
  Arrays.fill(shares,NOT_AVAILABLE);
  IntIntOpenHashMap[] maps=new IntIntOpenHashMap[array[0].length];
  for (int level=0; level < maps.length; level++) {
    maps[level]=new IntIntOpenHashMap(hierarchy.getDistinctValues()[level]);
  }
  for (int value=0; value < array.length; value++) {
    int[] transformation=array[value];
    for (int level=0; level < transformation.length; level++) {
      maps[level].putOrAdd(transformation[level],1,1);
    }
  }
  for (int level=0; level < maps.length; level++) {
    IntIntOpenHashMap map=maps[level];
    boolean[] allocated=map.allocated;
    int[] keys=map.keys;
    int[] values=map.values;
    for (int index=0; index < allocated.length; index++) {
      if (allocated[index]) {
        int key=keys[index];
        double share=(double)values[index] / size;
        double stored=shares[key];
        if (stored != NOT_AVAILABLE) {
          if (stored == share) {
            continue;
          }
          if (stored >= 0d) {
            shares[key]=-shares[key];
          }
          long dkey=(((long)key) << 32) | (level & 0xffffffffL);
          duplicates.put(dkey,share);
        }
 else {
          shares[key]=share;
        }
      }
    }
  }
}
Program: 108363
Project: 108363
Buggy source:
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  super.initializeInternal(definition,input,hierarchies,config);
  this.shares=new DomainShare[hierarchies.length];
  for (int i=0; i < shares.length; i++) {
    shares[i]=new DomainShare(hierarchies[i]);
  }
  this.tuples=input.getDataLength();
  if (config.containsCriterion(DPresence.class)) {
    Set<DPresence> criteria=config.getCriteria(DPresence.class);
    if (criteria.size() > 1) {
      throw new IllegalStateException("String_Node_Str");
    }
    this.tuples=criteria.iterator().next().getSubset().getArray().length;
  }
  double[] min=new double[shares.length];
  Arrays.fill(min,0d);
  double[] max=new double[shares.length];
  Arrays.fill(max,1d);
  super.setMin(min);
  super.setMax(max);
}

Fixed version (ground truth):
@Override protected void initializeInternal(final DataDefinition definition,final Data input,final GeneralizationHierarchy[] hierarchies,final ARXConfiguration config){
  super.initializeInternal(definition,input,hierarchies,config);
  this.shares=new DomainShare[hierarchies.length];
  for (int i=0; i < shares.length; i++) {
    shares[i]=new DomainShare(hierarchies[i],input.getDictionary().getMapping()[i]);
  }
  this.tuples=input.getDataLength();
  if (config.containsCriterion(DPresence.class)) {
    Set<DPresence> criteria=config.getCriteria(DPresence.class);
    if (criteria.size() > 1) {
      throw new IllegalStateException("String_Node_Str");
    }
    this.tuples=criteria.iterator().next().getSubset().getArray().length;
  }
  double[] min=new double[shares.length];
  Arrays.fill(min,0d);
  double[] max=new double[shares.length];
  Arrays.fill(max,1d);
  super.setMin(min);
  super.setMax(max);
}
Program: 108364
Project: 108364
Buggy source:
@Override protected AbstractILMultiDimensional getLowerBoundInternal(Node node,IHashGroupify groupify){
  return getLowerBoundInternal(node);
}

Fixed version (ground truth):
@Override protected AbstractILMultiDimensional getLowerBoundInternal(Node node,IHashGroupify groupify){
  return this.getLowerBoundInternal(node);
}
Program: 108365
Project: 108365
Buggy source:
@Override protected AbstractILMultiDimensional getLowerBoundInternal(Node node,IHashGroupify groupify){
  return super.getLowerBoundInternal(node);
}

Fixed version (ground truth):
@Override protected AbstractILMultiDimensional getLowerBoundInternal(Node node,IHashGroupify groupify){
  return super.getInformationLossInternal(node,null).getLowerBound();
}
Program: 108367
Project: 108367
Buggy source:
protected ARXNode getOptimum(){
  return optimum;
}

Fixed version (ground truth):
/** 
 * Returns the optimum, if any
 * @return
 */
protected ARXNode getOptimum(){
  return optimum;
}
Program: 108368
Project: 108368
Buggy source:
/** 
 * Estimates minimal information loss
 */
private void estimateNonMonotonicLoss(){
  InformationLoss<?> min=null;
  InformationLoss<?> max=null;
  for (int i=0; i < levels.length; i++) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      InformationLoss<?> nodeMin=node.getMinimumInformationLoss();
      InformationLoss<?> nodeMax=node.getMaximumInformationLoss();
      if (nodeMin != null && nodeMin.equals(nodeMax)) {
        if (min == null || min.compareTo(nodeMin) > 0) {
          min=nodeMin.clone();
        }
        if (max == null || max.compareTo(nodeMax) < 0) {
          max=nodeMax.clone();
        }
      }
    }
  }
  if (min == null)   min=metric.createMinInformationLoss();
  if (max == null)   max=metric.createMaxInformationLoss();
  for (int i=0; i < levels.length; i++) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      if (node.minInformationLoss == null) {
        node.minInformationLoss=min.clone();
      }
      if (node.maxInformationLoss == null) {
        node.maxInformationLoss=max.clone();
      }
    }
  }
  this.minimumInformationLoss=min.clone();
  this.maximumInformationLoss=max.clone();
}

Fixed version (ground truth):
/** 
 * Estimates minimal information loss
 */
private void estimateNonMonotonicLoss(){
  InformationLoss<?> min=metric.createMinInformationLoss();
  InformationLoss<?> max=metric.createMaxInformationLoss();
  for (int i=0; i < levels.length; i++) {
    final ARXNode[] level=levels[i];
    for (    final ARXNode node : level) {
      if (node.minInformationLoss == null) {
        node.minInformationLoss=min.clone();
      }
      if (node.maxInformationLoss == null) {
        node.maxInformationLoss=max.clone();
      }
    }
  }
  this.minimumInformationLoss=min.clone();
  this.maximumInformationLoss=max.clone();
}
Program: 108369
Project: 108369
Buggy source:
@Override protected InformationLossWithBound<InformationLossDefault> getInformationLossInternal(final Node node,final IHashGroupify g){
  if (node.getLowerBound() != null) {
    return new InformationLossWithBound<InformationLossDefault>((InformationLossDefault)node.getLowerBound(),(InformationLossDefault)node.getLowerBound());
  }
  double result=0;
  for (int column=0; column < hierarchies.length; column++) {
    final int state=node.getTransformation()[column];
    double value=cache[column][state];
    if (value == NA) {
      value=0d;
      final int[][] cardinality=cardinalities[column];
      final int[][] hierarchy=hierarchies[column];
      for (int in=0; in < hierarchy.length; in++) {
        final int out=hierarchy[in][state];
        final double a=cardinality[in][0];
        final double b=cardinality[out][state];
        if (a != 0d) {
          value+=a * log2(a / b);
        }
      }
      cache[column][state]=value;
    }
    result+=value;
  }
  return new InformationLossDefaultWithBound(-result,-result);
}

Fixed version (ground truth):
@Override protected InformationLossWithBound<InformationLossDefault> getInformationLossInternal(final Node node,final IHashGroupify g){
  if (node.getLowerBound() != null) {
    return new InformationLossWithBound<InformationLossDefault>((InformationLossDefault)node.getLowerBound(),(InformationLossDefault)node.getLowerBound());
  }
  double result=0;
  for (int column=0; column < hierarchies.length; column++) {
    final int state=node.getTransformation()[column];
    double value=cache[column][state];
    if (value == NA) {
      value=0d;
      final int[][] cardinality=cardinalities[column];
      final int[][] hierarchy=hierarchies[column];
      for (int in=0; in < hierarchy.length; in++) {
        final int out=hierarchy[in][state];
        final double a=cardinality[in][0];
        final double b=cardinality[out][state];
        if (a != 0d) {
          value+=a * log2(a / b);
        }
      }
      cache[column][state]=value;
    }
    result+=value;
  }
  result=result == 0.0d ? result : -result;
  return new InformationLossDefaultWithBound(result,result);
}
Program: 108370
Project: 108370
Buggy source:
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(final Node node,final IHashGroupify g){
  int[][][] cardinalities=this.cardinalities.getCardinalities();
  double[] result=new double[hierarchies.length];
  for (int column=0; column < hierarchies.length; column++) {
    final int transformation=node.getTransformation()[column];
    double value=cache[column][transformation];
    if (value == NOT_AVAILABLE) {
      value=0d;
      final int[][] cardinality=cardinalities[column];
      final int[][] hierarchy=hierarchies[column];
      for (int in=0; in < hierarchy.length; in++) {
        final int out=hierarchy[in][transformation];
        final double a=cardinality[in][0];
        final double b=cardinality[out][transformation];
        if (a != 0d) {
          value+=a * log2(a / b);
        }
      }
      cache[column][transformation]=value;
    }
    result[column]=value;
  }
  return new ILMultiDimensionalWithBound(super.createInformationLoss(result),super.createInformationLoss(result));
}

Fixed version (ground truth):
@Override protected ILMultiDimensionalWithBound getInformationLossInternal(final Node node,final IHashGroupify g){
  int[][][] cardinalities=this.cardinalities.getCardinalities();
  double[] result=new double[hierarchies.length];
  for (int column=0; column < hierarchies.length; column++) {
    final int transformation=node.getTransformation()[column];
    double value=cache[column][transformation];
    if (value == NOT_AVAILABLE) {
      value=0d;
      final int[][] cardinality=cardinalities[column];
      final int[][] hierarchy=hierarchies[column];
      for (int in=0; in < hierarchy.length; in++) {
        final int out=hierarchy[in][transformation];
        final double a=cardinality[in][0];
        final double b=cardinality[out][transformation];
        if (a != 0d) {
          value+=a * log2(a / b);
        }
      }
      cache[column][transformation]=value;
    }
    result[column]=value;
  }
  for (int column=0; column < hierarchies.length; column++) {
    result[column]=result[column] == 0.0d ? result[column] : -result[column];
  }
  return new ILMultiDimensionalWithBound(super.createInformationLoss(result),super.createInformationLoss(result));
}
Program: 108371
Project: 108371
Buggy source:
/** 
 * Creates a new instance. The precomputed variant will be used if  #distinctValues / #rows <= threshold for all quasi-identifiers.
 * @param threshold
 * @param function
 */
protected MetricMDNUNMEntropyPotentiallyPrecomputed(double threshold,AggregateFunction function){
  super(new MetricMDNUNMEntropy(function),new MetricMDNUNMEntropyPrecomputed(function),threshold);
}

Fixed version (ground truth):
/** 
 * Creates a new instance. The pre-computed variant will be used if  #distinctValues / #rows <= threshold for all quasi-identifiers.
 * @param threshold
 * @param function
 */
protected MetricMDNUNMEntropyPotentiallyPrecomputed(double threshold,AggregateFunction function){
  super(new MetricMDNUNMEntropy(function),new MetricMDNUNMEntropyPrecomputed(function),threshold);
}
Program: 108372
Project: 108372
Buggy source:
/** 
 * Applies and checks a transformation
 * @param testcase 
 * @param result
 * @param node
 */
private void checkTransformation(ARXUtilityMetricsTestCase testcase,ARXResult result,ARXNode node){
  InformationLoss<?> min=node.getMinimumInformationLoss();
  InformationLoss<?> max=node.getMaximumInformationLoss();
  result.getOutput(node,false);
  assertTrue("String_Node_Str",node.getMinimumInformationLoss().compareTo(node.getMaximumInformationLoss()) == 0);
  if (min.compareTo(node.getMaximumInformationLoss()) > 0) {
    System.out.println(min + "String_Node_Str" + node.getMaximumInformationLoss()+ "String_Node_Str"+ max);
    System.out.println("String_Node_Str" + node.getAnonymity() + "String_Node_Str"+ testcase.config.isSuppressionAlwaysEnabled());
    System.out.println(testcase.getDescription());
  }
  assertTrue("String_Node_Str",min.compareTo(node.getMaximumInformationLoss()) <= 0);
  assertTrue("String_Node_Str",max.compareTo(node.getMaximumInformationLoss()) >= 0);
}

Fixed version (ground truth):
/** 
 * Applies and checks a transformation
 * @param testcase 
 * @param result
 * @param node
 */
private void checkTransformation(ARXUtilityMetricsTestCase testcase,ARXResult result,ARXNode node){
  InformationLoss<?> min=node.getMinimumInformationLoss();
  InformationLoss<?> max=node.getMaximumInformationLoss();
  result.getOutput(node,false);
  assertTrue("String_Node_Str",compareWithTolerance(node.getMinimumInformationLoss(),node.getMaximumInformationLoss()) == 0);
  if (min.compareTo(node.getMaximumInformationLoss()) > 0) {
    System.out.println(min + "String_Node_Str" + node.getMaximumInformationLoss()+ "String_Node_Str"+ max);
    System.out.println("String_Node_Str" + node.getAnonymity() + "String_Node_Str"+ testcase.config.isSuppressionAlwaysEnabled());
    System.out.println(testcase.getDescription());
  }
  assertTrue("String_Node_Str",compareWithTolerance(min,node.getMaximumInformationLoss()) <= 0);
  assertTrue("String_Node_Str",compareWithTolerance(max,node.getMaximumInformationLoss()) >= 0);
}
Program: 108373
Project: 108373
Buggy source:
/** 
 * Tests all estimates within a lattice
 * @param lattice
 */
private void checkLattice(ARXLattice lattice){
  for (  ARXNode[] level : lattice.getLevels()) {
    for (    ARXNode node : level) {
      assertTrue("String_Node_Str",node.getMinimumInformationLoss().compareTo(node.getMaximumInformationLoss()) <= 0);
    }
  }
}

Fixed version (ground truth):
/** 
 * Tests all estimates within a lattice
 * @param lattice
 */
private void checkLattice(ARXLattice lattice){
  for (  ARXNode[] level : lattice.getLevels()) {
    for (    ARXNode node : level) {
      assertTrue("String_Node_Str",compareWithTolerance(node.getMinimumInformationLoss(),node.getMaximumInformationLoss()) <= 0);
    }
  }
}