1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.lang3;
19
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertFalse;
22 import static org.junit.jupiter.api.Assertions.assertNotEquals;
23 import static org.junit.jupiter.api.Assertions.assertNotNull;
24 import static org.junit.jupiter.api.Assertions.assertSame;
25 import static org.junit.jupiter.api.Assertions.assertThrows;
26 import static org.junit.jupiter.api.Assertions.assertTrue;
27
28 import java.util.Comparator;
29
30 import org.junit.jupiter.api.BeforeEach;
31 import org.junit.jupiter.api.Test;
32
33
34
35
36 @SuppressWarnings("boxing")
37 public class RangeTest extends AbstractLangTest {
38
39 abstract static class AbstractComparable implements Comparable<AbstractComparable> {
40 @Override
41 public int compareTo(final AbstractComparable o) {
42 return 0;
43 }
44 }
45 static final class DerivedComparableA extends AbstractComparable {
46
47 }
48 static final class DerivedComparableB extends AbstractComparable {
49
50 }
51
52 private Range<Byte> byteRange;
53 private Range<Byte> byteRange2;
54 private Range<Byte> byteRange3;
55 private Range<Double> doubleRange;
56 private Range<Float> floatRange;
57 private Range<Integer> intRange;
58 private Range<Long> longRange;
59
60 @BeforeEach
61 public void setUp() {
62 byteRange = Range.of((byte) 0, (byte) 5);
63 byteRange2 = Range.of((byte) 0, (byte) 5);
64 byteRange3 = Range.of((byte) 0, (byte) 10);
65
66 intRange = Range.of(10, 20);
67 longRange = Range.of(10L, 20L);
68 floatRange = Range.of((float) 10, (float) 20);
69 doubleRange = Range.of((double) 10, (double) 20);
70 }
71
72 @Test
73 public void testBetweenWithCompare() {
74
75 final Comparator<Integer> c = (o1, o2) -> 0;
76 final Comparator<String> lengthComp = Comparator.comparingInt(String::length);
77 Range<Integer> rb = Range.between(-10, 20);
78 assertFalse(rb.contains(null), "should not contain null");
79 assertTrue(rb.contains(10), "should contain 10");
80 assertTrue(rb.contains(-10), "should contain -10");
81 assertFalse(rb.contains(21), "should not contain 21");
82 assertFalse(rb.contains(-11), "should not contain -11");
83 rb = Range.between(-10, 20, c);
84 assertFalse(rb.contains(null), "should not contain null");
85 assertTrue(rb.contains(10), "should contain 10");
86 assertTrue(rb.contains(-10), "should contain -10");
87 assertTrue(rb.contains(21), "should contain 21");
88 assertTrue(rb.contains(-11), "should contain -11");
89 Range<String> rbstr = Range.between("house", "i");
90 assertFalse(rbstr.contains(null), "should not contain null");
91 assertTrue(rbstr.contains("house"), "should contain house");
92 assertTrue(rbstr.contains("i"), "should contain i");
93 assertFalse(rbstr.contains("hose"), "should not contain hose");
94 assertFalse(rbstr.contains("ice"), "should not contain ice");
95 rbstr = Range.between("house", "i", lengthComp);
96 assertFalse(rbstr.contains(null), "should not contain null");
97 assertTrue(rbstr.contains("house"), "should contain house");
98 assertTrue(rbstr.contains("i"), "should contain i");
99 assertFalse(rbstr.contains("houses"), "should not contain houses");
100 assertFalse(rbstr.contains(""), "should not contain ''");
101
102 assertThrows(NullPointerException.class, () -> Range.between(null, null, lengthComp));
103 }
104
105 @SuppressWarnings({"rawtypes", "unchecked"})
106 @Test
107 public void testComparableConstructors() {
108 final Comparable c = other -> 1;
109 final Range r1 = Range.is(c);
110 final Range r2 = Range.between(c, c);
111 assertTrue(r1.isNaturalOrdering());
112 assertTrue(r2.isNaturalOrdering());
113 }
114
115 @Test
116 public void testConstructorSignatureWithAbstractComparableClasses() {
117 final DerivedComparableA derivedComparableA = new DerivedComparableA();
118 final DerivedComparableB derivedComparableB = new DerivedComparableB();
119
120 Range<AbstractComparable> mixed = Range.between(derivedComparableA, derivedComparableB);
121 mixed = Range.between(derivedComparableA, derivedComparableB, null);
122 assertTrue(mixed.contains(derivedComparableA));
123
124 Range<AbstractComparable> same = Range.between(derivedComparableA, derivedComparableA);
125 same = Range.between(derivedComparableA, derivedComparableA, null);
126 assertTrue(same.contains(derivedComparableA));
127
128 Range<DerivedComparableA> rangeA = Range.between(derivedComparableA, derivedComparableA);
129 rangeA = Range.between(derivedComparableA, derivedComparableA, null);
130 assertTrue(rangeA.contains(derivedComparableA));
131
132 Range<DerivedComparableB> rangeB = Range.is(derivedComparableB);
133 rangeB = Range.is(derivedComparableB, null);
134 assertTrue(rangeB.contains(derivedComparableB));
135 }
136
137 @Test
138 public void testContains() {
139 assertFalse(intRange.contains(null));
140
141 assertFalse(intRange.contains(5));
142 assertTrue(intRange.contains(10));
143 assertTrue(intRange.contains(15));
144 assertTrue(intRange.contains(20));
145 assertFalse(intRange.contains(25));
146 }
147
148 @Test
149 public void testContainsRange() {
150
151
152 assertFalse(intRange.containsRange(null));
153
154
155 assertTrue(intRange.containsRange(Range.between(12, 18)));
156
157
158 assertFalse(intRange.containsRange(Range.between(32, 45)));
159 assertFalse(intRange.containsRange(Range.between(2, 8)));
160
161
162 assertTrue(intRange.containsRange(Range.between(10, 20)));
163
164
165 assertFalse(intRange.containsRange(Range.between(9, 14)));
166 assertFalse(intRange.containsRange(Range.between(16, 21)));
167
168
169 assertTrue(intRange.containsRange(Range.between(10, 19)));
170 assertFalse(intRange.containsRange(Range.between(10, 21)));
171
172
173 assertTrue(intRange.containsRange(Range.between(11, 20)));
174 assertFalse(intRange.containsRange(Range.between(9, 20)));
175
176
177 assertFalse(intRange.containsRange(Range.between(-11, -18)));
178 }
179
180 @Test
181 public void testElementCompareTo() {
182 assertThrows(NullPointerException.class, () -> intRange.elementCompareTo(null));
183
184 assertEquals(-1, intRange.elementCompareTo(5));
185 assertEquals(0, intRange.elementCompareTo(10));
186 assertEquals(0, intRange.elementCompareTo(15));
187 assertEquals(0, intRange.elementCompareTo(20));
188 assertEquals(1, intRange.elementCompareTo(25));
189 }
190
191 @Test
192 public void testEqualsObject() {
193 assertEquals(byteRange, byteRange);
194 assertEquals(byteRange, byteRange2);
195 assertEquals(byteRange2, byteRange2);
196 assertEquals(byteRange, byteRange);
197 assertEquals(byteRange2, byteRange2);
198 assertEquals(byteRange3, byteRange3);
199 assertNotEquals(byteRange2, byteRange3);
200 assertNotEquals(null, byteRange2);
201 assertNotEquals("Ni!", byteRange2);
202 }
203
204 @Test
205 public void testFit() {
206 assertEquals(intRange.getMinimum(), intRange.fit(Integer.MIN_VALUE));
207 assertEquals(intRange.getMinimum(), intRange.fit(intRange.getMinimum()));
208 assertEquals(intRange.getMaximum(), intRange.fit(Integer.MAX_VALUE));
209 assertEquals(intRange.getMaximum(), intRange.fit(intRange.getMaximum()));
210 assertEquals(15, intRange.fit(15));
211 }
212
213 @Test
214 public void testFitNull() {
215 assertThrows(NullPointerException.class, () -> {
216 intRange.fit(null);
217 });
218 }
219
220 @Test
221 public void testGetMaximum() {
222 assertEquals(20, (int) intRange.getMaximum());
223 assertEquals(20L, (long) longRange.getMaximum());
224 assertEquals(20f, floatRange.getMaximum(), 0.00001f);
225 assertEquals(20d, doubleRange.getMaximum(), 0.00001d);
226 }
227
228 @Test
229 public void testGetMinimum() {
230 assertEquals(10, (int) intRange.getMinimum());
231 assertEquals(10L, (long) longRange.getMinimum());
232 assertEquals(10f, floatRange.getMinimum(), 0.00001f);
233 assertEquals(10d, doubleRange.getMinimum(), 0.00001d);
234 }
235
236 @Test
237 public void testHashCode() {
238 assertEquals(byteRange.hashCode(), byteRange2.hashCode());
239 assertNotEquals(byteRange.hashCode(), byteRange3.hashCode());
240
241 assertEquals(intRange.hashCode(), intRange.hashCode());
242 assertTrue(intRange.hashCode() != 0);
243 }
244
245 @Test
246 public void testIntersectionWith() {
247 assertSame(intRange, intRange.intersectionWith(intRange));
248 assertSame(byteRange, byteRange.intersectionWith(byteRange));
249 assertSame(longRange, longRange.intersectionWith(longRange));
250 assertSame(floatRange, floatRange.intersectionWith(floatRange));
251 assertSame(doubleRange, doubleRange.intersectionWith(doubleRange));
252
253 assertEquals(Range.between(10, 15), intRange.intersectionWith(Range.between(5, 15)));
254 }
255
256 @Test
257 public void testIntersectionWithNonOverlapping() {
258 assertThrows(IllegalArgumentException.class, () -> intRange.intersectionWith(Range.between(0, 9)));
259 }
260
261 @Test
262 public void testIntersectionWithNull() {
263 assertThrows(IllegalArgumentException.class, () -> intRange.intersectionWith(null));
264 }
265
266 @Test
267 public void testIsAfter() {
268 assertFalse(intRange.isAfter(null));
269
270 assertTrue(intRange.isAfter(5));
271 assertFalse(intRange.isAfter(10));
272 assertFalse(intRange.isAfter(15));
273 assertFalse(intRange.isAfter(20));
274 assertFalse(intRange.isAfter(25));
275 }
276
277 @Test
278 public void testIsAfterRange() {
279 assertFalse(intRange.isAfterRange(null));
280
281 assertTrue(intRange.isAfterRange(Range.between(5, 9)));
282
283 assertFalse(intRange.isAfterRange(Range.between(5, 10)));
284 assertFalse(intRange.isAfterRange(Range.between(5, 20)));
285 assertFalse(intRange.isAfterRange(Range.between(5, 25)));
286 assertFalse(intRange.isAfterRange(Range.between(15, 25)));
287
288 assertFalse(intRange.isAfterRange(Range.between(21, 25)));
289
290 assertFalse(intRange.isAfterRange(Range.between(10, 20)));
291 }
292
293 @Test
294 public void testIsBefore() {
295 assertFalse(intRange.isBefore(null));
296
297 assertFalse(intRange.isBefore(5));
298 assertFalse(intRange.isBefore(10));
299 assertFalse(intRange.isBefore(15));
300 assertFalse(intRange.isBefore(20));
301 assertTrue(intRange.isBefore(25));
302 }
303
304 @Test
305 public void testIsBeforeRange() {
306 assertFalse(intRange.isBeforeRange(null));
307
308 assertFalse(intRange.isBeforeRange(Range.between(5, 9)));
309
310 assertFalse(intRange.isBeforeRange(Range.between(5, 10)));
311 assertFalse(intRange.isBeforeRange(Range.between(5, 20)));
312 assertFalse(intRange.isBeforeRange(Range.between(5, 25)));
313 assertFalse(intRange.isBeforeRange(Range.between(15, 25)));
314
315 assertTrue(intRange.isBeforeRange(Range.between(21, 25)));
316
317 assertFalse(intRange.isBeforeRange(Range.between(10, 20)));
318 }
319
320 @Test
321 public void testIsEndedBy() {
322 assertFalse(intRange.isEndedBy(null));
323
324 assertFalse(intRange.isEndedBy(5));
325 assertFalse(intRange.isEndedBy(10));
326 assertFalse(intRange.isEndedBy(15));
327 assertTrue(intRange.isEndedBy(20));
328 assertFalse(intRange.isEndedBy(25));
329 }
330
331 @Test
332 public void testIsOverlappedBy() {
333
334
335 assertFalse(intRange.isOverlappedBy(null));
336
337
338 assertTrue(intRange.isOverlappedBy(Range.between(12, 18)));
339
340
341 assertFalse(intRange.isOverlappedBy(Range.between(32, 45)));
342 assertFalse(intRange.isOverlappedBy(Range.between(2, 8)));
343
344
345 assertTrue(intRange.isOverlappedBy(Range.between(10, 20)));
346
347
348 assertTrue(intRange.isOverlappedBy(Range.between(9, 14)));
349 assertTrue(intRange.isOverlappedBy(Range.between(16, 21)));
350
351
352 assertTrue(intRange.isOverlappedBy(Range.between(10, 19)));
353 assertTrue(intRange.isOverlappedBy(Range.between(10, 21)));
354
355
356 assertTrue(intRange.isOverlappedBy(Range.between(11, 20)));
357 assertTrue(intRange.isOverlappedBy(Range.between(9, 20)));
358
359
360 assertFalse(intRange.isOverlappedBy(Range.between(-11, -18)));
361
362
363 assertTrue(intRange.isOverlappedBy(Range.between(9, 21)));
364 }
365
366 @Test
367 public void testIsStartedBy() {
368 assertFalse(intRange.isStartedBy(null));
369
370 assertFalse(intRange.isStartedBy(5));
371 assertTrue(intRange.isStartedBy(10));
372 assertFalse(intRange.isStartedBy(15));
373 assertFalse(intRange.isStartedBy(20));
374 assertFalse(intRange.isStartedBy(25));
375 }
376
377 @Test
378 public void testIsWithCompare() {
379
380 final Comparator<Integer> c = (o1, o2) -> 0;
381 Range<Integer> ri = Range.is(10);
382 assertFalse(ri.contains(null), "should not contain null");
383 assertTrue(ri.contains(10), "should contain 10");
384 assertFalse(ri.contains(11), "should not contain 11");
385 ri = Range.is(10, c);
386 assertFalse(ri.contains(null), "should not contain null");
387 assertTrue(ri.contains(10), "should contain 10");
388 assertTrue(ri.contains(11), "should contain 11");
389 }
390
391 @Test
392 public void testOfWithCompare() {
393
394 final Comparator<Integer> c = (o1, o2) -> 0;
395 final Comparator<String> lengthComp = Comparator.comparingInt(String::length);
396 Range<Integer> rb = Range.of(-10, 20);
397 assertFalse(rb.contains(null), "should not contain null");
398 assertTrue(rb.contains(10), "should contain 10");
399 assertTrue(rb.contains(-10), "should contain -10");
400 assertFalse(rb.contains(21), "should not contain 21");
401 assertFalse(rb.contains(-11), "should not contain -11");
402 rb = Range.of(-10, 20, c);
403 assertFalse(rb.contains(null), "should not contain null");
404 assertTrue(rb.contains(10), "should contain 10");
405 assertTrue(rb.contains(-10), "should contain -10");
406 assertTrue(rb.contains(21), "should contain 21");
407 assertTrue(rb.contains(-11), "should contain -11");
408 Range<String> rbstr = Range.of("house", "i");
409 assertFalse(rbstr.contains(null), "should not contain null");
410 assertTrue(rbstr.contains("house"), "should contain house");
411 assertTrue(rbstr.contains("i"), "should contain i");
412 assertFalse(rbstr.contains("hose"), "should not contain hose");
413 assertFalse(rbstr.contains("ice"), "should not contain ice");
414 rbstr = Range.of("house", "i", lengthComp);
415 assertFalse(rbstr.contains(null), "should not contain null");
416 assertTrue(rbstr.contains("house"), "should contain house");
417 assertTrue(rbstr.contains("i"), "should contain i");
418 assertFalse(rbstr.contains("houses"), "should not contain houses");
419 assertFalse(rbstr.contains(""), "should not contain ''");
420
421 assertThrows(NullPointerException.class, () -> Range.of(null, null, lengthComp));
422 }
423
424 @Test
425 public void testRangeOfChars() {
426 final Range<Character> chars = Range.between('a', 'z');
427 assertTrue(chars.contains('b'));
428 assertFalse(chars.contains('B'));
429 }
430
431 @Test
432 public void testSerializing() {
433 SerializationUtils.clone(intRange);
434 }
435
436 @Test
437 public void testToString() {
438 assertNotNull(byteRange.toString());
439
440 final String str = intRange.toString();
441 assertEquals("[10..20]", str);
442 assertEquals("[-20..-10]", Range.between(-20, -10).toString());
443 }
444
445 @Test
446 public void testToStringFormat() {
447 final String str = intRange.toString("From %1$s to %2$s");
448 assertEquals("From 10 to 20", str);
449 }
450 }