@Override
 public List<MessageModel> search(String geohash, int pageSize, int pageNum) {
   String prefixKey = geohash.substring(0, prefixLength);
   List<MessageModel> messageModelList = cache.get(prefixKey);
   List<MessageModel> messageResultModels = new ArrayList<>();
   if (messageModelList != null) {
     if ((pageSize * pageNum) <= messageModelList.size()) {
       // 按时间进行降序
       messageResultModels =
           messageModelList
               .parallelStream()
               .sorted(Comparator.comparing(MessageModel::getCreateTime).reversed())
               .collect(Collectors.toList())
               .subList(pageSize * (pageNum - 1), pageSize * pageNum);
     } else if (pageSize * (pageNum - 1) <= messageModelList.size()) {
       messageResultModels =
           messageModelList
               .parallelStream()
               .sorted(Comparator.comparing(MessageModel::getCreateTime).reversed())
               .collect(Collectors.toList())
               .subList(pageSize * (pageNum - 1), messageModelList.size());
     }
   }
   return messageResultModels;
 }
 @Test
 public void testNodeComparator2() {
   ICoverageNode d1 = new MockNode(18);
   ICoverageNode d2 = new MockNode(15);
   final Comparator<ICoverageNode> cmp = CounterComparator.TOTALITEMS.on(CounterEntity.LINE);
   assertEquals(0, cmp.compare(d1, d2), 0.0);
 }
  @Test
  public void testEqualsPerformance() {
    boolean testEnabled = false;

    if (testEnabled) {
      final int ITERATIONS = 10000000;
      long start1 = System.currentTimeMillis();
      for (int i = 0; i < ITERATIONS; i++) {
        Comparator<byte[]> comparator = UnsignedBytes.lexicographicalComparator();

        comparator.compare(wrapper1.getData(), wrapper2.getData());
      }
      System.out.println(System.currentTimeMillis() - start1 + "ms");

      long start2 = System.currentTimeMillis();
      for (int i = 0; i < ITERATIONS; i++) {
        Arrays.equals(wrapper1.getData(), wrapper2.getData());
      }
      System.out.println(System.currentTimeMillis() - start2 + "ms");

      long start3 = System.currentTimeMillis();
      for (int i = 0; i < ITERATIONS; i++) {
        FastByteComparisons.compareTo(
            wrapper1.getData(),
            0,
            wrapper1.getData().length,
            wrapper2.getData(),
            0,
            wrapper1.getData().length);
      }
      System.out.println(System.currentTimeMillis() - start3 + "ms");
    }
  }
 protected static void assertLesser(
     Comparator<ExhaustiveSearchNode> comparator, ExhaustiveSearchNode a, ExhaustiveSearchNode b) {
   assertTrue(
       "Node (" + a + ") must be lesser than node (" + b + ").", comparator.compare(a, b) < 0);
   assertTrue(
       "Node (" + b + ") must be greater than node (" + a + ").", comparator.compare(b, a) > 0);
 }
  /**
   * Performs a binary search on the dataSet
   *
   * @param element is the value in to be searched for in dataSet
   * @return the index of dataSet that contains the element, or -1 if element does not exist in the
   *     dataSet.
   */
  public int binarySearch(E element) {
    if (element == null) return -1;

    Comparator<? super E> binaryComparator = comparator();

    if (binaryComparator == null)
      binaryComparator = (Comparator<? super E>) Comparator.naturalOrder();

    int lowerBound = 0;
    int upperBound = size - 1;
    int index = (lowerBound + upperBound) / 2;
    while (lowerBound <= upperBound) {

      int comparisonInt = binaryComparator.compare(element, dataSet[index]);
      if (comparisonInt == 0) {
        return index;
      } else if (comparisonInt > 0) {
        lowerBound = index + 1;
        index = (lowerBound + upperBound) / 2;
      } else {
        upperBound = index - 1;
        index = (lowerBound + upperBound) / 2;
      }
    }
    return -1;
  }
