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