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    *      https://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.apache.commons.lang3.LangAssertions.assertIllegalArgumentException;
21  import static org.apache.commons.lang3.LangAssertions.assertNullPointerException;
22  import static org.junit.jupiter.api.Assertions.assertEquals;
23  import static org.junit.jupiter.api.Assertions.assertFalse;
24  import static org.junit.jupiter.api.Assertions.assertNotEquals;
25  import static org.junit.jupiter.api.Assertions.assertNotNull;
26  import static org.junit.jupiter.api.Assertions.assertSame;
27  import static org.junit.jupiter.api.Assertions.assertTrue;
28  
29  import java.util.Comparator;
30  import java.util.stream.IntStream;
31  
32  import org.junit.jupiter.api.BeforeEach;
33  import org.junit.jupiter.api.Test;
34  
35  /**
36   * Tests {@link IntegerRange}.
37   */
38  @SuppressWarnings("boxing")
39  class IntegerRangeTest extends AbstractLangTest {
40  
41      private static IntegerRange of(final int min, final int max) {
42          return IntegerRange.of(min, max);
43      }
44  
45      private static IntegerRange of(final Integer min, final Integer max) {
46          return IntegerRange.of(min, max);
47      }
48  
49      private IntegerRange range1;
50  
51      private IntegerRange range2;
52  
53      private IntegerRange range3;
54  
55      private IntegerRange rangeFull;
56  
57      @BeforeEach
58      public void setUp() {
59          range1 = of(10, 20);
60          range2 = of(10, 20);
61          range3 = of(-2, -1);
62          rangeFull = of(Integer.MIN_VALUE, Integer.MAX_VALUE);
63      }
64  
65      @Test
66      void testContainsInt() {
67          assertFalse(range1.contains(null));
68  
69          assertTrue(rangeFull.contains(Integer.MIN_VALUE));
70          assertTrue(rangeFull.contains(Integer.MAX_VALUE));
71  
72          assertFalse(range1.contains(5));
73          assertTrue(range1.contains(10));
74          assertTrue(range1.contains(15));
75          assertTrue(range1.contains(20));
76          assertFalse(range1.contains(25));
77      }
78  
79      @Test
80      void testContainsRange() {
81  
82          // null handling
83          assertFalse(range1.containsRange(null));
84  
85          // easy inside range
86          assertTrue(range1.containsRange(Range.of(12, 18)));
87          assertTrue(range1.containsRange(of(12, 18)));
88  
89          // outside range on each side
90          assertFalse(range1.containsRange(Range.of(32, 45)));
91          assertFalse(range1.containsRange(of(32, 45)));
92          assertFalse(range1.containsRange(Range.of(2, 8)));
93          assertFalse(range1.containsRange(of(2, 8)));
94  
95          // equals range
96          assertTrue(range1.containsRange(Range.of(10, 20)));
97          assertTrue(range1.containsRange(of(10, 20)));
98  
99          // overlaps
100         assertFalse(range1.containsRange(Range.of(9, 14)));
101         assertFalse(range1.containsRange(of(9, 14)));
102         assertFalse(range1.containsRange(Range.of(16, 21)));
103         assertFalse(range1.containsRange(of(16, 21)));
104 
105         // touches lower boundary
106         assertTrue(range1.containsRange(Range.of(10, 19)));
107         assertTrue(range1.containsRange(of(10, 19)));
108         assertFalse(range1.containsRange(Range.of(10, 21)));
109         assertFalse(range1.containsRange(of(10, 21)));
110 
111         // touches upper boundary
112         assertTrue(range1.containsRange(Range.of(11, 20)));
113         assertTrue(range1.containsRange(of(11, 20)));
114         assertFalse(range1.containsRange(Range.of(9, 20)));
115         assertFalse(range1.containsRange(of(9, 20)));
116 
117         // negative
118         assertFalse(range1.containsRange(Range.of(-11, -18)));
119         assertFalse(range1.containsRange(of(-11, -18)));
120     }
121 
122     @Test
123     void testElementCompareTo() {
124         assertNullPointerException(() -> range1.elementCompareTo(null));
125 
126         assertEquals(-1, range1.elementCompareTo(5));
127         assertEquals(0, range1.elementCompareTo(10));
128         assertEquals(0, range1.elementCompareTo(15));
129         assertEquals(0, range1.elementCompareTo(20));
130         assertEquals(1, range1.elementCompareTo(25));
131     }
132 
133     @Test
134     void testEqualsObject() {
135         assertEquals(range1, range1);
136         assertEquals(range1, range2);
137         assertEquals(range2, range2);
138         assertEquals(range1, range1);
139         assertEquals(range2, range2);
140         assertEquals(range3, range3);
141         assertNotEquals(range2, range3);
142         assertNotEquals(null, range2);
143         assertNotEquals("Ni!", range2);
144     }
145 
146     @Test
147     void testFit() {
148         assertEquals(range1.getMinimum(), range1.fit(Integer.MIN_VALUE));
149         assertEquals(range1.getMinimum(), range1.fit(range1.getMinimum()));
150         assertEquals(range1.getMaximum(), range1.fit(Integer.MAX_VALUE));
151         assertEquals(range1.getMaximum(), range1.fit(range1.getMaximum()));
152         assertEquals(15, range1.fit(15));
153     }
154 
155     @Test
156     void testFitNull() {
157         assertNullPointerException(() -> {
158             range1.fit(null);
159         });
160     }
161 
162     @Test
163     void testGetMaximum() {
164         assertEquals(20, (int) range1.getMaximum());
165     }
166 
167     @Test
168     void testGetMinimum() {
169         assertEquals(10, (int) range1.getMinimum());
170     }
171 
172     @Test
173     void testHashCode() {
174         assertEquals(range1.hashCode(), range2.hashCode());
175         assertNotEquals(range1.hashCode(), range3.hashCode());
176 
177         assertEquals(range1.hashCode(), range1.hashCode());
178         assertTrue(range1.hashCode() != 0);
179     }
180 
181     @Test
182     void testIntersectionWith() {
183         assertSame(range1, range1.intersectionWith(range1));
184 
185         assertEquals(Range.of(10, 15), range1.intersectionWith(Range.of(5, 15)));
186     }
187 
188     @Test
189     void testIntersectionWithNonOverlapping() {
190         assertIllegalArgumentException(() -> range1.intersectionWith(Range.of(0, 9)));
191     }
192 
193     @Test
194     void testIntersectionWithNull() {
195         assertIllegalArgumentException(() -> range1.intersectionWith(null));
196     }
197 
198     @Test
199     void testIsAfter() {
200         assertFalse(range1.isAfter(null));
201 
202         assertTrue(range1.isAfter(5));
203         assertFalse(range1.isAfter(10));
204         assertFalse(range1.isAfter(15));
205         assertFalse(range1.isAfter(20));
206         assertFalse(range1.isAfter(25));
207     }
208 
209     @Test
210     void testIsAfterRange() {
211         assertFalse(range1.isAfterRange(null));
212 
213         assertTrue(range1.isAfterRange(Range.of(5, 9)));
214 
215         assertFalse(range1.isAfterRange(Range.of(5, 10)));
216         assertFalse(range1.isAfterRange(Range.of(5, 20)));
217         assertFalse(range1.isAfterRange(Range.of(5, 25)));
218         assertFalse(range1.isAfterRange(Range.of(15, 25)));
219 
220         assertFalse(range1.isAfterRange(Range.of(21, 25)));
221 
222         assertFalse(range1.isAfterRange(Range.of(10, 20)));
223     }
224 
225     @Test
226     void testIsBefore() {
227         assertFalse(range1.isBefore(null));
228 
229         assertFalse(range1.isBefore(5));
230         assertFalse(range1.isBefore(10));
231         assertFalse(range1.isBefore(15));
232         assertFalse(range1.isBefore(20));
233         assertTrue(range1.isBefore(25));
234     }
235 
236     @Test
237     void testIsBeforeIntegerRange() {
238         assertFalse(range1.isBeforeRange(null));
239 
240         assertFalse(range1.isBeforeRange(of(5, 9)));
241 
242         assertFalse(range1.isBeforeRange(of(5, 10)));
243         assertFalse(range1.isBeforeRange(of(5, 20)));
244         assertFalse(range1.isBeforeRange(of(5, 25)));
245         assertFalse(range1.isBeforeRange(of(15, 25)));
246 
247         assertTrue(range1.isBeforeRange(of(21, 25)));
248 
249         assertFalse(range1.isBeforeRange(of(10, 20)));
250     }
251 
252     @Test
253     void testIsBeforeRange() {
254         assertFalse(range1.isBeforeRange(null));
255 
256         assertFalse(range1.isBeforeRange(Range.of(5, 9)));
257 
258         assertFalse(range1.isBeforeRange(Range.of(5, 10)));
259         assertFalse(range1.isBeforeRange(Range.of(5, 20)));
260         assertFalse(range1.isBeforeRange(Range.of(5, 25)));
261         assertFalse(range1.isBeforeRange(Range.of(15, 25)));
262 
263         assertTrue(range1.isBeforeRange(Range.of(21, 25)));
264 
265         assertFalse(range1.isBeforeRange(Range.of(10, 20)));
266     }
267 
268     @Test
269     void testIsEndedBy() {
270         assertFalse(range1.isEndedBy(null));
271 
272         assertFalse(range1.isEndedBy(5));
273         assertFalse(range1.isEndedBy(10));
274         assertFalse(range1.isEndedBy(15));
275         assertTrue(range1.isEndedBy(20));
276         assertFalse(range1.isEndedBy(25));
277     }
278 
279     @Test
280     void testIsOverlappedByIntegerRange() {
281 
282         // null handling
283         assertFalse(range1.isOverlappedBy(null));
284 
285         // easy inside range
286         assertTrue(range1.isOverlappedBy(of(12, 18)));
287 
288         // outside range on each side
289         assertFalse(range1.isOverlappedBy(of(32, 45)));
290         assertFalse(range1.isOverlappedBy(of(2, 8)));
291 
292         // equals range
293         assertTrue(range1.isOverlappedBy(of(10, 20)));
294 
295         // overlaps
296         assertTrue(range1.isOverlappedBy(of(9, 14)));
297         assertTrue(range1.isOverlappedBy(of(16, 21)));
298 
299         // touches lower boundary
300         assertTrue(range1.isOverlappedBy(of(10, 19)));
301         assertTrue(range1.isOverlappedBy(of(10, 21)));
302 
303         // touches upper boundary
304         assertTrue(range1.isOverlappedBy(of(11, 20)));
305         assertTrue(range1.isOverlappedBy(of(9, 20)));
306 
307         // negative
308         assertFalse(range1.isOverlappedBy(of(-11, -18)));
309 
310         // outside range whole range
311         assertTrue(range1.isOverlappedBy(of(9, 21)));
312     }
313 
314     @Test
315     void testIsOverlappedByRange() {
316 
317         // null handling
318         assertFalse(range1.isOverlappedBy(null));
319 
320         // easy inside range
321         assertTrue(range1.isOverlappedBy(Range.of(12, 18)));
322 
323         // outside range on each side
324         assertFalse(range1.isOverlappedBy(Range.of(32, 45)));
325         assertFalse(range1.isOverlappedBy(Range.of(2, 8)));
326 
327         // equals range
328         assertTrue(range1.isOverlappedBy(Range.of(10, 20)));
329 
330         // overlaps
331         assertTrue(range1.isOverlappedBy(Range.of(9, 14)));
332         assertTrue(range1.isOverlappedBy(Range.of(16, 21)));
333 
334         // touches lower boundary
335         assertTrue(range1.isOverlappedBy(Range.of(10, 19)));
336         assertTrue(range1.isOverlappedBy(Range.of(10, 21)));
337 
338         // touches upper boundary
339         assertTrue(range1.isOverlappedBy(Range.of(11, 20)));
340         assertTrue(range1.isOverlappedBy(Range.of(9, 20)));
341 
342         // negative
343         assertFalse(range1.isOverlappedBy(Range.of(-11, -18)));
344 
345         // outside range whole range
346         assertTrue(range1.isOverlappedBy(Range.of(9, 21)));
347     }
348 
349     @Test
350     void testIsStartedBy() {
351         assertFalse(range1.isStartedBy(null));
352 
353         assertFalse(range1.isStartedBy(5));
354         assertTrue(range1.isStartedBy(10));
355         assertFalse(range1.isStartedBy(15));
356         assertFalse(range1.isStartedBy(20));
357         assertFalse(range1.isStartedBy(25));
358     }
359 
360     @Test
361     void testIsWithCompareRange() {
362         // all integers are equal
363         final Comparator<Integer> c = (o1, o2) -> 0;
364         Range<Integer> ri = Range.is(10);
365         assertFalse(ri.contains(null), "should not contain null");
366         assertTrue(ri.contains(10), "should contain 10");
367         assertFalse(ri.contains(11), "should not contain 11");
368         ri = Range.is(10, c);
369         assertFalse(ri.contains(null), "should not contain null");
370         assertTrue(ri.contains(10), "should contain 10");
371         assertTrue(ri.contains(11), "should contain 11");
372     }
373 
374     @Test
375     void testOfWithContains() {
376         // all integers are equal
377         final IntegerRange rb = of(-10, 20);
378         assertFalse(rb.contains(null), "should not contain null");
379         assertTrue(rb.contains(10), "should contain 10");
380         assertTrue(rb.contains(-10), "should contain -10");
381         assertFalse(rb.contains(21), "should not contain 21");
382         assertFalse(rb.contains(-11), "should not contain -11");
383 
384         assertNullPointerException(() -> of(null, null));
385     }
386 
387     @Test
388     void testRangeOfChars() {
389         final IntegerRange chars = of('a', 'z');
390         assertTrue(chars.contains((int) 'b'));
391         assertFalse(chars.contains((int) 'B'));
392     }
393 
394     @Test
395     void testSerializing() {
396         SerializationUtils.clone(range1);
397     }
398 
399     @Test
400     void testToIntStream() {
401         try (IntStream stream = range1.toIntStream()) {
402             assertEquals(165, stream.sum());
403         }
404     }
405 
406     @Test
407     void testToString() {
408         assertNotNull(range1.toString());
409 
410         final String str = range1.toString();
411         assertEquals("[10..20]", str);
412         assertEquals("[-20..-10]", Range.of(-20, -10).toString());
413     }
414 
415     @Test
416     void testToStringFormat() {
417         final String str = range1.toString("From %1$s to %2$s");
418         assertEquals("From 10 to 20", str);
419     }
420 }