Removed deprecated org.apache.commons.lang.NumberUtils class as per LANG-438
git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@753625 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Henri Yandell
parent
cba79c706b
commit
5ca11e049c
|
|
@ -1,715 +0,0 @@
|
|||
/*
|
||||
* 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.lang;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.BigInteger;
|
||||
|
||||
/**
|
||||
* <p>Provides extra functionality for Java Number classes.</p>
|
||||
*
|
||||
* @author <a href="mailto:rand_mcneely@yahoo.com">Rand McNeely</a>
|
||||
* @author Stephen Colebourne
|
||||
* @author <a href="mailto:steve.downey@netfolio.com">Steve Downey</a>
|
||||
* @author Eric Pugh
|
||||
* @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 !!!
|
||||
|
||||
/**
|
||||
* <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() {
|
||||
super();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <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 successively 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.length() == 1 && !Character.isDigit(val.charAt(0))) {
|
||||
throw new NumberFormatException(val + " 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
|
||||
&& (numeric.charAt(0) == '-' && isDigits(numeric.substring(1)) || isDigits(numeric))) {
|
||||
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 does not have the precision we want
|
||||
return f;
|
||||
}
|
||||
|
||||
} catch (NumberFormatException e) {
|
||||
// ignore the bad number
|
||||
}
|
||||
//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) {
|
||||
// empty catch
|
||||
}
|
||||
try {
|
||||
return createBigDecimal(numeric);
|
||||
} catch (NumberFormatException e) {
|
||||
// empty catch
|
||||
}
|
||||
//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) {
|
||||
// empty catch
|
||||
}
|
||||
try {
|
||||
return createLong(val);
|
||||
} catch (NumberFormatException nfe) {
|
||||
// empty catch
|
||||
}
|
||||
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) {
|
||||
// empty catch
|
||||
}
|
||||
try {
|
||||
Double d = createDouble(val);
|
||||
if (!(d.isInfinite() || (d.doubleValue() == 0.0D && !allZeros))) {
|
||||
return d;
|
||||
}
|
||||
} catch (NumberFormatException nfe) {
|
||||
// empty catch
|
||||
}
|
||||
|
||||
return createBigDecimal(val);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Utility method for {@link #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 minimum(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 minimum(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>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 maximum(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 maximum(int a, int b, int c) {
|
||||
if (b > a) {
|
||||
a = b;
|
||||
}
|
||||
if (c > a) {
|
||||
a = c;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <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 positive 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 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 float
|
||||
* <li>Normal positive 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 (StringUtils.isEmpty(str)) {
|
||||
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 exponent
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -71,7 +71,6 @@ public class LangTestSuite extends TestCase {
|
|||
suite.addTest(NotImplementedExceptionTest.suite());
|
||||
suite.addTest(NullArgumentExceptionTest.suite());
|
||||
suite.addTest(NumberRangeTest.suite());
|
||||
suite.addTest(NumberUtilsTest.suite());
|
||||
suite.addTest(ObjectUtilsTest.suite());
|
||||
suite.addTest(RandomStringUtilsTest.suite());
|
||||
suite.addTest(SerializationUtilsTest.suite());
|
||||
|
|
|
|||
|
|
@ -1,536 +0,0 @@
|
|||
/*
|
||||
* 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.lang;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.BigInteger;
|
||||
|
||||
import junit.framework.Test;
|
||||
import junit.framework.TestCase;
|
||||
import junit.framework.TestSuite;
|
||||
|
||||
/**
|
||||
* Unit tests {@link org.apache.commons.lang.NumberUtils}.
|
||||
*
|
||||
* @author <a href="mailto:rand_mcneely@yahoo.com">Rand McNeely</a>
|
||||
* @author <a href="mailto:ridesmet@users.sourceforge.net">Ringo De Smet</a>
|
||||
* @author Eric Pugh
|
||||
* @author Phil Steitz
|
||||
* @author Stephen Colebourne
|
||||
* @version $Id$
|
||||
*/
|
||||
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 BigInteger(Long.MAX_VALUE + "0"), NumberUtils.createNumber(Long.MAX_VALUE + "0L"));
|
||||
assertEquals("createNumber(String) 7 failed", new Long(12345), NumberUtils.createNumber("12345L"));
|
||||
assertEquals("createNumber(String) 8 failed", new Float("-1234.5"), NumberUtils.createNumber("-1234.5"));
|
||||
assertEquals("createNumber(String) 9 failed", new Integer("-12345"), NumberUtils.createNumber("-12345"));
|
||||
assertTrue("createNumber(String) 10 failed", 0xFADE == NumberUtils.createNumber("0xFADE").intValue());
|
||||
assertTrue("createNumber(String) 11 failed", -0xFADE == NumberUtils.createNumber("-0xFADE").intValue());
|
||||
assertEquals("createNumber(String) 12 failed", new Double("1.1E200"), NumberUtils.createNumber("1.1E200"));
|
||||
assertEquals("createNumber(String) 13 failed", new Float("1.1E20"), NumberUtils.createNumber("1.1E20"));
|
||||
assertEquals("createNumber(String) 14 failed", new Double("-1.1E200"), NumberUtils.createNumber("-1.1E200"));
|
||||
assertEquals("createNumber(String) 15 failed", new Double("1.1E-200"), NumberUtils.createNumber("1.1E-200"));
|
||||
assertEquals("createNumber(String) 16 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.minimum(12345L, 12345L + 1L, 12345L + 2L));
|
||||
assertEquals("minimum(long,long,long) 2 failed", 12345L, NumberUtils.minimum(12345L + 1L, 12345L, 12345 + 2L));
|
||||
assertEquals("minimum(long,long,long) 3 failed", 12345L, NumberUtils.minimum(12345L + 1L, 12345L + 2L, 12345L));
|
||||
assertEquals("minimum(long,long,long) 4 failed", 12345L, NumberUtils.minimum(12345L + 1L, 12345L, 12345L));
|
||||
assertEquals("minimum(long,long,long) 5 failed", 12345L, NumberUtils.minimum(12345L, 12345L, 12345L));
|
||||
|
||||
}
|
||||
|
||||
public void testMinimumInt() {
|
||||
assertEquals("minimum(int,int,int) 1 failed", 12345, NumberUtils.minimum(12345, 12345 + 1, 12345 + 2));
|
||||
assertEquals("minimum(int,int,int) 2 failed", 12345, NumberUtils.minimum(12345 + 1, 12345, 12345 + 2));
|
||||
assertEquals("minimum(int,int,int) 3 failed", 12345, NumberUtils.minimum(12345 + 1, 12345 + 2, 12345));
|
||||
assertEquals("minimum(int,int,int) 4 failed", 12345, NumberUtils.minimum(12345 + 1, 12345, 12345));
|
||||
assertEquals("minimum(int,int,int) 5 failed", 12345, NumberUtils.minimum(12345, 12345, 12345));
|
||||
|
||||
}
|
||||
|
||||
public void testMaximumLong() {
|
||||
assertEquals("maximum(long,long,long) 1 failed", 12345L, NumberUtils.maximum(12345L, 12345L - 1L, 12345L - 2L));
|
||||
assertEquals("maximum(long,long,long) 2 failed", 12345L, NumberUtils.maximum(12345L - 1L, 12345L, 12345L - 2L));
|
||||
assertEquals("maximum(long,long,long) 3 failed", 12345L, NumberUtils.maximum(12345L - 1L, 12345L - 2L, 12345L));
|
||||
assertEquals("maximum(long,long,long) 4 failed", 12345L, NumberUtils.maximum(12345L - 1L, 12345L, 12345L));
|
||||
assertEquals("maximum(long,long,long) 5 failed", 12345L, NumberUtils.maximum(12345L, 12345L, 12345L));
|
||||
|
||||
}
|
||||
|
||||
public void testMaximumInt() {
|
||||
assertEquals("maximum(int,int,int) 1 failed", 12345, NumberUtils.maximum(12345, 12345 - 1, 12345 - 2));
|
||||
assertEquals("maximum(int,int,int) 2 failed", 12345, NumberUtils.maximum(12345 - 1, 12345, 12345 - 2));
|
||||
assertEquals("maximum(int,int,int) 3 failed", 12345, NumberUtils.maximum(12345 - 1, 12345 - 2, 12345));
|
||||
assertEquals("maximum(int,int,int) 4 failed", 12345, NumberUtils.maximum(12345 - 1, 12345, 12345));
|
||||
assertEquals("maximum(int,int,int) 5 failed", 12345, NumberUtils.maximum(12345, 12345, 12345));
|
||||
|
||||
}
|
||||
|
||||
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));
|
||||
|
||||
}
|
||||
|
||||
public void testIsNumberInvalidInput() {
|
||||
String val = "0x";
|
||||
assertEquals("isNumber() with 0x wasn't false", false, NumberUtils.isNumber(val));
|
||||
val = "0x3x3";
|
||||
assertEquals("isNumber() with 0x3x3 wasn't false", false, NumberUtils.isNumber(val));
|
||||
val = "20EE-3";
|
||||
assertEquals("isNumber() with 20EE-3 wasn't false", false, NumberUtils.isNumber(val));
|
||||
val = "2435q";
|
||||
assertEquals("isNumber() with 2435q wasn't false", false, NumberUtils.isNumber(val));
|
||||
val = ".";
|
||||
assertEquals("isNumber() with . wasn't false", false, NumberUtils.isNumber(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 testPublicNoArgConstructor() {
|
||||
try {
|
||||
NumberUtils nu = new NumberUtils();
|
||||
} catch( Exception e ) {
|
||||
fail( "Error calling public no-arg constructor" );
|
||||
}
|
||||
}
|
||||
|
||||
public void testLang457() {
|
||||
String[] badInputs = new String[] { "l", "L", "f", "F", "junk", "bobL"};
|
||||
for(int i=0; i<badInputs.length; i++) {
|
||||
try {
|
||||
NumberUtils.createNumber(badInputs[i]);
|
||||
fail("NumberFormatException was expected for " + badInputs[i]);
|
||||
} catch (NumberFormatException e) {
|
||||
return; // expected
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue