This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new 2f38c4b Sort members.
2f38c4b is described below
commit 2f38c4b5a871bfa77a2f05e9a5859879eb7301bd
Author: Gary Gregory <gardgreg...@gmail.com>
AuthorDate: Wed Aug 21 22:47:13 2019 -0400
Sort members.
---
.../java/org/apache/commons/lang3/RangeTest.java | 311 ++++++++++-----------
1 file changed, 155 insertions(+), 156 deletions(-)
diff --git a/src/test/java/org/apache/commons/lang3/RangeTest.java
b/src/test/java/org/apache/commons/lang3/RangeTest.java
index fe229b9..4705115 100644
--- a/src/test/java/org/apache/commons/lang3/RangeTest.java
+++ b/src/test/java/org/apache/commons/lang3/RangeTest.java
@@ -42,12 +42,11 @@ public class RangeTest {
private Range<Byte> byteRange2;
private Range<Byte> byteRange3;
+ private Range<Double> doubleRange;
+ private Range<Float> floatRange;
private Range<Integer> intRange;
private Range<Long> longRange;
- private Range<Float> floatRange;
- private Range<Double> doubleRange;
- @SuppressWarnings("cast") // intRange
@BeforeEach
public void setUp() {
byteRange = Range.between((byte) 0, (byte) 5);
@@ -60,31 +59,6 @@ public class RangeTest {
doubleRange = Range.between((double) 10, (double) 20);
}
- // -----------------------------------------------------------------------
- @SuppressWarnings({ "rawtypes", "unchecked" })
- @Test
- public void testComparableConstructors() {
- final Comparable c = other -> 1;
- final Range r1 = Range.is(c);
- final Range r2 = Range.between(c, c);
- assertTrue(r1.isNaturalOrdering());
- assertTrue(r2.isNaturalOrdering());
- }
-
- @Test
- public void testIsWithCompare() {
- // 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 testBetweenWithCompare() {
// all integers are equal
@@ -117,11 +91,69 @@ public class RangeTest {
}
// -----------------------------------------------------------------------
+ @SuppressWarnings({ "rawtypes", "unchecked" })
@Test
- public void testRangeOfChars() {
- final Range<Character> chars = Range.between('a', 'z');
- assertTrue(chars.contains('b'));
- assertFalse(chars.contains('B'));
+ public void testComparableConstructors() {
+ final Comparable c = other -> 1;
+ final Range r1 = Range.is(c);
+ final Range r2 = Range.between(c, c);
+ assertTrue(r1.isNaturalOrdering());
+ assertTrue(r2.isNaturalOrdering());
+ }
+
+ @Test
+ public void testContains() {
+ assertFalse(intRange.contains(null));
+
+ assertFalse(intRange.contains(5));
+ assertTrue(intRange.contains(10));
+ assertTrue(intRange.contains(15));
+ assertTrue(intRange.contains(20));
+ assertFalse(intRange.contains(25));
+ }
+
+ // -----------------------------------------------------------------------
+ @Test
+ public void testContainsRange() {
+
+ // null handling
+ assertFalse(intRange.containsRange(null));
+
+ // easy inside range
+ assertTrue(intRange.containsRange(Range.between(12, 18)));
+
+ // outside range on each side
+ assertFalse(intRange.containsRange(Range.between(32, 45)));
+ assertFalse(intRange.containsRange(Range.between(2, 8)));
+
+ // equals range
+ assertTrue(intRange.containsRange(Range.between(10, 20)));
+
+ // overlaps
+ assertFalse(intRange.containsRange(Range.between(9, 14)));
+ assertFalse(intRange.containsRange(Range.between(16, 21)));
+
+ // touches lower boundary
+ assertTrue(intRange.containsRange(Range.between(10, 19)));
+ assertFalse(intRange.containsRange(Range.between(10, 21)));
+
+ // touches upper boundary
+ assertTrue(intRange.containsRange(Range.between(11, 20)));
+ assertFalse(intRange.containsRange(Range.between(9, 20)));
+
+ // negative
+ assertFalse(intRange.containsRange(Range.between(-11, -18)));
+ }
+
+ @Test
+ public void testElementCompareTo() {
+ assertThrows(NullPointerException.class, () ->
intRange.elementCompareTo(null));
+
+ assertEquals(-1, intRange.elementCompareTo(5));
+ assertEquals(0, intRange.elementCompareTo(10));
+ assertEquals(0, intRange.elementCompareTo(15));
+ assertEquals(0, intRange.elementCompareTo(20));
+ assertEquals(1, intRange.elementCompareTo(25));
}
// -----------------------------------------------------------------------
@@ -139,27 +171,11 @@ public class RangeTest {
}
@Test
- public void testHashCode() {
- assertEquals(byteRange.hashCode(), byteRange2.hashCode());
- assertNotEquals(byteRange.hashCode(), byteRange3.hashCode());
-
- assertEquals(intRange.hashCode(), intRange.hashCode());
- assertTrue(intRange.hashCode() != 0);
- }
-
- @Test
- public void testToString() {
- assertNotNull(byteRange.toString());
-
- final String str = intRange.toString();
- assertEquals("[10..20]", str);
- assertEquals("[-20..-10]", Range.between(-20, -10).toString());
- }
-
- @Test
- public void testToStringFormat() {
- final String str = intRange.toString("From %1$s to %2$s");
- assertEquals("From 10 to 20", str);
+ public void testGetMaximum() {
+ assertEquals(20, (int) intRange.getMaximum());
+ assertEquals(20L, (long) longRange.getMaximum());
+ assertEquals(20f, floatRange.getMaximum(), 0.00001f);
+ assertEquals(20d, doubleRange.getMaximum(), 0.00001d);
}
// -----------------------------------------------------------------------
@@ -172,22 +188,33 @@ public class RangeTest {
}
@Test
- public void testGetMaximum() {
- assertEquals(20, (int) intRange.getMaximum());
- assertEquals(20L, (long) longRange.getMaximum());
- assertEquals(20f, floatRange.getMaximum(), 0.00001f);
- assertEquals(20d, doubleRange.getMaximum(), 0.00001d);
+ public void testHashCode() {
+ assertEquals(byteRange.hashCode(), byteRange2.hashCode());
+ assertNotEquals(byteRange.hashCode(), byteRange3.hashCode());
+
+ assertEquals(intRange.hashCode(), intRange.hashCode());
+ assertTrue(intRange.hashCode() != 0);
}
@Test
- public void testContains() {
- assertFalse(intRange.contains(null));
+ public void testIntersectionWith() {
+ assertSame(intRange, intRange.intersectionWith(intRange));
+ assertSame(byteRange, byteRange.intersectionWith(byteRange));
+ assertSame(longRange, longRange.intersectionWith(longRange));
+ assertSame(floatRange, floatRange.intersectionWith(floatRange));
+ assertSame(doubleRange, doubleRange.intersectionWith(doubleRange));
- assertFalse(intRange.contains(5));
- assertTrue(intRange.contains(10));
- assertTrue(intRange.contains(15));
- assertTrue(intRange.contains(20));
- assertFalse(intRange.contains(25));
+ assertEquals(Range.between(10, 15),
intRange.intersectionWith(Range.between(5, 15)));
+ }
+
+ @Test
+ public void testIntersectionWithNonOverlapping() {
+ assertThrows(IllegalArgumentException.class, () ->
intRange.intersectionWith(Range.between(0, 9)));
+ }
+
+ @Test
+ public void testIntersectionWithNull() {
+ assertThrows(IllegalArgumentException.class, () ->
intRange.intersectionWith(null));
}
@Test
@@ -202,25 +229,19 @@ public class RangeTest {
}
@Test
- public void testIsStartedBy() {
- assertFalse(intRange.isStartedBy(null));
+ public void testIsAfterRange() {
+ assertFalse(intRange.isAfterRange(null));
- assertFalse(intRange.isStartedBy(5));
- assertTrue(intRange.isStartedBy(10));
- assertFalse(intRange.isStartedBy(15));
- assertFalse(intRange.isStartedBy(20));
- assertFalse(intRange.isStartedBy(25));
- }
+ assertTrue(intRange.isAfterRange(Range.between(5, 9)));
- @Test
- public void testIsEndedBy() {
- assertFalse(intRange.isEndedBy(null));
+ assertFalse(intRange.isAfterRange(Range.between(5, 10)));
+ assertFalse(intRange.isAfterRange(Range.between(5, 20)));
+ assertFalse(intRange.isAfterRange(Range.between(5, 25)));
+ assertFalse(intRange.isAfterRange(Range.between(15, 25)));
- assertFalse(intRange.isEndedBy(5));
- assertFalse(intRange.isEndedBy(10));
- assertFalse(intRange.isEndedBy(15));
- assertTrue(intRange.isEndedBy(20));
- assertFalse(intRange.isEndedBy(25));
+ assertFalse(intRange.isAfterRange(Range.between(21, 25)));
+
+ assertFalse(intRange.isAfterRange(Range.between(10, 20)));
}
@Test
@@ -235,63 +256,30 @@ public class RangeTest {
}
@Test
- public void testElementCompareTo() {
- assertThrows(NullPointerException.class, () ->
intRange.elementCompareTo(null));
-
- assertEquals(-1, intRange.elementCompareTo(5));
- assertEquals(0, intRange.elementCompareTo(10));
- assertEquals(0, intRange.elementCompareTo(15));
- assertEquals(0, intRange.elementCompareTo(20));
- assertEquals(1, intRange.elementCompareTo(25));
- }
-
- // -----------------------------------------------------------------------
- @Test
- public void testContainsRange() {
-
- // null handling
- assertFalse(intRange.containsRange(null));
-
- // easy inside range
- assertTrue(intRange.containsRange(Range.between(12, 18)));
-
- // outside range on each side
- assertFalse(intRange.containsRange(Range.between(32, 45)));
- assertFalse(intRange.containsRange(Range.between(2, 8)));
-
- // equals range
- assertTrue(intRange.containsRange(Range.between(10, 20)));
+ public void testIsBeforeRange() {
+ assertFalse(intRange.isBeforeRange(null));
- // overlaps
- assertFalse(intRange.containsRange(Range.between(9, 14)));
- assertFalse(intRange.containsRange(Range.between(16, 21)));
+ assertFalse(intRange.isBeforeRange(Range.between(5, 9)));
- // touches lower boundary
- assertTrue(intRange.containsRange(Range.between(10, 19)));
- assertFalse(intRange.containsRange(Range.between(10, 21)));
+ assertFalse(intRange.isBeforeRange(Range.between(5, 10)));
+ assertFalse(intRange.isBeforeRange(Range.between(5, 20)));
+ assertFalse(intRange.isBeforeRange(Range.between(5, 25)));
+ assertFalse(intRange.isBeforeRange(Range.between(15, 25)));
- // touches upper boundary
- assertTrue(intRange.containsRange(Range.between(11, 20)));
- assertFalse(intRange.containsRange(Range.between(9, 20)));
+ assertTrue(intRange.isBeforeRange(Range.between(21, 25)));
- // negative
- assertFalse(intRange.containsRange(Range.between(-11, -18)));
+ assertFalse(intRange.isBeforeRange(Range.between(10, 20)));
}
@Test
- public void testIsAfterRange() {
- assertFalse(intRange.isAfterRange(null));
-
- assertTrue(intRange.isAfterRange(Range.between(5, 9)));
-
- assertFalse(intRange.isAfterRange(Range.between(5, 10)));
- assertFalse(intRange.isAfterRange(Range.between(5, 20)));
- assertFalse(intRange.isAfterRange(Range.between(5, 25)));
- assertFalse(intRange.isAfterRange(Range.between(15, 25)));
-
- assertFalse(intRange.isAfterRange(Range.between(21, 25)));
+ public void testIsEndedBy() {
+ assertFalse(intRange.isEndedBy(null));
- assertFalse(intRange.isAfterRange(Range.between(10, 20)));
+ assertFalse(intRange.isEndedBy(5));
+ assertFalse(intRange.isEndedBy(10));
+ assertFalse(intRange.isEndedBy(15));
+ assertTrue(intRange.isEndedBy(20));
+ assertFalse(intRange.isEndedBy(25));
}
@Test
@@ -327,46 +315,57 @@ public class RangeTest {
}
@Test
- public void testIsBeforeRange() {
- assertFalse(intRange.isBeforeRange(null));
-
- assertFalse(intRange.isBeforeRange(Range.between(5, 9)));
-
- assertFalse(intRange.isBeforeRange(Range.between(5, 10)));
- assertFalse(intRange.isBeforeRange(Range.between(5, 20)));
- assertFalse(intRange.isBeforeRange(Range.between(5, 25)));
- assertFalse(intRange.isBeforeRange(Range.between(15, 25)));
-
- assertTrue(intRange.isBeforeRange(Range.between(21, 25)));
+ public void testIsStartedBy() {
+ assertFalse(intRange.isStartedBy(null));
- assertFalse(intRange.isBeforeRange(Range.between(10, 20)));
+ assertFalse(intRange.isStartedBy(5));
+ assertTrue(intRange.isStartedBy(10));
+ assertFalse(intRange.isStartedBy(15));
+ assertFalse(intRange.isStartedBy(20));
+ assertFalse(intRange.isStartedBy(25));
}
@Test
- public void testIntersectionWith() {
- assertSame(intRange, intRange.intersectionWith(intRange));
- assertSame(byteRange, byteRange.intersectionWith(byteRange));
- assertSame(longRange, longRange.intersectionWith(longRange));
- assertSame(floatRange, floatRange.intersectionWith(floatRange));
- assertSame(doubleRange, doubleRange.intersectionWith(doubleRange));
+ public void testIsWithCompare() {
+ // 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");
+ }
- assertEquals(Range.between(10, 15),
intRange.intersectionWith(Range.between(5, 15)));
+ // -----------------------------------------------------------------------
+ @Test
+ public void testRangeOfChars() {
+ final Range<Character> chars = Range.between('a', 'z');
+ assertTrue(chars.contains('b'));
+ assertFalse(chars.contains('B'));
}
+ // -----------------------------------------------------------------------
@Test
- public void testIntersectionWithNull() {
- assertThrows(IllegalArgumentException.class, () ->
intRange.intersectionWith(null));
+ public void testSerializing() {
+ SerializationUtils.clone(intRange);
}
@Test
- public void testIntersectionWithNonOverlapping() {
- assertThrows(IllegalArgumentException.class, () ->
intRange.intersectionWith(Range.between(0, 9)));
+ public void testToString() {
+ assertNotNull(byteRange.toString());
+
+ final String str = intRange.toString();
+ assertEquals("[10..20]", str);
+ assertEquals("[-20..-10]", Range.between(-20, -10).toString());
}
- // -----------------------------------------------------------------------
@Test
- public void testSerializing() {
- SerializationUtils.clone(intRange);
+ public void testToStringFormat() {
+ final String str = intRange.toString("From %1$s to %2$s");
+ assertEquals("From 10 to 20", str);
}
}