Exemple #6
0
 public static void main(String[] args) {
   Personne[] tab = {
     new Personne("thibault", "Rougier", 2001),
     new Personne("thomas", "Niesseron", 1987),
     new Personne("thifaine", "Mitenne", 1959),
     new Personne("maxime", "Forest", 1995),
     new Personne("jules", "Forest", 1995)
   };
   System.out.println("--- Nes apres 1985 : ");
   Stream.of(tab)
       .filter(pp -> pp.getAnnee() > 1985)
       .forEach(pp -> System.out.print(pp.getPrenom() + ", "));
   System.out.println("\n--- Nes avant 2000 :");
   long nombre =
       Stream.of(tab)
           .filter(pp -> pp.getAnnee() < 2000)
           .sorted(Comparator.comparing(Personne::getNom))
           .peek(pp -> System.out.print(pp.getNom() + " "))
           .count();
   System.out.println("\n       Ils sont " + nombre);
   System.out.println("--- Tous tries sur nom + prenom : ");
   Stream.of(tab)
       .sorted(Comparator.comparing(pp -> pp.getNom() + pp.getPrenom()))
       .forEach(pp -> System.out.print("(" + pp.getNom() + ", " + pp.getPrenom() + ") "));
 }
 /**
  * Return a Comparator that will order the specified units in preferred unload order. If needed it
  * may also inspect the transport holding the units.
  */
 public static Comparator<Unit> getUnloadableUnitsComparator(
     final List<Unit> units, final Route route, final PlayerID player) {
   // compare transports
   final Comparator<Unit> unloadableTransportsComparator =
       getUnloadableTransportsComparator(units, route, player, false);
   // if noTies is set, sort by hashcode so that result is deterministic
   final Comparator<Unit> movableUnitsComparator = getMovableUnitsComparator(units, route);
   return (u1, u2) -> {
     final Unit t1 = TripleAUnit.get(u1).getTransportedBy();
     final Unit t2 = TripleAUnit.get(u2).getTransportedBy();
     // check if unloadable units are in a transport
     if (t1 != null && t2 == null) {
       return -1;
     }
     if (t1 == null && t2 != null) {
       return 1;
     }
     if (t1 != null && t2 != null) {
       final int compareTransports = unloadableTransportsComparator.compare(t1, t2);
       if (compareTransports != 0) {
         return compareTransports;
       }
     }
     // we are sorting air units, or no difference found yet
     // if noTies is set, sort by hashcode so that result is deterministic
     return movableUnitsComparator.compare(u1, u2);
   };
 }
Exemple #8
0
  public static <T1, T2, T3, T4> Comparator<Tuple4<T1, T2, T3, T4>> comparator(
      Comparator<? super T1> t1Comp,
      Comparator<? super T2> t2Comp,
      Comparator<? super T3> t3Comp,
      Comparator<? super T4> t4Comp) {
    return (Comparator<Tuple4<T1, T2, T3, T4>> & Serializable)
        (t1, t2) -> {
          final int check1 = t1Comp.compare(t1._1, t2._1);
          if (check1 != 0) {
            return check1;
          }

          final int check2 = t2Comp.compare(t1._2, t2._2);
          if (check2 != 0) {
            return check2;
          }

          final int check3 = t3Comp.compare(t1._3, t2._3);
          if (check3 != 0) {
            return check3;
          }

          final int check4 = t4Comp.compare(t1._4, t2._4);
          if (check4 != 0) {
            return check4;
          }

          // all components are equal
          return 0;
        };
  }
 public int compare(T m1, T m2) {
   for (Comparator<? super T> comparator : comparators) {
     int comparisonResult = comparator.compare(m1, m2);
     if (comparisonResult != 0) return comparisonResult;
   }
   return 0;
 }
