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 22 import com.google.common.annotations.GwtCompatible; 23 import com.google.common.collect.testing.Helpers; 24 import com.google.common.testing.EqualsTester; 25 import java.util.Collections; 26 import java.util.Comparator; 27 import junit.framework.TestCase; 28 import org.checkerframework.checker.nullness.qual.Nullable; 29 30 /** 31 * Tests for {@code Comparators}. 32 * 33 * @author Louis Wasserman 34 */ 35 @GwtCompatible 36 public class ComparatorsTest extends TestCase { 37 @SuppressWarnings("unchecked") // dang varargs testLexicographical()38 public void testLexicographical() { 39 Comparator<String> comparator = Ordering.natural(); 40 Comparator<Iterable<String>> lexy = Comparators.lexicographical(comparator); 41 42 ImmutableList<String> empty = ImmutableList.of(); 43 ImmutableList<String> a = ImmutableList.of("a"); 44 ImmutableList<String> aa = ImmutableList.of("a", "a"); 45 ImmutableList<String> ab = ImmutableList.of("a", "b"); 46 ImmutableList<String> b = ImmutableList.of("b"); 47 48 Helpers.testComparator(lexy, empty, a, aa, ab, b); 49 50 new EqualsTester() 51 .addEqualityGroup(lexy, Comparators.lexicographical(comparator)) 52 .addEqualityGroup(Comparators.lexicographical(String.CASE_INSENSITIVE_ORDER)) 53 .addEqualityGroup(Ordering.natural()) 54 .testEquals(); 55 } 56 testIsInOrder()57 public void testIsInOrder() { 58 assertFalse(Comparators.isInOrder(asList(5, 3, 0, 9), Ordering.natural())); 59 assertFalse(Comparators.isInOrder(asList(0, 5, 3, 9), Ordering.natural())); 60 assertTrue(Comparators.isInOrder(asList(0, 3, 5, 9), Ordering.natural())); 61 assertTrue(Comparators.isInOrder(asList(0, 0, 3, 3), Ordering.natural())); 62 assertTrue(Comparators.isInOrder(asList(0, 3), Ordering.natural())); 63 assertTrue(Comparators.isInOrder(Collections.singleton(1), Ordering.natural())); 64 assertTrue(Comparators.isInOrder(Collections.<Integer>emptyList(), Ordering.natural())); 65 } 66 testIsInStrictOrder()67 public void testIsInStrictOrder() { 68 assertFalse(Comparators.isInStrictOrder(asList(5, 3, 0, 9), Ordering.natural())); 69 assertFalse(Comparators.isInStrictOrder(asList(0, 5, 3, 9), Ordering.natural())); 70 assertTrue(Comparators.isInStrictOrder(asList(0, 3, 5, 9), Ordering.natural())); 71 assertFalse(Comparators.isInStrictOrder(asList(0, 0, 3, 3), Ordering.natural())); 72 assertTrue(Comparators.isInStrictOrder(asList(0, 3), Ordering.natural())); 73 assertTrue(Comparators.isInStrictOrder(Collections.singleton(1), Ordering.natural())); 74 assertTrue(Comparators.isInStrictOrder(Collections.<Integer>emptyList(), Ordering.natural())); 75 } 76 testMinMaxNatural()77 public void testMinMaxNatural() { 78 assertThat(Comparators.min(1, 2)).isEqualTo(1); 79 assertThat(Comparators.min(2, 1)).isEqualTo(1); 80 assertThat(Comparators.max(1, 2)).isEqualTo(2); 81 assertThat(Comparators.max(2, 1)).isEqualTo(2); 82 } 83 testMinMaxNatural_equalInstances()84 public void testMinMaxNatural_equalInstances() { 85 Foo a = new Foo(1); 86 Foo b = new Foo(1); 87 assertThat(Comparators.min(a, b)).isSameInstanceAs(a); 88 assertThat(Comparators.max(a, b)).isSameInstanceAs(a); 89 } 90 testMinMaxComparator()91 public void testMinMaxComparator() { 92 Comparator<Integer> natural = Ordering.natural(); 93 Comparator<Integer> reverse = Collections.reverseOrder(natural); 94 assertThat(Comparators.min(1, 2, reverse)).isEqualTo(2); 95 assertThat(Comparators.min(2, 1, reverse)).isEqualTo(2); 96 assertThat(Comparators.max(1, 2, reverse)).isEqualTo(1); 97 assertThat(Comparators.max(2, 1, reverse)).isEqualTo(1); 98 } 99 testMinMaxComparator_equalInstances()100 public void testMinMaxComparator_equalInstances() { 101 Comparator<Foo> natural = Ordering.natural(); 102 Comparator<Foo> reverse = Collections.reverseOrder(natural); 103 Foo a = new Foo(1); 104 Foo b = new Foo(1); 105 assertThat(Comparators.min(a, b, reverse)).isSameInstanceAs(a); 106 assertThat(Comparators.max(a, b, reverse)).isSameInstanceAs(a); 107 } 108 109 private static class Foo implements Comparable<Foo> { 110 final Integer value; 111 Foo(int value)112 Foo(int value) { 113 this.value = value; 114 } 115 116 @Override hashCode()117 public int hashCode() { 118 return value.hashCode(); 119 } 120 121 @Override equals(@ullable Object o)122 public boolean equals(@Nullable Object o) { 123 return (o instanceof Foo) && ((Foo) o).value.equals(value); 124 } 125 126 @Override compareTo(Foo other)127 public int compareTo(Foo other) { 128 return value.compareTo(other.value); 129 } 130 } 131 } 132