1 /*
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 8001667 8010279
27 * @run testng BasicTest
28 */
29
30 import java.util.Comparator;
31 import java.util.Comparators;
32 import java.util.AbstractMap;
33 import java.util.Map;
34 import org.testng.annotations.Test;
35
36 import java.util.function.BinaryOperator;
37 import java.util.function.Function;
38 import java.util.function.ToIntFunction;
39 import java.util.function.ToLongFunction;
40 import java.util.function.ToDoubleFunction;
41
42 import static org.testng.Assert.assertEquals;
43 import static org.testng.Assert.assertTrue;
44 import static org.testng.Assert.assertSame;
45 import static org.testng.Assert.fail;
46
47 /**
48 * Unit tests for helper methods in Comparators
49 */
50 @Test(groups = "unit")
51 public class BasicTest {
52 private static class Thing {
53 public final int intField;
54 public final long longField;
55 public final double doubleField;
56 public final String stringField;
57
58 private Thing(int intField, long longField, double doubleField, String stringField) {
59 this.intField = intField;
60 this.longField = longField;
61 this.doubleField = doubleField;
62 this.stringField = stringField;
63 }
64
65 public int getIntField() {
66 return intField;
67 }
68
69 public long getLongField() {
70 return longField;
71 }
72
73 public double getDoubleField() {
74 return doubleField;
75 }
76
77 public String getStringField() {
78 return stringField;
79 }
80 }
81
82 private final int[] intValues = { -2, -2, -1, -1, 0, 0, 1, 1, 2, 2 };
83 private final long[] longValues = { -2, -2, -1, -1, 0, 0, 1, 1, 2, 2 };
84 private final double[] doubleValues = { -2, -2, -1, -1, 0, 0, 1, 1, 2, 2 };
85 private final String[] stringValues = { "a", "a", "b", "b", "c", "c", "d", "d", "e", "e" };
86 private final int[] comparisons = { 0, -1, 0, -1, 0, -1, 0, -1, 0 };
87
88 private<T> void assertComparisons(T[] things, Comparator<T> comp, int[] comparisons) {
89 for (int i=0; i<comparisons.length; i++) {
90 assertEquals(comparisons.length + 1, things.length);
91 assertEquals(comparisons[i], comp.compare(things[i], things[i+1]));
92 assertEquals(-comparisons[i], comp.compare(things[i+1], things[i]));
93 }
94 }
95
96 public void testIntComparator() {
97 Thing[] things = new Thing[intValues.length];
98 for (int i=0; i<intValues.length; i++)
99 things[i] = new Thing(intValues[i], 0L, 0.0, null);
100 Comparator<Thing> comp = Comparators.comparing(new ToIntFunction<BasicTest.Thing>() {
101 @Override
102 public int applyAsInt(Thing thing) {
103 return thing.getIntField();
104 }
105 });
106
107 assertComparisons(things, comp, comparisons);
108 }
109
110 public void testLongComparator() {
111 Thing[] things = new Thing[longValues.length];
112 for (int i=0; i<longValues.length; i++)
113 things[i] = new Thing(0, longValues[i], 0.0, null);
114 Comparator<Thing> comp = Comparators.comparing(new ToLongFunction<BasicTest.Thing>() {
115 @Override
116 public long applyAsLong(Thing thing) {
117 return thing.getLongField();
118 }
119 });
120
121 assertComparisons(things, comp, comparisons);
122 }
123
124 public void testDoubleComparator() {
125 Thing[] things = new Thing[doubleValues.length];
126 for (int i=0; i<doubleValues.length; i++)
127 things[i] = new Thing(0, 0L, doubleValues[i], null);
128 Comparator<Thing> comp = Comparators.comparing(new ToDoubleFunction<BasicTest.Thing>() {
129 @Override
130 public double applyAsDouble(Thing thing) {
131 return thing.getDoubleField();
132 }
133 });
134
135 assertComparisons(things, comp, comparisons);
136 }
137
138 public void testComparing() {
139 Thing[] things = new Thing[doubleValues.length];
140 for (int i=0; i<doubleValues.length; i++)
141 things[i] = new Thing(0, 0L, 0.0, stringValues[i]);
142 Comparator<Thing> comp = Comparators.comparing(new Function<Thing, String>() {
143 @Override
144 public String apply(Thing thing) {
145 return thing.getStringField();
146 }
147 });
148
149 assertComparisons(things, comp, comparisons);
150 }
151
152 public void testNaturalOrderComparator() {
153 Comparator<String> comp = Comparators.naturalOrder();
154
155 assertComparisons(stringValues, comp, comparisons);
156 }
157
158 public void testReverseComparator() {
159 Comparator<String> cmpr = Comparators.reverseOrder();
160 Comparator<String> cmp = cmpr.reverseOrder();
161
162 assertEquals(cmp.reverseOrder(), cmpr);
163 assertEquals(0, cmp.compare("a", "a"));
164 assertEquals(0, cmpr.compare("a", "a"));
165 assertTrue(cmp.compare("a", "b") < 0);
166 assertTrue(cmpr.compare("a", "b") > 0);
167 assertTrue(cmp.compare("b", "a") > 0);
168 assertTrue(cmpr.compare("b", "a") < 0);
169 }
170
171 public void testReverseComparator2() {
172 Comparator<String> cmp = (s1, s2) -> s1.length() - s2.length();
173 Comparator<String> cmpr = cmp.reverseOrder();
174
175 assertEquals(cmpr.reverseOrder(), cmp);
176 assertEquals(0, cmp.compare("abc", "def"));
177 assertEquals(0, cmpr.compare("abc", "def"));
178 assertTrue(cmp.compare("abcd", "def") > 0);
179 assertTrue(cmpr.compare("abcd", "def") < 0);
180 assertTrue(cmp.compare("abc", "defg") < 0);
181 assertTrue(cmpr.compare("abc", "defg") > 0);
182 }
183
184 @Test(expectedExceptions=NullPointerException.class)
185 public void testReverseComparatorNPE() {
186 Comparator<String> cmp = Comparators.reverseOrder(null);
187 }
188
189 public void testComposeComparator() {
190 // Longer string in front
191 Comparator<String> first = (s1, s2) -> s2.length() - s1.length();
192 Comparator<String> second = Comparators.naturalOrder();
193 Comparator<String> composed = Comparators.compose(first, second);
194
195 assertTrue(composed.compare("abcdefg", "abcdef") < 0);
196 assertTrue(composed.compare("abcdef", "abcdefg") > 0);
197 assertTrue(composed.compare("abcdef", "abcdef") == 0);
198 assertTrue(composed.compare("abcdef", "ghijkl") < 0);
199 assertTrue(composed.compare("ghijkl", "abcdefg") > 0);
200 }
201
202 private <K, V> void assertPairComparison(K k1, V v1, K k2, V v2,
203 Comparator<Map.Entry<K, V>> ck,
204 Comparator<Map.Entry<K, V>> cv) {
205 final Map.Entry<K, V> p11 = new AbstractMap.SimpleImmutableEntry<>(k1, v1);
206 final Map.Entry<K, V> p12 = new AbstractMap.SimpleImmutableEntry<>(k1, v2);
207 final Map.Entry<K, V> p21 = new AbstractMap.SimpleImmutableEntry<>(k2, v1);
208 final Map.Entry<K, V> p22 = new AbstractMap.SimpleImmutableEntry<>(k2, v2);
209
210 assertTrue(ck.compare(p11, p11) == 0);
211 assertTrue(ck.compare(p12, p11) == 0);
212 assertTrue(ck.compare(p11, p12) == 0);
213 assertTrue(ck.compare(p12, p22) < 0);
214 assertTrue(ck.compare(p12, p21) < 0);
215 assertTrue(ck.compare(p21, p11) > 0);
216 assertTrue(ck.compare(p21, p12) > 0);
217
218 assertTrue(cv.compare(p11, p11) == 0);
219 assertTrue(cv.compare(p12, p11) > 0);
220 assertTrue(cv.compare(p11, p12) < 0);
221 assertTrue(cv.compare(p12, p22) == 0);
222 assertTrue(cv.compare(p12, p21) > 0);
223 assertTrue(cv.compare(p21, p11) == 0);
224 assertTrue(cv.compare(p21, p12) < 0);
225
226 Comparator<Map.Entry<K, V>> cmp = Comparators.compose(ck, cv);
227 assertTrue(cmp.compare(p11, p11) == 0);
228 assertTrue(cmp.compare(p12, p11) > 0);
229 assertTrue(cmp.compare(p11, p12) < 0);
230 assertTrue(cmp.compare(p12, p22) < 0);
231 assertTrue(cmp.compare(p12, p21) < 0);
232 assertTrue(cmp.compare(p21, p11) > 0);
233 assertTrue(cmp.compare(p21, p12) > 0);
234
235 cmp = Comparators.compose(cv, ck);
236 assertTrue(cmp.compare(p11, p11) == 0);
237 assertTrue(cmp.compare(p12, p11) > 0);
238 assertTrue(cmp.compare(p11, p12) < 0);
239 assertTrue(cmp.compare(p12, p22) < 0);
240 assertTrue(cmp.compare(p12, p21) > 0);
241 assertTrue(cmp.compare(p21, p11) > 0);
242 assertTrue(cmp.compare(p21, p12) < 0);
243 }
244
245 public void testKVComparatorable() {
246 assertPairComparison(1, "ABC", 2, "XYZ",
247 Comparators.<Integer, String>naturalOrderKeys(),
248 Comparators.<Integer, String>naturalOrderValues());
249 }
250
251 private static class People {
252 final String firstName;
253 final String lastName;
254 final int age;
255
256 People(String first, String last, int age) {
257 firstName = first;
258 lastName = last;
259 this.age = age;
260 }
261
262 String getFirstName() { return firstName; }
263 String getLastName() { return lastName; }
264 int getAge() { return age; }
265 long getAgeAsLong() { return (long) age; };
266 double getAgeAsDouble() { return (double) age; };
267 }
268
269 private final People people[] = {
270 new People("John", "Doe", 34),
271 new People("Mary", "Doe", 30),
272 new People("Maria", "Doe", 14),
273 new People("Jonah", "Doe", 10),
274 new People("John", "Cook", 54),
275 new People("Mary", "Cook", 50),
276 };
277
278 public void testKVComparators() {
279 // Comparator<People> cmp = Comparators.naturalOrder(); // Should fail to compiler as People is not comparable
280 // We can use simple comparator, but those have been tested above.
281 // Thus choose to do compose for some level of interation.
282 Comparator<People> cmp1 = Comparators.comparing((Function<People, String>) People::getFirstName);
283 Comparator<People> cmp2 = Comparators.comparing((Function<People, String>) People::getLastName);
284 Comparator<People> cmp = Comparators.compose(cmp1, cmp2);
285
286 assertPairComparison(people[0], people[0], people[1], people[1],
287 Comparators.<People, People>byKey(cmp),
288 Comparators.<People, People>byValue(cmp));
289
290 }
291
292 private <T> void assertComparison(Comparator<T> cmp, T less, T greater) {
293 assertTrue(cmp.compare(less, greater) < 0, "less");
294 assertTrue(cmp.compare(less, less) == 0, "equal");
295 assertTrue(cmp.compare(greater, less) > 0, "greater");
296 }
297
298 public void testComparatorDefaultMethods() {
299 Comparator<People> cmp = Comparators.comparing((Function<People, String>) People::getFirstName);
300 Comparator<People> cmp2 = Comparators.comparing((Function<People, String>) People::getLastName);
301 // reverseOrder
302 assertComparison(cmp.reverseOrder(), people[1], people[0]);
303 // thenComparing(Comparator)
304 assertComparison(cmp.thenComparing(cmp2), people[0], people[1]);
305 assertComparison(cmp.thenComparing(cmp2), people[4], people[0]);
306 // thenComparing(Function)
307 assertComparison(cmp.thenComparing(People::getLastName), people[0], people[1]);
308 assertComparison(cmp.thenComparing(People::getLastName), people[4], people[0]);
309 // thenComparing(ToIntFunction)
310 assertComparison(cmp.thenComparing(People::getAge), people[0], people[1]);
311 assertComparison(cmp.thenComparing(People::getAge), people[1], people[5]);
312 // thenComparing(ToLongFunction)
313 assertComparison(cmp.thenComparing(People::getAgeAsLong), people[0], people[1]);
314 assertComparison(cmp.thenComparing(People::getAgeAsLong), people[1], people[5]);
315 // thenComparing(ToDoubleFunction)
316 assertComparison(cmp.thenComparing(People::getAgeAsDouble), people[0], people[1]);
317 assertComparison(cmp.thenComparing(People::getAgeAsDouble), people[1], people[5]);
318 }
319
320 public void testGreaterOf() {
321 // lesser
322 assertSame(Comparators.greaterOf(Comparators.comparing(
323 (Function<People, String>) People::getFirstName))
324 .apply(people[0], people[1]),
325 people[1]);
326 // euqal
327 assertSame(Comparators.greaterOf(Comparators.comparing(
328 (Function<People, String>) People::getLastName))
329 .apply(people[0], people[1]),
330 people[0]);
331 // greater
332 assertSame(Comparators.greaterOf(Comparators.comparing(
333 (ToIntFunction<People>) People::getAge))
334 .apply(people[0], people[1]),
335 people[0]);
336 }
337
338 public void testLesserOf() {
339 // lesser
340 assertSame(Comparators.lesserOf(Comparators.comparing(
341 (Function<People, String>) People::getFirstName))
342 .apply(people[0], people[1]),
343 people[0]);
344 // euqal
345 assertSame(Comparators.lesserOf(Comparators.comparing(
346 (Function<People, String>) People::getLastName))
347 .apply(people[0], people[1]),
348 people[0]);
349 // greater
350 assertSame(Comparators.lesserOf(Comparators.comparing(
351 (ToIntFunction<People>) People::getAge))
352 .apply(people[0], people[1]),
353 people[1]);
354 }
355
356 public void testNulls() {
357 try {
358 Comparators.<String>naturalOrder().compare("abc", (String) null);
359 fail("expected NPE with naturalOrder");
360 } catch (NullPointerException npe) {}
361 try {
362 Comparators.<String>naturalOrder().compare((String) null, "abc");
363 fail("expected NPE with naturalOrder");
364 } catch (NullPointerException npe) {}
365
366 try {
367 Comparators.<String>reverseOrder().compare("abc", (String) null);
368 fail("expected NPE with naturalOrder");
369 } catch (NullPointerException npe) {}
370 try {
371 Comparators.<String>reverseOrder().compare((String) null, "abc");
372 fail("expected NPE with naturalOrder");
373 } catch (NullPointerException npe) {}
374
375 try {
376 Comparator<Map.Entry<String, String>> cmp = Comparators.byKey(null);
377 fail("byKey(null) should throw NPE");
378 } catch (NullPointerException npe) {}
379
380 try {
381 Comparator<Map.Entry<String, String>> cmp = Comparators.byValue(null);
382 fail("byValue(null) should throw NPE");
383 } catch (NullPointerException npe) {}
384
385 try {
386 Comparator<People> cmp = Comparators.comparing((Function<People, String>) null);
387 fail("comparing(null) should throw NPE");
388 } catch (NullPointerException npe) {}
389 try {
390 Comparator<People> cmp = Comparators.comparing((ToIntFunction<People>) null);
391 fail("comparing(null) should throw NPE");
392 } catch (NullPointerException npe) {}
393 try {
394 Comparator<People> cmp = Comparators.comparing((ToLongFunction<People>) null);
395 fail("comparing(null) should throw NPE");
396 } catch (NullPointerException npe) {}
397 try {
398 Comparator<People> cmp = Comparators.comparing((ToDoubleFunction<People>) null);
399 fail("comparing(null) should throw NPE");
400 } catch (NullPointerException npe) {}
401
402 try {
403 BinaryOperator<String> op = Comparators.lesserOf(null);
404 fail("lesserOf(null) should throw NPE");
405 } catch (NullPointerException npe) {}
406
407 try {
408 BinaryOperator<String> op = Comparators.greaterOf(null);
409 fail("lesserOf(null) should throw NPE");
410 } catch (NullPointerException npe) {}
411 }
412 }