Exemple #10
0
  /** {@inheritDoc} */
  @Override
  protected void iterateSimplex(final Comparator<RealPointValuePair> comparator)
      throws FunctionEvaluationException, OptimizationException, IllegalArgumentException {

    while (true) {

      incrementIterationsCounter();

      // save the original vertex
      final RealPointValuePair[] original = simplex;
      final RealPointValuePair best = original[0];

      // perform a reflection step
      final RealPointValuePair reflected = evaluateNewSimplex(original, 1.0, comparator);
      if (comparator.compare(reflected, best) < 0) {

        // compute the expanded simplex
        final RealPointValuePair[] reflectedSimplex = simplex;
        final RealPointValuePair expanded = evaluateNewSimplex(original, khi, comparator);
        if (comparator.compare(reflected, expanded) <= 0) {
          // accept the reflected simplex
          simplex = reflectedSimplex;
        }

        return;
      }

      // compute the contracted simplex
      final RealPointValuePair contracted = evaluateNewSimplex(original, gamma, comparator);
      if (comparator.compare(contracted, best) < 0) {
        // accept the contracted simplex
        return;
      }
    }
  }
  @Test
  public void testNext() {
    boolean expected = true;
    EasyMock.expect(peekIterator.hasNext()).andReturn(expected).times(4);
    String defaultString = "S1";
    String resString = "S2";
    EasyMock.expect(peekIterator.next()).andReturn(defaultString);
    EasyMock.expect(binaryFn.apply(EasyMock.eq(defaultString), EasyMock.isNull()))
        .andReturn(resString);
    EasyMock.expect(peekIterator.next()).andReturn(defaultString);
    EasyMock.expect(comparator.compare(EasyMock.eq(resString), EasyMock.eq(defaultString)))
        .andReturn(0);
    EasyMock.expect(peekIterator.next()).andReturn(defaultString);
    EasyMock.expect(binaryFn.apply(EasyMock.eq(resString), EasyMock.eq(defaultString)))
        .andReturn(resString);
    EasyMock.expect(comparator.compare(EasyMock.eq(resString), EasyMock.eq(defaultString)))
        .andReturn(1);

    EasyMock.replay(peekIterator);
    EasyMock.replay(binaryFn);
    EasyMock.replay(comparator);

    String actual = testingIterator.next();
    Assert.assertEquals(resString, actual);

    EasyMock.verify(peekIterator);
    EasyMock.verify(comparator);
    EasyMock.verify(binaryFn);
  }
 @Test
 public void testUnsignedComparator() {
   Comparator<Integer> cmp = (x, y) -> Integer.compareUnsigned(x, y);
   assertEquals(0, cmp.compare(0, 0));
   assertEquals(1, cmp.compare(-100, 100));
   assertEquals(-1, cmp.compare(100, -100));
 }
  @Override
  public RMContainer preemptContainer() {
    RMContainer toBePreempted = null;

    // If this queue is not over its fair share, reject
    if (!preemptContainerPreCheck()) {
      return toBePreempted;
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug(
          "Queue " + getName() + " is going to preempt a container " + "from its applications.");
    }

    // Choose the app that is most over fair share
    Comparator<Schedulable> comparator = policy.getComparator();
    FSAppAttempt candidateSched = null;
    for (FSAppAttempt sched : runnableApps) {
      if (candidateSched == null || comparator.compare(sched, candidateSched) > 0) {
        candidateSched = sched;
      }
    }

    // Preempt from the selected app
    if (candidateSched != null) {
      toBePreempted = candidateSched.preemptContainer();
    }
    return toBePreempted;
  }
  @Override
  protected int partition(Comparator<Object> c, int p, int r) {
    char[] x = keyTable[p];
    Object temp = null;
    int i = p;
    int j = r;

    while (true) {
      while (c.compare(keyTable[j], x) > 0) {
        j--;
      }
      if (i < j) {
        while (c.compare(keyTable[i], x) < 0) {
          i++;
        }
      }

      if (i < j) {
        temp = keyTable[j];
        keyTable[j] = keyTable[i];
        keyTable[i] = (char[]) temp;

        temp = valueTable[j];
        valueTable[j] = valueTable[i];
        valueTable[i] = temp;
      } else {
        return j;
      }
    }
  }
  /**
   * Sort a range in the array
   *
   * @param <T> The data type of the array
   * @param S The array
   * @param start The index of the first element in the range to sort
   * @param end Unused, instead start + 3 is always the last element in the range.
   * @return The array
   */
  @Override
  public <T> T[] sort(T[] S, int start, int end, Comparator<T> comparator) {
    if (comparator == null) comparator = naturalOrderingComparator;
    int i0 = start;
    int i1 = start + 1;
    int i2 = start + 2;
    int i3 = start + 3;

    if (comparator.compare(S[i0], S[i1]) > i0) {
      permutator.swap(S, i0, i1);
    }
    if (comparator.compare(S[i2], S[i3]) > i0) {
      permutator.swap(S, i2, i3);
    }
    if (comparator.compare(S[i1], S[i3]) > i0) {
      // This establishes the maximum into S[i3]
      permutator.swap(S, i1, i3);
    }
    if (comparator.compare(S[i0], S[i2]) > i0) {
      // This establishes the minimum into S[i0]
      permutator.swap(S, i0, i2);
    }
    if (comparator.compare(S[i1], S[i2]) > i0) {
      // This sorts the remaining two elements
      permutator.swap(S, i1, i2);
    }
    return S;
  }
  /** {@inheritDoc} */
  @Override
  public List<Row> postReconciliationProcessing(List<IndexExpression> clause, List<Row> rows) {
    int startSize = rows.size();
    long startTime = System.currentTimeMillis();

    // Remove duplicates
    TreeSet<Row> set = new TreeSet<>(rowService.comparator());
    set.addAll(rows);
    List<Row> result = new ArrayList<>(set);

    // Sort
    Search search = search(clause);
    Comparator<Row> comparator = rowService.comparator(search);
    Collections.sort(result, comparator);

    String comparatorName = comparator.getClass().getSimpleName();
    int endSize = result.size();
    long endTime = System.currentTimeMillis() - startTime;

    Log.debug(
        "Sorted %d rows to %d with comparator %s in %d ms\n",
        startSize, endSize, comparatorName, endTime);

    return result;
  }
