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