Lines Matching refs:Ordering
29 import com.google.common.collect.Ordering.ArbitraryOrdering;
30 import com.google.common.collect.Ordering.IncomparableValueException;
48 * Unit tests for {@code Ordering}.
56 private final Ordering<Number> numberOrdering = new NumberOrdering();
59 Ordering<Integer> comparator = Ordering.natural();
75 assertEquals("Ordering.natural()", comparator.toString());
79 Ordering<String> caseInsensitiveOrdering
80 = Ordering.from(String.CASE_INSENSITIVE_ORDER);
86 Ordering<String> orderingFromOrdering =
87 Ordering.from(Ordering.<String>natural());
89 .addEqualityGroup(caseInsensitiveOrdering, Ordering.from(String.CASE_INSENSITIVE_ORDER))
90 .addEqualityGroup(orderingFromOrdering, Ordering.natural())
96 = Ordering.explicit(Collections.<Integer>emptyList());
107 Comparator<Integer> c = Ordering.explicit(0);
116 assertEquals("Ordering.explicit([0])", c.toString());
120 Comparator<Integer> c = Ordering.explicit(42, 5);
131 .addEqualityGroup(c, Ordering.explicit(42, 5))
132 .addEqualityGroup(Ordering.explicit(5, 42))
133 .addEqualityGroup(Ordering.explicit(42))
140 = Ordering.explicit(2, 8, 6, 1, 7, 5, 3, 4, 0, 9);
149 Ordering.explicit(1, 2, 3, 4, 2);
163 Ordering<Object> arbitrary = Ordering.arbitrary();
170 assertEquals("Ordering.arbitrary()", arbitrary.toString());
179 Ordering<Object> arbitrary = new ArbitraryOrdering() {
196 Ordering<Object> ordering = Ordering.usingToString();
198 assertEquals("Ordering.usingToString()", ordering.toString());
222 private static Ordering<String> byCharAt(int index) {
223 return Ordering.natural().onResultOf(CharAtFunction.values()[index]);
227 Comparator<String> comparator = Ordering.compound(asList(
255 Ordering<Object> objects = Ordering.explicit((Object) 1);
256 Ordering<Number> numbers = Ordering.explicit((Number) 1);
257 Ordering<Integer> integers = Ordering.explicit(1);
260 Ordering<Number> a = numbers.compound(numbers);
264 Ordering<Number> b = numbers.compound(objects);
265 Ordering<Number> c = objects.compound(numbers);
267 Ordering<Integer> d = numbers.compound(integers);
268 Ordering<Integer> e = integers.compound(numbers);
273 Ordering<Number> f = numbers.compound(objects).compound(objects); //bad IDEA
274 Ordering<Number> g = objects.compound(numbers).compound(objects);
275 Ordering<Number> h = objects.compound(objects).compound(numbers);
277 Ordering<Number> i = numbers.compound(objects.compound(objects));
278 Ordering<Number> j = objects.compound(numbers.compound(objects)); //bad IDEA
279 Ordering<Number> k = objects.compound(objects.compound(numbers));
283 Ordering<Integer> l = objects.compound(numbers);
286 // Ordering<Object> m = numbers.compound(objects);
290 // Ordering<Object> n = objects.compound(numbers);
294 Ordering<Number> reverseOrder = numberOrdering.reverse();
300 .addEqualityGroup(Ordering.natural().reverse())
320 private static final Ordering<Integer> DECREASING_INTEGER
321 = Ordering.natural().reverse();
325 = Ordering.natural().onResultOf(StringLengthFunction.StringLength);
333 Ordering.natural().onResultOf(StringLengthFunction.StringLength))
337 assertEquals("Ordering.natural().onResultOf(StringLength)",
354 .addEqualityGroup(Ordering.natural())
357 assertEquals("Ordering.natural().reverse().onResultOf(StringLength)",
363 Ordering<String> ordering = Ordering.natural();
364 Ordering<Iterable<String>> lexy = ordering.lexicographical();
376 Ordering<Integer> ordering = Ordering.natural().nullsFirst();
381 Ordering<Integer> ordering = Ordering.natural().nullsLast();
412 Ordering.natural().nullsFirst().immutableSortedCopy(listWithNull);
530 Ordering<Integer> ordering = Ordering.natural();
639 private static class NumberOrdering extends Ordering<Number> {
662 testExhaustively(Ordering.<String>natural(), Arrays.asList("a", "b"));
666 testExhaustively(Ordering.explicit("a", "b", "c", "d"),
671 testExhaustively(Ordering.usingToString(), Arrays.asList(1, 12, 2));
675 Ordering<Object> arbitrary = Ordering.arbitrary();
684 Ordering<? super T> ordering, List<T> list) {
687 Scenario<T> starter = new Scenario<T>((Ordering) ordering, list);
709 final Ordering<T> ordering;
712 Scenario(Ordering<T> ordering, List<T> strictlyOrderedList) {
747 * A means for changing an Ordering into another Ordering. Each instance is
748 * responsible for creating the alternate Ordering, and providing a List that
750 * according to the input Ordering.
786 Ordering<Integer> ordering = scenario.ordering.onResultOf(
807 Ordering<Composite<T>> ordering =
809 .compound(Ordering.natural());
822 Ordering<Composite<T>> ordering = Ordering.natural().compound(
880 tester.testAllPublicStaticMethods(Ordering.class);
882 // any Ordering<Object> instance that accepts nulls should be good enough
883 tester.testAllPublicInstanceMethods(Ordering.usingToString().nullsFirst());