Add NumberRange, DoubleRange, IntegerRange, LongRange.

Fix changes.xml

4 files changed, 1291 insertions, 14 deletions

diff --git a/src/test/java/org/apache/commons/lang3/DoubleRangeTest.java b/src/test/java/org/apache/commons/lang3/DoubleRangeTest.java
new file mode 100644
index 000000000..75b9ab66a
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/DoubleRangeTest.java
@@ -0,0 +1,412 @@
+/*
+ * 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
+ *
+ *      http://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.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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Comparator;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link DoubleRange}.
+ */
+@SuppressWarnings("boxing")
+public class DoubleRangeTest extends AbstractLangTest {
+
+    private static DoubleRange of(final double min, final double max) {
+        return DoubleRange.of(min, max);
+    }
+
+    private static DoubleRange of(final Double min, final Double max) {
+        return DoubleRange.of(min, max);
+    }
+
+    private DoubleRange range1;
+
+    private DoubleRange range2;
+
+    private DoubleRange range3;
+
+    private DoubleRange rangeFull;
+
+    @BeforeEach
+    public void setUp() {
+        range1 = of(10, 20);
+        range2 = of(10, 20);
+        range3 = of(-2, -1);
+        rangeFull = of(Double.MIN_VALUE, Double.MAX_VALUE);
+    }
+
+    @Test
+    public void testContainsInt() {
+        assertFalse(range1.contains(null));
+
+        assertTrue(rangeFull.contains(Double.MIN_VALUE));
+        assertTrue(rangeFull.contains(Double.MAX_VALUE));
+
+        assertFalse(range1.contains(5d));
+        assertTrue(range1.contains(10d));
+        assertTrue(range1.contains(15d));
+        assertTrue(range1.contains(20d));
+        assertFalse(range1.contains(25d));
+    }
+
+    @Test
+    public void testContainsRange() {
+
+        // null handling
+        assertFalse(range1.containsRange(null));
+
+        // easy inside range
+        assertTrue(range1.containsRange(Range.of(12d, 18d)));
+        assertTrue(range1.containsRange(of(12, 18)));
+
+        // outside range on each side
+        assertFalse(range1.containsRange(Range.of(32d, 45d)));
+        assertFalse(range1.containsRange(of(32, 45)));
+        assertFalse(range1.containsRange(Range.of(2d, 8d)));
+        assertFalse(range1.containsRange(of(2, 8)));
+
+        // equals range
+        assertTrue(range1.containsRange(Range.of(10d, 20d)));
+        assertTrue(range1.containsRange(of(10, 20)));
+
+        // overlaps
+        assertFalse(range1.containsRange(Range.of(9d, 14d)));
+        assertFalse(range1.containsRange(of(9, 14)));
+        assertFalse(range1.containsRange(Range.of(16d, 21d)));
+        assertFalse(range1.containsRange(of(16, 21)));
+
+        // touches lower boundary
+        assertTrue(range1.containsRange(Range.of(10d, 19d)));
+        assertTrue(range1.containsRange(of(10, 19)));
+        assertFalse(range1.containsRange(Range.of(10d, 21d)));
+        assertFalse(range1.containsRange(of(10, 21)));
+
+        // touches upper boundary
+        assertTrue(range1.containsRange(Range.of(11d, 20d)));
+        assertTrue(range1.containsRange(of(11, 20)));
+        assertFalse(range1.containsRange(Range.of(9d, 20d)));
+        assertFalse(range1.containsRange(of(9, 20)));
+
+        // negative
+        assertFalse(range1.containsRange(Range.of(-11d, -18d)));
+        assertFalse(range1.containsRange(of(-11, -18)));
+    }
+
+    @Test
+    public void testElementCompareTo() {
+        assertThrows(NullPointerException.class, () -> range1.elementCompareTo(null));
+
+        assertEquals(-1, range1.elementCompareTo(5d));
+        assertEquals(0, range1.elementCompareTo(10d));
+        assertEquals(0, range1.elementCompareTo(15d));
+        assertEquals(0, range1.elementCompareTo(20d));
+        assertEquals(1, range1.elementCompareTo(25d));
+    }
+
+    @Test
+    public 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
+    public void testFit() {
+        assertEquals(range1.getMinimum(), range1.fit(Double.MIN_VALUE));
+        assertEquals(range1.getMinimum(), range1.fit(range1.getMinimum()));
+        assertEquals(range1.getMaximum(), range1.fit(Double.MAX_VALUE));
+        assertEquals(range1.getMaximum(), range1.fit(range1.getMaximum()));
+        assertEquals(15, range1.fit(15d));
+    }
+
+    @Test
+    public void testFitNull() {
+        assertThrows(NullPointerException.class, () -> {
+            range1.fit(null);
+        });
+    }
+
+    @Test
+    public void testGetMaximum() {
+        assertEquals(20d, range1.getMaximum());
+    }
+
+    @Test
+    public void testGetMinimum() {
+        assertEquals(10d, range1.getMinimum());
+    }
+
+    @Test
+    public void testHashCode() {
+        assertEquals(range1.hashCode(), range2.hashCode());
+        assertNotEquals(range1.hashCode(), range3.hashCode());
+
+        assertEquals(range1.hashCode(), range1.hashCode());
+        assertTrue(range1.hashCode() != 0);
+    }
+
+    @Test
+    public void testIntersectionWith() {
+        assertSame(range1, range1.intersectionWith(range1));
+
+        assertEquals(Range.of(10d, 15d), range1.intersectionWith(Range.of(5d, 15d)));
+    }
+
+    @Test
+    public void testIntersectionWithNonOverlapping() {
+        assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(Range.of(0d, 9d)));
+    }
+
+    @Test
+    public void testIntersectionWithNull() {
+        assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(null));
+    }
+
+    @Test
+    public void testIsAfter() {
+        assertFalse(range1.isAfter(null));
+
+        assertTrue(range1.isAfter(5d));
+        assertFalse(range1.isAfter(10d));
+        assertFalse(range1.isAfter(15d));
+        assertFalse(range1.isAfter(20d));
+        assertFalse(range1.isAfter(25d));
+    }
+
+    @Test
+    public void testIsAfterRange() {
+        assertFalse(range1.isAfterRange(null));
+
+        assertTrue(range1.isAfterRange(Range.of(5d, 9d)));
+
+        assertFalse(range1.isAfterRange(Range.of(5d, 10d)));
+        assertFalse(range1.isAfterRange(Range.of(5d, 20d)));
+        assertFalse(range1.isAfterRange(Range.of(5d, 25d)));
+        assertFalse(range1.isAfterRange(Range.of(15d, 25d)));
+
+        assertFalse(range1.isAfterRange(Range.of(21d, 25d)));
+
+        assertFalse(range1.isAfterRange(Range.of(10d, 20d)));
+    }
+
+    @Test
+    public void testIsBefore() {
+        assertFalse(range1.isBefore(null));
+
+        assertFalse(range1.isBefore(5d));
+        assertFalse(range1.isBefore(10d));
+        assertFalse(range1.isBefore(15d));
+        assertFalse(range1.isBefore(20d));
+        assertTrue(range1.isBefore(25d));
+    }
+
+    @Test
+    public 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
+    public void testIsBeforeRange() {
+        assertFalse(range1.isBeforeRange(null));
+
+        assertFalse(range1.isBeforeRange(Range.of(5d, 9d)));
+
+        assertFalse(range1.isBeforeRange(Range.of(5d, 10d)));
+        assertFalse(range1.isBeforeRange(Range.of(5d, 20d)));
+        assertFalse(range1.isBeforeRange(Range.of(5d, 25d)));
+        assertFalse(range1.isBeforeRange(Range.of(15d, 25d)));
+
+        assertTrue(range1.isBeforeRange(Range.of(21d, 25d)));
+
+        assertFalse(range1.isBeforeRange(Range.of(10d, 20d)));
+    }
+
+    @Test
+    public void testIsEndedBy() {
+        assertFalse(range1.isEndedBy(null));
+
+        assertFalse(range1.isEndedBy(5d));
+        assertFalse(range1.isEndedBy(10d));
+        assertFalse(range1.isEndedBy(15d));
+        assertTrue(range1.isEndedBy(20d));
+        assertFalse(range1.isEndedBy(25d));
+    }
+
+    @Test
+    public 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
+    public void testIsOverlappedByRange() {
+
+        // null handling
+        assertFalse(range1.isOverlappedBy(null));
+
+        // easy inside range
+        assertTrue(range1.isOverlappedBy(Range.of(12d, 18d)));
+
+        // outside range on each side
+        assertFalse(range1.isOverlappedBy(Range.of(32d, 45d)));
+        assertFalse(range1.isOverlappedBy(Range.of(2d, 8d)));
+
+        // equals range
+        assertTrue(range1.isOverlappedBy(Range.of(10d, 20d)));
+
+        // overlaps
+        assertTrue(range1.isOverlappedBy(Range.of(9d, 14d)));
+        assertTrue(range1.isOverlappedBy(Range.of(16d, 21d)));
+
+        // touches lower boundary
+        assertTrue(range1.isOverlappedBy(Range.of(10d, 19d)));
+        assertTrue(range1.isOverlappedBy(Range.of(10d, 21d)));
+
+        // touches upper boundary
+        assertTrue(range1.isOverlappedBy(Range.of(11d, 20d)));
+        assertTrue(range1.isOverlappedBy(Range.of(9d, 20d)));
+
+        // negative
+        assertFalse(range1.isOverlappedBy(Range.of(-11d, -18d)));
+
+        // outside range whole range
+        assertTrue(range1.isOverlappedBy(Range.of(9d, 21d)));
+    }
+
+    @Test
+    public void testIsStartedBy() {
+        assertFalse(range1.isStartedBy(null));
+
+        assertFalse(range1.isStartedBy(5d));
+        assertTrue(range1.isStartedBy(10d));
+        assertFalse(range1.isStartedBy(15d));
+        assertFalse(range1.isStartedBy(20d));
+        assertFalse(range1.isStartedBy(25d));
+    }
+
+    @Test
+    public 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
+    public void testOfWithContains() {
+        // all integers are equal
+        final DoubleRange rb = of(-10, 20);
+        assertFalse(rb.contains(null), "should not contain null");
+        assertTrue(rb.contains(10d), "should contain 10");
+        assertTrue(rb.contains(-10d), "should contain -10");
+        assertFalse(rb.contains(21d), "should not contain 21");
+        assertFalse(rb.contains(-11d), "should not contain -11");
+
+        assertThrows(NullPointerException.class, () -> of(null, null));
+    }
+
+    @Test
+    public void testRangeOfChars() {
+        final DoubleRange chars = of('a', 'z');
+        assertTrue(chars.contains((double) 'b'));
+        assertFalse(chars.contains((double) 'B'));
+    }
+
+    @Test
+    public void testSerializing() {
+        SerializationUtils.clone(range1);
+    }
+
+    @Test
+    public void testToString() {
+        assertNotNull(range1.toString());
+
+        final String str = range1.toString();
+        assertEquals("[10.0..20.0]", str);
+        assertEquals("[-20.0..-10.0]", Range.of(-20d, -10d).toString());
+        assertEquals("[-20.0..-10.0]", DoubleRange.of(-20d, -10d).toString());
+    }
+
+    @Test
+    public void testToStringFormat() {
+        final String str = range1.toString("From %1$s to %2$s");
+        assertEquals("From 10.0 to 20.0", str);
+    }
+}
diff --git a/src/test/java/org/apache/commons/lang3/IntegerRangeTest.java b/src/test/java/org/apache/commons/lang3/IntegerRangeTest.java
new file mode 100644
index 000000000..7c894f298
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/IntegerRangeTest.java
@@ -0,0 +1,411 @@
+/*
+ * 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
+ *
+ *      http://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.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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Comparator;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link IntegerRange}.
+ */
+@SuppressWarnings("boxing")
+public class IntegerRangeTest extends AbstractLangTest {
+
+    private static IntegerRange of(final int min, final int max) {
+        return IntegerRange.of(min, max);
+    }
+
+    private static IntegerRange of(final Integer min, final Integer max) {
+        return IntegerRange.of(min, max);
+    }
+
+    private IntegerRange range1;
+
+    private IntegerRange range2;
+
+    private IntegerRange range3;
+
+    private IntegerRange rangeFull;
+
+    @BeforeEach
+    public void setUp() {
+        range1 = of(10, 20);
+        range2 = of(10, 20);
+        range3 = of(-2, -1);
+        rangeFull = of(Integer.MIN_VALUE, Integer.MAX_VALUE);
+    }
+
+    @Test
+    public void testContainsInt() {
+        assertFalse(range1.contains(null));
+
+        assertTrue(rangeFull.contains(Integer.MIN_VALUE));
+        assertTrue(rangeFull.contains(Integer.MAX_VALUE));
+
+        assertFalse(range1.contains(5));
+        assertTrue(range1.contains(10));
+        assertTrue(range1.contains(15));
+        assertTrue(range1.contains(20));
+        assertFalse(range1.contains(25));
+    }
+
+    @Test
+    public void testContainsRange() {
+
+        // null handling
+        assertFalse(range1.containsRange(null));
+
+        // easy inside range
+        assertTrue(range1.containsRange(Range.of(12, 18)));
+        assertTrue(range1.containsRange(of(12, 18)));
+
+        // outside range on each side
+        assertFalse(range1.containsRange(Range.of(32, 45)));
+        assertFalse(range1.containsRange(of(32, 45)));
+        assertFalse(range1.containsRange(Range.of(2, 8)));
+        assertFalse(range1.containsRange(of(2, 8)));
+
+        // equals range
+        assertTrue(range1.containsRange(Range.of(10, 20)));
+        assertTrue(range1.containsRange(of(10, 20)));
+
+        // overlaps
+        assertFalse(range1.containsRange(Range.of(9, 14)));
+        assertFalse(range1.containsRange(of(9, 14)));
+        assertFalse(range1.containsRange(Range.of(16, 21)));
+        assertFalse(range1.containsRange(of(16, 21)));
+
+        // touches lower boundary
+        assertTrue(range1.containsRange(Range.of(10, 19)));
+        assertTrue(range1.containsRange(of(10, 19)));
+        assertFalse(range1.containsRange(Range.of(10, 21)));
+        assertFalse(range1.containsRange(of(10, 21)));
+
+        // touches upper boundary
+        assertTrue(range1.containsRange(Range.of(11, 20)));
+        assertTrue(range1.containsRange(of(11, 20)));
+        assertFalse(range1.containsRange(Range.of(9, 20)));
+        assertFalse(range1.containsRange(of(9, 20)));
+
+        // negative
+        assertFalse(range1.containsRange(Range.of(-11, -18)));
+        assertFalse(range1.containsRange(of(-11, -18)));
+    }
+
+    @Test
+    public void testElementCompareTo() {
+        assertThrows(NullPointerException.class, () -> range1.elementCompareTo(null));
+
+        assertEquals(-1, range1.elementCompareTo(5));
+        assertEquals(0, range1.elementCompareTo(10));
+        assertEquals(0, range1.elementCompareTo(15));
+        assertEquals(0, range1.elementCompareTo(20));
+        assertEquals(1, range1.elementCompareTo(25));
+    }
+
+    @Test
+    public 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
+    public 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(15));
+    }
+
+    @Test
+    public void testFitNull() {
+        assertThrows(NullPointerException.class, () -> {
+            range1.fit(null);
+        });
+    }
+
+    @Test
+    public void testGetMaximum() {
+        assertEquals(20, (int) range1.getMaximum());
+    }
+
+    @Test
+    public void testGetMinimum() {
+        assertEquals(10, (int) range1.getMinimum());
+    }
+
+    @Test
+    public void testHashCode() {
+        assertEquals(range1.hashCode(), range2.hashCode());
+        assertNotEquals(range1.hashCode(), range3.hashCode());
+
+        assertEquals(range1.hashCode(), range1.hashCode());
+        assertTrue(range1.hashCode() != 0);
+    }
+
+    @Test
+    public void testIntersectionWith() {
+        assertSame(range1, range1.intersectionWith(range1));
+
+        assertEquals(Range.of(10, 15), range1.intersectionWith(Range.of(5, 15)));
+    }
+
+    @Test
+    public void testIntersectionWithNonOverlapping() {
+        assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(Range.of(0, 9)));
+    }
+
+    @Test
+    public void testIntersectionWithNull() {
+        assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(null));
+    }
+
+    @Test
+    public void testIsAfter() {
+        assertFalse(range1.isAfter(null));
+
+        assertTrue(range1.isAfter(5));
+        assertFalse(range1.isAfter(10));
+        assertFalse(range1.isAfter(15));
+        assertFalse(range1.isAfter(20));
+        assertFalse(range1.isAfter(25));
+    }
+
+    @Test
+    public void testIsAfterRange() {
+        assertFalse(range1.isAfterRange(null));
+
+        assertTrue(range1.isAfterRange(Range.of(5, 9)));
+
+        assertFalse(range1.isAfterRange(Range.of(5, 10)));
+        assertFalse(range1.isAfterRange(Range.of(5, 20)));
+        assertFalse(range1.isAfterRange(Range.of(5, 25)));
+        assertFalse(range1.isAfterRange(Range.of(15, 25)));
+
+        assertFalse(range1.isAfterRange(Range.of(21, 25)));
+
+        assertFalse(range1.isAfterRange(Range.of(10, 20)));
+    }
+
+    @Test
+    public void testIsBefore() {
+        assertFalse(range1.isBefore(null));
+
+        assertFalse(range1.isBefore(5));
+        assertFalse(range1.isBefore(10));
+        assertFalse(range1.isBefore(15));
+        assertFalse(range1.isBefore(20));
+        assertTrue(range1.isBefore(25));
+    }
+
+    @Test
+    public 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
+    public void testIsBeforeRange() {
+        assertFalse(range1.isBeforeRange(null));
+
+        assertFalse(range1.isBeforeRange(Range.of(5, 9)));
+
+        assertFalse(range1.isBeforeRange(Range.of(5, 10)));
+        assertFalse(range1.isBeforeRange(Range.of(5, 20)));
+        assertFalse(range1.isBeforeRange(Range.of(5, 25)));
+        assertFalse(range1.isBeforeRange(Range.of(15, 25)));
+
+        assertTrue(range1.isBeforeRange(Range.of(21, 25)));
+
+        assertFalse(range1.isBeforeRange(Range.of(10, 20)));
+    }
+
+    @Test
+    public void testIsEndedBy() {
+        assertFalse(range1.isEndedBy(null));
+
+        assertFalse(range1.isEndedBy(5));
+        assertFalse(range1.isEndedBy(10));
+        assertFalse(range1.isEndedBy(15));
+        assertTrue(range1.isEndedBy(20));
+        assertFalse(range1.isEndedBy(25));
+    }
+
+    @Test
+    public 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
+    public void testIsOverlappedByRange() {
+
+        // null handling
+        assertFalse(range1.isOverlappedBy(null));
+
+        // easy inside range
+        assertTrue(range1.isOverlappedBy(Range.of(12, 18)));
+
+        // outside range on each side
+        assertFalse(range1.isOverlappedBy(Range.of(32, 45)));
+        assertFalse(range1.isOverlappedBy(Range.of(2, 8)));
+
+        // equals range
+        assertTrue(range1.isOverlappedBy(Range.of(10, 20)));
+
+        // overlaps
+        assertTrue(range1.isOverlappedBy(Range.of(9, 14)));
+        assertTrue(range1.isOverlappedBy(Range.of(16, 21)));
+
+        // touches lower boundary
+        assertTrue(range1.isOverlappedBy(Range.of(10, 19)));
+        assertTrue(range1.isOverlappedBy(Range.of(10, 21)));
+
+        // touches upper boundary
+        assertTrue(range1.isOverlappedBy(Range.of(11, 20)));
+        assertTrue(range1.isOverlappedBy(Range.of(9, 20)));
+
+        // negative
+        assertFalse(range1.isOverlappedBy(Range.of(-11, -18)));
+
+        // outside range whole range
+        assertTrue(range1.isOverlappedBy(Range.of(9, 21)));
+    }
+
+    @Test
+    public void testIsStartedBy() {
+        assertFalse(range1.isStartedBy(null));
+
+        assertFalse(range1.isStartedBy(5));
+        assertTrue(range1.isStartedBy(10));
+        assertFalse(range1.isStartedBy(15));
+        assertFalse(range1.isStartedBy(20));
+        assertFalse(range1.isStartedBy(25));
+    }
+
+    @Test
+    public 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
+    public void testOfWithContains() {
+        // all integers are equal
+        final IntegerRange rb = of(-10, 20);
+        assertFalse(rb.contains(null), "should not contain null");
+        assertTrue(rb.contains(10), "should contain 10");
+        assertTrue(rb.contains(-10), "should contain -10");
+        assertFalse(rb.contains(21), "should not contain 21");
+        assertFalse(rb.contains(-11), "should not contain -11");
+
+        assertThrows(NullPointerException.class, () -> of(null, null));
+    }
+
+    @Test
+    public void testRangeOfChars() {
+        final IntegerRange chars = of('a', 'z');
+        assertTrue(chars.contains((int) 'b'));
+        assertFalse(chars.contains((int) 'B'));
+    }
+
+    @Test
+    public void testSerializing() {
+        SerializationUtils.clone(range1);
+    }
+
+    @Test
+    public void testToString() {
+        assertNotNull(range1.toString());
+
+        final String str = range1.toString();
+        assertEquals("[10..20]", str);
+        assertEquals("[-20..-10]", Range.of(-20, -10).toString());
+    }
+
+    @Test
+    public void testToStringFormat() {
+        final String str = range1.toString("From %1$s to %2$s");
+        assertEquals("From 10 to 20", str);
+    }
+}
diff --git a/src/test/java/org/apache/commons/lang3/LongRangeTest.java b/src/test/java/org/apache/commons/lang3/LongRangeTest.java
new file mode 100644
index 000000000..290ce8a00
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/LongRangeTest.java
@@ -0,0 +1,426 @@
+/*
+ * 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
+ *
+ *      http://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.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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Comparator;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link LongRange}.
+ */
+@SuppressWarnings("boxing")
+public 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
+    public 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
+    public 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
+    public 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
+    public void testElementCompareTo() {
+        assertThrows(NullPointerException.class, () -> 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
+    public 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
+    public void testFit() {
+        assertEquals(range1.getMinimum(), range1.fit((long) Integer.MIN_VALUE));
+        assertEquals(range1.getMinimum(), range1.fit(range1.getMinimum()));
+        assertEquals(range1.getMaximum(), range1.fit((long) Integer.MAX_VALUE));
+        assertEquals(range1.getMaximum(), range1.fit(range1.getMaximum()));
+        assertEquals(15, range1.fit(15L));
+    }
+
+    @Test
+    public void testFitNull() {
+        assertThrows(NullPointerException.class, () -> {
+            range1.fit(null);
+        });
+    }
+
+    @Test
+    public void testGetMaximum() {
+        assertEquals(20, range1.getMaximum());
+    }
+
+    @Test
+    public void testGetMinimum() {
+        assertEquals(10, range1.getMinimum());
+    }
+
+    @Test
+    public void testHashCode() {
+        assertEquals(range1.hashCode(), range2.hashCode());
+        assertNotEquals(range1.hashCode(), range3.hashCode());
+
+        assertEquals(range1.hashCode(), range1.hashCode());
+        assertTrue(range1.hashCode() != 0);
+    }
+
+    @Test
+    public void testIntersectionWith() {
+        assertSame(range1, range1.intersectionWith(range1));
+
+        assertEquals(Range.of(10L, 15L), range1.intersectionWith(Range.of(5L, 15L)));
+    }
+
+    @Test
+    public void testIntersectionWithNonOverlapping() {
+        assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(Range.of(0L, 9L)));
+    }
+
+    @Test
+    public void testIntersectionWithNull() {
+        assertThrows(IllegalArgumentException.class, () -> range1.intersectionWith(null));
+    }
+
+    @Test
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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
+    public 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");
+
+        assertThrows(NullPointerException.class, () -> of(null, null));
+    }
+
+    @Test
+    public void testRangeOfChars() {
+        final LongRange chars = of((long) 'a', (long) 'z');
+        assertTrue(chars.contains((long) 'b'));
+        assertFalse(chars.contains((long) 'B'));
+    }
+
+    @Test
+    public void testSerializing() {
+        SerializationUtils.clone(range1);
+    }
+
+    @Test
+    public void testToString() {
+        assertNotNull(range1.toString());
+
+        final String str = range1.toString();
+        assertEquals("[10..20]", str);
+        assertEquals("[-20..-10]", Range.of(-20, -10).toString());
+    }
+
+    @Test
+    public void testToStringFormat() {
+        final String str = range1.toString("From %1$s to %2$s");
+        assertEquals("From 10 to 20", str);
+    }
+}
diff --git a/src/test/java/org/apache/commons/lang3/RangeTest.java b/src/test/java/org/apache/commons/lang3/RangeTest.java
index 4ed18cdf4..8b477c354 100644
--- a/src/test/java/org/apache/commons/lang3/RangeTest.java
+++ b/src/test/java/org/apache/commons/lang3/RangeTest.java
@@ -53,23 +53,20 @@ public class RangeTest extends AbstractLangTest {
     private Range<Byte> byteRange2;
     private Range<Byte> byteRange3;
     private Range<Double> doubleRange;
-
     private Range<Float> floatRange;
-
     private Range<Integer> intRange;
-
     private Range<Long> longRange;
 
     @BeforeEach
     public void setUp() {
-        byteRange = Range.between((byte) 0, (byte) 5);
-        byteRange2 = Range.between((byte) 0, (byte) 5);
-        byteRange3 = Range.between((byte) 0, (byte) 10);
-
-        intRange = Range.between(10, 20);
-        longRange = Range.between(10L, 20L);
-        floatRange = Range.between((float) 10, (float) 20);
-        doubleRange = Range.between((double) 10, (double) 20);
+        byteRange = Range.of((byte) 0, (byte) 5);
+        byteRange2 = Range.of((byte) 0, (byte) 5);
+        byteRange3 = Range.of((byte) 0, (byte) 10);
+
+        intRange = Range.of(10, 20);
+        longRange = Range.of(10L, 20L);
+        floatRange = Range.of((float) 10, (float) 20);
+        doubleRange = Range.of((double) 10, (double) 20);
     }
 
     @Test
@@ -102,9 +99,40 @@ public class RangeTest extends AbstractLangTest {
         assertFalse(rbstr.contains("houses"), "should not contain houses");
         assertFalse(rbstr.contains(""), "should not contain ''");
 
-        assertThrows(
-                IllegalArgumentException.class,
-                () -> Range.between(null, null, lengthComp));
+        assertThrows(NullPointerException.class, () -> Range.between(null, null, lengthComp));
+    }
+
+    @Test
+    public void testOfWithCompare() {
+        // all integers are equal
+        final Comparator<Integer> c = (o1, o2) -> 0;
+        final Comparator<String> lengthComp = Comparator.comparingInt(String::length);
+        Range<Integer> rb = Range.of(-10, 20);
+        assertFalse(rb.contains(null), "should not contain null");
+        assertTrue(rb.contains(10), "should contain 10");
+        assertTrue(rb.contains(-10), "should contain -10");
+        assertFalse(rb.contains(21), "should not contain 21");
+        assertFalse(rb.contains(-11), "should not contain -11");
+        rb = Range.of(-10, 20, c);
+        assertFalse(rb.contains(null), "should not contain null");
+        assertTrue(rb.contains(10), "should contain 10");
+        assertTrue(rb.contains(-10), "should contain -10");
+        assertTrue(rb.contains(21), "should contain 21");
+        assertTrue(rb.contains(-11), "should contain -11");
+        Range<String> rbstr = Range.of("house", "i");
+        assertFalse(rbstr.contains(null), "should not contain null");
+        assertTrue(rbstr.contains("house"), "should contain house");
+        assertTrue(rbstr.contains("i"), "should contain i");
+        assertFalse(rbstr.contains("hose"), "should not contain hose");
+        assertFalse(rbstr.contains("ice"), "should not contain ice");
+        rbstr = Range.of("house", "i", lengthComp);
+        assertFalse(rbstr.contains(null), "should not contain null");
+        assertTrue(rbstr.contains("house"), "should contain house");
+        assertTrue(rbstr.contains("i"), "should contain i");
+        assertFalse(rbstr.contains("houses"), "should not contain houses");
+        assertFalse(rbstr.contains(""), "should not contain ''");
+
+        assertThrows(NullPointerException.class, () -> Range.of(null, null, lengthComp));
     }
 
     @SuppressWarnings({"rawtypes", "unchecked"})