Exemple #17
0
 private void sortTail() {
   // size > limit here
   T[] d = data;
   int l = limit, s = size;
   Comparator<? super T> cmp = comparator;
   Arrays.sort(d, l, s, cmp);
   if (cmp.compare(d[s - 1], d[0]) < 0) {
     // Common case: descending sequence
     // Assume size - limit <= limit here
     System.arraycopy(d, 0, d, s - l, 2 * l - s);
     System.arraycopy(d, l, d, 0, s - l);
   } else {
     // Merge presorted 0..limit-1 and limit..size-1
     @SuppressWarnings("unchecked")
     T[] buf = (T[]) new Object[l];
     int i = 0, j = l, k = 0;
     // d[l-1] is guaranteed to be the worst element, thus no need to
     // check it
     while (i < l - 1 && k < l && j < s) {
       if (cmp.compare(d[i], d[j]) <= 0) {
         buf[k++] = d[i++];
       } else {
         buf[k++] = d[j++];
       }
     }
     if (k < l) {
       System.arraycopy(d, i < l - 1 ? i : j, d, k, l - k);
     }
     System.arraycopy(buf, 0, d, 0, k);
   }
   size = l;
 }
Exemple #18
0
  @Test
  public void testCustomMatcher() {
    Comparator mock = mock(Comparator.class);
    mock.compare("Hello", "World");
    mock.compare("Foo", "Bar");
    mock.compare("Foo", null);

    BasicMatcher<Object> myFooBarMatcher =
        new BasicMatcher<Object>() {
          @Override
          public boolean matches(Object value) {
            return "Foo".equals(value) || "Bar".equals(value);
          }

          @Override
          public Class<Object> getType() {
            return Object.class;
          }

          @Override
          protected String asString() {
            return "(Foo or Bar)";
          }
        };
    verifyOnce().on(mock).compare(match(myFooBarMatcher), match(myFooBarMatcher));
  }
