Add NumberRange, DoubleRange, IntegerRange, LongRange.
Fix changes.xml
This commit is contained in:
Gary Gregory
parent
6c3ffa44ff
commit
57ddce1195
|
|
@ -103,7 +103,7 @@ The <action> type attribute can be add,update,fix,remove.
|
|||
<action issue="LANG-1638" type="fix" dev="ggregory" due-to="Shailendra Soni, Michael Osipov, Arun Avanathan, Andrew Thomas, Bruno P. Kinoshita, Gary Gregory">Added docs regarding week year support #924.</action>
|
||||
<action issue="LANG-1691" type="fix" dev="ggregory" due-to="Thiyagarajan, Gary Gregory">ClassUtils.getShortCanonicalName doesn't use the canonicalName #949.</action>
|
||||
<action type="fix" dev="aherbert" due-to="Piotr Stawirej">Validate: Get error messages without using String.format when varargs is empty.</action>
|
||||
<action type="fix" dev="ggregory" due-to="Arturo Bernal">Simplify expression (length is never < 0) #962.</action>
|
||||
<action type="fix" dev="ggregory" due-to="Arturo Bernal">Simplify expression (length is never < 0) #962.</action>
|
||||
<!-- ADD -->
|
||||
<action type="add" dev="ggregory" due-to="Gary Gregory">Add GitHub coverage.yml.</action>
|
||||
<action type="add" dev="ggregory" due-to="Gary Gregory">Add EnumUtils.getEnumSystemProperty(...).</action>
|
||||
|
|
@ -182,6 +182,7 @@ The <action> type attribute can be add,update,fix,remove.
|
|||
<action type="add" dev="ggregory" due-to="Gary Gregory">Add BooleanUtils.values() and forEach().</action>
|
||||
<action type="add" dev="ggregory" due-to="Gary Gregory">Add ClassPathUtils.packageToPath(String) and pathToPackage(String)</action>
|
||||
<action type="add" dev="ggregory" due-to="Arturo Bernal">Add CalendarUtils#getDayOfYear() #968</action>
|
||||
<action type="add" dev="ggregory" due-to="ary Gregory">Add NumberRange, DoubleRange, IntegerRange, LongRange.</action>
|
||||
<!-- UPDATE -->
|
||||
<action type="update" dev="ggregory" due-to="Dependabot, XenoAmess, Gary Gregory">Bump actions/cache from 2.1.4 to 3.0.10 #742, #752, #764, #833, #867, #959, #964.</action>
|
||||
<action type="update" dev="ggregory" due-to="Dependabot, Gary Gregory">Bump actions/checkout from 2 to 3.1.0 #819, #825, #859, #963.</action>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
* 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;
|
||||
|
||||
/**
|
||||
* Specializes {@link NumberRange} for {@link Double}s.
|
||||
*
|
||||
* <p>
|
||||
* This class is not designed to interoperate with other NumberRanges
|
||||
* </p>
|
||||
*
|
||||
* @since 3.13.0
|
||||
*/
|
||||
public final class DoubleRange extends NumberRange<Double> {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>
|
||||
* The range uses the natural ordering of the elements 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 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.
|
||||
*/
|
||||
public static DoubleRange of(final double fromInclusive, final double toInclusive) {
|
||||
return of(Double.valueOf(fromInclusive), Double.valueOf(toInclusive));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>
|
||||
* The range uses the natural ordering of the elements 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 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.
|
||||
*/
|
||||
public static DoubleRange of(final Double fromInclusive, final Double toInclusive) {
|
||||
return new DoubleRange(fromInclusive, toInclusive);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an instance.
|
||||
*
|
||||
* @param number1 the first element, not null
|
||||
* @param number2 the second element, not null
|
||||
* @param comp the comparator to be used, null for natural ordering
|
||||
* @throws NullPointerException when element1 is null.
|
||||
* @throws NullPointerException when element2 is null.
|
||||
*/
|
||||
private DoubleRange(final Double number1, final Double number2) {
|
||||
super(number1, number2, null);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
* 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;
|
||||
|
||||
/**
|
||||
* Specializes {@link NumberRange} for {@link Integer}s.
|
||||
*
|
||||
* <p>
|
||||
* This class is not designed to interoperate with other NumberRanges
|
||||
* </p>
|
||||
*
|
||||
* @since 3.13.0
|
||||
*/
|
||||
public final class IntegerRange extends NumberRange<Integer> {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>
|
||||
* The range uses the natural ordering of the elements 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 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.
|
||||
*/
|
||||
public static IntegerRange of(final int fromInclusive, final int toInclusive) {
|
||||
return of(Integer.valueOf(fromInclusive), Integer.valueOf(toInclusive));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>
|
||||
* The range uses the natural ordering of the elements 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 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.
|
||||
*/
|
||||
public static IntegerRange of(final Integer fromInclusive, final Integer toInclusive) {
|
||||
return new IntegerRange(fromInclusive, toInclusive);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an instance.
|
||||
*
|
||||
* @param number1 the first element, not null
|
||||
* @param number2 the second element, not null
|
||||
* @param comp the comparator to be used, null for natural ordering
|
||||
* @throws NullPointerException when element1 is null.
|
||||
* @throws NullPointerException when element2 is null.
|
||||
*/
|
||||
private IntegerRange(final Integer number1, final Integer number2) {
|
||||
super(number1, number2, null);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
* 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;
|
||||
|
||||
/**
|
||||
* Specializes {@link NumberRange} for {@link Long}s.
|
||||
*
|
||||
* <p>
|
||||
* This class is not designed to interoperate with other NumberRanges
|
||||
* </p>
|
||||
*
|
||||
* @since 3.13.0
|
||||
*/
|
||||
public final class LongRange extends NumberRange<Long> {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>
|
||||
* The range uses the natural ordering of the elements 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 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.
|
||||
*/
|
||||
public static LongRange of(final long fromInclusive, final long toInclusive) {
|
||||
return of(Long.valueOf(fromInclusive), Long.valueOf(toInclusive));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>
|
||||
* The range uses the natural ordering of the elements 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 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.
|
||||
*/
|
||||
public static LongRange of(final Long fromInclusive, final Long toInclusive) {
|
||||
return new LongRange(fromInclusive, toInclusive);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an instance.
|
||||
*
|
||||
* @param number1 the first element, not null
|
||||
* @param number2 the second element, not null
|
||||
* @param comp the comparator to be used, null for natural ordering
|
||||
* @throws NullPointerException when element1 is null.
|
||||
* @throws NullPointerException when element2 is null.
|
||||
*/
|
||||
private LongRange(final Long number1, final Long number2) {
|
||||
super(number1, number2, null);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/*
|
||||
* 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 java.util.Comparator;
|
||||
|
||||
/**
|
||||
* Specializes {@link Range} for {@link Number}s.
|
||||
* <p>
|
||||
* We only offer specializations for Integer, Long, and Double (like Java Streams).
|
||||
* </p>
|
||||
*
|
||||
* @param <N> The Number class.
|
||||
* @since 3.13.0
|
||||
*/
|
||||
public class NumberRange<N extends Number> extends Range<N> {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
/**
|
||||
* Creates an instance.
|
||||
*
|
||||
* @param number1 the first element, not null
|
||||
* @param number2 the second element, not null
|
||||
* @param comp the comparator to be used, null for natural ordering
|
||||
* @throws NullPointerException when element1 is null.
|
||||
* @throws NullPointerException when element2 is null.
|
||||
*/
|
||||
public NumberRange(final N number1, final N number2, final Comparator<N> comp) {
|
||||
super(number1, number2, comp);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -18,6 +18,7 @@ package org.apache.commons.lang3;
|
|||
|
||||
import java.io.Serializable;
|
||||
import java.util.Comparator;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* An immutable range of objects from a minimum to maximum point inclusive.
|
||||
|
|
@ -30,7 +31,7 @@ import java.util.Comparator;
|
|||
* @param <T> The type of range values.
|
||||
* @since 3.0
|
||||
*/
|
||||
public final class Range<T> implements Serializable {
|
||||
public class Range<T> implements Serializable {
|
||||
|
||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
||||
private enum ComparableComparator implements Comparator {
|
||||
|
|
@ -69,11 +70,14 @@ public final class Range<T> implements Serializable {
|
|||
* @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 NullPointerException when fromInclusive is null.
|
||||
* @throws NullPointerException when toInclusive is null.
|
||||
* @throws ClassCastException if the elements are not {@link Comparable}
|
||||
* @deprecated Use {@link #of(Comparable, Comparable)}.
|
||||
*/
|
||||
@Deprecated
|
||||
public static <T extends Comparable<? super T>> Range<T> between(final T fromInclusive, final T toInclusive) {
|
||||
return between(fromInclusive, toInclusive, null);
|
||||
return of(fromInclusive, toInclusive, null);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -90,9 +94,12 @@ public final class Range<T> implements Serializable {
|
|||
* @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 NullPointerException when fromInclusive is null.
|
||||
* @throws NullPointerException when toInclusive is null.
|
||||
* @throws ClassCastException if using natural ordering and the elements are not {@link Comparable}
|
||||
* @deprecated Use {@link #of(Object, Object, Comparator)}.
|
||||
*/
|
||||
@Deprecated
|
||||
public static <T> Range<T> between(final T fromInclusive, final T toInclusive, final Comparator<T> comparator) {
|
||||
return new Range<>(fromInclusive, toInclusive, comparator);
|
||||
}
|
||||
|
|
@ -107,11 +114,11 @@ public final class Range<T> implements Serializable {
|
|||
* @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 NullPointerException if the element is null
|
||||
* @throws ClassCastException if the element is not {@link Comparable}
|
||||
*/
|
||||
public static <T extends Comparable<? super T>> Range<T> is(final T element) {
|
||||
return between(element, element, null);
|
||||
return of(element, element, null);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -125,11 +132,55 @@ public final class Range<T> implements Serializable {
|
|||
* @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 NullPointerException if the element is null
|
||||
* @throws ClassCastException if using natural ordering and the elements are not {@link Comparable}
|
||||
*/
|
||||
public static <T> Range<T> is(final T element, final Comparator<T> comparator) {
|
||||
return between(element, element, comparator);
|
||||
return of(element, element, comparator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>The range uses the natural ordering of the elements 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 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 NullPointerException if either element is null
|
||||
* @throws ClassCastException if the elements are not {@link Comparable}
|
||||
* @since 3.13.0
|
||||
*/
|
||||
public static <T extends Comparable<? super T>> Range<T> of(final T fromInclusive, final T toInclusive) {
|
||||
return of(fromInclusive, toInclusive, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a range with the specified minimum and maximum values (both inclusive).
|
||||
*
|
||||
* <p>The range uses the specified {@link 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 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 NullPointerException when fromInclusive is null.
|
||||
* @throws NullPointerException when toInclusive is null.
|
||||
* @throws ClassCastException if using natural ordering and the elements are not {@link Comparable}
|
||||
* @since 3.13.0
|
||||
*/
|
||||
public static <T> Range<T> of(final T fromInclusive, final T toInclusive, final Comparator<T> comparator) {
|
||||
return new Range<>(fromInclusive, toInclusive, comparator);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -163,13 +214,13 @@ public final class Range<T> implements Serializable {
|
|||
* @param element1 the first element, not null
|
||||
* @param element2 the second element, not null
|
||||
* @param comp the comparator to be used, null for natural ordering
|
||||
* @throws NullPointerException when element1 is null.
|
||||
* @throws NullPointerException when element2 is null.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
Range(final T element1, final T element2, final Comparator<T> comp) {
|
||||
if (element1 == null || element2 == null) {
|
||||
throw new IllegalArgumentException("Elements in a range must not be null: element1=" +
|
||||
element1 + ", element2=" + element2);
|
||||
}
|
||||
Objects.requireNonNull(element1, "element1");
|
||||
Objects.requireNonNull(element2, "element2");
|
||||
if (comp == null) {
|
||||
this.comparator = ComparableComparator.INSTANCE;
|
||||
} else {
|
||||
|
|
@ -357,7 +408,7 @@ public final class Range<T> implements Serializable {
|
|||
}
|
||||
final T min = getComparator().compare(minimum, other.minimum) < 0 ? other.minimum : minimum;
|
||||
final T max = getComparator().compare(maximum, other.maximum) < 0 ? maximum : other.maximum;
|
||||
return between(min, max, getComparator());
|
||||
return of(min, max, getComparator());
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -24,8 +24,8 @@ import java.time.temporal.Temporal;
|
|||
import java.util.Objects;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import org.apache.commons.lang3.LongRange;
|
||||
import org.apache.commons.lang3.ObjectUtils;
|
||||
import org.apache.commons.lang3.Range;
|
||||
import org.apache.commons.lang3.function.FailableBiConsumer;
|
||||
import org.apache.commons.lang3.function.FailableConsumer;
|
||||
import org.apache.commons.lang3.function.FailableRunnable;
|
||||
|
|
@ -41,8 +41,7 @@ public class DurationUtils {
|
|||
/**
|
||||
* An Integer Range that accepts Longs.
|
||||
*/
|
||||
static final Range<Long> LONG_TO_INT_RANGE = Range.between(NumberUtils.LONG_INT_MIN_VALUE,
|
||||
NumberUtils.LONG_INT_MAX_VALUE);
|
||||
static final LongRange LONG_TO_INT_RANGE = LongRange.of(NumberUtils.LONG_INT_MIN_VALUE, NumberUtils.LONG_INT_MAX_VALUE);
|
||||
|
||||
/**
|
||||
* Accepts the function with the duration as a long milliseconds and int nanoseconds.
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
byteRange = Range.of((byte) 0, (byte) 5);
|
||||
byteRange2 = Range.of((byte) 0, (byte) 5);
|
||||
byteRange3 = Range.of((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);
|
||||
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"})
|
||||
|
|
|
|||
Loading…
Reference in New Issue