• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
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  * Tests {@link Range}.
35  */
36 @SuppressWarnings("boxing")
37 public class RangeTest extends AbstractLangTest {
38 
39     abstract static class AbstractComparable implements Comparable<AbstractComparable> {
40         @Override
compareTo(final AbstractComparable o)41         public int compareTo(final AbstractComparable o) {
42             return 0;
43         }
44     }
45     static final class DerivedComparableA extends AbstractComparable {
46         // empty
47     }
48     static final class DerivedComparableB extends AbstractComparable {
49         // empty
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
setUp()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
testBetweenWithCompare()73     public void testBetweenWithCompare() {
74         // all integers are equal
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     @Test
testOfWithCompare()106     public void testOfWithCompare() {
107         // all integers are equal
108         final Comparator<Integer> c = (o1, o2) -> 0;
109         final Comparator<String> lengthComp = Comparator.comparingInt(String::length);
110         Range<Integer> rb = Range.of(-10, 20);
111         assertFalse(rb.contains(null), "should not contain null");
112         assertTrue(rb.contains(10), "should contain 10");
113         assertTrue(rb.contains(-10), "should contain -10");
114         assertFalse(rb.contains(21), "should not contain 21");
115         assertFalse(rb.contains(-11), "should not contain -11");
116         rb = Range.of(-10, 20, c);
117         assertFalse(rb.contains(null), "should not contain null");
118         assertTrue(rb.contains(10), "should contain 10");
119         assertTrue(rb.contains(-10), "should contain -10");
120         assertTrue(rb.contains(21), "should contain 21");
121         assertTrue(rb.contains(-11), "should contain -11");
122         Range<String> rbstr = Range.of("house", "i");
123         assertFalse(rbstr.contains(null), "should not contain null");
124         assertTrue(rbstr.contains("house"), "should contain house");
125         assertTrue(rbstr.contains("i"), "should contain i");
126         assertFalse(rbstr.contains("hose"), "should not contain hose");
127         assertFalse(rbstr.contains("ice"), "should not contain ice");
128         rbstr = Range.of("house", "i", lengthComp);
129         assertFalse(rbstr.contains(null), "should not contain null");
130         assertTrue(rbstr.contains("house"), "should contain house");
131         assertTrue(rbstr.contains("i"), "should contain i");
132         assertFalse(rbstr.contains("houses"), "should not contain houses");
133         assertFalse(rbstr.contains(""), "should not contain ''");
134 
135         assertThrows(NullPointerException.class, () -> Range.of(null, null, lengthComp));
136     }
137 
138     @SuppressWarnings({"rawtypes", "unchecked"})
139     @Test
testComparableConstructors()140     public void testComparableConstructors() {
141         final Comparable c = other -> 1;
142         final Range r1 = Range.is(c);
143         final Range r2 = Range.between(c, c);
144         assertTrue(r1.isNaturalOrdering());
145         assertTrue(r2.isNaturalOrdering());
146     }
147 
148     @Test
testConstructorSignatureWithAbstractComparableClasses()149     public void testConstructorSignatureWithAbstractComparableClasses() {
150         final DerivedComparableA derivedComparableA = new DerivedComparableA();
151         final DerivedComparableB derivedComparableB = new DerivedComparableB();
152 
153         Range<AbstractComparable> mixed = Range.between(derivedComparableA, derivedComparableB);
154         mixed = Range.between(derivedComparableA, derivedComparableB, null);
155         assertTrue(mixed.contains(derivedComparableA));
156 
157         Range<AbstractComparable> same = Range.between(derivedComparableA, derivedComparableA);
158         same = Range.between(derivedComparableA, derivedComparableA, null);
159         assertTrue(same.contains(derivedComparableA));
160 
161         Range<DerivedComparableA> rangeA = Range.between(derivedComparableA, derivedComparableA);
162         rangeA = Range.between(derivedComparableA, derivedComparableA, null);
163         assertTrue(rangeA.contains(derivedComparableA));
164 
165         Range<DerivedComparableB> rangeB = Range.is(derivedComparableB);
166         rangeB = Range.is(derivedComparableB, null);
167         assertTrue(rangeB.contains(derivedComparableB));
168     }
169 
170     @Test
testContains()171     public void testContains() {
172         assertFalse(intRange.contains(null));
173 
174         assertFalse(intRange.contains(5));
175         assertTrue(intRange.contains(10));
176         assertTrue(intRange.contains(15));
177         assertTrue(intRange.contains(20));
178         assertFalse(intRange.contains(25));
179     }
180 
181     @Test
testContainsRange()182     public void testContainsRange() {
183 
184         // null handling
185         assertFalse(intRange.containsRange(null));
186 
187         // easy inside range
188         assertTrue(intRange.containsRange(Range.between(12, 18)));
189 
190         // outside range on each side
191         assertFalse(intRange.containsRange(Range.between(32, 45)));
192         assertFalse(intRange.containsRange(Range.between(2, 8)));
193 
194         // equals range
195         assertTrue(intRange.containsRange(Range.between(10, 20)));
196 
197         // overlaps
198         assertFalse(intRange.containsRange(Range.between(9, 14)));
199         assertFalse(intRange.containsRange(Range.between(16, 21)));
200 
201         // touches lower boundary
202         assertTrue(intRange.containsRange(Range.between(10, 19)));
203         assertFalse(intRange.containsRange(Range.between(10, 21)));
204 
205         // touches upper boundary
206         assertTrue(intRange.containsRange(Range.between(11, 20)));
207         assertFalse(intRange.containsRange(Range.between(9, 20)));
208 
209         // negative
210         assertFalse(intRange.containsRange(Range.between(-11, -18)));
211     }
212 
213     @Test
testElementCompareTo()214     public void testElementCompareTo() {
215         assertThrows(NullPointerException.class, () -> intRange.elementCompareTo(null));
216 
217         assertEquals(-1, intRange.elementCompareTo(5));
218         assertEquals(0, intRange.elementCompareTo(10));
219         assertEquals(0, intRange.elementCompareTo(15));
220         assertEquals(0, intRange.elementCompareTo(20));
221         assertEquals(1, intRange.elementCompareTo(25));
222     }
223 
224     @Test
testEqualsObject()225     public void testEqualsObject() {
226         assertEquals(byteRange, byteRange);
227         assertEquals(byteRange, byteRange2);
228         assertEquals(byteRange2, byteRange2);
229         assertEquals(byteRange, byteRange);
230         assertEquals(byteRange2, byteRange2);
231         assertEquals(byteRange3, byteRange3);
232         assertNotEquals(byteRange2, byteRange3);
233         assertNotEquals(null, byteRange2);
234         assertNotEquals("Ni!", byteRange2);
235     }
236 
237     @Test
testFit()238     public void testFit() {
239         assertEquals(intRange.getMinimum(), intRange.fit(Integer.MIN_VALUE));
240         assertEquals(intRange.getMinimum(), intRange.fit(intRange.getMinimum()));
241         assertEquals(intRange.getMaximum(), intRange.fit(Integer.MAX_VALUE));
242         assertEquals(intRange.getMaximum(), intRange.fit(intRange.getMaximum()));
243         assertEquals(15, intRange.fit(15));
244     }
245 
246     @Test
testFitNull()247     public void testFitNull() {
248         assertThrows(NullPointerException.class, () -> {
249             intRange.fit(null);
250         });
251     }
252 
253     @Test
testGetMaximum()254     public void testGetMaximum() {
255         assertEquals(20, (int) intRange.getMaximum());
256         assertEquals(20L, (long) longRange.getMaximum());
257         assertEquals(20f, floatRange.getMaximum(), 0.00001f);
258         assertEquals(20d, doubleRange.getMaximum(), 0.00001d);
259     }
260 
261     @Test
testGetMinimum()262     public void testGetMinimum() {
263         assertEquals(10, (int) intRange.getMinimum());
264         assertEquals(10L, (long) longRange.getMinimum());
265         assertEquals(10f, floatRange.getMinimum(), 0.00001f);
266         assertEquals(10d, doubleRange.getMinimum(), 0.00001d);
267     }
268 
269     @Test
testHashCode()270     public void testHashCode() {
271         assertEquals(byteRange.hashCode(), byteRange2.hashCode());
272         assertNotEquals(byteRange.hashCode(), byteRange3.hashCode());
273 
274         assertEquals(intRange.hashCode(), intRange.hashCode());
275         assertTrue(intRange.hashCode() != 0);
276     }
277 
278     @Test
testIntersectionWith()279     public void testIntersectionWith() {
280         assertSame(intRange, intRange.intersectionWith(intRange));
281         assertSame(byteRange, byteRange.intersectionWith(byteRange));
282         assertSame(longRange, longRange.intersectionWith(longRange));
283         assertSame(floatRange, floatRange.intersectionWith(floatRange));
284         assertSame(doubleRange, doubleRange.intersectionWith(doubleRange));
285 
286         assertEquals(Range.between(10, 15), intRange.intersectionWith(Range.between(5, 15)));
287     }
288 
289     @Test
testIntersectionWithNonOverlapping()290     public void testIntersectionWithNonOverlapping() {
291         assertThrows(IllegalArgumentException.class, () -> intRange.intersectionWith(Range.between(0, 9)));
292     }
293 
294     @Test
testIntersectionWithNull()295     public void testIntersectionWithNull() {
296         assertThrows(IllegalArgumentException.class, () -> intRange.intersectionWith(null));
297     }
298 
299     @Test
testIsAfter()300     public void testIsAfter() {
301         assertFalse(intRange.isAfter(null));
302 
303         assertTrue(intRange.isAfter(5));
304         assertFalse(intRange.isAfter(10));
305         assertFalse(intRange.isAfter(15));
306         assertFalse(intRange.isAfter(20));
307         assertFalse(intRange.isAfter(25));
308     }
309 
310     @Test
testIsAfterRange()311     public void testIsAfterRange() {
312         assertFalse(intRange.isAfterRange(null));
313 
314         assertTrue(intRange.isAfterRange(Range.between(5, 9)));
315 
316         assertFalse(intRange.isAfterRange(Range.between(5, 10)));
317         assertFalse(intRange.isAfterRange(Range.between(5, 20)));
318         assertFalse(intRange.isAfterRange(Range.between(5, 25)));
319         assertFalse(intRange.isAfterRange(Range.between(15, 25)));
320 
321         assertFalse(intRange.isAfterRange(Range.between(21, 25)));
322 
323         assertFalse(intRange.isAfterRange(Range.between(10, 20)));
324     }
325 
326     @Test
testIsBefore()327     public void testIsBefore() {
328         assertFalse(intRange.isBefore(null));
329 
330         assertFalse(intRange.isBefore(5));
331         assertFalse(intRange.isBefore(10));
332         assertFalse(intRange.isBefore(15));
333         assertFalse(intRange.isBefore(20));
334         assertTrue(intRange.isBefore(25));
335     }
336 
337     @Test
testIsBeforeRange()338     public void testIsBeforeRange() {
339         assertFalse(intRange.isBeforeRange(null));
340 
341         assertFalse(intRange.isBeforeRange(Range.between(5, 9)));
342 
343         assertFalse(intRange.isBeforeRange(Range.between(5, 10)));
344         assertFalse(intRange.isBeforeRange(Range.between(5, 20)));
345         assertFalse(intRange.isBeforeRange(Range.between(5, 25)));
346         assertFalse(intRange.isBeforeRange(Range.between(15, 25)));
347 
348         assertTrue(intRange.isBeforeRange(Range.between(21, 25)));
349 
350         assertFalse(intRange.isBeforeRange(Range.between(10, 20)));
351     }
352 
353     @Test
testIsEndedBy()354     public void testIsEndedBy() {
355         assertFalse(intRange.isEndedBy(null));
356 
357         assertFalse(intRange.isEndedBy(5));
358         assertFalse(intRange.isEndedBy(10));
359         assertFalse(intRange.isEndedBy(15));
360         assertTrue(intRange.isEndedBy(20));
361         assertFalse(intRange.isEndedBy(25));
362     }
363 
364     @Test
testIsOverlappedBy()365     public void testIsOverlappedBy() {
366 
367         // null handling
368         assertFalse(intRange.isOverlappedBy(null));
369 
370         // easy inside range
371         assertTrue(intRange.isOverlappedBy(Range.between(12, 18)));
372 
373         // outside range on each side
374         assertFalse(intRange.isOverlappedBy(Range.between(32, 45)));
375         assertFalse(intRange.isOverlappedBy(Range.between(2, 8)));
376 
377         // equals range
378         assertTrue(intRange.isOverlappedBy(Range.between(10, 20)));
379 
380         // overlaps
381         assertTrue(intRange.isOverlappedBy(Range.between(9, 14)));
382         assertTrue(intRange.isOverlappedBy(Range.between(16, 21)));
383 
384         // touches lower boundary
385         assertTrue(intRange.isOverlappedBy(Range.between(10, 19)));
386         assertTrue(intRange.isOverlappedBy(Range.between(10, 21)));
387 
388         // touches upper boundary
389         assertTrue(intRange.isOverlappedBy(Range.between(11, 20)));
390         assertTrue(intRange.isOverlappedBy(Range.between(9, 20)));
391 
392         // negative
393         assertFalse(intRange.isOverlappedBy(Range.between(-11, -18)));
394 
395         // outside range whole range
396         assertTrue(intRange.isOverlappedBy(Range.between(9, 21)));
397 }
398 
399     @Test
testIsStartedBy()400     public void testIsStartedBy() {
401         assertFalse(intRange.isStartedBy(null));
402 
403         assertFalse(intRange.isStartedBy(5));
404         assertTrue(intRange.isStartedBy(10));
405         assertFalse(intRange.isStartedBy(15));
406         assertFalse(intRange.isStartedBy(20));
407         assertFalse(intRange.isStartedBy(25));
408     }
409 
410     @Test
testIsWithCompare()411     public void testIsWithCompare() {
412         // all integers are equal
413         final Comparator<Integer> c = (o1, o2) -> 0;
414         Range<Integer> ri = Range.is(10);
415         assertFalse(ri.contains(null), "should not contain null");
416         assertTrue(ri.contains(10), "should contain 10");
417         assertFalse(ri.contains(11), "should not contain 11");
418         ri = Range.is(10, c);
419         assertFalse(ri.contains(null), "should not contain null");
420         assertTrue(ri.contains(10), "should contain 10");
421         assertTrue(ri.contains(11), "should contain 11");
422     }
423 
424     @Test
testRangeOfChars()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
testSerializing()432     public void testSerializing() {
433         SerializationUtils.clone(intRange);
434     }
435 
436     @Test
testToString()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
testToStringFormat()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 }
451