• 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 LongRange}.
35  */
36 @SuppressWarnings("boxing")
37 public class LongRangeTest extends AbstractLangTest {
38 
of(final int min, final int max)39     private static LongRange of(final int min, final int max) {
40         return LongRange.of(min, max);
41     }
42 
of(final Long min, final Long max)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
setUp()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
testContainsInt()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
testContainsLong()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
testContainsRange()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
testElementCompareTo()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
testEqualsObject()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
testFit()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
testFitNull()169     public void testFitNull() {
170         assertThrows(NullPointerException.class, () -> {
171             range1.fit(null);
172         });
173     }
174 
175     @Test
testGetMaximum()176     public void testGetMaximum() {
177         assertEquals(20, range1.getMaximum());
178     }
179 
180     @Test
testGetMinimum()181     public void testGetMinimum() {
182         assertEquals(10, range1.getMinimum());
183     }
184 
185     @Test
testHashCode()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
testIntersectionWith()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
testIntersectionWithNonOverlapping()202     public void testIntersectionWithNonOverlapping() {
203         assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(Range.of(0L, 9L)));
204     }
205 
206     @Test
testIntersectionWithNull()207     public void testIntersectionWithNull() {
208         assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(null));
209     }
210 
211     @Test
testIsAfter()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
testIsAfterRange()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
testIsBefore()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
testIsBeforeIntegerRange()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
testIsBeforeRange()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
testIsEndedBy()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
testIsOverlappedByIntegerRange()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
testIsOverlappedByRange()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
testIsStartedBy()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
testIsWithCompareRange()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
testOfWithContains()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
testRangeOfChars()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
testSerializing()408     public void testSerializing() {
409         SerializationUtils.clone(range1);
410     }
411 
412     @Test
testToString()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
testToStringFormat()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 }
427