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