Exemple #19
0
  public void drawFeatures(Graphics2D graphics, final StreamingRenderer renderer, String layerId)
      throws IOException, FactoryException, NoninvertibleTransformException, SchemaException,
          TransformException {
    // 1) init all the readers and the lfts associated to them (one at a time to avoid deadlock)
    // and create one RenderableFeature for each
    // 2) process all the features one z-level at a time, backtracking if there are multiple
    // fts for a certain layer.

    // a listener passed around to stop data reading/painting if rendering stop request is
    // issued
    ProgressListener cancellationListener =
        new DefaultProgressListener() {
          public boolean isCanceled() {
            return renderer.renderingStopRequested;
          };
        };

    List<ZGroupLayerPainter> painters = null;
    try {
      painters = buildLayerPainters(graphics, renderer, layerId, cancellationListener);
      if (painters.isEmpty()) {
        return;
      }

      // get a comparator to find the first key to paint
      Comparator<SortKey> comparator = SortKey.buildComparator(painters.get(0).sortBy);

      // paint all the features as we can
      SortKey previousKey = null;
      while (!painters.isEmpty()) {
        SortKey smallestKey = getSmallestKey(painters, comparator);
        if (previousKey == null) {
          previousKey = smallestKey;
        } else if (comparator.compare(previousKey, smallestKey) >= 0) {
          throw new IllegalStateException(
              "The sorted rendering moved from a set of "
                  + "sort attributes, to one that's equal or greater, this is unexpected, "
                  + "bailing out to avoid an infinite loop");
        } else {
          previousKey = smallestKey;
        }

        for (Iterator it = painters.iterator(); it.hasNext(); ) {
          ZGroupLayerPainter painter = (ZGroupLayerPainter) it.next();
          painter.paintKey(smallestKey);
          // if the painter is done, close it
          if (painter.complete()) {
            painter.close();
            it.remove();
          }
        }
      }
    } finally {
      if (painters != null) {
        for (ZGroupLayerPainter painter : painters) {
          painter.close();
        }
      }
    }
  }
  public void testProcessReportsComparator() throws Exception {
    final Comparator<ProcessReports> comparator = new ProcessControl.ProcessReportsComparator();

    final AgentIdentity agentIdentity1 = new StubAgentIdentity("my agent");

    final AgentProcessReport agentProcessReport1 =
        new StubAgentProcessReport(agentIdentity1, AgentProcessReport.STATE_RUNNING);

    final RandomStubFactory<ProcessReports> processReportsStubFactory1 =
        RandomStubFactory.create(ProcessReports.class);
    final ProcessReports processReports1 = processReportsStubFactory1.getStub();
    processReportsStubFactory1.setResult("getAgentProcessReport", agentProcessReport1);

    assertEquals(0, comparator.compare(processReports1, processReports1));

    final AgentProcessReport agentProcessReport2 =
        new StubAgentProcessReport(agentIdentity1, AgentProcessReport.STATE_FINISHED);

    final RandomStubFactory<ProcessReports> processReportsStubFactory2 =
        RandomStubFactory.create(ProcessReports.class);
    final ProcessReports processReports2 = processReportsStubFactory2.getStub();
    processReportsStubFactory2.setResult("getAgentProcessReport", agentProcessReport2);

    assertEquals(0, comparator.compare(processReports2, processReports2));
    assertTrue(comparator.compare(processReports1, processReports2) < 0);
    assertTrue(comparator.compare(processReports2, processReports1) > 0);
  }
 private Comparator<StrBean> getComparator(SortOrder<String> so) {
   Comparator<StrBean> comparator = propertyToComparatorMap.get(so.getSorted());
   if (so.getDirection() == SortDirection.DESCENDING) {
     comparator = comparator.reversed();
   }
   return comparator;
 }
  /**
   * Either adds a value to set or does nothing if value is already present.
   *
   * @param val Value to add.
   * @return The instance of value from this set or {@code null} if value was added.
   */
  @Nullable
  public V addx(V val) {
    A.notNull(val, "val");

    if (comp == null) {
      for (V v : vals) if (v.equals(val)) return v;

      vals.add(val);

      return null;
    }

    if (strict) {
      for (ListIterator<V> it = vals.listIterator(); it.hasNext(); ) {
        V v = it.next();

        // Prefer equals to comparator.
        if (v.equals(val)) return v;

        int c = comp.compare(v, val);

        if (c == 0) throw new IllegalStateException("Inconsistent equals and compare methods.");

        if (c > 0) {
          // Back up.
          it.previous();

          it.add(val);

          return null;
        }
      }

      vals.add(val);

      return null;
    }

    // Full scan first.
    for (V v : vals) if (v.equals(val)) return v;

    for (ListIterator<V> it = vals.listIterator(); it.hasNext(); ) {
      V v = it.next();

      if (comp.compare(v, val) > 0) {
        do {
          // Back up.
          v = it.previous();
        } while (comp.compare(v, val) == 0);

        it.add(val);

        return null;
      }
    }

    vals.add(val);

    return null;
  }
 /**
  * Compare two file lists for files which have been created, modified or deleted.
  *
  * @param parent The parent entry
  * @param previous The original list of files
  * @param files The current list of files
  */
 private void checkAndNotify(FileEntry parent, FileEntry[] previous, File[] files) {
   int c = 0;
   FileEntry[] current = files.length > 0 ? new FileEntry[files.length] : FileEntry.EMPTY_ENTRIES;
   for (FileEntry entry : previous) {
     while (c < files.length && comparator.compare(entry.getFile(), files[c]) > 0) {
       current[c] = createFileEntry(parent, files[c]);
       doCreate(current[c]);
       c++;
     }
     if (c < files.length && comparator.compare(entry.getFile(), files[c]) == 0) {
       doMatch(entry, files[c]);
       checkAndNotify(entry, entry.getChildren(), listFiles(files[c]));
       current[c] = entry;
       c++;
     } else {
       checkAndNotify(entry, entry.getChildren(), FileUtils.EMPTY_FILE_ARRAY);
       doDelete(entry);
     }
   }
   for (; c < files.length; c++) {
     current[c] = createFileEntry(parent, files[c]);
     doCreate(current[c]);
   }
   parent.setChildren(current);
 }
