Author: scolebourne
Date: Wed May 25 15:43:35 2011
New Revision: 1127565
URL: http://svn.apache.org/viewvc?rev=1127565&view=rev
Log:
Refactor Range with lots of new methods
Modified:
commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Range.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/RangeTest.java
Modified:
commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Range.java
URL:
http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Range.java?rev=1127565&r1=1127564&r2=1127565&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Range.java
(original)
+++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Range.java
Wed May 25 15:43:35 2011
@@ -18,21 +18,23 @@ package org.apache.commons.lang3;
import java.io.Serializable;
import java.util.Comparator;
+import java.util.Formattable;
/**
- * <p>{@code Range} represents an immutable range of comparables of the same
type.</p>
- * <p>The objects need to either be implementations of {@code
java.lang.Comparable}
- * or you need to supply a {@code java.util.Comparator}. </p>
+ * <p>An immutable range of objects from a minimum to maximum point
inclusive.</p>
+ *
+ * <p>The objects need to either be implementations of {@code Comparable}
+ * or you need to supply a {@code Comparator}. </p>
*
- * <p>#ThreadSafe# if the comparables are thread-safe</p>
+ * <p>#ThreadSafe# if the objects and comparator are thread-safe</p>
+ *
* @since 3.0
* @version $Id$
*/
public final class Range<T> implements Serializable {
/**
- * Required for serialization support.
- *
+ * Serialization version.
* @see java.io.Serializable
*/
private static final long serialVersionUID = 1L;
@@ -41,124 +43,123 @@ public final class Range<T> implements S
* The ordering scheme used in this range.
*/
private final Comparator<T> comparator;
-
/**
* The minimum value in this range (inclusive).
*/
private final T minimum;
-
/**
* The maximum value in this range (inclusive).
*/
private final T maximum;
-
/**
* Cached output hashCode (class is immutable).
*/
- private transient int hashCode = 0;
-
+ private transient int hashCode;
/**
* Cached output toString (class is immutable).
*/
- private transient String toString = null;
+ private transient String toString;
/**
- * <p>Constructs a new {@code Range} using the specified
- * element as both the minimum and maximum in this range.</p>
- * <p>The range uses the natural ordering of the elements to
- * determine where values lie in the range.</p>
- *
- * @param <T> the type of this {@code Range}
- * @param element the value to use for this range, must not be {@code
null}
- * @return the new range object
- * @throws IllegalArgumentException if the value is {@code null}
- * @throws ClassCastException if the value is not Comparable
+ * <p>Obtains a range using the specified element as both the minimum
+ * and maximum in this range.</p>
+ *
+ * <p>The range uses the natural ordering of the elements to determine
where
+ * values lie in the range.</p>
+ *
+ * @param <T> the type of the elements in this range
+ * @param element the value to use for this range, not null
+ * @return the range object, not null
+ * @throws IllegalArgumentException if the element is null
+ * @throws ClassCastException if the element is not {@code Comparable}
*/
public static <T extends Comparable<T>> Range<T> is(T element) {
- return new Range<T>(element, element,
ComparableComparator.<T>getInstance());
+ return between(element, element, null);
}
/**
- * <p>Constructs a new {@code Range} with the specified
- * minimum and maximum values (both inclusive).</p>
- * <p>The range uses the natural ordering of the elements to
- * determine where values lie in the range.</p>
+ * <p>Obtains a range using the specified element as both the minimum
+ * and maximum in this range.</p>
+ *
+ * <p>The range uses the specified {@code Comparator} to determine where
+ * values lie in the range.</p>
*
- * <p>The arguments may be passed in the order (min,max) or (max,min). The
- * getMinimum and getMaximum methods will return the correct values.</p>
- *
- * @param <T> the type of this {@code Range}
- * @param element1 first value that defines the edge of the range,
inclusive
- * @param element2 second value that defines the edge of the range,
inclusive
- * @return the new range object
- * @throws IllegalArgumentException if either value is {@code null}
- * @throws ClassCastException if either value is not Comparable
+ * @param <T> the type of the elements in this range
+ * @param element the value to use for this range, must not be {@code
null}
+ * @param comparator the comparator to be used, null for natural ordering
+ * @return the range object, not null
+ * @throws IllegalArgumentException if the element is null
+ * @throws ClassCastException if using natural ordering and the elements
are not {@code Comparable}
*/
- public static <T extends Comparable<T>> Range<T> between(T element1, T
element2) {
- return new Range<T>( element1, element2,
ComparableComparator.<T>getInstance());
+ public static <T> Range<T> is(T element, Comparator<T> comparator) {
+ return between(element, element, comparator);
}
/**
- * <p>Constructs a new {@code Range} using the specified
- * element as both the minimum and maximum in this range.</p>
- * <p>The range uses the passed in {@code Comparator} to
- * determine where values lie in the range.</p>
+ * <p>Obtains a range with the specified minimum and maximum values (both
inclusive).</p>
+ *
+ * <p>The range uses the natural ordering of the elements to determine
where
+ * values lie in the range.</p>
*
- * @param <T> the type of this {@code Range}
- * @param element the value to use for this range, must not be {@code
null}
- * @param c comparator to be used
- * @return the new range object
- * @throws IllegalArgumentException if the value is {@code null}
+ * <p>The arguments may be passed in the order (min,max) or (max,min).
+ * The getMinimum and getMaximum methods will return the correct
values.</p>
+ *
+ * @param <T> the type of the elements in this range
+ * @param fromInclusive the first value that defines the edge of the
range, inclusive
+ * @param toInclusive the second value that defines the edge of the
range, inclusive
+ * @return the range object, not null
+ * @throws IllegalArgumentException if either element is null
+ * @throws ClassCastException if the elements are not {@code Comparable}
*/
- public static <T> Range<T> is(T element, Comparator<T> c) {
- return new Range<T>(element, element, c);
+ public static <T extends Comparable<T>> Range<T> between(T fromInclusive,
T toInclusive) {
+ return between(fromInclusive, toInclusive, null);
}
/**
- * <p>Constructs a new {@code Range} with the specified
- * minimum and maximum values (both inclusive).</p>
- * <p>The range uses the passed in {@code Comparator} to
- * determine where values lie in the range.</p>
+ * <p>Obtains a range with the specified minimum and maximum values (both
inclusive).</p>
+ *
+ * <p>The range uses the specified {@code Comparator} to determine where
+ * values lie in the range.</p>
*
- * <p>The arguments may be passed in the order (min,max) or (max,min). The
- * getMinimum and getMaximum methods will return the correct values.</p>
+ * <p>The arguments may be passed in the order (min,max) or (max,min).
+ * The getMinimum and getMaximum methods will return the correct
values.</p>
*
- * @param <T> the type of this {@code Range}
- * @param element1 first value that defines the edge of the range,
inclusive
- * @param element2 second value that defines the edge of the range,
inclusive
- * @param c comparator to be used
- * @return the new range object
- * @throws IllegalArgumentException if either value is {@code null}
+ * @param <T> the type of the elements in this range
+ * @param fromInclusive the first value that defines the edge of the
range, inclusive
+ * @param toInclusive the second value that defines the edge of the
range, inclusive
+ * @param comparator the comparator to be used, null for natural ordering
+ * @return the range object, not null
+ * @throws IllegalArgumentException if either element is null
+ * @throws ClassCastException if using natural ordering and the elements
are not {@code Comparable}
*/
- public static <T> Range<T> between(T element1, T element2, Comparator<T>
c) {
- return new Range<T>(element1, element2, c);
+ public static <T> Range<T> between(T fromInclusive, T toInclusive,
Comparator<T> comparator) {
+ return new Range<T>(fromInclusive, toInclusive, comparator);
}
/**
- * Creates a new instance of {@code Range}.
+ * Creates an instance.
*
- * @param element1 the first element
- * @param element2 the second element
- * @param c the comparator to be used
+ * @param element1 the first element, not null
+ * @param element2 the second element, not null
+ * @param comparator the comparator to be used, null for natural ordering
*/
- private Range(T element1, T element2, Comparator<T> c) {
- if(element1 == null || element2 == null) {
+ @SuppressWarnings("unchecked")
+ private Range(T element1, T element2, Comparator<T> comparator) {
+ if (element1 == null || element2 == null) {
throw new IllegalArgumentException("Elements in a range must not
be null: element1=" +
element1 + ", element2=" +
element2);
}
-
- if(c == null) {
- throw new IllegalArgumentException("Comparator must not be null");
+ if (comparator == null) {
+ comparator = ComparableComparator.INSTANCE;
}
-
- if(c.compare(element1, element2) < 1) {
+ if (comparator.compare(element1, element2) < 1) {
this.minimum = element1;
this.maximum = element2;
} else {
this.minimum = element2;
this.maximum = element1;
}
- this.comparator = c;
+ this.comparator = comparator;
}
// Accessors
@@ -167,108 +168,131 @@ public final class Range<T> implements S
/**
* <p>Gets the minimum value in this range.</p>
*
- * @return the minimum value in this range
+ * @return the minimum value in this range, not null
*/
public T getMinimum() {
- return this.minimum;
+ return minimum;
}
/**
* <p>Gets the maximum value in this range.</p>
*
- * @return the maximum value in this range
+ * @return the maximum value in this range, not null
*/
public T getMaximum() {
- return this.maximum;
+ return maximum;
}
/**
- * <p>Gets the comparator being used to determine if objects are within
the range. </p>
+ * <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
+ * method never returns null. See {@link #isNaturalOrdering()}.</p>
*
- * @return the comparator being used
+ * @return the comparator being used, not null
*/
public Comparator<T> getComparator() {
- return this.comparator;
+ return comparator;
}
/**
- * <p>Whether or not the Range is using the default natural comparison
method
- * to compare elements. </p>
+ * <p>Whether or not the Range is using the natural ordering of the
elements.</p>
+ *
+ * <p>Natural ordering uses an internal comparator implementation, thus
this
+ * method is the only way to check if a null comparator was specified.</p>
*
- * @return whether or not the default Comparator is in use
+ * @return true if using natural ordering
*/
- public boolean isDefaultNaturalOrdering() {
- return this.comparator == ComparableComparator.INSTANCE;
+ public boolean isNaturalOrdering() {
+ return comparator == ComparableComparator.INSTANCE;
}
- // Include tests
+ // Element tests
//--------------------------------------------------------------------
/**
- * <p>Tests whether the specified element occurs within this range.</p>
- *
- * <p>{@code null} is handled and returns {@code false}.</p>
+ * <p>Checks whether the specified element occurs within this range.</p>
*
- * @param element the element to test, may be {@code null}
- * @return {@code true} if the specified element occurs within this range
+ * @param element the element to check for, null returns false
+ * @return true if the specified element occurs within this range
*/
public boolean contains(T element) {
- if(element == null) {
+ if (element == null) {
return false;
}
- return (comparator.compare(element, this.minimum) > -1) &&
(comparator.compare(element, this.maximum) < 1);
+ return (comparator.compare(element, minimum) > -1) &&
(comparator.compare(element, maximum) < 1);
}
/**
- * <p>Tests whether the specified element occurs before this range.</p>
- *
- * <p>{@code null} is handled and returns {@code false}.</p>
+ * <p>Checks whether this range is after the specified element.</p>
*
- * @param element the element to test, may be {@code null}
- * @return {@code true} if the specified element occurs before this range
+ * @param element the element to check for, null returns false
+ * @return true if this range is entirely after the specified element
*/
- public boolean elementBefore(T element) {
+ public boolean isAfter(T element) {
if (element == null) {
return false;
}
-
- return this.comparator.compare(element, this.minimum) < 0;
+ return comparator.compare(element, minimum) < 0;
}
/**
- * <p>Tests whether the specified element occurs after this range.</p>
+ * <p>Checks whether this range starts with the specified element.</p>
*
- * <p>{@code null} is handled and returns {@code false}.</p>
+ * @param element the element to check for, null returns false
+ * @return true if the specified element occurs within this range
+ */
+ public boolean isStartedBy(T element) {
+ if (element == null) {
+ return false;
+ }
+ return comparator.compare(element, minimum) == 0;
+ }
+
+ /**
+ * <p>Checks whether this range starts with the specified element.</p>
*
- * @param element the element to test, may be {@code null}
- * @return {@code true} if the specified element occurs after this range
+ * @param element the element to check for, null returns false
+ * @return true if the specified element occurs within this range
*/
- public boolean elementAfter(T element) {
+ public boolean isEndedBy(T element) {
if (element == null) {
return false;
}
+ return comparator.compare(element, maximum) == 0;
+ }
- return this.comparator.compare(element, this.maximum) > 0;
+ /**
+ * <p>Checks whether this range is before the specified element.</p>
+ *
+ * @param element the element to check for, null returns false
+ * @return true if this range is entirely before the specified element
+ */
+ public boolean isBefore(T element) {
+ if (element == null) {
+ return false;
+ }
+ return comparator.compare(element, maximum) > 0;
}
/**
- * <p>Tests where the specified element occurs relative to this range.</p>
+ * <p>Checks where the specified element occurs relative to this range.</p>
+ *
* <p>The API is reminiscent of the Comparable interface returning {@code
-1} if
* the element is before the range, {@code 0} if contained within the
range and
* {@code 1} if the element is after the range. </p>
*
- * @param element the element to test
+ * @param element the element to check for, not null
* @return -1, 0 or +1 depending on the element's location relative to the
range
*/
public int elementCompareTo(T element) {
- if(element == null) {
+ if (element == null) {
// Comparable API says throw NPE on null
throw new NullPointerException("Element is null");
}
- if(elementBefore(element)) {
+ if (isAfter(element)) {
return -1;
- } else
- if(elementAfter(element)) {
+ } else if (isBefore(element)) {
return 1;
} else {
return 0;
@@ -279,40 +303,73 @@ public final class Range<T> implements S
//--------------------------------------------------------------------
/**
- * <p>Tests whether the specified range occurs entirely within this
range.</p>
+ * <p>Checks whether this range contains all the elements of the specified
range.</p>
+ *
+ * <p>This method may fail if the ranges have two different comparators or
element types.</p>
+ *
+ * @param otherRange the range to check, null returns false
+ * @return true if this range contains the specified range
+ * @throws RuntimeException if ranges cannot be compared
+ */
+ public boolean containsRange(Range<T> otherRange) {
+ if (otherRange == null) {
+ return false;
+ }
+ return contains(otherRange.minimum)
+ && contains(otherRange.maximum);
+ }
+
+ /**
+ * <p>Checks whether this range is completely after the specified
range.</p>
*
- * <p>{@code null} is handled and returns {@code false}.</p>
+ * <p>This method may fail if the ranges have two different comparators or
element types.</p>
*
- * @param range the range to test, may be {@code null}
- * @return {@code true} if the specified range occurs entirely within
- * this range; otherwise, {@code false}
- * @throws IllegalArgumentException if the {@code Range} cannot be compared
+ * @param otherRange the range to check, null returns false
+ * @return true if this range is completely after the specified range
+ * @throws RuntimeException if ranges cannot be compared
*/
- public boolean containsAll(Range<T> range) {
- if (range == null) {
+ public boolean isAfterRange(Range<T> otherRange) {
+ if (otherRange == null) {
return false;
}
- return contains(range.getMinimum())
- && contains(range.getMaximum());
+ return isAfter(otherRange.maximum);
}
/**
- * <p>Tests whether the specified range overlaps with this range.</p>
+ * <p>Checks whether this range is overlapped by the specified range.</p>
+ *
+ * <p>Two ranges overlap if there is at least one element in common.</p>
*
- * <p>{@code null} is handled and returns {@code false}.</p>
+ * <p>This method may fail if the ranges have two different comparators or
element types.</p>
*
- * @param range the range to test, may be {@code null}
- * @return {@code true} if the specified range overlaps with this
+ * @param otherRange the range to test, null returns false
+ * @return true if the specified range overlaps with this
* range; otherwise, {@code false}
- * @throws IllegalArgumentException if the {@code Range} cannot be compared
+ * @throws RuntimeException if ranges cannot be compared
*/
- public boolean overlapsWith(Range<T> range) {
- if (range == null) {
+ public boolean isOverlappedBy(Range<T> otherRange) {
+ if (otherRange == null) {
return false;
}
- return range.contains(this.minimum)
- || range.contains(this.maximum)
- || contains(range.getMinimum());
+ return otherRange.contains(minimum)
+ || otherRange.contains(maximum)
+ || contains(otherRange.minimum);
+ }
+
+ /**
+ * <p>Checks whether this range is completely before the specified
range.</p>
+ *
+ * <p>This method may fail if the ranges have two different comparators or
element types.</p>
+ *
+ * @param otherRange the range to check, null returns false
+ * @return true if this range is completely before the specified range
+ * @throws RuntimeException if ranges cannot be compared
+ */
+ public boolean isBeforeRange(Range<T> otherRange) {
+ if (otherRange == null) {
+ return false;
+ }
+ return isBefore(otherRange.minimum);
}
// Basics
@@ -321,10 +378,11 @@ public final class Range<T> implements S
/**
* <p>Compares this range to another object to test if they are equal.</p>.
*
- * <p>To be equal, the class, minimum and maximum must be equal.</p>
+ * <p>To be equal, the minimum and maximum values must be equal, which
+ * ignores any differences in the comparator.</p>
*
* @param obj the reference object with which to compare
- * @return {@code true} if this object is equal
+ * @return true if this object is equal
*/
@Override
public boolean equals(Object obj) {
@@ -335,13 +393,13 @@ public final class Range<T> implements S
} else {
@SuppressWarnings("unchecked") // OK because we checked the class
above
Range<T> range = (Range<T>) obj;
- return getMinimum().equals(range.getMinimum()) &&
- getMaximum().equals(range.getMaximum());
+ return minimum.equals(range.minimum) &&
+ maximum.equals(range.maximum);
}
}
/**
- * <p>Gets a hashCode for the range.</p>
+ * <p>Gets a suitable hash code for the range.</p>
*
* @return a hash code value for this object
*/
@@ -351,8 +409,8 @@ public final class Range<T> implements S
if (hashCode == 0) {
result = 17;
result = 37 * result + getClass().hashCode();
- result = 37 * result + this.minimum.hashCode();
- result = 37 * result + this.maximum.hashCode();
+ result = 37 * result + minimum.hashCode();
+ result = 37 * result + maximum.hashCode();
hashCode = result;
}
return result;
@@ -361,7 +419,7 @@ public final class Range<T> implements S
/**
* <p>Gets the range as a {@code String}.</p>
*
- * <p>The format of the String is 'Range[<i>min</i>,<i>max</i>]'.</p>
+ * <p>The format of the String is '[<i>min</i>..<i>max</i>]'.</p>
*
* @return the {@code String} representation of this range
*/
@@ -370,10 +428,10 @@ public final class Range<T> implements S
String result = toString;
if (result == null) {
StringBuilder buf = new StringBuilder(32);
- buf.append("Range[");
- buf.append(this.minimum);
- buf.append(',');
- buf.append(this.maximum);
+ buf.append('[');
+ buf.append(minimum);
+ buf.append("..");
+ buf.append(maximum);
buf.append(']');
result = buf.toString();
toString = result;
@@ -381,54 +439,29 @@ public final class Range<T> implements S
return result;
}
- // Taken from Commons Collections - documentation removed as not a public
class
- private static class ComparableComparator<E extends Comparable<? super E>>
implements Comparator<E>, Serializable {
-
- private static final long serialVersionUID = 1L;
-
- @SuppressWarnings("rawtypes") // Comparator works for all types
- public static final ComparableComparator<?> INSTANCE = new
ComparableComparator();
-
- /**
- * Returns a comparator for the specified {@code Comparable} type.
- *
- * @param <E> the {@code Comparable} type
- * @return the comparator for this type
- */
- @SuppressWarnings("unchecked") // OK to cast, because comparator works
for all types
- public static <E extends Comparable<? super E>>
ComparableComparator<E> getInstance() {
- return (ComparableComparator<E>) INSTANCE;
- }
-
- /**
- * Creates a new instance of {@code ComparableComparator}.
- */
- public ComparableComparator() {
- super();
- }
-
- /**
- * Compares two objects.
- *
- * @param obj1 the first object
- * @param obj2 the second object
- * @return the result of the comparison
- */
- public int compare(E obj1, E obj2) {
- return obj1.compareTo(obj2);
- }
-
- @Override
- public int hashCode() {
- return "ComparableComparator".hashCode();
- }
-
- @Override
- public boolean equals(Object object) {
- return (this == object) ||
- ((null != object) &&
(object.getClass().equals(this.getClass())));
+ /**
+ * <p>Formats the receiver using the given format.</p>
+ *
+ * <p>This uses {@link Formattable} to perform the formatting. Three
variables may
+ * be used to embed the minimum, maximum and comparator.
+ * Use {@code %1$s} for the minimum element, {@code %2$s} for the maximum
element
+ * and {@code %3$s} for the comparator.
+ * The default format used by {@code toString()} is {@code
[%1$s..%2$s]}.</p>
+ *
+ * @param format the format string, optionally containing {@code %1$s},
{@code %2$s} and {@code %3$s}, not null
+ * @return the formatted string, not null
+ */
+ public String toString(String format) {
+ return String.format(format, minimum, maximum, comparator);
+ }
+
+ //-----------------------------------------------------------------------
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ private enum ComparableComparator implements Comparator {
+ INSTANCE;
+ public int compare(Object obj1, Object obj2) {
+ return ((Comparable) obj1).compareTo(obj2);
}
-
}
}
Modified:
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/RangeTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/RangeTest.java?rev=1127565&r1=1127564&r2=1127565&view=diff
==============================================================================
---
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/RangeTest.java
(original)
+++
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/RangeTest.java
Wed May 25 15:43:35 2011
@@ -53,8 +53,8 @@ public class RangeTest extends TestCase
doubleRange = Range.between((double) 10, (double) 20);
}
- //
--------------------------------------------------------------------------
-
+ //-----------------------------------------------------------------------
+ @SuppressWarnings({ "rawtypes", "unchecked" })
public void testComparableConstructors() {
Comparable c =
new Comparable() {
@@ -62,8 +62,10 @@ public class RangeTest extends TestCase
return 1;
}
};
- Range.is(c);
- Range.between(c, c);
+ Range r1 = Range.is(c);
+ Range r2 = Range.between(c, c);
+ assertEquals(true, r1.isNaturalOrdering());
+ assertEquals(true, r2.isNaturalOrdering());
}
public void testIsWithCompare(){
@@ -103,16 +105,14 @@ public class RangeTest extends TestCase
assertTrue("should contain -11",rb.contains(-11));
}
- //
--------------------------------------------------------------------------
-
+ //-----------------------------------------------------------------------
public void testRangeOfChars() {
Range<Character> chars = Range.between('a', 'z');
assertTrue(chars.contains('b'));
assertFalse(chars.contains('B'));
}
- //
--------------------------------------------------------------------------
-
+ //-----------------------------------------------------------------------
public void testEqualsObject() {
assertEquals(byteRange, byteRange);
assertEquals(byteRange, byteRange2);
@@ -128,29 +128,32 @@ public class RangeTest extends TestCase
public void testHashCode() {
assertEquals(byteRange.hashCode(), byteRange2.hashCode());
assertFalse(byteRange.hashCode() == byteRange3.hashCode());
-
+
assertEquals(intRange.hashCode(), intRange.hashCode());
assertTrue(intRange.hashCode() != 0);
}
public void testToString() {
assertNotNull(byteRange.toString());
-
+
String str = intRange.toString();
- assertEquals("Range[10,20]", str);
-// assertSame(str, intRange.toString()); // no longer passes - does it
matter?
- assertEquals("Range[-20,-10]", Range.between(-20, -10).toString());
+ assertEquals("[10..20]", str);
+ assertEquals("[-20..-10]", Range.between(-20, -10).toString());
}
- //
--------------------------------------------------------------------------
+ public void testToStringFormat() {
+ String str = intRange.toString("From %1$s to %2$s");
+ assertEquals("From 10 to 20", str);
+ }
+ //-----------------------------------------------------------------------
public void testGetMinimum() {
assertEquals(10, (int) intRange.getMinimum());
assertEquals(10L, (long) longRange.getMinimum());
assertEquals(10f, floatRange.getMinimum(), 0.00001f);
assertEquals(10d, doubleRange.getMinimum(), 0.00001d);
}
-
+
public void testGetMaximum() {
assertEquals(20, (int) intRange.getMaximum());
assertEquals(20L, (long) longRange.getMaximum());
@@ -168,24 +171,44 @@ public class RangeTest extends TestCase
assertFalse(intRange.contains(25));
}
- public void testElementBefore() {
- assertFalse(intRange.elementBefore(null));
+ public void testIsAfter() {
+ assertFalse(intRange.isAfter(null));
+
+ assertTrue(intRange.isAfter(5));
+ assertFalse(intRange.isAfter(10));
+ assertFalse(intRange.isAfter(15));
+ assertFalse(intRange.isAfter(20));
+ assertFalse(intRange.isAfter(25));
+ }
+
+ public void testIsStartedBy() {
+ assertFalse(intRange.isStartedBy(null));
+
+ assertFalse(intRange.isStartedBy(5));
+ assertTrue(intRange.isStartedBy(10));
+ assertFalse(intRange.isStartedBy(15));
+ assertFalse(intRange.isStartedBy(20));
+ assertFalse(intRange.isStartedBy(25));
+ }
+
+ public void testIsEndedBy() {
+ assertFalse(intRange.isEndedBy(null));
- assertTrue(intRange.elementBefore(5));
- assertFalse(intRange.elementBefore(10));
- assertFalse(intRange.elementBefore(15));
- assertFalse(intRange.elementBefore(20));
- assertFalse(intRange.elementBefore(25));
- }
-
- public void testElementAfter() {
- assertFalse(intRange.elementAfter(null));
-
- assertFalse(intRange.elementAfter(5));
- assertFalse(intRange.elementAfter(10));
- assertFalse(intRange.elementAfter(15));
- assertFalse(intRange.elementAfter(20));
- assertTrue(intRange.elementAfter(25));
+ assertFalse(intRange.isEndedBy(5));
+ assertFalse(intRange.isEndedBy(10));
+ assertFalse(intRange.isEndedBy(15));
+ assertTrue(intRange.isEndedBy(20));
+ assertFalse(intRange.isEndedBy(25));
+ }
+
+ public void testIsBefore() {
+ assertFalse(intRange.isBefore(null));
+
+ assertFalse(intRange.isBefore(5));
+ assertFalse(intRange.isBefore(10));
+ assertFalse(intRange.isBefore(15));
+ assertFalse(intRange.isBefore(20));
+ assertTrue(intRange.isBefore(25));
}
public void testElementCompareTo() {
@@ -203,72 +226,100 @@ public class RangeTest extends TestCase
assertEquals(1, intRange.elementCompareTo(25));
}
- //
--------------------------------------------------------------------------
-
- public void testContainsAll() {
+ //-----------------------------------------------------------------------
+ public void testContainsRange() {
// null handling
- assertFalse(intRange.containsAll(null));
+ assertFalse(intRange.containsRange(null));
// easy inside range
- assertTrue(intRange.containsAll(Range.between(12, 18)));
+ assertTrue(intRange.containsRange(Range.between(12, 18)));
// outside range on each side
- assertFalse(intRange.containsAll(Range.between(32, 45)));
- assertFalse(intRange.containsAll(Range.between(2, 8)));
+ assertFalse(intRange.containsRange(Range.between(32, 45)));
+ assertFalse(intRange.containsRange(Range.between(2, 8)));
// equals range
- assertTrue(intRange.containsAll(Range.between(10, 20)));
+ assertTrue(intRange.containsRange(Range.between(10, 20)));
// overlaps
- assertFalse(intRange.containsAll(Range.between(9, 14)));
- assertFalse(intRange.containsAll(Range.between(16, 21)));
+ assertFalse(intRange.containsRange(Range.between(9, 14)));
+ assertFalse(intRange.containsRange(Range.between(16, 21)));
// touches lower boundary
- assertTrue(intRange.containsAll(Range.between(10, 19)));
- assertFalse(intRange.containsAll(Range.between(10, 21)));
+ assertTrue(intRange.containsRange(Range.between(10, 19)));
+ assertFalse(intRange.containsRange(Range.between(10, 21)));
// touches upper boundary
- assertTrue(intRange.containsAll(Range.between(11, 20)));
- assertFalse(intRange.containsAll(Range.between(9, 20)));
+ assertTrue(intRange.containsRange(Range.between(11, 20)));
+ assertFalse(intRange.containsRange(Range.between(9, 20)));
// negative
- assertFalse(intRange.containsAll(Range.between(-11, -18)));
+ assertFalse(intRange.containsRange(Range.between(-11, -18)));
+ }
+ 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)));
+
+ assertFalse(intRange.isAfterRange(Range.between(10, 20)));
}
- public void testOverlapsWith() {
+ public void testIsOverlappedBy() {
// null handling
- assertFalse(intRange.overlapsWith(null));
+ assertFalse(intRange.isOverlappedBy(null));
// easy inside range
- assertTrue(intRange.overlapsWith(Range.between(12, 18)));
+ assertTrue(intRange.isOverlappedBy(Range.between(12, 18)));
// outside range on each side
- assertFalse(intRange.overlapsWith(Range.between(32, 45)));
- assertFalse(intRange.overlapsWith(Range.between(2, 8)));
+ assertFalse(intRange.isOverlappedBy(Range.between(32, 45)));
+ assertFalse(intRange.isOverlappedBy(Range.between(2, 8)));
// equals range
- assertTrue(intRange.overlapsWith(Range.between(10, 20)));
+ assertTrue(intRange.isOverlappedBy(Range.between(10, 20)));
// overlaps
- assertTrue(intRange.overlapsWith(Range.between(9, 14)));
- assertTrue(intRange.overlapsWith(Range.between(16, 21)));
+ assertTrue(intRange.isOverlappedBy(Range.between(9, 14)));
+ assertTrue(intRange.isOverlappedBy(Range.between(16, 21)));
// touches lower boundary
- assertTrue(intRange.overlapsWith(Range.between(10, 19)));
- assertTrue(intRange.overlapsWith(Range.between(10, 21)));
+ assertTrue(intRange.isOverlappedBy(Range.between(10, 19)));
+ assertTrue(intRange.isOverlappedBy(Range.between(10, 21)));
// touches upper boundary
- assertTrue(intRange.overlapsWith(Range.between(11, 20)));
- assertTrue(intRange.overlapsWith(Range.between(9, 20)));
+ assertTrue(intRange.isOverlappedBy(Range.between(11, 20)));
+ assertTrue(intRange.isOverlappedBy(Range.between(9, 20)));
// negative
- assertFalse(intRange.overlapsWith(Range.between(-11, -18)));
+ assertFalse(intRange.isOverlappedBy(Range.between(-11, -18)));
+ }
+ 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)));
+
+ assertFalse(intRange.isBeforeRange(Range.between(10, 20)));
}
+ //-----------------------------------------------------------------------
public void testSerializing() {
SerializationUtils.clone(intRange);
}
