| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.commons.lang3; |
| |
| import static org.apache.commons.lang3.LangAssertions.assertIllegalArgumentException; |
| import static org.apache.commons.lang3.LangAssertions.assertNullPointerException; |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertFalse; |
| import static org.junit.jupiter.api.Assertions.assertNotEquals; |
| import static org.junit.jupiter.api.Assertions.assertNotNull; |
| import static org.junit.jupiter.api.Assertions.assertSame; |
| import static org.junit.jupiter.api.Assertions.assertTrue; |
| |
| import java.util.Comparator; |
| import java.util.stream.LongStream; |
| |
| import org.junit.jupiter.api.BeforeEach; |
| import org.junit.jupiter.api.Test; |
| |
| /** |
| * Tests {@link LongRange}. |
| */ |
| @SuppressWarnings("boxing") |
| class LongRangeTest extends AbstractLangTest { |
| |
| private static LongRange of(final int min, final int max) { |
| return LongRange.of(min, max); |
| } |
| |
| private static LongRange of(final Long min, final Long max) { |
| return LongRange.of(min, max); |
| } |
| |
| private LongRange range1; |
| |
| private LongRange range2; |
| |
| private LongRange range3; |
| |
| private LongRange rangeFull; |
| |
| @BeforeEach |
| public void setUp() { |
| range1 = of(10, 20); |
| range2 = of(10, 20); |
| range3 = of(-2, -1); |
| rangeFull = of(Long.MIN_VALUE, Long.MAX_VALUE); |
| } |
| |
| @Test |
| void testContainsInt() { |
| assertFalse(range1.contains(null)); |
| |
| assertFalse(range1.contains(5L)); |
| assertTrue(range1.contains(10L)); |
| assertTrue(range1.contains(15L)); |
| assertTrue(range1.contains(20L)); |
| assertFalse(range1.contains(25L)); |
| } |
| |
| @Test |
| void testContainsLong() { |
| assertFalse(range1.contains(null)); |
| |
| assertTrue(rangeFull.contains(Long.MAX_VALUE)); |
| assertTrue(rangeFull.contains(Long.MIN_VALUE)); |
| assertTrue(rangeFull.contains((long) Integer.MAX_VALUE + 1)); |
| assertTrue(rangeFull.contains((long) Integer.MIN_VALUE - 1)); |
| assertTrue(rangeFull.contains((long) Integer.MAX_VALUE)); |
| assertTrue(rangeFull.contains((long) Integer.MIN_VALUE)); |
| |
| assertFalse(range1.contains(5L)); |
| assertTrue(range1.contains(10L)); |
| assertTrue(range1.contains(15L)); |
| assertTrue(range1.contains(20L)); |
| assertFalse(range1.contains(25L)); |
| } |
| |
| @Test |
| void testContainsRange() { |
| |
| // null handling |
| assertFalse(range1.containsRange(null)); |
| |
| // easy inside range |
| assertTrue(range1.containsRange(Range.of(12L, 18L))); |
| assertTrue(range1.containsRange(of(12, 18))); |
| |
| // outside range on each side |
| assertFalse(range1.containsRange(Range.of(32L, 45L))); |
| assertFalse(range1.containsRange(of(32, 45))); |
| assertFalse(range1.containsRange(Range.of(2L, 8L))); |
| assertFalse(range1.containsRange(of(2, 8))); |
| |
| // equals range |
| assertTrue(range1.containsRange(Range.of(10L, 20L))); |
| assertTrue(range1.containsRange(of(10, 20))); |
| |
| // overlaps |
| assertFalse(range1.containsRange(Range.of(9L, 14L))); |
| assertFalse(range1.containsRange(of(9, 14))); |
| assertFalse(range1.containsRange(Range.of(16L, 21L))); |
| assertFalse(range1.containsRange(of(16, 21))); |
| |
| // touches lower boundary |
| assertTrue(range1.containsRange(Range.of(10L, 19L))); |
| assertTrue(range1.containsRange(of(10, 19))); |
| assertFalse(range1.containsRange(Range.of(10L, 21L))); |
| assertFalse(range1.containsRange(of(10, 21))); |
| |
| // touches upper boundary |
| assertTrue(range1.containsRange(Range.of(11L, 20L))); |
| assertTrue(range1.containsRange(of(11, 20))); |
| assertFalse(range1.containsRange(Range.of(9L, 20L))); |
| assertFalse(range1.containsRange(of(9, 20))); |
| |
| // negative |
| assertFalse(range1.containsRange(Range.of(-11L, -18L))); |
| assertFalse(range1.containsRange(of(-11, -18))); |
| } |
| |
| @Test |
| void testElementCompareTo() { |
| assertNullPointerException(() -> range1.elementCompareTo(null)); |
| |
| assertEquals(-1, range1.elementCompareTo(5L)); |
| assertEquals(0, range1.elementCompareTo(10L)); |
| assertEquals(0, range1.elementCompareTo(15L)); |
| assertEquals(0, range1.elementCompareTo(20L)); |
| assertEquals(1, range1.elementCompareTo(25L)); |
| } |
| |
| @Test |
| void testEqualsObject() { |
| assertEquals(range1, range1); |
| assertEquals(range1, range2); |
| assertEquals(range2, range2); |
| assertEquals(range1, range1); |
| assertEquals(range2, range2); |
| assertEquals(range3, range3); |
| assertNotEquals(range2, range3); |
| assertNotEquals(null, range2); |
| assertNotEquals("Ni!", range2); |
| } |
| |
| @Test |
| void testFit() { |
| assertEquals(range1.getMinimum(), range1.fit(Integer.MIN_VALUE)); |
| assertEquals(range1.getMinimum(), range1.fit(range1.getMinimum())); |
| assertEquals(range1.getMaximum(), range1.fit(Integer.MAX_VALUE)); |
| assertEquals(range1.getMaximum(), range1.fit(range1.getMaximum())); |
| assertEquals(15, range1.fit(15L)); |
| } |
| |
| @Test |
| void testFitNull() { |
| assertNullPointerException(() -> { |
| range1.fit(null); |
| }); |
| } |
| |
| @Test |
| void testGetMaximum() { |
| assertEquals(20, range1.getMaximum()); |
| } |
| |
| @Test |
| void testGetMinimum() { |
| assertEquals(10, range1.getMinimum()); |
| } |
| |
| @Test |
| void testHashCode() { |
| assertEquals(range1.hashCode(), range2.hashCode()); |
| assertNotEquals(range1.hashCode(), range3.hashCode()); |
| |
| assertEquals(range1.hashCode(), range1.hashCode()); |
| assertTrue(range1.hashCode() != 0); |
| } |
| |
| @Test |
| void testIntersectionWith() { |
| assertSame(range1, range1.intersectionWith(range1)); |
| |
| assertEquals(Range.of(10L, 15L), range1.intersectionWith(Range.of(5L, 15L))); |
| } |
| |
| @Test |
| void testIntersectionWithNonOverlapping() { |
| assertIllegalArgumentException(() -> range1.intersectionWith(Range.of(0L, 9L))); |
| } |
| |
| @Test |
| void testIntersectionWithNull() { |
| assertIllegalArgumentException(() -> range1.intersectionWith(null)); |
| } |
| |
| @Test |
| void testIsAfter() { |
| assertFalse(range1.isAfter(null)); |
| |
| assertTrue(range1.isAfter(5L)); |
| assertFalse(range1.isAfter(10L)); |
| assertFalse(range1.isAfter(15L)); |
| assertFalse(range1.isAfter(20L)); |
| assertFalse(range1.isAfter(25L)); |
| } |
| |
| @Test |
| void testIsAfterRange() { |
| assertFalse(range1.isAfterRange(null)); |
| |
| assertTrue(range1.isAfterRange(Range.of(5L, 9L))); |
| |
| assertFalse(range1.isAfterRange(Range.of(5L, 10L))); |
| assertFalse(range1.isAfterRange(Range.of(5L, 20L))); |
| assertFalse(range1.isAfterRange(Range.of(5L, 25L))); |
| assertFalse(range1.isAfterRange(Range.of(15L, 25L))); |
| |
| assertFalse(range1.isAfterRange(Range.of(21L, 25L))); |
| |
| assertFalse(range1.isAfterRange(Range.of(10L, 20L))); |
| } |
| |
| @Test |
| void testIsBefore() { |
| assertFalse(range1.isBefore(null)); |
| |
| assertFalse(range1.isBefore(5L)); |
| assertFalse(range1.isBefore(10L)); |
| assertFalse(range1.isBefore(15L)); |
| assertFalse(range1.isBefore(20L)); |
| assertTrue(range1.isBefore(25L)); |
| } |
| |
| @Test |
| void testIsBeforeIntegerRange() { |
| assertFalse(range1.isBeforeRange(null)); |
| |
| assertFalse(range1.isBeforeRange(of(5, 9))); |
| |
| assertFalse(range1.isBeforeRange(of(5, 10))); |
| assertFalse(range1.isBeforeRange(of(5, 20))); |
| assertFalse(range1.isBeforeRange(of(5, 25))); |
| assertFalse(range1.isBeforeRange(of(15, 25))); |
| |
| assertTrue(range1.isBeforeRange(of(21, 25))); |
| |
| assertFalse(range1.isBeforeRange(of(10, 20))); |
| } |
| |
| @Test |
| void testIsBeforeRange() { |
| assertFalse(range1.isBeforeRange(null)); |
| |
| assertFalse(range1.isBeforeRange(Range.of(5L, 9L))); |
| |
| assertFalse(range1.isBeforeRange(Range.of(5L, 10L))); |
| assertFalse(range1.isBeforeRange(Range.of(5L, 20L))); |
| assertFalse(range1.isBeforeRange(Range.of(5L, 25L))); |
| assertFalse(range1.isBeforeRange(Range.of(15L, 25L))); |
| |
| assertTrue(range1.isBeforeRange(Range.of(21L, 25L))); |
| |
| assertFalse(range1.isBeforeRange(Range.of(10L, 20L))); |
| } |
| |
| @Test |
| void testIsEndedBy() { |
| assertFalse(range1.isEndedBy(null)); |
| |
| assertFalse(range1.isEndedBy(5L)); |
| assertFalse(range1.isEndedBy(10L)); |
| assertFalse(range1.isEndedBy(15L)); |
| assertTrue(range1.isEndedBy(20L)); |
| assertFalse(range1.isEndedBy(25L)); |
| } |
| |
| @Test |
| void testIsOverlappedByIntegerRange() { |
| |
| // null handling |
| assertFalse(range1.isOverlappedBy(null)); |
| |
| // easy inside range |
| assertTrue(range1.isOverlappedBy(of(12, 18))); |
| |
| // outside range on each side |
| assertFalse(range1.isOverlappedBy(of(32, 45))); |
| assertFalse(range1.isOverlappedBy(of(2, 8))); |
| |
| // equals range |
| assertTrue(range1.isOverlappedBy(of(10, 20))); |
| |
| // overlaps |
| assertTrue(range1.isOverlappedBy(of(9, 14))); |
| assertTrue(range1.isOverlappedBy(of(16, 21))); |
| |
| // touches lower boundary |
| assertTrue(range1.isOverlappedBy(of(10, 19))); |
| assertTrue(range1.isOverlappedBy(of(10, 21))); |
| |
| // touches upper boundary |
| assertTrue(range1.isOverlappedBy(of(11, 20))); |
| assertTrue(range1.isOverlappedBy(of(9, 20))); |
| |
| // negative |
| assertFalse(range1.isOverlappedBy(of(-11, -18))); |
| |
| // outside range whole range |
| assertTrue(range1.isOverlappedBy(of(9, 21))); |
| } |
| |
| @Test |
| void testIsOverlappedByRange() { |
| |
| // null handling |
| assertFalse(range1.isOverlappedBy(null)); |
| |
| // easy inside range |
| assertTrue(range1.isOverlappedBy(Range.of(12L, 18L))); |
| |
| // outside range on each side |
| assertFalse(range1.isOverlappedBy(Range.of(32L, 45L))); |
| assertFalse(range1.isOverlappedBy(Range.of(2L, 8L))); |
| |
| // equals range |
| assertTrue(range1.isOverlappedBy(Range.of(10L, 20L))); |
| |
| // overlaps |
| assertTrue(range1.isOverlappedBy(Range.of(9L, 14L))); |
| assertTrue(range1.isOverlappedBy(Range.of(16L, 21L))); |
| |
| // touches lower boundary |
| assertTrue(range1.isOverlappedBy(Range.of(10L, 19L))); |
| assertTrue(range1.isOverlappedBy(Range.of(10L, 21L))); |
| |
| // touches upper boundary |
| assertTrue(range1.isOverlappedBy(Range.of(11L, 20L))); |
| assertTrue(range1.isOverlappedBy(Range.of(9L, 20L))); |
| |
| // negative |
| assertFalse(range1.isOverlappedBy(Range.of(-11L, -18L))); |
| |
| // outside range whole range |
| assertTrue(range1.isOverlappedBy(Range.of(9L, 21L))); |
| } |
| |
| @Test |
| void testIsStartedBy() { |
| assertFalse(range1.isStartedBy(null)); |
| |
| assertFalse(range1.isStartedBy(5L)); |
| assertTrue(range1.isStartedBy(10L)); |
| assertFalse(range1.isStartedBy(15L)); |
| assertFalse(range1.isStartedBy(20L)); |
| assertFalse(range1.isStartedBy(25L)); |
| } |
| |
| @Test |
| void testIsWithCompareRange() { |
| // all integers are equal |
| final Comparator<Integer> c = (o1, o2) -> 0; |
| Range<Integer> ri = Range.is(10); |
| assertFalse(ri.contains(null), "should not contain null"); |
| assertTrue(ri.contains(10), "should contain 10"); |
| assertFalse(ri.contains(11), "should not contain 11"); |
| ri = Range.is(10, c); |
| assertFalse(ri.contains(null), "should not contain null"); |
| assertTrue(ri.contains(10), "should contain 10"); |
| assertTrue(ri.contains(11), "should contain 11"); |
| } |
| |
| @Test |
| void testOfWithContains() { |
| // all integers are equal |
| final LongRange rb = of(-10, 20); |
| assertFalse(rb.contains(null), "should not contain null"); |
| assertTrue(rb.contains(10L), "should contain 10"); |
| assertTrue(rb.contains(-10L), "should contain -10"); |
| assertFalse(rb.contains(21L), "should not contain 21"); |
| assertFalse(rb.contains(-11L), "should not contain -11"); |
| |
| assertNullPointerException(() -> of(null, null)); |
| } |
| |
| @Test |
| void testRangeOfChars() { |
| final LongRange chars = of((long) 'a', (long) 'z'); |
| assertTrue(chars.contains((long) 'b')); |
| assertFalse(chars.contains((long) 'B')); |
| } |
| |
| @Test |
| void testSerializing() { |
| SerializationUtils.clone(range1); |
| } |
| |
| @Test |
| void testToIntStream() { |
| try (LongStream stream = range1.toLongStream()) { |
| assertEquals(165, stream.sum()); |
| } |
| } |
| |
| @Test |
| void testToString() { |
| assertNotNull(range1.toString()); |
| |
| final String str = range1.toString(); |
| assertEquals("[10..20]", str); |
| assertEquals("[-20..-10]", Range.of(-20, -10).toString()); |
| } |
| |
| @Test |
| void testToStringFormat() { |
| final String str = range1.toString("From %1$s to %2$s"); |
| assertEquals("From 10 to 20", str); |
| } |
| } |