Exemple #24
0
  void sort(int from, int to, Comparator<T> cmp) {
    int width = to - from;
    if (to - from <= 15) selectionSort(from, to, cmp);
    else {
      T pivot = myarray[rand.nextInt(width) + from];
      T tmp;
      int i = from - 1;
      int j = to;

      for (; ; ) {
        do i++;
        while (cmp.compare(myarray[i], pivot) < 0);
        do j--;
        while (cmp.compare(pivot, myarray[j]) < 0);

        if (i >= j) break;

        tmp = myarray[i];
        myarray[i] = myarray[j];
        myarray[j] = tmp;
      }

      sort(from, i, cmp);
      sort(i, to, cmp);
    }
  }
 @Test
 public void testUnsignedComparatorMRef() {
   Comparator<Integer> cmp = Integer::compareUnsigned;
   assertEquals(0, cmp.compare(0, 0));
   assertEquals(1, cmp.compare(-100, 100));
   assertEquals(-1, cmp.compare(100, -100));
 }
 public TestResult matchMessage(String actual, String expected) {
   if (actual == null) return TestResult.fail("NULL");
   if (actual.equals(replaceSymbols(expected)))
     return TestResult.pass(replaceSymbolsWithFullExpansion(expected));
   Comparator c = new Comparator(actual, expected);
   return c.evaluate();
 }
Exemple #27
0
  private GeneralRange(
      Comparator<? super T> comparator,
      boolean hasLowerBound,
      @Nullable T lowerEndpoint,
      BoundType lowerBoundType,
      boolean hasUpperBound,
      @Nullable T upperEndpoint,
      BoundType upperBoundType) {
    this.comparator = checkNotNull(comparator);
    this.hasLowerBound = hasLowerBound;
    this.hasUpperBound = hasUpperBound;
    this.lowerEndpoint = lowerEndpoint;
    this.lowerBoundType = checkNotNull(lowerBoundType);
    this.upperEndpoint = upperEndpoint;
    this.upperBoundType = checkNotNull(upperBoundType);

    if (hasLowerBound) {
      comparator.compare(lowerEndpoint, lowerEndpoint);
    }
    if (hasUpperBound) {
      comparator.compare(upperEndpoint, upperEndpoint);
    }
    if (hasLowerBound && hasUpperBound) {
      int cmp = comparator.compare(lowerEndpoint, upperEndpoint);
      // be consistent with Range
      checkArgument(
          cmp <= 0, "lowerEndpoint (%s) > upperEndpoint (%s)", lowerEndpoint, upperEndpoint);
      if (cmp == 0) {
        checkArgument(lowerBoundType != OPEN | upperBoundType != OPEN);
      }
    }
  }
Exemple #28
0
 public DatabaseConfig getConfig__wrappee__base() throws DatabaseException {
   DatabaseConfig showConfig = configuration.cloneConfig();
   Comparator btComp = (databaseImpl == null ? null : databaseImpl.getBtreeComparator());
   Comparator dupComp = (databaseImpl == null ? null : databaseImpl.getDuplicateComparator());
   showConfig.setBtreeComparator(btComp == null ? null : btComp.getClass());
   showConfig.setDuplicateComparator(dupComp == null ? null : dupComp.getClass());
   return showConfig;
 }
 static int unsafeCompare(Comparator<?> comparator, Object a, Object b) {
   // Pretend the comparator can compare anything. If it turns out it can't
   // compare a and b, we should get a CCE on the subsequent line. Only methods
   // that are spec'd to throw CCE should call this.
   @SuppressWarnings("unchecked")
   Comparator<Object> unsafeComparator = (Comparator<Object>) comparator;
   return unsafeComparator.compare(a, b);
 }
 @Test
 public void testNodeComparator1() {
   ICoverageNode d1 = new MockNode(18);
   ICoverageNode d2 = new MockNode(15);
   final Comparator<ICoverageNode> cmp =
       CounterComparator.TOTALITEMS.on(CounterEntity.INSTRUCTION);
   assertTrue(cmp.compare(d1, d2) > 0);
 }