View Javadoc
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
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
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          // 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     @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         // null handling
152         assertFalse(intRange.containsRange(null));
153 
154         // easy inside range
155         assertTrue(intRange.containsRange(Range.between(12, 18)));
156 
157         // outside range on each side
158         assertFalse(intRange.containsRange(Range.between(32, 45)));
159         assertFalse(intRange.containsRange(Range.between(2, 8)));
160 
161         // equals range
162         assertTrue(intRange.containsRange(Range.between(10, 20)));
163 
164         // overlaps
165         assertFalse(intRange.containsRange(Range.between(9, 14)));
166         assertFalse(intRange.containsRange(Range.between(16, 21)));
167 
168         // touches lower boundary
169         assertTrue(intRange.containsRange(Range.between(10, 19)));
170         assertFalse(intRange.containsRange(Range.between(10, 21)));
171 
172         // touches upper boundary
173         assertTrue(intRange.containsRange(Range.between(11, 20)));
174         assertFalse(intRange.containsRange(Range.between(9, 20)));
175 
176         // negative
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         // null handling
335         assertFalse(intRange.isOverlappedBy(null));
336 
337         // easy inside range
338         assertTrue(intRange.isOverlappedBy(Range.between(12, 18)));
339 
340         // outside range on each side
341         assertFalse(intRange.isOverlappedBy(Range.between(32, 45)));
342         assertFalse(intRange.isOverlappedBy(Range.between(2, 8)));
343 
344         // equals range
345         assertTrue(intRange.isOverlappedBy(Range.between(10, 20)));
346 
347         // overlaps
348         assertTrue(intRange.isOverlappedBy(Range.between(9, 14)));
349         assertTrue(intRange.isOverlappedBy(Range.between(16, 21)));
350 
351         // touches lower boundary
352         assertTrue(intRange.isOverlappedBy(Range.between(10, 19)));
353         assertTrue(intRange.isOverlappedBy(Range.between(10, 21)));
354 
355         // touches upper boundary
356         assertTrue(intRange.isOverlappedBy(Range.between(11, 20)));
357         assertTrue(intRange.isOverlappedBy(Range.between(9, 20)));
358 
359         // negative
360         assertFalse(intRange.isOverlappedBy(Range.between(-11, -18)));
361 
362         // outside range whole range
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         // all integers are equal
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         // all integers are equal
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 }