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 bda6a4f Sort members.
bda6a4f is described below
commit bda6a4fc838384fa1a40be20e14bada2bbeb8d2c
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Sun Oct 17 09:42:28 2021 -0400
Sort members.
---
src/main/java/org/apache/commons/lang3/Range.java | 66 +++++++++++-----------
.../java/org/apache/commons/lang3/RangeTest.java | 58 +++++++++----------
2 files changed, 62 insertions(+), 62 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/Range.java
b/src/main/java/org/apache/commons/lang3/Range.java
index 60fc9d7..9f8baea 100644
--- a/src/main/java/org/apache/commons/lang3/Range.java
+++ b/src/main/java/org/apache/commons/lang3/Range.java
@@ -264,6 +264,39 @@ public final class Range<T> implements Serializable {
}
/**
+ * <p>
+ * Fits the given element into this range by returning the given element
or, if out of bounds, the range minimum if
+ * below, or the range maximum if above.
+ * </p>
+ * <pre>
+ * Range<Integer> range = Range.between(16, 64);
+ * range.fit(-9) --> 16
+ * range.fit(0) --> 16
+ * range.fit(15) --> 16
+ * range.fit(16) --> 16
+ * range.fit(17) --> 17
+ * ...
+ * range.fit(63) --> 63
+ * range.fit(64) --> 64
+ * range.fit(99) --> 64
+ * </pre>
+ * @param element the element to check for, not null
+ * @return the minimum, the element, or the maximum depending on the
element's location relative to the range
+ * @since 3.10
+ */
+ public T fit(final T element) {
+ // Comparable API says throw NPE on null
+ Validate.notNull(element, "element");
+ if (isAfter(element)) {
+ return minimum;
+ }
+ if (isBefore(element)) {
+ return maximum;
+ }
+ return element;
+ }
+
+ /**
* <p>Gets the comparator being used to determine if objects are within
the range.</p>
*
* <p>Natural ordering uses an internal comparator implementation, thus
this
@@ -449,39 +482,6 @@ public final class Range<T> implements Serializable {
}
/**
- * <p>
- * Fits the given element into this range by returning the given element
or, if out of bounds, the range minimum if
- * below, or the range maximum if above.
- * </p>
- * <pre>
- * Range<Integer> range = Range.between(16, 64);
- * range.fit(-9) --> 16
- * range.fit(0) --> 16
- * range.fit(15) --> 16
- * range.fit(16) --> 16
- * range.fit(17) --> 17
- * ...
- * range.fit(63) --> 63
- * range.fit(64) --> 64
- * range.fit(99) --> 64
- * </pre>
- * @param element the element to check for, not null
- * @return the minimum, the element, or the maximum depending on the
element's location relative to the range
- * @since 3.10
- */
- public T fit(final T element) {
- // Comparable API says throw NPE on null
- Validate.notNull(element, "element");
- if (isAfter(element)) {
- return minimum;
- }
- if (isBefore(element)) {
- return maximum;
- }
- return element;
- }
-
- /**
* <p>Gets the range as a {@code String}.</p>
*
* <p>The format of the String is '[<i>min</i>..<i>max</i>]'.</p>
diff --git a/src/test/java/org/apache/commons/lang3/RangeTest.java
b/src/test/java/org/apache/commons/lang3/RangeTest.java
index 8c813b9..5003b88 100644
--- a/src/test/java/org/apache/commons/lang3/RangeTest.java
+++ b/src/test/java/org/apache/commons/lang3/RangeTest.java
@@ -38,51 +38,29 @@ import org.junit.jupiter.api.Test;
@SuppressWarnings("boxing")
public class RangeTest {
- private Range<Byte> byteRange;
- private Range<Byte> byteRange2;
- private Range<Byte> byteRange3;
-
- private Range<Double> doubleRange;
- private Range<Float> floatRange;
- private Range<Integer> intRange;
- private Range<Long> longRange;
-
abstract static class AbstractComparable implements
Comparable<AbstractComparable> {
@Override
public int compareTo(final AbstractComparable o) {
return 0;
}
}
-
static final class DerivedComparableA extends AbstractComparable {
// empty
}
-
static final class DerivedComparableB extends AbstractComparable {
// empty
}
- @Test
- public void testConstructorSignatureWithAbstractComparableClasses() {
- final DerivedComparableA derivedComparableA = new DerivedComparableA();
- final DerivedComparableB derivedComparableB = new DerivedComparableB();
-
- Range<AbstractComparable> mixed = Range.between(derivedComparableA,
derivedComparableB);
- mixed = Range.between(derivedComparableA, derivedComparableB, null);
- assertTrue(mixed.contains(derivedComparableA));
+ private Range<Byte> byteRange;
+ private Range<Byte> byteRange2;
+ private Range<Byte> byteRange3;
+ private Range<Double> doubleRange;
- Range<AbstractComparable> same = Range.between(derivedComparableA,
derivedComparableA);
- same = Range.between(derivedComparableA, derivedComparableA, null);
- assertTrue(same.contains(derivedComparableA));
+ private Range<Float> floatRange;
- Range<DerivedComparableA> rangeA = Range.between(derivedComparableA,
derivedComparableA);
- rangeA = Range.between(derivedComparableA, derivedComparableA, null);
- assertTrue(rangeA.contains(derivedComparableA));
+ private Range<Integer> intRange;
- Range<DerivedComparableB> rangeB = Range.is(derivedComparableB);
- rangeB = Range.is(derivedComparableB, null);
- assertTrue(rangeB.contains(derivedComparableB));
- }
+ private Range<Long> longRange;
@BeforeEach
public void setUp() {
@@ -139,6 +117,28 @@ public class RangeTest {
}
@Test
+ public void testConstructorSignatureWithAbstractComparableClasses() {
+ final DerivedComparableA derivedComparableA = new DerivedComparableA();
+ final DerivedComparableB derivedComparableB = new DerivedComparableB();
+
+ Range<AbstractComparable> mixed = Range.between(derivedComparableA,
derivedComparableB);
+ mixed = Range.between(derivedComparableA, derivedComparableB, null);
+ assertTrue(mixed.contains(derivedComparableA));
+
+ Range<AbstractComparable> same = Range.between(derivedComparableA,
derivedComparableA);
+ same = Range.between(derivedComparableA, derivedComparableA, null);
+ assertTrue(same.contains(derivedComparableA));
+
+ Range<DerivedComparableA> rangeA = Range.between(derivedComparableA,
derivedComparableA);
+ rangeA = Range.between(derivedComparableA, derivedComparableA, null);
+ assertTrue(rangeA.contains(derivedComparableA));
+
+ Range<DerivedComparableB> rangeB = Range.is(derivedComparableB);
+ rangeB = Range.is(derivedComparableB, null);
+ assertTrue(rangeB.contains(derivedComparableB));
+ }
+
+ @Test
public void testContains() {
assertFalse(intRange.contains(null));
