1 /*
2  * Copyright (C) 2015 The Android Open Source Project
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.android.tv.testing;
18 
19 import static junit.framework.Assert.assertEquals;
20 
21 import java.util.ArrayList;
22 import java.util.Arrays;
23 import java.util.Collection;
24 import java.util.Comparator;
25 import java.util.List;
26 
27 /**
28  * Tester for {@link Comparator} relationships between groups of T.
29  *
30  * <p>
31  * To use, create a new {@link ComparatorTester} and add comparable groups
32  * where each group contains objects that are
33  * {@link Comparator#compare(Object, Object)} == 0 to each other.
34  * Groups are added in order asserting that all earlier groups have compare < 0
35  * for all later groups.
36  *
37  * <pre>{@code
38  * ComparatorTester
39  *     .withoutEqualsTest(String.CASE_INSENSITIVE_ORDER)
40  *     .addComparableGroup("Hello", "HELLO")
41  *     .addComparableGroup("World", "wORLD")
42  *     .addComparableGroup("ZEBRA")
43  *     .test();
44  * }
45  * </pre>
46  *
47  * @param <T> the type of objects to compare.
48  */
49 public class ComparatorTester<T> {
50 
51     private final List<List<T>> listOfGroups = new ArrayList<>();
52 
53     private final Comparator<T> comparator;
54 
55 
withoutEqualsTest(Comparator<T> comparator)56     public static <T> ComparatorTester<T> withoutEqualsTest(Comparator<T> comparator) {
57         return new ComparatorTester<>(comparator);
58     }
59 
ComparatorTester(Comparator<T> comparator)60     private ComparatorTester(Comparator<T> comparator) {
61         this.comparator = comparator;
62     }
63 
64     @SafeVarargs
addComparableGroup(T... items)65     public final ComparatorTester<T> addComparableGroup(T... items) {
66         listOfGroups.add(Arrays.asList(items));
67         return this;
68     }
69 
test()70     public void test() {
71         for (int i = 0; i < listOfGroups.size(); i++) {
72             List<T> currentGroup = listOfGroups.get(i);
73             for (int j = 0; j < i; j++) {
74                 List<T> lhs = listOfGroups.get(j);
75                 assertOrder(i, j, lhs, currentGroup);
76             }
77             assertZero(currentGroup);
78             for (int j = i + 1; j < listOfGroups.size(); j++) {
79                 List<T> rhs = listOfGroups.get(j);
80                 assertOrder(i, j, currentGroup, rhs);
81             }
82         }
83         //TODO: also test equals
84     }
85 
assertOrder(int less, int more, List<T> lessGroup, List<T> moreGroup)86     private void assertOrder(int less, int more, List<T> lessGroup, List<T> moreGroup) {
87         assertLess(less, more, lessGroup, moreGroup);
88         assertMore(more, less, moreGroup, lessGroup);
89     }
90 
assertLess(int left, int right, Collection<T> leftGroup, Collection<T> rightGroup)91     private void assertLess(int left, int right, Collection<T> leftGroup,
92             Collection<T> rightGroup) {
93         int leftSub = 0;
94         for (T leftItem : leftGroup) {
95             int rightSub = 0;
96             for (T rightItem : rightGroup) {
97                 String leftName = "Item[" + left + "," + (leftSub++) + "]";
98                 String rName = "Item[" + right + "," + (rightSub++) + "]";
99                 assertEquals(leftName + " " + leftItem + " compareTo " + rName + " " + rightItem
100                                 + " is <0", true, comparator.compare(leftItem, rightItem) < 0);
101             }
102         }
103     }
104 
assertMore(int left, int right, Collection<T> leftGroup, Collection<T> rightGroup)105     private void assertMore(int left, int right, Collection<T> leftGroup,
106             Collection<T> rightGroup) {
107         int leftSub = 0;
108         for (T leftItem : leftGroup) {
109             int rightSub = 0;
110             for (T rightItem : rightGroup) {
111                 String leftName = "Item[" + left + "," + (leftSub++) + "]";
112                 String rName = "Item[" + right + "," + (rightSub++) + "]";
113                 assertEquals(leftName + " " + leftItem + " compareTo " + rName + " " + rightItem
114                                 + " is >0", true, comparator.compare(leftItem, rightItem) > 0);
115             }
116         }
117     }
118 
assertZero(Collection<T> group)119     private void assertZero(Collection<T> group) {
120         // Test everything against everything in both directions, including against itself.
121         for (T leftItem : group) {
122             for (T rightItem : group) {
123                 assertEquals(leftItem + " compareTo " + rightItem, 0,
124                         comparator.compare(leftItem, rightItem));
125             }
126         }
127     }
128 }