1 /* 2 * Copyright (C) 2016 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.collect; 18 19 import static com.google.common.truth.Truth.assertThat; 20 import static java.util.Arrays.asList; 21 import static java.util.Comparator.comparing; 22 import static java.util.Comparator.naturalOrder; 23 24 import com.google.common.annotations.GwtCompatible; 25 import com.google.common.collect.testing.Helpers; 26 import com.google.common.testing.EqualsTester; 27 import java.util.Collections; 28 import java.util.Comparator; 29 import java.util.Optional; 30 import junit.framework.TestCase; 31 import org.checkerframework.checker.nullness.qual.Nullable; 32 33 /** 34 * Tests for {@code Comparators}. 35 * 36 * @author Louis Wasserman 37 */ 38 @GwtCompatible 39 @ElementTypesAreNonnullByDefault 40 public class ComparatorsTest extends TestCase { testLexicographical()41 public void testLexicographical() { 42 Comparator<String> comparator = Ordering.natural(); 43 Comparator<Iterable<String>> lexy = Comparators.lexicographical(comparator); 44 45 ImmutableList<String> empty = ImmutableList.of(); 46 ImmutableList<String> a = ImmutableList.of("a"); 47 ImmutableList<String> aa = ImmutableList.of("a", "a"); 48 ImmutableList<String> ab = ImmutableList.of("a", "b"); 49 ImmutableList<String> b = ImmutableList.of("b"); 50 51 Helpers.testComparator(lexy, empty, a, aa, ab, b); 52 53 new EqualsTester() 54 .addEqualityGroup(lexy, Comparators.lexicographical(comparator)) 55 .addEqualityGroup(Comparators.lexicographical(String.CASE_INSENSITIVE_ORDER)) 56 .addEqualityGroup(Ordering.natural()) 57 .testEquals(); 58 } 59 testIsInOrder()60 public void testIsInOrder() { 61 assertFalse(Comparators.isInOrder(asList(5, 3, 0, 9), Ordering.natural())); 62 assertFalse(Comparators.isInOrder(asList(0, 5, 3, 9), Ordering.natural())); 63 assertTrue(Comparators.isInOrder(asList(0, 3, 5, 9), Ordering.natural())); 64 assertTrue(Comparators.isInOrder(asList(0, 0, 3, 3), Ordering.natural())); 65 assertTrue(Comparators.isInOrder(asList(0, 3), Ordering.natural())); 66 assertTrue(Comparators.isInOrder(Collections.singleton(1), Ordering.natural())); 67 assertTrue(Comparators.isInOrder(Collections.<Integer>emptyList(), Ordering.natural())); 68 } 69 testIsInStrictOrder()70 public void testIsInStrictOrder() { 71 assertFalse(Comparators.isInStrictOrder(asList(5, 3, 0, 9), Ordering.natural())); 72 assertFalse(Comparators.isInStrictOrder(asList(0, 5, 3, 9), Ordering.natural())); 73 assertTrue(Comparators.isInStrictOrder(asList(0, 3, 5, 9), Ordering.natural())); 74 assertFalse(Comparators.isInStrictOrder(asList(0, 0, 3, 3), Ordering.natural())); 75 assertTrue(Comparators.isInStrictOrder(asList(0, 3), Ordering.natural())); 76 assertTrue(Comparators.isInStrictOrder(Collections.singleton(1), Ordering.natural())); 77 assertTrue(Comparators.isInStrictOrder(Collections.<Integer>emptyList(), Ordering.natural())); 78 } 79 testEmptiesFirst()80 public void testEmptiesFirst() { 81 Optional<String> empty = Optional.empty(); 82 Optional<String> abc = Optional.of("abc"); 83 Optional<String> z = Optional.of("z"); 84 85 Comparator<Optional<String>> comparator = Comparators.emptiesFirst(comparing(String::length)); 86 Helpers.testComparator(comparator, empty, z, abc); 87 88 // Just demonstrate that no explicit type parameter is required 89 Comparator<Optional<String>> unused = Comparators.emptiesFirst(naturalOrder()); 90 } 91 testEmptiesLast()92 public void testEmptiesLast() { 93 Optional<String> empty = Optional.empty(); 94 Optional<String> abc = Optional.of("abc"); 95 Optional<String> z = Optional.of("z"); 96 97 Comparator<Optional<String>> comparator = Comparators.emptiesLast(comparing(String::length)); 98 Helpers.testComparator(comparator, z, abc, empty); 99 100 // Just demonstrate that no explicit type parameter is required 101 Comparator<Optional<String>> unused = Comparators.emptiesLast(naturalOrder()); 102 } 103 testMinMaxNatural()104 public void testMinMaxNatural() { 105 assertThat(Comparators.min(1, 2)).isEqualTo(1); 106 assertThat(Comparators.min(2, 1)).isEqualTo(1); 107 assertThat(Comparators.max(1, 2)).isEqualTo(2); 108 assertThat(Comparators.max(2, 1)).isEqualTo(2); 109 } 110 testMinMaxNatural_equalInstances()111 public void testMinMaxNatural_equalInstances() { 112 Foo a = new Foo(1); 113 Foo b = new Foo(1); 114 assertThat(Comparators.min(a, b)).isSameInstanceAs(a); 115 assertThat(Comparators.max(a, b)).isSameInstanceAs(a); 116 } 117 testMinMaxComparator()118 public void testMinMaxComparator() { 119 Comparator<Integer> natural = Ordering.natural(); 120 Comparator<Integer> reverse = Collections.reverseOrder(natural); 121 assertThat(Comparators.min(1, 2, reverse)).isEqualTo(2); 122 assertThat(Comparators.min(2, 1, reverse)).isEqualTo(2); 123 assertThat(Comparators.max(1, 2, reverse)).isEqualTo(1); 124 assertThat(Comparators.max(2, 1, reverse)).isEqualTo(1); 125 } 126 127 /** 128 * Fails compilation if the signature of min and max is changed to take {@code Comparator<T>} 129 * instead of {@code Comparator<? super T>}. 130 */ testMinMaxWithSupertypeComparator()131 public void testMinMaxWithSupertypeComparator() { 132 Comparator<Number> numberComparator = 133 // Can't use Comparator.comparing(Number::intValue) due to Java 7 compatibility. 134 new Comparator<Number>() { 135 @Override 136 public int compare(Number a, Number b) { 137 return a.intValue() - b.intValue(); 138 } 139 }; 140 Integer comparand1 = 1; 141 Integer comparand2 = 2; 142 143 Integer min = Comparators.min(comparand1, comparand2, numberComparator); 144 Integer max = Comparators.max(comparand1, comparand2, numberComparator); 145 146 assertThat(min).isEqualTo(1); 147 assertThat(max).isEqualTo(2); 148 } 149 testMinMaxComparator_equalInstances()150 public void testMinMaxComparator_equalInstances() { 151 Comparator<Foo> natural = Ordering.natural(); 152 Comparator<Foo> reverse = Collections.reverseOrder(natural); 153 Foo a = new Foo(1); 154 Foo b = new Foo(1); 155 assertThat(Comparators.min(a, b, reverse)).isSameInstanceAs(a); 156 assertThat(Comparators.max(a, b, reverse)).isSameInstanceAs(a); 157 } 158 159 private static class Foo implements Comparable<Foo> { 160 final Integer value; 161 Foo(int value)162 Foo(int value) { 163 this.value = value; 164 } 165 166 @Override hashCode()167 public int hashCode() { 168 return value.hashCode(); 169 } 170 171 @Override equals(@ullable Object o)172 public boolean equals(@Nullable Object o) { 173 return (o instanceof Foo) && ((Foo) o).value.equals(value); 174 } 175 176 @Override compareTo(Foo other)177 public int compareTo(Foo other) { 178 return value.compareTo(other.value); 179 } 180 } 181 } 182