/**
   * 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;
  }
  @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);
  }
 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);
 }
  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);
  }
  @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;
      }
    }
  }
 /**
  * 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);
 }
Beispiel #7
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));
 }
Beispiel #9
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);
      }
    }
  }
Beispiel #10
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));
  }
Beispiel #11
0
  /**
   * 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;
  }
Beispiel #12
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;
      }
    }
  }
 /**
  * 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);
   };
 }
Beispiel #14
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;
        };
  }
Beispiel #15
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;
 }
 @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));
 }
Beispiel #17
0
    @Override
    public SortedMap<K, V> subMap(K fromKey, K toKey) {
      Comparator<K> comparator = naturalComparator();

      return ((comparator.compare(this.entry.getKey(), toKey) < 0)
              && (comparator.compare(this.entry.getKey(), fromKey) >= 0))
          ? this
          : Collections.<K, V>emptySortedMap();
    }
Beispiel #18
0
  @Test
  public void testNotMatcher() {
    Comparator mock = mock(Comparator.class);
    mock.compare("Hello", "World");
    mock.compare("Foo", "Bar");
    mock.compare("Foo", null);

    verifyOnce().on(mock).compare(not(mType(List.class)), "World");
  }
 private void assertComparators(
     Player p1, Player p2, Comparator<Player> desc, Comparator<Player> asc) {
   Assert.assertTrue(desc.compare(p1, p2) > 0);
   Assert.assertTrue(desc.compare(p2, p1) < 0);
   Assert.assertTrue(desc.compare(p1, p1) == 0);
   Assert.assertTrue(asc.compare(p1, p2) < 0);
   Assert.assertTrue(asc.compare(p2, p1) > 0);
   Assert.assertTrue(asc.compare(p1, p1) == 0);
 }
  /** Execute() method */
  public Object execute(Object object) throws JMetalException {
    if (null == object) {
      throw new JMetalException("Null parameter");
    } else if (!(object instanceof Solution)) {
      throw new JMetalException("Invalid parameter class");
    }

    int i = 0;
    int best = 0;
    evaluations = 0;
    Solution solution = (Solution) object;

    int rounds = improvementRounds;

    if (rounds <= 0) {
      return new Solution(solution);
    }

    do {
      i++;
      Solution mutatedSolution = new Solution(solution);
      mutationOperator.execute(mutatedSolution);

      // Evaluate the getNumberOfConstraints
      if (problem.getNumberOfConstraints() > 0) {
        problem.evaluateConstraints(mutatedSolution);
        best = constraintComparator.compare(mutatedSolution, solution);
        if (best == 0) {
          // none of then is better that the other one
          problem.evaluate(mutatedSolution);
          evaluations++;
          best = dominanceComparator.compare(mutatedSolution, solution);
        } else if (best == -1) {
          // mutatedSolution is best
          problem.evaluate(mutatedSolution);
          evaluations++;
        }
      } else {
        problem.evaluate(mutatedSolution);
        evaluations++;
        best = dominanceComparator.compare(mutatedSolution, solution);
      }
      if (best == -1) {
        // mutated is best
        solution = mutatedSolution;
      } else if (best == 1) {
        // original is best

      } else {
        // mutatedSolution and original are non-dominated
        if (archive != null) {
          archive.add(mutatedSolution);
        }
      }
    } while (i < rounds);
    return new Solution(solution);
  }
Beispiel #21
0
    @Override
    public SortedSet<E> subSet(E fromElement, E toElement) {
      Comparator<E> comparator = naturalComparator();

      return ((comparator.compare(this.element, toElement) < 0)
              && (comparator.compare(this.element, fromElement) >= 0))
          ? this
          : Collections.<E>emptySortedSet();
    }
Beispiel #22
0
 @Override
 public int compareTo(Path o) {
   if (TagGenerator.SCORE_BY_LENGTH) {
     return LENGTH_FIRST_COMPARATOR.compare(this, o);
   }
   if (Math.abs(score - o.score) > SCORE_EPS) {
     return score > o.score ? -1 : 1;
   }
   return LENGTH_FIRST_COMPARATOR.compare(this, o);
 }
 /**
  * Routine which can be used instead of the one taking an interval, for the situation where the
  * endpoints are being retrieved from different data structures
  */
 public boolean overlaps(
     Object otherLowEndpoint, Object otherHighEndpoint, Comparator endpointComparator) {
   if (endpointComparator.compare(highEndpoint, otherLowEndpoint) <= 0) {
     return false;
   }
   if (endpointComparator.compare(lowEndpoint, otherHighEndpoint) >= 0) {
     return false;
   }
   return true;
 }
