scolebourne 2003/06/24 14:14:51
Modified: lang/src/java/org/apache/commons/lang/math Range.java
lang/src/java/org/apache/commons/lang/builder
CompareToBuilder.java
lang/src/java/org/apache/commons/lang BooleanUtils.java
NumberUtils.java StringUtils.java
lang/src/test/org/apache/commons/lang/math
MathTestSuite.java
lang/src/test/org/apache/commons/lang NumberUtilsTest.java
Added: lang/src/java/org/apache/commons/lang/math NumberUtils.java
lang/src/test/org/apache/commons/lang/math
NumberUtilsTest.java
Log:
NumberUtils moved to math subpackage
Revision Changes Path
1.3 +1 -3
jakarta-commons/lang/src/java/org/apache/commons/lang/math/Range.java
Index: Range.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/math/Range.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- Range.java 23 Mar 2003 17:51:15 -0000 1.2
+++ Range.java 24 Jun 2003 21:14:50 -0000 1.3
@@ -53,8 +53,6 @@
*/
package org.apache.commons.lang.math;
-import org.apache.commons.lang.NumberUtils;
-
/**
* <p><code>Range</code> represents a range of numbers of the same type.</p>
*
1.1
jakarta-commons/lang/src/java/org/apache/commons/lang/math/NumberUtils.java
Index: NumberUtils.java
===================================================================
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Commons", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact [EMAIL PROTECTED]
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.commons.lang.math;
import java.math.BigInteger;
import java.math.BigDecimal;
/**
* <p>Provides extra functionality for Java Number classes.</p>
*
* @author <a href="mailto:[EMAIL PROTECTED]">Henri Yandell</a>
* @author <a href="mailto:[EMAIL PROTECTED]">Rand McNeely</a>
* @author Stephen Colebourne
* @author <a href="mailto:[EMAIL PROTECTED]">Steve Downey</a>
* @author Eric Pugh
* @author Phil Steitz
* @since 1.0
* @version $Id: NumberUtils.java,v 1.1 2003/06/24 21:14:50 scolebourne Exp $
*/
public final class NumberUtils {
/** Reusable Long constant for zero. */
public static final Long LONG_ZERO = new Long(0L);
/** Reusable Long constant for one. */
public static final Long LONG_ONE = new Long(1L);
/** Reusable Long constant for minus one. */
public static final Long LONG_MINUS_ONE = new Long(-1L);
/** Reusable Integer constant for zero. */
public static final Integer INTEGER_ZERO = new Integer(0);
/** Reusable Integer constant for one. */
public static final Integer INTEGER_ONE = new Integer(1);
/** Reusable Integer constant for minus one. */
public static final Integer INTEGER_MINUS_ONE = new Integer(-1);
/** Reusable Short constant for zero. */
public static final Short SHORT_ZERO = new Short((short) 0);
/** Reusable Short constant for one. */
public static final Short SHORT_ONE = new Short((short) 1);
/** Reusable Short constant for minus one. */
public static final Short SHORT_MINUS_ONE = new Short((short) -1);
/** Reusable Byte constant for zero. */
public static final Byte BYTE_ZERO = new Byte((byte) 0);
/** Reusable Byte constant for one. */
public static final Byte BYTE_ONE = new Byte((byte) 1);
/** Reusable Byte constant for minus one. */
public static final Byte BYTE_MINUS_ONE = new Byte((byte) -1);
/** Reusable Double constant for zero. */
public static final Double DOUBLE_ZERO = new Double(0.0d);
/** Reusable Double constant for one. */
public static final Double DOUBLE_ONE = new Double(1.0d);
/** Reusable Double constant for minus one. */
public static final Double DOUBLE_MINUS_ONE = new Double(-1.0d);
/** Reusable Float constant for zero. */
public static final Float FLOAT_ZERO = new Float(0.0f);
/** Reusable Float constant for one. */
public static final Float FLOAT_ONE = new Float(1.0f);
/** Reusable Float constant for minus one. */
public static final Float FLOAT_MINUS_ONE = new Float(-1.0f);
/**
* <p><code>NumberUtils</code> instances should NOT be constructed in standard
programming.
* Instead, the class should be used as
<code>NumberUtils.stringToInt("6");</code>.</p>
*
* <p>This constructor is public to permit tools that require a JavaBean instance
* to operate.</p>
*/
public NumberUtils() {
}
//-----------------------------------------------------------------------
/**
* <p>Convert a <code>String</code> to an <code>int</code>, returning
* <code>zero</code> if the conversion fails.</p>
*
* @param str the string to convert
* @return the int represented by the string, or <code>zero</code> if
* conversion fails
*/
public static int stringToInt(String str) {
return stringToInt(str, 0);
}
/**
* <p>Convert a <code>String</code> to an <code>int</code>, returning a
* default value if the conversion fails.</p>
*
* @param str the string to convert
* @param defaultValue the default value
* @return the int represented by the string, or the default if conversion fails
*/
public static int stringToInt(String str, int defaultValue) {
try {
return Integer.parseInt(str);
} catch (NumberFormatException nfe) {
return defaultValue;
}
}
//-----------------------------------------------------------------------
// must handle Long, Float, Integer, Float, Short,
// BigDecimal, BigInteger and Byte
// useful methods:
// Byte.decode(String)
// Byte.valueOf(String,int radix)
// Byte.valueOf(String)
// Double.valueOf(String)
// Float.valueOf(String)
// new Float(String)
// Integer.valueOf(String,int radix)
// Integer.valueOf(String)
// Integer.decode(String)
// Integer.getInteger(String)
// Integer.getInteger(String,int val)
// Integer.getInteger(String,Integer val)
// new Integer(String)
// new Double(String)
// new Byte(String)
// new Long(String)
// Long.getLong(String)
// Long.getLong(String,int)
// Long.getLong(String,Integer)
// Long.valueOf(String,int)
// Long.valueOf(String)
// new Short(String)
// Short.decode(String)
// Short.valueOf(String,int)
// Short.valueOf(String)
// new BigDecimal(String)
// new BigInteger(String)
// new BigInteger(String,int radix)
// Possible inputs:
// 45 45.5 45E7 4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd
// plus minus everything. Prolly more. A lot are not separable.
/**
* <p>Turns a string value into a java.lang.Number.</p>
*
* <p>First, the value is examined for a type qualifier on the end
* (<code>'f','F','d','D','l','L'</code>). If it is found, it starts
* trying to create succissively larger types from the type specified
* until one is found that can hold the value.</p>
*
* <p>If a type specifier is not found, it will check for a decimal point
* and then try successively larger types from <code>Integer</code> to
* <code>BigInteger</code> and from <code>Float</code> to
* <code>BigDecimal</code>.</p>
*
* <p>If the string starts with <code>0x</code> or <code>-0x</code>, it
* will be interpreted as a hexadecimal integer. Values with leading
* <code>0</code>'s will not be interpreted as octal.</p>
*
* @param val String containing a number
* @return Number created from the string
* @throws NumberFormatException if the value cannot be converted
*/
public static Number createNumber(String val) throws NumberFormatException {
if (val == null) {
return null;
}
if (val.length() == 0) {
throw new NumberFormatException("\"\" is not a valid number.");
}
if (val.startsWith("--")) {
// this is protection for poorness in java.lang.BigDecimal.
// it accepts this as a legal value, but it does not appear
// to be in specification of class. OS X Java parses it to
// a wrong value.
return null;
}
if (val.startsWith("0x") || val.startsWith("-0x")) {
return createInteger(val);
}
char lastChar = val.charAt(val.length() - 1);
String mant;
String dec;
String exp;
int decPos = val.indexOf('.');
int expPos = val.indexOf('e') + val.indexOf('E') + 1;
if (decPos > -1) {
if (expPos > -1) {
if (expPos < decPos) {
throw new NumberFormatException(val + " is not a valid number.");
}
dec = val.substring(decPos + 1, expPos);
} else {
dec = val.substring(decPos + 1);
}
mant = val.substring(0, decPos);
} else {
if (expPos > -1) {
mant = val.substring(0, expPos);
} else {
mant = val;
}
dec = null;
}
if (!Character.isDigit(lastChar)) {
if (expPos > -1 && expPos < val.length() - 1) {
exp = val.substring(expPos + 1, val.length() - 1);
} else {
exp = null;
}
//Requesting a specific type..
String numeric = val.substring(0, val.length() - 1);
boolean allZeros = isAllZeros(mant) && isAllZeros(exp);
switch (lastChar) {
case 'l' :
case 'L' :
if (dec == null
&& exp == null
&& isDigits(numeric.substring(1))
&& (numeric.charAt(0) == '-' ||
Character.isDigit(numeric.charAt(0)))) {
try {
return createLong(numeric);
} catch (NumberFormatException nfe) {
//Too big for a long
}
return createBigInteger(numeric);
}
throw new NumberFormatException(val + " is not a valid number.");
case 'f' :
case 'F' :
try {
Float f = NumberUtils.createFloat(numeric);
if (!(f.isInfinite() || (f.floatValue() == 0.0F &&
!allZeros))) {
//If it's too big for a float or the float value = 0 and
the string
//has non-zeros in it, then float doens't have the
presision we want
return f;
}
} catch (NumberFormatException nfe) {
}
//Fall through
case 'd' :
case 'D' :
try {
Double d = NumberUtils.createDouble(numeric);
if (!(d.isInfinite() || (d.floatValue() == 0.0D &&
!allZeros))) {
return d;
}
} catch (NumberFormatException nfe) {
}
try {
return createBigDecimal(numeric);
} catch (NumberFormatException e) {
}
//Fall through
default :
throw new NumberFormatException(val + " is not a valid number.");
}
} else {
//User doesn't have a preference on the return type, so let's start
//small and go from there...
if (expPos > -1 && expPos < val.length() - 1) {
exp = val.substring(expPos + 1, val.length());
} else {
exp = null;
}
if (dec == null && exp == null) {
//Must be an int,long,bigint
try {
return createInteger(val);
} catch (NumberFormatException nfe) {
}
try {
return createLong(val);
} catch (NumberFormatException nfe) {
}
return createBigInteger(val);
} else {
//Must be a float,double,BigDec
boolean allZeros = isAllZeros(mant) && isAllZeros(exp);
try {
Float f = createFloat(val);
if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) {
return f;
}
} catch (NumberFormatException nfe) {
}
try {
Double d = createDouble(val);
if (!(d.isInfinite() || (d.doubleValue() == 0.0D && !allZeros)))
{
return d;
}
} catch (NumberFormatException nfe) {
}
return createBigDecimal(val);
}
}
}
/**
* <p>Utility method for [EMAIL PROTECTED] #createNumber(java.lang.String)}.</p>
*
* <p>Returns <code>true</code> if s is <code>null</code>.</p>
*
* @param s the String to check
* @return if it is all zeros or <code>null</code>
*/
private static boolean isAllZeros(String s) {
if (s == null) {
return true;
}
for (int i = s.length() - 1; i >= 0; i--) {
if (s.charAt(i) != '0') {
return false;
}
}
return s.length() > 0;
}
//-----------------------------------------------------------------------
/**
* <p>Convert a <code>String</code> to a <code>Float</code>.</p>
*
* @param val a <code>String</code> to convert
* @return converted <code>Float</code>
* @throws NumberFormatException if the value cannot be converted
*/
public static Float createFloat(String val) {
return Float.valueOf(val);
}
/**
* <p>Convert a <code>String</code> to a <code>Double</code>.</p>
*
* @param val a <code>String</code> to convert
* @return converted <code>Double</code>
* @throws NumberFormatException if the value cannot be converted
*/
public static Double createDouble(String val) {
return Double.valueOf(val);
}
/**
* <p>Convert a <code>String</code> to a <code>Integer</code>, handling
* hex and octal notations.</p>
*
* @param val a <code>String</code> to convert
* @return converted <code>Integer</code>
* @throws NumberFormatException if the value cannot be converted
*/
public static Integer createInteger(String val) {
// decode() handles 0xAABD and 0777 (hex and octal) as well.
return Integer.decode(val);
}
/**
* <p>Convert a <code>String</code> to a <code>Long</code>.</p>
*
* @param val a <code>String</code> to convert
* @return converted <code>Long</code>
* @throws NumberFormatException if the value cannot be converted
*/
public static Long createLong(String val) {
return Long.valueOf(val);
}
/**
* <p>Convert a <code>String</code> to a <code>BigInteger</code>.</p>
*
* @param val a <code>String</code> to convert
* @return converted <code>BigInteger</code>
* @throws NumberFormatException if the value cannot be converted
*/
public static BigInteger createBigInteger(String val) {
BigInteger bi = new BigInteger(val);
return bi;
}
/**
* <p>Convert a <code>String</code> to a <code>BigDecimal</code>.</p>
*
* @param val a <code>String</code> to convert
* @return converted <code>BigDecimal</code>
* @throws NumberFormatException if the value cannot be converted
*/
public static BigDecimal createBigDecimal(String val) {
BigDecimal bd = new BigDecimal(val);
return bd;
}
//-----------------------------------------------------------------------
/**
* <p>Gets the minimum of three <code>long</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static long min(long a, long b, long c) {
if (b < a) {
a = b;
}
if (c < a) {
a = c;
}
return a;
}
/**
* <p>Gets the minimum of three <code>int</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static int min(int a, int b, int c) {
if (b < a) {
a = b;
}
if (c < a) {
a = c;
}
return a;
}
/**
* <p>Gets the minimum of three <code>short</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static short min(short a, short b, short c) {
if (b < a) {
a = b;
}
if (c < a) {
a = c;
}
return a;
}
/**
* <p>Gets the minimum of three <code>byte</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static byte min(byte a, byte b, byte c) {
if (b < a) {
a = b;
}
if (c < a) {
a = c;
}
return a;
}
/**
* <p>Gets the minimum of three <code>double</code> values.</p>
*
* <p>If any value is NaN, NaN is returned. Infinity is handled.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static double min(double a, double b, double c) {
return Math.min(Math.min(a, b), c);
}
/**
* <p>Gets the minimum of three <code>float</code> values.</p>
*
* <p>If any value is NaN, NaN is returned. Infinity is handled.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the smallest of the values
*/
public static float min(float a, float b, float c) {
return Math.min(Math.min(a, b), c);
}
//-----------------------------------------------------------------------
/**
* <p>Gets the maximum of three <code>long</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static long max(long a, long b, long c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
/**
* <p>Gets the maximum of three <code>int</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static int max(int a, int b, int c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
/**
* <p>Gets the maximum of three <code>short</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static short max(short a, short b, short c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
/**
* <p>Gets the maximum of three <code>byte</code> values.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static byte max(byte a, byte b, byte c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
/**
* <p>Gets the maximum of three <code>double</code> values.</p>
*
* <p>If any value is NaN, NaN is returned. Infinity is handled.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static double max(double a, double b, double c) {
return Math.max(Math.max(a, b), c);
}
/**
* <p>Gets the maximum of three <code>float</code> values.</p>
*
* <p>If any value is NaN, NaN is returned. Infinity is handled.</p>
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static float max(float a, float b, float c) {
return Math.max(Math.max(a, b), c);
}
//-----------------------------------------------------------------------
/**
* <p>Compares two <code>doubles</code> for order.</p>
*
* <p>This method is more comprehensive than the standard Java greater
* than, less than and equals operators.</p>
* <ul>
* <li>It returns <code>-1</code> if the first value is less than the second.
* <li>It returns <code>+1</code> if the first value is greater than the second.
* <li>It returns <code>0</code> if the values are equal.
* </ul>
*
* <p>
* The ordering is as follows, largest to smallest:
* <ul>
* <li>NaN
* <li>Positive infinity
* <li>Maximum double
* <li>Normal positve numbers
* <li>+0.0
* <li>-0.0
* <li>Normal negative numbers
* <li>Minimum double (-Double.MAX_VALUE)
* <li>Negative infinity
* </ul>
* </p>
*
* <p>Comparing <code>NaN</code> with <code>NaN</code> will
* return <code>0</code>.</p>
*
* @param lhs the first <code>double</code>
* @param rhs the second <code>double</code>
* @return <code>-1</code> if lhs is less, <code>+1</code> if greater,
* <code>0</code> if equal to rhs
*/
public static int compare(double lhs, double rhs) {
if (lhs < rhs) {
return -1;
}
if (lhs > rhs) {
return +1;
}
// Need to compare bits to handle 0.0 == -0.0 being true
// compare should put -0.0 < +0.0
// Two NaNs are also == for compare purposes
// where NaN == NaN is false
long lhsBits = Double.doubleToLongBits(lhs);
long rhsBits = Double.doubleToLongBits(rhs);
if (lhsBits == rhsBits) {
return 0;
}
// Something exotic! A comparison to NaN or 0.0 vs -0.0
// Fortunately NaN's long is > than everything else
// Also negzeros bits < poszero
// NAN: 9221120237041090560
// MAX: 9218868437227405311
// NEGZERO: -9223372036854775808
if (lhsBits < rhsBits) {
return -1;
} else {
return +1;
}
}
/**
* <p>Compares two floats for order.</p>
*
* <p>This method is more comprhensive than the standard Java greater than,
* less than and equals operators.</p>
* <ul>
* <li>It returns <code>-1</code> if the first value is less than the second.
* <li>It returns <code>+1</code> if the first value is greater than the second.
* <li>It returns <code>0</code> if the values are equal.
* </ul>
*
* <p> The ordering is as follows, largest to smallest:
* <ul>
* <li>NaN
* <li>Positive infinity
* <li>Maximum float
* <li>Normal positve numbers
* <li>+0.0
* <li>-0.0
* <li>Normal negative numbers
* <li>Minimum float (-Float.MAX_VALUE)
* <li>Negative infinity
* </ul>
*
* <p>Comparing <code>NaN</code> with <code>NaN</code> will return
* <code>0</code>.</p>
*
* @param lhs the first <code>float</code>
* @param rhs the second <code>float</code>
* @return <code>-1</code> if lhs is less, <code>+1</code> if greater,
* <code>0</code> if equal to rhs
*/
public static int compare(float lhs, float rhs) {
if (lhs < rhs) {
return -1;
}
if (lhs > rhs) {
return +1;
}
//Need to compare bits to handle 0.0 == -0.0 being true
// compare should put -0.0 < +0.0
// Two NaNs are also == for compare purposes
// where NaN == NaN is false
int lhsBits = Float.floatToIntBits(lhs);
int rhsBits = Float.floatToIntBits(rhs);
if (lhsBits == rhsBits) {
return 0;
}
//Something exotic! A comparison to NaN or 0.0 vs -0.0
//Fortunately NaN's int is > than everything else
//Also negzeros bits < poszero
//NAN: 2143289344
//MAX: 2139095039
//NEGZERO: -2147483648
if (lhsBits < rhsBits) {
return -1;
} else {
return +1;
}
}
//-----------------------------------------------------------------------
/**
* <p>Checks whether the <code>String</code> contains only
* digit characters.</p>
*
* <p><code>Null</code> and empty String will return
* <code>false</code>.</p>
*
* @param str the <code>String</code> to check
* @return <code>true</code> if str contains only unicode numeric
*/
public static boolean isDigits(String str) {
if ((str == null) || (str.length() == 0)) {
return false;
}
for (int i = 0; i < str.length(); i++) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
}
/**
* <p>Checks whether the String a valid Java number.</p>
*
* <p>Valid numbers include hexadecimal marked with the <code>0x</code>
* qualifier, scientific notation and numbers marked with a type
* qualifier (e.g. 123L).</p>
*
* <p><code>Null</code> and empty String will return
* <code>false</code>.</p>
*
* @param str the <code>String</code> to check
* @return <code>true</code> if the string is a correctly formatted number
*/
public static boolean isNumber(String str) {
if ((str == null) || (str.length() == 0)) {
return false;
}
char[] chars = str.toCharArray();
int sz = chars.length;
boolean hasExp = false;
boolean hasDecPoint = false;
boolean allowSigns = false;
boolean foundDigit = false;
// deal with any possible sign up front
int start = (chars[0] == '-') ? 1 : 0;
if (sz > start + 1) {
if (chars[start] == '0' && chars[start + 1] == 'x') {
int i = start + 2;
if (i == sz) {
return false; // str == "0x"
}
// checking hex (it can't be anything else)
for (; i < chars.length; i++) {
if ((chars[i] < '0' || chars[i] > '9')
&& (chars[i] < 'a' || chars[i] > 'f')
&& (chars[i] < 'A' || chars[i] > 'F')) {
return false;
}
}
return true;
}
}
sz--; // don't want to loop to the last char, check it afterwords
// for type qualifiers
int i = start;
// loop to the next to last char or to the last char if we need another
digit to
// make a valid number (e.g. chars[0..5] = "1234E")
while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) {
if (chars[i] >= '0' && chars[i] <= '9') {
foundDigit = true;
allowSigns = false;
} else if (chars[i] == '.') {
if (hasDecPoint || hasExp) {
// two decimal points or dec in exponent
return false;
}
hasDecPoint = true;
} else if (chars[i] == 'e' || chars[i] == 'E') {
// we've already taken care of hex.
if (hasExp) {
// two E's
return false;
}
if (!foundDigit) {
return false;
}
hasExp = true;
allowSigns = true;
} else if (chars[i] == '+' || chars[i] == '-') {
if (!allowSigns) {
return false;
}
allowSigns = false;
foundDigit = false; // we need a digit after the E
} else {
return false;
}
i++;
}
if (i < chars.length) {
if (chars[i] >= '0' && chars[i] <= '9') {
// no type qualifier, OK
return true;
}
if (chars[i] == 'e' || chars[i] == 'E') {
// can't have an E at the last byte
return false;
}
if (!allowSigns
&& (chars[i] == 'd'
|| chars[i] == 'D'
|| chars[i] == 'f'
|| chars[i] == 'F')) {
return foundDigit;
}
if (chars[i] == 'l'
|| chars[i] == 'L') {
// not allowing L with an exponoent
return foundDigit && !hasExp;
}
// last character is illegal
return false;
}
// allowSigns is true iff the val ends in 'E'
// found digit it to make sure weird stuff like '.' and '1E-' doesn't pass
return !allowSigns && foundDigit;
}
}
1.15 +3 -2
jakarta-commons/lang/src/java/org/apache/commons/lang/builder/CompareToBuilder.java
Index: CompareToBuilder.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/builder/CompareToBuilder.java,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -r1.14 -r1.15
--- CompareToBuilder.java 18 Apr 2003 09:12:16 -0000 1.14
+++ CompareToBuilder.java 24 Jun 2003 21:14:50 -0000 1.15
@@ -57,7 +57,8 @@
import java.lang.reflect.Modifier;
import java.util.Comparator;
-import org.apache.commons.lang.NumberUtils;
+import org.apache.commons.lang.math.NumberUtils;
+
/**
* <p><code>CompareTo</code> generation routines.</p>
*
1.5 +3 -1
jakarta-commons/lang/src/java/org/apache/commons/lang/BooleanUtils.java
Index: BooleanUtils.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/BooleanUtils.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- BooleanUtils.java 4 Feb 2003 22:50:31 -0000 1.4
+++ BooleanUtils.java 24 Jun 2003 21:14:50 -0000 1.5
@@ -53,6 +53,8 @@
*/
package org.apache.commons.lang;
+import org.apache.commons.lang.math.NumberUtils;
+
/**
* <p><code>BooleanUtils</code> contains utility methods for working for
* boolean and Boolean objects.</p>
1.11 +6 -38
jakarta-commons/lang/src/java/org/apache/commons/lang/NumberUtils.java
Index: NumberUtils.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/NumberUtils.java,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -r1.10 -r1.11
--- NumberUtils.java 8 Jun 2003 14:14:01 -0000 1.10
+++ NumberUtils.java 24 Jun 2003 21:14:50 -0000 1.11
@@ -55,6 +55,7 @@
import java.math.BigInteger;
import java.math.BigDecimal;
+
/**
* <p>Provides extra functionality for Java Number classes.</p>
*
@@ -66,46 +67,13 @@
* @author Phil Steitz
* @since 1.0
* @version $Id$
+ *
+ * @deprecated Moved to org.apache.commons.lang.math.
+ * Class will be removed in Commons Lang 3.0.
*/
public final class NumberUtils {
+ // DEPRECATED CLASS !!!
- /** Reusable Long constant for zero. */
- public static final Long LONG_ZERO = new Long(0L);
- /** Reusable Long constant for one. */
- public static final Long LONG_ONE = new Long(1L);
- /** Reusable Long constant for minus one. */
- public static final Long LONG_MINUS_ONE = new Long(-1L);
- /** Reusable Integer constant for zero. */
- public static final Integer INTEGER_ZERO = new Integer(0);
- /** Reusable Integer constant for one. */
- public static final Integer INTEGER_ONE = new Integer(1);
- /** Reusable Integer constant for minus one. */
- public static final Integer INTEGER_MINUS_ONE = new Integer(-1);
- /** Reusable Short constant for zero. */
- public static final Short SHORT_ZERO = new Short((short) 0);
- /** Reusable Short constant for one. */
- public static final Short SHORT_ONE = new Short((short) 1);
- /** Reusable Short constant for minus one. */
- public static final Short SHORT_MINUS_ONE = new Short((short) -1);
- /** Reusable Byte constant for zero. */
- public static final Byte BYTE_ZERO = new Byte((byte) 0);
- /** Reusable Byte constant for one. */
- public static final Byte BYTE_ONE = new Byte((byte) 1);
- /** Reusable Byte constant for minus one. */
- public static final Byte BYTE_MINUS_ONE = new Byte((byte) -1);
- /** Reusable Double constant for zero. */
- public static final Double DOUBLE_ZERO = new Double(0.0d);
- /** Reusable Double constant for one. */
- public static final Double DOUBLE_ONE = new Double(1.0d);
- /** Reusable Double constant for minus one. */
- public static final Double DOUBLE_MINUS_ONE = new Double(-1.0d);
- /** Reusable Float constant for zero. */
- public static final Float FLOAT_ZERO = new Float(0.0f);
- /** Reusable Float constant for one. */
- public static final Float FLOAT_ONE = new Float(1.0f);
- /** Reusable Float constant for minus one. */
- public static final Float FLOAT_MINUS_ONE = new Float(-1.0f);
-
/**
* <p><code>NumberUtils</code> instances should NOT be constructed in standard
programming.
* Instead, the class should be used as
<code>NumberUtils.stringToInt("6");</code>.</p>
1.51 +4 -2
jakarta-commons/lang/src/java/org/apache/commons/lang/StringUtils.java
Index: StringUtils.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/StringUtils.java,v
retrieving revision 1.50
retrieving revision 1.51
diff -u -r1.50 -r1.51
--- StringUtils.java 24 Jun 2003 08:15:15 -0000 1.50
+++ StringUtils.java 24 Jun 2003 21:14:50 -0000 1.51
@@ -56,6 +56,8 @@
import java.util.Iterator;
import java.util.StringTokenizer;
+import org.apache.commons.lang.math.NumberUtils;
+
/**
* <p>Common <code>String</code> manipulation routines.</p>
*
@@ -2292,7 +2294,7 @@
}
// Step 6
- d[i][j] = NumberUtils.minimum(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i
- 1][j - 1] + cost);
+ d[i][j] = NumberUtils.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i -
1][j - 1] + cost);
}
}
1.4 +3 -2
jakarta-commons/lang/src/test/org/apache/commons/lang/math/MathTestSuite.java
Index: MathTestSuite.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/math/MathTestSuite.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- MathTestSuite.java 14 May 2003 02:41:26 -0000 1.3
+++ MathTestSuite.java 24 Jun 2003 21:14:51 -0000 1.4
@@ -1,7 +1,7 @@
/* ====================================================================
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2002 The Apache Software Foundation. All rights
+ * Copyright (c) 2002-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -91,6 +91,7 @@
suite.addTest(IntRangeTest.suite());
suite.addTest(LongRangeTest.suite());
suite.addTest(NumberRangeTest.suite());
+ suite.addTest(NumberUtilsTest.suite());
suite.addTest(RandomUtilsTest.suite());
return suite;
}
1.1
jakarta-commons/lang/src/test/org/apache/commons/lang/math/NumberUtilsTest.java
Index: NumberUtilsTest.java
===================================================================
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Commons", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact [EMAIL PROTECTED]
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.commons.lang.math;
import java.math.BigDecimal;
import java.math.BigInteger;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.apache.commons.lang.SystemUtils;
/**
* Unit tests [EMAIL PROTECTED] org.apache.commons.lang.math.NumberUtils}.
*
* @author <a href="mailto:[EMAIL PROTECTED]">Rand McNeely</a>
* @author <a href="mailto:[EMAIL PROTECTED]">Ringo De Smet</a>
* @author Eric Pugh
* @author Phil Steitz
* @author Stephen Colebourne
* @version $Id: NumberUtilsTest.java,v 1.1 2003/06/24 21:14:51 scolebourne Exp $
*/
public class NumberUtilsTest extends TestCase {
public NumberUtilsTest(String name) {
super(name);
}
public static Test suite() {
TestSuite suite = new TestSuite(NumberUtilsTest.class);
suite.setName("NumberUtils Tests");
return suite;
}
//---------------------------------------------------------------------
/**
* Test for int stringToInt(String)
*/
public void testStringToIntString() {
assertTrue("stringToInt(String) 1 failed", NumberUtils.stringToInt("12345")
== 12345);
assertTrue("stringToInt(String) 2 failed", NumberUtils.stringToInt("abc") ==
0);
}
/**
* Test for int stringToInt(String, int)
*/
public void testStringToIntStringI() {
assertTrue("stringToInt(String,int) 1 failed",
NumberUtils.stringToInt("12345", 5) == 12345);
assertTrue("stringToInt(String,int) 2 failed",
NumberUtils.stringToInt("1234.5", 5) == 5);
}
public void testCreateNumber() {
//a lot of things can go wrong
assertEquals("createNumber(String) 1 failed", new Float("1234.5"),
NumberUtils.createNumber("1234.5"));
assertEquals("createNumber(String) 2 failed", new Integer("12345"),
NumberUtils.createNumber("12345"));
assertEquals("createNumber(String) 3 failed", new Double("1234.5"),
NumberUtils.createNumber("1234.5D"));
assertEquals("createNumber(String) 4 failed", new Float("1234.5"),
NumberUtils.createNumber("1234.5F"));
assertEquals("createNumber(String) 5 failed", new Long(Integer.MAX_VALUE +
1L), NumberUtils.createNumber("" + (Integer.MAX_VALUE + 1L)));
assertEquals("createNumber(String) 6 failed", new Long(12345),
NumberUtils.createNumber("12345L"));
assertEquals("createNumber(String) 7 failed", new Float("-1234.5"),
NumberUtils.createNumber("-1234.5"));
assertEquals("createNumber(String) 8 failed", new Integer("-12345"),
NumberUtils.createNumber("-12345"));
assertTrue("createNumber(String) 9 failed", 0xFADE ==
NumberUtils.createNumber("0xFADE").intValue());
assertTrue("createNumber(String) 10 failed", -0xFADE ==
NumberUtils.createNumber("-0xFADE").intValue());
assertEquals("createNumber(String) 11 failed", new Double("1.1E200"),
NumberUtils.createNumber("1.1E200"));
assertEquals("createNumber(String) 12 failed", new Float("1.1E20"),
NumberUtils.createNumber("1.1E20"));
assertEquals("createNumber(String) 13 failed", new Double("-1.1E200"),
NumberUtils.createNumber("-1.1E200"));
assertEquals("createNumber(String) 14 failed", new Double("1.1E-200"),
NumberUtils.createNumber("1.1E-200"));
// jdk 1.2 doesn't support this. unsure about jdk 1.2.2
if(SystemUtils.isJavaVersionAtLeast(1.3f)) {
assertEquals("createNumber(String) 15 failed", new
BigDecimal("1.1E-700"), NumberUtils.createNumber("1.1E-700F"));
}
assertEquals(
"createNumber(String) 16 failed",
new Long("10" + Integer.MAX_VALUE),
NumberUtils.createNumber("10" + Integer.MAX_VALUE + "L"));
assertEquals(
"createNumber(String) 17 failed",
new Long("10" + Integer.MAX_VALUE),
NumberUtils.createNumber("10" + Integer.MAX_VALUE));
assertEquals(
"createNumber(String) 18 failed",
new BigInteger("10" + Long.MAX_VALUE),
NumberUtils.createNumber("10" + Long.MAX_VALUE));
}
public void testCreateFloat() {
assertEquals("createFloat(String) failed", new Float("1234.5"),
NumberUtils.createFloat("1234.5"));
}
public void testCreateDouble() {
assertEquals("createDouble(String) failed", new Double("1234.5"),
NumberUtils.createDouble("1234.5"));
}
public void testCreateInteger() {
assertEquals("createInteger(String) failed", new Integer("12345"),
NumberUtils.createInteger("12345"));
}
public void testCreateLong() {
assertEquals("createInteger(String) failed", new Long("12345"),
NumberUtils.createLong("12345"));
}
public void testCreateBigInteger() {
assertEquals("createBigInteger(String) failed", new BigInteger("12345"),
NumberUtils.createBigInteger("12345"));
}
public void testCreateBigDecimal() {
assertEquals("createBigDecimal(String) failed", new BigDecimal("1234.5"),
NumberUtils.createBigDecimal("1234.5"));
}
public void testMinimumLong() {
assertEquals("minimum(long,long,long) 1 failed", 12345L,
NumberUtils.min(12345L, 12345L + 1L, 12345L + 2L));
assertEquals("minimum(long,long,long) 2 failed", 12345L,
NumberUtils.min(12345L + 1L, 12345L, 12345 + 2L));
assertEquals("minimum(long,long,long) 3 failed", 12345L,
NumberUtils.min(12345L + 1L, 12345L + 2L, 12345L));
assertEquals("minimum(long,long,long) 4 failed", 12345L,
NumberUtils.min(12345L + 1L, 12345L, 12345L));
assertEquals("minimum(long,long,long) 5 failed", 12345L,
NumberUtils.min(12345L, 12345L, 12345L));
}
public void testMinimumInt() {
assertEquals("minimum(int,int,int) 1 failed", 12345, NumberUtils.min(12345,
12345 + 1, 12345 + 2));
assertEquals("minimum(int,int,int) 2 failed", 12345, NumberUtils.min(12345 +
1, 12345, 12345 + 2));
assertEquals("minimum(int,int,int) 3 failed", 12345, NumberUtils.min(12345 +
1, 12345 + 2, 12345));
assertEquals("minimum(int,int,int) 4 failed", 12345, NumberUtils.min(12345 +
1, 12345, 12345));
assertEquals("minimum(int,int,int) 5 failed", 12345, NumberUtils.min(12345,
12345, 12345));
}
public void testMinimumShort() {
short low = 1234;
short mid = 1234 + 1;
short high = 1234 + 2;
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(low, mid,
high));
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(mid, low,
high));
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(mid,
high, low));
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(low, mid,
low));
}
public void testMinimumByte() {
byte low = 123;
byte mid = 123 + 1;
byte high = 123 + 2;
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(low, mid,
high));
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(mid, low,
high));
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(mid,
high, low));
assertEquals("minimum(int,int,int) 1 failed", low, NumberUtils.min(low, mid,
low));
}
public void testMaximumLong() {
assertEquals("maximum(long,long,long) 1 failed", 12345L,
NumberUtils.max(12345L, 12345L - 1L, 12345L - 2L));
assertEquals("maximum(long,long,long) 2 failed", 12345L,
NumberUtils.max(12345L - 1L, 12345L, 12345L - 2L));
assertEquals("maximum(long,long,long) 3 failed", 12345L,
NumberUtils.max(12345L - 1L, 12345L - 2L, 12345L));
assertEquals("maximum(long,long,long) 4 failed", 12345L,
NumberUtils.max(12345L - 1L, 12345L, 12345L));
assertEquals("maximum(long,long,long) 5 failed", 12345L,
NumberUtils.max(12345L, 12345L, 12345L));
}
public void testMaximumInt() {
assertEquals("maximum(int,int,int) 1 failed", 12345, NumberUtils.max(12345,
12345 - 1, 12345 - 2));
assertEquals("maximum(int,int,int) 2 failed", 12345, NumberUtils.max(12345 -
1, 12345, 12345 - 2));
assertEquals("maximum(int,int,int) 3 failed", 12345, NumberUtils.max(12345 -
1, 12345 - 2, 12345));
assertEquals("maximum(int,int,int) 4 failed", 12345, NumberUtils.max(12345 -
1, 12345, 12345));
assertEquals("maximum(int,int,int) 5 failed", 12345, NumberUtils.max(12345,
12345, 12345));
}
public void testMaximumShort() {
short low = 1234;
short mid = 1234 + 1;
short high = 1234 + 2;
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(low,
mid, high));
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(mid,
low, high));
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(mid,
high, low));
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(high,
mid, high));
}
public void testMaximumByte() {
byte low = 123;
byte mid = 123 + 1;
byte high = 123 + 2;
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(low,
mid, high));
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(mid,
low, high));
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(mid,
high, low));
assertEquals("minimum(int,int,int) 1 failed", high, NumberUtils.max(high,
mid, high));
}
public void testCompareDouble() {
assertTrue(NumberUtils.compare(Double.NaN, Double.NaN) == 0);
assertTrue(NumberUtils.compare(Double.NaN, Double.POSITIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(Double.NaN, Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(Double.NaN, 1.2d) == +1);
assertTrue(NumberUtils.compare(Double.NaN, 0.0d) == +1);
assertTrue(NumberUtils.compare(Double.NaN, -0.0d) == +1);
assertTrue(NumberUtils.compare(Double.NaN, -1.2d) == +1);
assertTrue(NumberUtils.compare(Double.NaN, -Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(Double.NaN, Double.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, Double.NaN) == -1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY,
Double.POSITIVE_INFINITY) == 0);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, Double.MAX_VALUE)
== +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, 1.2d) == +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, 0.0d) == +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, -0.0d) == +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, -1.2d) == +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY, -Double.MAX_VALUE)
== +1);
assertTrue(NumberUtils.compare(Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, Double.NaN) == -1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, Double.POSITIVE_INFINITY)
== -1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, Double.MAX_VALUE) == 0);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, 1.2d) == +1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, 0.0d) == +1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, -0.0d) == +1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, -1.2d) == +1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, -Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(Double.MAX_VALUE, Double.NEGATIVE_INFINITY)
== +1);
assertTrue(NumberUtils.compare(1.2d, Double.NaN) == -1);
assertTrue(NumberUtils.compare(1.2d, Double.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(1.2d, Double.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(1.2d, 1.2d) == 0);
assertTrue(NumberUtils.compare(1.2d, 0.0d) == +1);
assertTrue(NumberUtils.compare(1.2d, -0.0d) == +1);
assertTrue(NumberUtils.compare(1.2d, -1.2d) == +1);
assertTrue(NumberUtils.compare(1.2d, -Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(1.2d, Double.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(0.0d, Double.NaN) == -1);
assertTrue(NumberUtils.compare(0.0d, Double.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(0.0d, Double.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(0.0d, 1.2d) == -1);
assertTrue(NumberUtils.compare(0.0d, 0.0d) == 0);
assertTrue(NumberUtils.compare(0.0d, -0.0d) == +1);
assertTrue(NumberUtils.compare(0.0d, -1.2d) == +1);
assertTrue(NumberUtils.compare(0.0d, -Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(0.0d, Double.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(-0.0d, Double.NaN) == -1);
assertTrue(NumberUtils.compare(-0.0d, Double.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(-0.0d, Double.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(-0.0d, 1.2d) == -1);
assertTrue(NumberUtils.compare(-0.0d, 0.0d) == -1);
assertTrue(NumberUtils.compare(-0.0d, -0.0d) == 0);
assertTrue(NumberUtils.compare(-0.0d, -1.2d) == +1);
assertTrue(NumberUtils.compare(-0.0d, -Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(-0.0d, Double.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(-1.2d, Double.NaN) == -1);
assertTrue(NumberUtils.compare(-1.2d, Double.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(-1.2d, Double.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(-1.2d, 1.2d) == -1);
assertTrue(NumberUtils.compare(-1.2d, 0.0d) == -1);
assertTrue(NumberUtils.compare(-1.2d, -0.0d) == -1);
assertTrue(NumberUtils.compare(-1.2d, -1.2d) == 0);
assertTrue(NumberUtils.compare(-1.2d, -Double.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(-1.2d, Double.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, Double.NaN) == -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, Double.POSITIVE_INFINITY)
== -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, Double.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, 1.2d) == -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, 0.0d) == -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, -0.0d) == -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, -1.2d) == -1);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, -Double.MAX_VALUE) == 0);
assertTrue(NumberUtils.compare(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY)
== +1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, Double.NaN) == -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY,
Double.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, Double.MAX_VALUE)
== -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, 1.2d) == -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, 0.0d) == -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, -0.0d) == -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, -1.2d) == -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY, -Double.MAX_VALUE)
== -1);
assertTrue(NumberUtils.compare(Double.NEGATIVE_INFINITY,
Double.NEGATIVE_INFINITY) == 0);
}
public void testCompareFloat() {
assertTrue(NumberUtils.compare(Float.NaN, Float.NaN) == 0);
assertTrue(NumberUtils.compare(Float.NaN, Float.POSITIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(Float.NaN, Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(Float.NaN, 1.2f) == +1);
assertTrue(NumberUtils.compare(Float.NaN, 0.0f) == +1);
assertTrue(NumberUtils.compare(Float.NaN, -0.0f) == +1);
assertTrue(NumberUtils.compare(Float.NaN, -1.2f) == +1);
assertTrue(NumberUtils.compare(Float.NaN, -Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(Float.NaN, Float.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, Float.NaN) == -1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY,
Float.POSITIVE_INFINITY) == 0);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, Float.MAX_VALUE) ==
+1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, 1.2f) == +1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, 0.0f) == +1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, -0.0f) == +1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, -1.2f) == +1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY, -Float.MAX_VALUE) ==
+1);
assertTrue(NumberUtils.compare(Float.POSITIVE_INFINITY,
Float.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, Float.NaN) == -1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, Float.POSITIVE_INFINITY) ==
-1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, Float.MAX_VALUE) == 0);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, 1.2f) == +1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, 0.0f) == +1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, -0.0f) == +1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, -1.2f) == +1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, -Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(Float.MAX_VALUE, Float.NEGATIVE_INFINITY) ==
+1);
assertTrue(NumberUtils.compare(1.2f, Float.NaN) == -1);
assertTrue(NumberUtils.compare(1.2f, Float.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(1.2f, Float.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(1.2f, 1.2f) == 0);
assertTrue(NumberUtils.compare(1.2f, 0.0f) == +1);
assertTrue(NumberUtils.compare(1.2f, -0.0f) == +1);
assertTrue(NumberUtils.compare(1.2f, -1.2f) == +1);
assertTrue(NumberUtils.compare(1.2f, -Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(1.2f, Float.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(0.0f, Float.NaN) == -1);
assertTrue(NumberUtils.compare(0.0f, Float.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(0.0f, Float.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(0.0f, 1.2f) == -1);
assertTrue(NumberUtils.compare(0.0f, 0.0f) == 0);
assertTrue(NumberUtils.compare(0.0f, -0.0f) == +1);
assertTrue(NumberUtils.compare(0.0f, -1.2f) == +1);
assertTrue(NumberUtils.compare(0.0f, -Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(0.0f, Float.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(-0.0f, Float.NaN) == -1);
assertTrue(NumberUtils.compare(-0.0f, Float.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(-0.0f, Float.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(-0.0f, 1.2f) == -1);
assertTrue(NumberUtils.compare(-0.0f, 0.0f) == -1);
assertTrue(NumberUtils.compare(-0.0f, -0.0f) == 0);
assertTrue(NumberUtils.compare(-0.0f, -1.2f) == +1);
assertTrue(NumberUtils.compare(-0.0f, -Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(-0.0f, Float.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(-1.2f, Float.NaN) == -1);
assertTrue(NumberUtils.compare(-1.2f, Float.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(-1.2f, Float.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(-1.2f, 1.2f) == -1);
assertTrue(NumberUtils.compare(-1.2f, 0.0f) == -1);
assertTrue(NumberUtils.compare(-1.2f, -0.0f) == -1);
assertTrue(NumberUtils.compare(-1.2f, -1.2f) == 0);
assertTrue(NumberUtils.compare(-1.2f, -Float.MAX_VALUE) == +1);
assertTrue(NumberUtils.compare(-1.2f, Float.NEGATIVE_INFINITY) == +1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, Float.NaN) == -1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, Float.POSITIVE_INFINITY) ==
-1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, Float.MAX_VALUE) == -1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, 1.2f) == -1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, 0.0f) == -1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, -0.0f) == -1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, -1.2f) == -1);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, -Float.MAX_VALUE) == 0);
assertTrue(NumberUtils.compare(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY) ==
+1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, Float.NaN) == -1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY,
Float.POSITIVE_INFINITY) == -1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, Float.MAX_VALUE) ==
-1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, 1.2f) == -1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, 0.0f) == -1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, -0.0f) == -1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, -1.2f) == -1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE) ==
-1);
assertTrue(NumberUtils.compare(Float.NEGATIVE_INFINITY,
Float.NEGATIVE_INFINITY) == 0);
}
public void testIsDigits() {
assertEquals("isDigits(null) failed", false, NumberUtils.isDigits(null));
assertEquals("isDigits('') failed", false, NumberUtils.isDigits(""));
assertEquals("isDigits(String) failed", true, NumberUtils.isDigits("12345"));
assertEquals("isDigits(String) neg 1 failed", false,
NumberUtils.isDigits("1234.5"));
assertEquals("isDigits(String) neg 3 failed", false,
NumberUtils.isDigits("1ab"));
assertEquals("isDigits(String) neg 4 failed", false,
NumberUtils.isDigits("abc"));
}
/**
* Tests isNumber(String) and tests that createNumber(String) returns
* a valid number iff isNumber(String) returns false.
*/
public void testIsNumber() {
String val = "12345";
assertTrue("isNumber(String) 1 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 1 failed",
checkCreateNumber(val));
val = "1234.5";
assertTrue("isNumber(String) 2 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 2 failed",
checkCreateNumber(val));
val = ".12345";
assertTrue("isNumber(String) 3 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 3 failed",
checkCreateNumber(val));
val = "1234E5";
assertTrue("isNumber(String) 4 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 4 failed",
checkCreateNumber(val));
val = "1234E+5";
assertTrue("isNumber(String) 5 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 5 failed",
checkCreateNumber(val));
val = "1234E-5";
assertTrue("isNumber(String) 6 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 6 failed",
checkCreateNumber(val));
val = "123.4E5";
assertTrue("isNumber(String) 7 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 7 failed",
checkCreateNumber(val));
val = "-1234";
assertTrue("isNumber(String) 8 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 8 failed",
checkCreateNumber(val));
val = "-1234.5";
assertTrue("isNumber(String) 9 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 9 failed",
checkCreateNumber(val));
val = "-.12345";
assertTrue("isNumber(String) 10 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 10 failed",
checkCreateNumber(val));
val = "-1234E5";
assertTrue("isNumber(String) 11 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 11 failed",
checkCreateNumber(val));
val = "0";
assertTrue("isNumber(String) 12 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 12 failed",
checkCreateNumber(val));
val = "-0";
assertTrue("isNumber(String) 13 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 13 failed",
checkCreateNumber(val));
val = "01234";
assertTrue("isNumber(String) 14 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 14 failed",
checkCreateNumber(val));
val = "-01234";
assertTrue("isNumber(String) 15 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 15 failed",
checkCreateNumber(val));
val = "0xABC123";
assertTrue("isNumber(String) 16 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 16 failed",
checkCreateNumber(val));
val = "0x0";
assertTrue("isNumber(String) 17 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 17 failed",
checkCreateNumber(val));
val = "123.4E21D";
assertTrue("isNumber(String) 19 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 19 failed",
checkCreateNumber(val));
val = "-221.23F";
assertTrue("isNumber(String) 20 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 20 failed",
checkCreateNumber(val));
val = "22338L";
assertTrue("isNumber(String) 21 failed", NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 21 failed",
checkCreateNumber(val));
val = null;
assertTrue("isNumber(String) 1 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 1 Neg failed",
!checkCreateNumber(val));
val = "";
assertTrue("isNumber(String) 2 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 2 Neg failed",
!checkCreateNumber(val));
val = "--2.3";
assertTrue("isNumber(String) 3 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 3 Neg failed",
!checkCreateNumber(val));
val = ".12.3";
assertTrue("isNumber(String) 4 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 4 Neg failed",
!checkCreateNumber(val));
val = "-123E";
assertTrue("isNumber(String) 5 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 5 Neg failed",
!checkCreateNumber(val));
val = "-123E+-212";
assertTrue("isNumber(String) 6 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 6 Neg failed",
!checkCreateNumber(val));
val = "-123E2.12";
assertTrue("isNumber(String) 7 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 7 Neg failed",
!checkCreateNumber(val));
val = "0xGF";
assertTrue("isNumber(String) 8 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 8 Neg failed",
!checkCreateNumber(val));
val = "0xFAE-1";
assertTrue("isNumber(String) 9 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 9 Neg failed",
!checkCreateNumber(val));
val = ".";
assertTrue("isNumber(String) 10 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 10 Neg failed",
!checkCreateNumber(val));
val = "-0ABC123";
assertTrue("isNumber(String) 11 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 11 Neg failed",
!checkCreateNumber(val));
val = "123.4E-D";
assertTrue("isNumber(String) 12 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 12 Neg failed",
!checkCreateNumber(val));
val = "123.4ED";
assertTrue("isNumber(String) 13 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 13 Neg failed",
!checkCreateNumber(val));
val = "1234E5l";
assertTrue("isNumber(String) 14 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 14 Neg failed",
!checkCreateNumber(val));
val = "11a";
assertTrue("isNumber(String) 15 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 15 Neg failed",
!checkCreateNumber(val));
val = "1a";
assertTrue("isNumber(String) 16 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 16 Neg failed",
!checkCreateNumber(val));
val = "a";
assertTrue("isNumber(String) 17 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 17 Neg failed",
!checkCreateNumber(val));
val = "11g";
assertTrue("isNumber(String) 18 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 18 Neg failed",
!checkCreateNumber(val));
val = "11z";
assertTrue("isNumber(String) 19 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 19 Neg failed",
!checkCreateNumber(val));
val = "11def";
assertTrue("isNumber(String) 20 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 20 Neg failed",
!checkCreateNumber(val));
val = "11d11";
assertTrue("isNumber(String) 21 Neg failed", !NumberUtils.isNumber(val));
assertTrue("isNumber(String)/createNumber(String) 21 Neg failed",
!checkCreateNumber(val));
}
private boolean checkCreateNumber(String val) {
try {
Object obj = NumberUtils.createNumber(val);
if (obj == null) {
return false;
}
return true;
} catch (NumberFormatException e) {
return false;
} catch (NullPointerException e) {
return false;
}
}
public void testConstants() {
assertTrue(NumberUtils.LONG_ZERO instanceof Long);
assertTrue(NumberUtils.LONG_ONE instanceof Long);
assertTrue(NumberUtils.LONG_MINUS_ONE instanceof Long);
assertTrue(NumberUtils.INTEGER_ZERO instanceof Integer);
assertTrue(NumberUtils.INTEGER_ONE instanceof Integer);
assertTrue(NumberUtils.INTEGER_MINUS_ONE instanceof Integer);
assertTrue(NumberUtils.SHORT_ZERO instanceof Short);
assertTrue(NumberUtils.SHORT_ONE instanceof Short);
assertTrue(NumberUtils.SHORT_MINUS_ONE instanceof Short);
assertTrue(NumberUtils.BYTE_ZERO instanceof Byte);
assertTrue(NumberUtils.BYTE_ONE instanceof Byte);
assertTrue(NumberUtils.BYTE_MINUS_ONE instanceof Byte);
assertTrue(NumberUtils.DOUBLE_ZERO instanceof Double);
assertTrue(NumberUtils.DOUBLE_ONE instanceof Double);
assertTrue(NumberUtils.DOUBLE_MINUS_ONE instanceof Double);
assertTrue(NumberUtils.FLOAT_ZERO instanceof Float);
assertTrue(NumberUtils.FLOAT_ONE instanceof Float);
assertTrue(NumberUtils.FLOAT_MINUS_ONE instanceof Float);
assertTrue(NumberUtils.LONG_ZERO.longValue() == 0);
assertTrue(NumberUtils.LONG_ONE.longValue() == 1);
assertTrue(NumberUtils.LONG_MINUS_ONE.longValue() == -1);
assertTrue(NumberUtils.INTEGER_ZERO.intValue() == 0);
assertTrue(NumberUtils.INTEGER_ONE.intValue() == 1);
assertTrue(NumberUtils.INTEGER_MINUS_ONE.intValue() == -1);
assertTrue(NumberUtils.SHORT_ZERO.shortValue() == 0);
assertTrue(NumberUtils.SHORT_ONE.shortValue() == 1);
assertTrue(NumberUtils.SHORT_MINUS_ONE.shortValue() == -1);
assertTrue(NumberUtils.BYTE_ZERO.byteValue() == 0);
assertTrue(NumberUtils.BYTE_ONE.byteValue() == 1);
assertTrue(NumberUtils.BYTE_MINUS_ONE.byteValue() == -1);
assertTrue(NumberUtils.DOUBLE_ZERO.doubleValue() == 0.0d);
assertTrue(NumberUtils.DOUBLE_ONE.doubleValue() == 1.0d);
assertTrue(NumberUtils.DOUBLE_MINUS_ONE.doubleValue() == -1.0d);
assertTrue(NumberUtils.FLOAT_ZERO.floatValue() == 0.0f);
assertTrue(NumberUtils.FLOAT_ONE.floatValue() == 1.0f);
assertTrue(NumberUtils.FLOAT_MINUS_ONE.floatValue() == -1.0f);
}
}
1.8 +1 -40
jakarta-commons/lang/src/test/org/apache/commons/lang/NumberUtilsTest.java
Index: NumberUtilsTest.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/NumberUtilsTest.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- NumberUtilsTest.java 8 Jun 2003 14:14:01 -0000 1.7
+++ NumberUtilsTest.java 24 Jun 2003 21:14:51 -0000 1.8
@@ -534,43 +534,4 @@
}
}
- public void testConstants() {
- assertTrue(NumberUtils.LONG_ZERO instanceof Long);
- assertTrue(NumberUtils.LONG_ONE instanceof Long);
- assertTrue(NumberUtils.LONG_MINUS_ONE instanceof Long);
- assertTrue(NumberUtils.INTEGER_ZERO instanceof Integer);
- assertTrue(NumberUtils.INTEGER_ONE instanceof Integer);
- assertTrue(NumberUtils.INTEGER_MINUS_ONE instanceof Integer);
- assertTrue(NumberUtils.SHORT_ZERO instanceof Short);
- assertTrue(NumberUtils.SHORT_ONE instanceof Short);
- assertTrue(NumberUtils.SHORT_MINUS_ONE instanceof Short);
- assertTrue(NumberUtils.BYTE_ZERO instanceof Byte);
- assertTrue(NumberUtils.BYTE_ONE instanceof Byte);
- assertTrue(NumberUtils.BYTE_MINUS_ONE instanceof Byte);
- assertTrue(NumberUtils.DOUBLE_ZERO instanceof Double);
- assertTrue(NumberUtils.DOUBLE_ONE instanceof Double);
- assertTrue(NumberUtils.DOUBLE_MINUS_ONE instanceof Double);
- assertTrue(NumberUtils.FLOAT_ZERO instanceof Float);
- assertTrue(NumberUtils.FLOAT_ONE instanceof Float);
- assertTrue(NumberUtils.FLOAT_MINUS_ONE instanceof Float);
-
- assertTrue(NumberUtils.LONG_ZERO.longValue() == 0);
- assertTrue(NumberUtils.LONG_ONE.longValue() == 1);
- assertTrue(NumberUtils.LONG_MINUS_ONE.longValue() == -1);
- assertTrue(NumberUtils.INTEGER_ZERO.intValue() == 0);
- assertTrue(NumberUtils.INTEGER_ONE.intValue() == 1);
- assertTrue(NumberUtils.INTEGER_MINUS_ONE.intValue() == -1);
- assertTrue(NumberUtils.SHORT_ZERO.shortValue() == 0);
- assertTrue(NumberUtils.SHORT_ONE.shortValue() == 1);
- assertTrue(NumberUtils.SHORT_MINUS_ONE.shortValue() == -1);
- assertTrue(NumberUtils.BYTE_ZERO.byteValue() == 0);
- assertTrue(NumberUtils.BYTE_ONE.byteValue() == 1);
- assertTrue(NumberUtils.BYTE_MINUS_ONE.byteValue() == -1);
- assertTrue(NumberUtils.DOUBLE_ZERO.doubleValue() == 0.0d);
- assertTrue(NumberUtils.DOUBLE_ONE.doubleValue() == 1.0d);
- assertTrue(NumberUtils.DOUBLE_MINUS_ONE.doubleValue() == -1.0d);
- assertTrue(NumberUtils.FLOAT_ZERO.floatValue() == 0.0f);
- assertTrue(NumberUtils.FLOAT_ONE.floatValue() == 1.0f);
- assertTrue(NumberUtils.FLOAT_MINUS_ONE.floatValue() == -1.0f);
- }
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
