예제 #1
0
 public void testExplicit_withDuplicates() {
   try {
     Ordering.explicit(1, 2, 3, 4, 2);
     fail();
   } catch (IllegalArgumentException expected) {
   }
 }
예제 #2
0
 public void testExplicit_sortingExample() {
   Comparator<Integer> c = Ordering.explicit(2, 8, 6, 1, 7, 5, 3, 4, 0, 9);
   List<Integer> list = Arrays.asList(0, 3, 5, 6, 7, 8, 9);
   Collections.sort(list, c);
   assertThat(list).containsExactly(8, 6, 7, 5, 3, 0, 9).inOrder();
   reserializeAndAssert(c);
 }
예제 #3
0
 public void testExplicit_two() {
   Comparator<Integer> c = Ordering.explicit(42, 5);
   assertEquals(0, c.compare(5, 5));
   assertTrue(c.compare(5, 42) > 0);
   assertTrue(c.compare(42, 5) < 0);
   try {
     c.compare(5, 666);
     fail();
   } catch (IncomparableValueException expected) {
     assertEquals(666, expected.value);
   }
   new EqualsTester()
       .addEqualityGroup(c, Ordering.explicit(42, 5))
       .addEqualityGroup(Ordering.explicit(5, 42))
       .addEqualityGroup(Ordering.explicit(42))
       .testEquals();
   reserializeAndAssert(c);
 }
예제 #4
0
 public void testExplicit_none() {
   Comparator<Integer> c = Ordering.explicit(Collections.<Integer>emptyList());
   try {
     c.compare(0, 0);
     fail();
   } catch (IncomparableValueException expected) {
     assertEquals(0, expected.value);
   }
   reserializeAndAssert(c);
 }
예제 #5
0
 private static Ordering<String> createExplicitComparator(String[] elements) {
   // Collapse equal elements, which Ordering.explicit() doesn't support, while
   // maintaining the ordering by first occurrence.
   Set<String> elementsPlus = Sets.newLinkedHashSet();
   elementsPlus.add(BEFORE_FIRST);
   elementsPlus.add(BEFORE_FIRST_2);
   elementsPlus.addAll(Arrays.asList(elements));
   elementsPlus.add(AFTER_LAST);
   elementsPlus.add(AFTER_LAST_2);
   return Ordering.explicit(Lists.newArrayList(elementsPlus));
 }
예제 #6
0
 public void testExplicit_one() {
   Comparator<Integer> c = Ordering.explicit(0);
   assertEquals(0, c.compare(0, 0));
   try {
     c.compare(0, 1);
     fail();
   } catch (IncomparableValueException expected) {
     assertEquals(1, expected.value);
   }
   reserializeAndAssert(c);
   assertEquals("Ordering.explicit([0])", c.toString());
 }
예제 #7
0
  public void testCompound_instance_generics() {
    Ordering<Object> objects = Ordering.explicit((Object) 1);
    Ordering<Number> numbers = Ordering.explicit((Number) 1);
    Ordering<Integer> integers = Ordering.explicit(1);

    // Like by like equals like
    Ordering<Number> a = numbers.compound(numbers);

    // The compound takes the more specific type of the two, regardless of order

    Ordering<Number> b = numbers.compound(objects);
    Ordering<Number> c = objects.compound(numbers);

    Ordering<Integer> d = numbers.compound(integers);
    Ordering<Integer> e = integers.compound(numbers);

    // This works with three levels too (IDEA falsely reports errors as noted
    // below. Both javac and eclipse handle these cases correctly.)

    Ordering<Number> f = numbers.compound(objects).compound(objects); // bad IDEA
    Ordering<Number> g = objects.compound(numbers).compound(objects);
    Ordering<Number> h = objects.compound(objects).compound(numbers);

    Ordering<Number> i = numbers.compound(objects.compound(objects));
    Ordering<Number> j = objects.compound(numbers.compound(objects)); // bad IDEA
    Ordering<Number> k = objects.compound(objects.compound(numbers));

    // You can also arbitrarily assign a more restricted type - not an intended
    // feature, exactly, but unavoidable (I think) and harmless
    Ordering<Integer> l = objects.compound(numbers);

    // This correctly doesn't work:
    // Ordering<Object> m = numbers.compound(objects);

    // Sadly, the following works in javac 1.6, but at least it fails for
    // eclipse, and is *correctly* highlighted red in IDEA.
    // Ordering<Object> n = objects.compound(numbers);
  }
예제 #8
0
 @Test(groups = "ordering")
 public void orderingExplicit() {
   // Which is better? Phantom Menace or A New Hope?
   assertEquals(
       Ordering.explicit(
               phantomMenace,
               attackOfTheClones,
               revengeOfTheSith,
               returnOfTheJedi,
               aNewHope,
               empireStrikesBack)
           .max(revengeOfTheSith, aNewHope),
       aNewHope);
 }
예제 #9
0
  @Test(groups = "ordering")
  public void orderingExplicitAnotherTest() {
    StarWarsEpisode planetOfTheApes = new StarWarsEpisode("Planet of the Apes", 12, 1965);

    // Which is better? Planet of the Apes or A New Hope?
    try {
      Ordering.explicit(
              phantomMenace,
              attackOfTheClones,
              revengeOfTheSith,
              returnOfTheJedi,
              aNewHope,
              empireStrikesBack)
          .max(planetOfTheApes, aNewHope);
    } catch (Exception ive) {
      assertTrue(true);
    }
  }
예제 #10
0
 @GwtIncompatible("too slow")
 public void testCombinationsExhaustively_startingFromExplicit() {
   testExhaustively(Ordering.explicit("a", "b", "c", "d"), "a", "b", "d");
 }