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