Beispiel #24
0
  @Override
  public int compare(Literal l1, Literal l2) {
    if (l1 == l2) return 0;

    int c = l1.name.compareTo(l2.name);
    if (c != 0) return c;

    if (l1.isNegation != l2.isNegation)
      return l1.isNegation ? Integer.MAX_VALUE : Integer.MIN_VALUE;

    // same name, negation sign
    // check mode and temporal
    c = l1.mode.compareTo(l2.mode);
    if (c != 0) return c;

    if (isCheckTemporal) {
      c =
          null == temporalComparator
              ? DEFAULT_TEMPORAL_COMPARTOR.compare(l1.temporal, l2.temporal)
              : temporalComparator.compare(l1.temporal, l2.temporal);

      //	System.out.println("literalComparator.checkTemporal:("+l1+","+l2+")="+c);
      if (c != 0) return c;
      // if (null == l1.temporal) {
      // if (null != l2.temporal) {
      // Temporal t2=l2.temporal;
      // if (Long.MIN_VALUE == t2.startTime) return Long.MAX_VALUE==t2.endTime?0 :Integer.MAX_VALUE;
      // return Integer.MIN_VALUE;
      // }
      // } else {
      // Temporal t1=l1.temporal;
      // if (null == l2.temporal) {
      // if (Long.MIN_VALUE == t1.startTime) return Long.MAX_VALUE==t1.endTime?0: Integer.MIN_VALUE;
      // return Integer.MAX_VALUE;
      // } else {
      // Temporal t2 = l2.temporal;
      // c = null == temporalComparator ? t1.compareTo(t2) : temporalComparator.compare(t1, t2);
      // if (c != 0) return c;
      // }
      // }
    }

    c = l1.predicates.length - l2.predicates.length;
    if (c != 0) return c;
    for (int i = 0; i < l1.predicates.length; i++) {
      if (!l1.isPredicateGrounded(i) && !l2.isPredicateGrounded(i)) {
      } else if (l1.isPredicateGrounded(i) && l2.isPredicateGrounded(i)) {
        c = l1.predicates[i].compareTo(l2.predicates[i]);
        if (c != 0) return c;
      } else {
        return l1.isPredicateGrounded(i) ? Integer.MAX_VALUE : Integer.MIN_VALUE;
      }
    }
    return 0;
  }
  @Test
  public void stubThrowingAnException() {

    asError.expect(IllegalArgumentException.class);

    Comparator<String> comparator = mock(Comparator.class);
    when(comparator.compare(any(String.class), any(String.class)))
        .thenThrow(new IllegalArgumentException());

    comparator.compare("a", "b");
  }
Beispiel #26
0
  private Node<T, V> insertTree(Node<T, V> subTree, T t, V v) // called by public void insert(T t)
      { // insert to a subtree and return the reference of this subtree
    Node<T, V> ansNode = null;
    if (subTree == null) {
      ansNode = new Node<T, V>(t, v);
      ansNode.leftChild = null;
      ansNode.rightChild = null;
      ansNode.height = 0; // null tree's height is -1
    } else if (comp.compare(t, subTree.t) < 0) // insert to the leftSubTree of subTree
    {
      subTree.leftChild = insertTree(subTree.leftChild, t, v);
      if (getHeight(subTree.leftChild) - getHeight(subTree.rightChild)
          == 2) // subtree is the minimum unbalanced subTree
      {
        // singleLeftRotate or doubleLeftRightRorate
        if (getHeight(subTree.leftChild.leftChild) > getHeight(subTree.leftChild.rightChild)) {
          ansNode = singleLeftRotate(subTree);
        } else {
          ansNode = doubleLeftRightRotate(subTree);
        }
      } else {
        // Only the change of structure of tree causes the change of it's height
        subTree.height =
            1
                + (getHeight(subTree.leftChild) >= getHeight(subTree.rightChild)
                    ? getHeight(subTree.leftChild)
                    : getHeight(subTree.rightChild));
        ansNode = subTree;
      }

    } else if (comp.compare(t, subTree.t) > 0) // insert to the rightSubTree of subTree
    {
      subTree.rightChild = insertTree(subTree.rightChild, t, v);
      if (getHeight(subTree.rightChild) - getHeight(subTree.leftChild)
          == 2) // subtree is the minimum unbalanced subTree
      {
        // singleLeftRotate or doubleLeftRightRorate
        if (getHeight(subTree.rightChild.rightChild) > getHeight(subTree.rightChild.leftChild)) {
          ansNode = singleRightRotate(subTree);
        } else {
          ansNode = doubleRightLeftRotate(subTree);
        }
      } else {
        // Only the change of structure of tree causes the change of it's height
        subTree.height =
            1
                + (getHeight(subTree.leftChild) > getHeight(subTree.rightChild)
                    ? getHeight(subTree.leftChild)
                    : getHeight(subTree.rightChild));
        ansNode = subTree;
      }
    }
    return ansNode;
  }
 @Test
 public void testOnlyOneNull() {
   ProductDimension dimension = createOtherProductDimension();
   assertThat(
       "Null should be greater than non-null",
       comparator.compare(null, dimension),
       Matchers.greaterThan(0));
   assertThat(
       "Non-null should be less than null",
       comparator.compare(dimension, null),
       Matchers.lessThan(0));
 }
  public void testCompareSingleProperty() {
    comparator = new MultiKeyComparator(new boolean[] {false});

    firstValues = new MultiKeyUntyped(new Object[] {3d});
    secondValues = new MultiKeyUntyped(new Object[] {4d});
    assertTrue(comparator.compare(firstValues, secondValues) < 0);

    comparator = new MultiKeyComparator(new boolean[] {true});

    assertTrue(comparator.compare(firstValues, secondValues) > 0);
    assertTrue(comparator.compare(firstValues, firstValues) == 0);
  }
  public void testCompareTwoProperties() {
    comparator = new MultiKeyComparator(new boolean[] {false, false});

    firstValues = new MultiKeyUntyped(new Object[] {3d, 3L});
    secondValues = new MultiKeyUntyped(new Object[] {3d, 4L});
    assertTrue(comparator.compare(firstValues, secondValues) < 0);

    comparator = new MultiKeyComparator(new boolean[] {false, true});

    assertTrue(comparator.compare(firstValues, secondValues) > 0);
    assertTrue(comparator.compare(firstValues, firstValues) == 0);
  }
  public void testCompare_sameQuadrant() {
    final DoublesPair first = DoublesPair.of(0.0, 0.0);
    final DoublesPair second = DoublesPair.of(1.0, 0.0);

    final Comparator<DoublesPair> test = QuadrantDoublesPairComparator.INSTANCE;

    assertTrue(test.compare(first, first) == 0);
    assertTrue(test.compare(first, second) < 0);

    assertTrue(test.compare(second, first) > 0);
    assertTrue(test.compare(second, second) == 0);
  }