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