/*
* Copyright 2004, 2005, 2006 Odysseus Software GmbH
*
* Licensed 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 de.odysseus.calyxo.base.util;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import junit.framework.TestCase;
/**
* NumberUtils test case.
*
* @author Oliver Stuhr
*/
public class NumberUtilsTest extends TestCase {
static final Byte BYTE_ZERO = Byte.valueOf("0"), BYTE_MIN_VALUE = new Byte(Byte.MIN_VALUE), BYTE_MAX_VALUE = new Byte(Byte.MAX_VALUE);
static final Short SHORT_ZERO = Short.valueOf("0"), SHORT_MIN_VALUE = new Short(Short.MIN_VALUE), SHORT_MAX_VALUE = new Short(Short.MAX_VALUE);
static final Integer INT_ZERO = Integer.valueOf("0"), INT_MIN_VALUE = new Integer(Integer.MIN_VALUE), INT_MAX_VALUE = new Integer(Integer.MAX_VALUE);
static final Long LONG_ZERO = Long.valueOf("0"), LONG_MIN_VALUE = new Long(Long.MIN_VALUE), LONG_MAX_VALUE = new Long(Long.MAX_VALUE);
static final Float FLOAT_ZERO = Float.valueOf("0.0"), FLOAT_MZERO = Float.valueOf("-0.0"), FLOAT_MIN_VALUE = new Float(Float.MIN_VALUE), FLOAT_MAX_VALUE = new Float(Float.MAX_VALUE), FLOAT_NEG_INF = new Float(Float.NEGATIVE_INFINITY), FLOAT_POS_INF = new Float(Float.POSITIVE_INFINITY), FLOAT_NAN = new Float(Float.NaN);
static final Double DOUBLE_ZERO = Double.valueOf("0.0"), DOUBLE_MZERO = Double.valueOf("-0.0"), DOUBLE_MIN_VALUE = new Double(Double.MIN_VALUE), DOUBLE_MAX_VALUE = new Double(Double.MAX_VALUE), DOUBLE_NEG_INF = new Double(Double.NEGATIVE_INFINITY), DOUBLE_POS_INF = new Double(Double.POSITIVE_INFINITY), DOUBLE_NAN = new Double(Double.NaN);;
static final BigInteger BIGINT_ZERO = BigInteger.valueOf(0);
static final BigDecimal BIGDEC_ZERO = BigDecimal.valueOf(0);
public void testisLongCompatible() {
assertFalse(NumberUtils.isLongCompatible(null));
assertTrue(NumberUtils.isLongCompatible(BYTE_ZERO));
assertTrue(NumberUtils.isLongCompatible(SHORT_ZERO));
assertTrue(NumberUtils.isLongCompatible(INT_ZERO));
assertTrue(NumberUtils.isLongCompatible(LONG_ZERO));
assertFalse(NumberUtils.isLongCompatible(FLOAT_ZERO));
assertFalse(NumberUtils.isLongCompatible(DOUBLE_ZERO));
assertFalse(NumberUtils.isLongCompatible(BIGINT_ZERO));
assertFalse(NumberUtils.isLongCompatible(BIGDEC_ZERO));
}
public void testisDoubleCompatible() {
assertFalse(NumberUtils.isDoubleCompatible(null));
assertFalse(NumberUtils.isDoubleCompatible(BYTE_ZERO));
assertFalse(NumberUtils.isDoubleCompatible(SHORT_ZERO));
assertFalse(NumberUtils.isDoubleCompatible(INT_ZERO));
assertFalse(NumberUtils.isDoubleCompatible(LONG_ZERO));
assertTrue(NumberUtils.isDoubleCompatible(FLOAT_ZERO));
assertTrue(NumberUtils.isDoubleCompatible(DOUBLE_ZERO));
assertFalse(NumberUtils.isDoubleCompatible(BIGINT_ZERO));
assertFalse(NumberUtils.isDoubleCompatible(BIGDEC_ZERO));
}
public void testIsBig() {
assertFalse(NumberUtils.isBig(null));
assertFalse(NumberUtils.isBig(BYTE_ZERO));
assertFalse(NumberUtils.isBig(SHORT_ZERO));
assertFalse(NumberUtils.isBig(INT_ZERO));
assertFalse(NumberUtils.isBig(LONG_ZERO));
assertFalse(NumberUtils.isBig(FLOAT_ZERO));
assertFalse(NumberUtils.isBig(DOUBLE_ZERO));
assertTrue(NumberUtils.isBig(BIGINT_ZERO));
assertTrue(NumberUtils.isBig(BIGDEC_ZERO));
}
public void testIsNaN() {
assertFalse(NumberUtils.isNaN(null));
assertFalse(NumberUtils.isNaN(BYTE_MIN_VALUE));
assertFalse(NumberUtils.isNaN(BYTE_ZERO));
assertFalse(NumberUtils.isNaN(BYTE_MAX_VALUE));
assertFalse(NumberUtils.isNaN(SHORT_MIN_VALUE));
assertFalse(NumberUtils.isNaN(SHORT_ZERO));
assertFalse(NumberUtils.isNaN(SHORT_MAX_VALUE));
assertFalse(NumberUtils.isNaN(INT_MIN_VALUE));
assertFalse(NumberUtils.isNaN(INT_ZERO));
assertFalse(NumberUtils.isNaN(INT_MAX_VALUE));
assertFalse(NumberUtils.isNaN(LONG_MIN_VALUE));
assertFalse(NumberUtils.isNaN(LONG_ZERO));
assertFalse(NumberUtils.isNaN(LONG_MAX_VALUE));
assertTrue(NumberUtils.isNaN(FLOAT_NAN));
assertFalse(NumberUtils.isNaN(FLOAT_NEG_INF));
assertFalse(NumberUtils.isNaN(FLOAT_MZERO));
assertFalse(NumberUtils.isNaN(FLOAT_ZERO));
assertFalse(NumberUtils.isNaN(FLOAT_MIN_VALUE));
assertFalse(NumberUtils.isNaN(FLOAT_MAX_VALUE));
assertFalse(NumberUtils.isNaN(FLOAT_POS_INF));
assertTrue(NumberUtils.isNaN(DOUBLE_NAN));
assertFalse(NumberUtils.isNaN(DOUBLE_NEG_INF));
assertFalse(NumberUtils.isNaN(DOUBLE_MZERO));
assertFalse(NumberUtils.isNaN(DOUBLE_ZERO));
assertFalse(NumberUtils.isNaN(DOUBLE_MIN_VALUE));
assertFalse(NumberUtils.isNaN(DOUBLE_MAX_VALUE));
assertFalse(NumberUtils.isNaN(DOUBLE_POS_INF));
assertFalse(NumberUtils.isNaN(BIGINT_ZERO));
assertFalse(NumberUtils.isNaN(BIGDEC_ZERO));
}
public void testIsInfinite() {
assertFalse(NumberUtils.isInfinite(null));
assertFalse(NumberUtils.isInfinite(BYTE_MIN_VALUE));
assertFalse(NumberUtils.isInfinite(BYTE_ZERO));
assertFalse(NumberUtils.isInfinite(BYTE_MAX_VALUE));
assertFalse(NumberUtils.isInfinite(SHORT_MIN_VALUE));
assertFalse(NumberUtils.isInfinite(SHORT_ZERO));
assertFalse(NumberUtils.isInfinite(SHORT_MAX_VALUE));
assertFalse(NumberUtils.isInfinite(INT_MIN_VALUE));
assertFalse(NumberUtils.isInfinite(INT_ZERO));
assertFalse(NumberUtils.isInfinite(INT_MAX_VALUE));
assertFalse(NumberUtils.isInfinite(LONG_MIN_VALUE));
assertFalse(NumberUtils.isInfinite(LONG_ZERO));
assertFalse(NumberUtils.isInfinite(LONG_MAX_VALUE));
assertFalse(NumberUtils.isInfinite(FLOAT_NAN));
assertTrue(NumberUtils.isInfinite(FLOAT_NEG_INF));
assertFalse(NumberUtils.isInfinite(FLOAT_MZERO));
assertFalse(NumberUtils.isInfinite(FLOAT_ZERO));
assertFalse(NumberUtils.isInfinite(FLOAT_MIN_VALUE));
assertFalse(NumberUtils.isInfinite(FLOAT_MAX_VALUE));
assertTrue(NumberUtils.isInfinite(FLOAT_POS_INF));
assertFalse(NumberUtils.isInfinite(DOUBLE_NAN));
assertTrue(NumberUtils.isInfinite(DOUBLE_NEG_INF));
assertFalse(NumberUtils.isInfinite(DOUBLE_MZERO));
assertFalse(NumberUtils.isInfinite(DOUBLE_ZERO));
assertFalse(NumberUtils.isInfinite(DOUBLE_MIN_VALUE));
assertFalse(NumberUtils.isInfinite(DOUBLE_MAX_VALUE));
assertTrue(NumberUtils.isInfinite(DOUBLE_POS_INF));
assertFalse(NumberUtils.isInfinite(BIGINT_ZERO));
assertFalse(NumberUtils.isInfinite(BIGDEC_ZERO));
}
public void testSignum() {
try {
NumberUtils.signum(null);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(-1, NumberUtils.signum(BYTE_MIN_VALUE));
assertEquals(0, NumberUtils.signum(BYTE_ZERO));
assertEquals(1, NumberUtils.signum(BYTE_MAX_VALUE));
assertEquals(-1, NumberUtils.signum(SHORT_MIN_VALUE));
assertEquals(0, NumberUtils.signum(SHORT_ZERO));
assertEquals(1, NumberUtils.signum(SHORT_MAX_VALUE));
assertEquals(-1, NumberUtils.signum(INT_MIN_VALUE));
assertEquals(0, NumberUtils.signum(INT_ZERO));
assertEquals(1, NumberUtils.signum(INT_MAX_VALUE));
assertEquals(-1, NumberUtils.signum(LONG_MIN_VALUE));
assertEquals(0, NumberUtils.signum(LONG_ZERO));
assertEquals(1, NumberUtils.signum(LONG_MAX_VALUE));
try {
NumberUtils.signum(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(-1, NumberUtils.signum(FLOAT_NEG_INF));
assertEquals(0, NumberUtils.signum(FLOAT_MZERO));
assertEquals(0, NumberUtils.signum(FLOAT_ZERO));
assertEquals(1, NumberUtils.signum(FLOAT_MIN_VALUE));
assertEquals(1, NumberUtils.signum(FLOAT_MAX_VALUE));
assertEquals(1, NumberUtils.signum(FLOAT_POS_INF));
try {
NumberUtils.signum(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(-1, NumberUtils.signum(DOUBLE_NEG_INF));
assertEquals(0, NumberUtils.signum(DOUBLE_MZERO));
assertEquals(0, NumberUtils.signum(DOUBLE_ZERO));
assertEquals(1, NumberUtils.signum(DOUBLE_MIN_VALUE));
assertEquals(1, NumberUtils.signum(DOUBLE_MAX_VALUE));
assertEquals(1, NumberUtils.signum(DOUBLE_POS_INF));
assertEquals(0, NumberUtils.signum(BIGINT_ZERO));
assertEquals(0, NumberUtils.signum(BIGDEC_ZERO));
}
public void testToByte() {
assertNull(NumberUtils.toByte(null));
assertEquals(BYTE_MIN_VALUE, NumberUtils.toByte(BYTE_MIN_VALUE));
assertEquals(BYTE_ZERO, NumberUtils.toByte(BYTE_ZERO));
assertEquals(BYTE_MAX_VALUE, NumberUtils.toByte(BYTE_MAX_VALUE));
assertEquals(BYTE_ZERO, NumberUtils.toByte(SHORT_ZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(INT_ZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(LONG_ZERO));
try {
NumberUtils.toByte(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toByte(FLOAT_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BYTE_ZERO, NumberUtils.toByte(FLOAT_MZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(FLOAT_ZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(FLOAT_MIN_VALUE));
try {
NumberUtils.toByte(FLOAT_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toByte(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toByte(DOUBLE_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BYTE_ZERO, NumberUtils.toByte(DOUBLE_MZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(DOUBLE_ZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(DOUBLE_MIN_VALUE));
try {
NumberUtils.toByte(DOUBLE_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BYTE_ZERO, NumberUtils.toByte(BIGINT_ZERO));
assertEquals(BYTE_ZERO, NumberUtils.toByte(BIGDEC_ZERO));
}
public void testToShort() {
assertNull(NumberUtils.toShort(null));
assertEquals(new Short(Byte.MIN_VALUE), NumberUtils.toShort(BYTE_MIN_VALUE));
assertEquals(SHORT_ZERO, NumberUtils.toShort(BYTE_ZERO));
assertEquals(new Short(Byte.MAX_VALUE), NumberUtils.toShort(BYTE_MAX_VALUE));
assertEquals(SHORT_MIN_VALUE, NumberUtils.toShort(SHORT_MIN_VALUE));
assertEquals(SHORT_ZERO, NumberUtils.toShort(SHORT_ZERO));
assertEquals(SHORT_MAX_VALUE, NumberUtils.toShort(SHORT_MAX_VALUE));
assertEquals(SHORT_ZERO, NumberUtils.toShort(INT_ZERO));
assertEquals(SHORT_ZERO, NumberUtils.toShort(LONG_ZERO));
try {
NumberUtils.toShort(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toShort(FLOAT_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(SHORT_ZERO, NumberUtils.toShort(FLOAT_MZERO));
assertEquals(SHORT_ZERO, NumberUtils.toShort(FLOAT_ZERO));
assertEquals(SHORT_ZERO, NumberUtils.toShort(FLOAT_MIN_VALUE));
try {
NumberUtils.toShort(FLOAT_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toShort(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toShort(DOUBLE_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(SHORT_ZERO, NumberUtils.toShort(DOUBLE_MZERO));
assertEquals(SHORT_ZERO, NumberUtils.toShort(DOUBLE_ZERO));
assertEquals(SHORT_ZERO, NumberUtils.toShort(DOUBLE_MIN_VALUE));
try {
NumberUtils.toShort(DOUBLE_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(SHORT_ZERO, NumberUtils.toShort(BIGINT_ZERO));
assertEquals(SHORT_ZERO, NumberUtils.toShort(BIGDEC_ZERO));
}
public void testToInteger() {
assertNull(NumberUtils.toInteger(null));
assertEquals(new Integer(Byte.MIN_VALUE), NumberUtils.toInteger(BYTE_MIN_VALUE));
assertEquals(INT_ZERO, NumberUtils.toInteger(BYTE_ZERO));
assertEquals(new Integer(Byte.MAX_VALUE), NumberUtils.toInteger(BYTE_MAX_VALUE));
assertEquals(new Integer(Short.MIN_VALUE), NumberUtils.toInteger(SHORT_MIN_VALUE));
assertEquals(INT_ZERO, NumberUtils.toInteger(SHORT_ZERO));
assertEquals(new Integer(Short.MAX_VALUE), NumberUtils.toInteger(SHORT_MAX_VALUE));
assertEquals(INT_MIN_VALUE, NumberUtils.toInteger(INT_MIN_VALUE));
assertEquals(INT_ZERO, NumberUtils.toInteger(INT_ZERO));
assertEquals(INT_MAX_VALUE, NumberUtils.toInteger(INT_MAX_VALUE));
assertEquals(INT_ZERO, NumberUtils.toInteger(LONG_ZERO));
try {
NumberUtils.toInteger(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toInteger(FLOAT_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(INT_ZERO, NumberUtils.toInteger(FLOAT_MZERO));
assertEquals(INT_ZERO, NumberUtils.toInteger(FLOAT_ZERO));
assertEquals(INT_ZERO, NumberUtils.toInteger(FLOAT_MIN_VALUE));
try {
NumberUtils.toInteger(FLOAT_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toInteger(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toInteger(DOUBLE_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(INT_ZERO, NumberUtils.toInteger(DOUBLE_MZERO));
assertEquals(INT_ZERO, NumberUtils.toInteger(DOUBLE_ZERO));
assertEquals(INT_ZERO, NumberUtils.toInteger(DOUBLE_MIN_VALUE));
try {
NumberUtils.toInteger(DOUBLE_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(INT_ZERO, NumberUtils.toInteger(BIGINT_ZERO));
assertEquals(INT_ZERO, NumberUtils.toInteger(BIGDEC_ZERO));
}
public void testToLong() {
assertNull(NumberUtils.toLong(null));
assertEquals(new Long(Byte.MIN_VALUE), NumberUtils.toLong(BYTE_MIN_VALUE));
assertEquals(LONG_ZERO, NumberUtils.toLong(BYTE_ZERO));
assertEquals(new Long(Byte.MAX_VALUE), NumberUtils.toLong(BYTE_MAX_VALUE));
assertEquals(new Long(Short.MIN_VALUE), NumberUtils.toLong(SHORT_MIN_VALUE));
assertEquals(LONG_ZERO, NumberUtils.toLong(SHORT_ZERO));
assertEquals(new Long(Short.MAX_VALUE), NumberUtils.toLong(SHORT_MAX_VALUE));
assertEquals(new Long(Integer.MIN_VALUE), NumberUtils.toLong(INT_MIN_VALUE));
assertEquals(LONG_ZERO, NumberUtils.toLong(INT_ZERO));
assertEquals(new Long(Integer.MAX_VALUE), NumberUtils.toLong(INT_MAX_VALUE));
assertEquals(LONG_MIN_VALUE, NumberUtils.toLong(LONG_MIN_VALUE));
assertEquals(LONG_ZERO, NumberUtils.toLong(LONG_ZERO));
assertEquals(LONG_MAX_VALUE, NumberUtils.toLong(LONG_MAX_VALUE));
try {
NumberUtils.toLong(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toLong(FLOAT_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(LONG_ZERO, NumberUtils.toLong(FLOAT_MZERO));
assertEquals(LONG_ZERO, NumberUtils.toLong(FLOAT_ZERO));
assertEquals(LONG_ZERO, NumberUtils.toLong(FLOAT_MIN_VALUE));
try {
NumberUtils.toLong(FLOAT_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toLong(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toLong(DOUBLE_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(LONG_ZERO, NumberUtils.toLong(DOUBLE_MZERO));
assertEquals(LONG_ZERO, NumberUtils.toLong(DOUBLE_ZERO));
assertEquals(LONG_ZERO, NumberUtils.toLong(DOUBLE_MIN_VALUE));
try {
NumberUtils.toLong(DOUBLE_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(LONG_ZERO, NumberUtils.toLong(BIGINT_ZERO));
assertEquals(LONG_ZERO, NumberUtils.toLong(BIGDEC_ZERO));
}
public void testToFloat() {
assertNull(NumberUtils.toFloat(null));
assertEquals(new Float(Byte.MIN_VALUE), NumberUtils.toFloat(BYTE_MIN_VALUE));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(BYTE_ZERO));
assertEquals(new Float(Byte.MAX_VALUE), NumberUtils.toFloat(BYTE_MAX_VALUE));
assertEquals(new Float(Short.MIN_VALUE), NumberUtils.toFloat(SHORT_MIN_VALUE));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(SHORT_ZERO));
assertEquals(new Float(Short.MAX_VALUE), NumberUtils.toFloat(SHORT_MAX_VALUE));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(INT_ZERO));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(LONG_ZERO));
assertEquals(FLOAT_NAN, NumberUtils.toFloat(FLOAT_NAN));
assertEquals(FLOAT_NEG_INF, NumberUtils.toFloat(FLOAT_NEG_INF));
assertEquals(FLOAT_MZERO, NumberUtils.toFloat(FLOAT_MZERO));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(FLOAT_ZERO));
assertEquals(FLOAT_MIN_VALUE, NumberUtils.toFloat(FLOAT_MIN_VALUE));
assertEquals(FLOAT_MAX_VALUE, NumberUtils.toFloat(FLOAT_MAX_VALUE));
assertEquals(FLOAT_POS_INF, NumberUtils.toFloat(FLOAT_POS_INF));
assertEquals(FLOAT_NAN, NumberUtils.toFloat(DOUBLE_NAN));
assertEquals(FLOAT_NEG_INF, NumberUtils.toFloat(DOUBLE_NEG_INF));
assertEquals(FLOAT_MZERO, NumberUtils.toFloat(DOUBLE_MZERO));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(DOUBLE_ZERO));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(DOUBLE_MIN_VALUE));
assertEquals(FLOAT_POS_INF, NumberUtils.toFloat(DOUBLE_POS_INF));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(BIGINT_ZERO));
assertEquals(FLOAT_ZERO, NumberUtils.toFloat(BIGDEC_ZERO));
}
public void testToDouble() {
assertNull(NumberUtils.toDouble(null));
assertEquals(new Double(Byte.MIN_VALUE), NumberUtils.toDouble(BYTE_MIN_VALUE));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(BYTE_ZERO));
assertEquals(new Double(Byte.MAX_VALUE), NumberUtils.toDouble(BYTE_MAX_VALUE));
assertEquals(new Double(Short.MIN_VALUE), NumberUtils.toDouble(SHORT_MIN_VALUE));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(SHORT_ZERO));
assertEquals(new Double(Short.MAX_VALUE), NumberUtils.toDouble(SHORT_MAX_VALUE));
assertEquals(new Double(Integer.MIN_VALUE), NumberUtils.toDouble(INT_MIN_VALUE));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(INT_ZERO));
assertEquals(new Double(Integer.MAX_VALUE), NumberUtils.toDouble(INT_MAX_VALUE));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(LONG_ZERO));
assertEquals(DOUBLE_NAN, NumberUtils.toDouble(FLOAT_NAN));
assertEquals(DOUBLE_NEG_INF, NumberUtils.toDouble(FLOAT_NEG_INF));
assertEquals(DOUBLE_MZERO, NumberUtils.toDouble(FLOAT_MZERO));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(FLOAT_ZERO));
assertEquals(new Double(Float.MIN_VALUE), NumberUtils.toDouble(FLOAT_MIN_VALUE));
assertEquals(new Double(Float.MAX_VALUE), NumberUtils.toDouble(FLOAT_MAX_VALUE));
assertEquals(DOUBLE_POS_INF, NumberUtils.toDouble(FLOAT_POS_INF));
assertEquals(DOUBLE_NAN, NumberUtils.toDouble(DOUBLE_NAN));
assertEquals(DOUBLE_NEG_INF, NumberUtils.toDouble(DOUBLE_NEG_INF));
assertEquals(DOUBLE_MZERO, NumberUtils.toDouble(DOUBLE_MZERO));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(DOUBLE_ZERO));
assertEquals(DOUBLE_MIN_VALUE, NumberUtils.toDouble(DOUBLE_MIN_VALUE));
assertEquals(DOUBLE_MAX_VALUE, NumberUtils.toDouble(DOUBLE_MAX_VALUE));
assertEquals(DOUBLE_POS_INF, NumberUtils.toDouble(DOUBLE_POS_INF));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(BIGINT_ZERO));
assertEquals(DOUBLE_ZERO, NumberUtils.toDouble(BIGDEC_ZERO));
}
public void testToBigInteger() {
assertNull(NumberUtils.toBigInteger(null));
assertEquals(new BigInteger("" + BYTE_MIN_VALUE), NumberUtils.toBigInteger(BYTE_MIN_VALUE));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(BYTE_ZERO));
assertEquals(new BigInteger("" + BYTE_MAX_VALUE), NumberUtils.toBigInteger(BYTE_MAX_VALUE));
assertEquals(new BigInteger("" + SHORT_MIN_VALUE), NumberUtils.toBigInteger(SHORT_MIN_VALUE));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(SHORT_ZERO));
assertEquals(new BigInteger("" + SHORT_MAX_VALUE), NumberUtils.toBigInteger(SHORT_MAX_VALUE));
assertEquals(new BigInteger("" + INT_MIN_VALUE), NumberUtils.toBigInteger(INT_MIN_VALUE));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(INT_ZERO));
assertEquals(new BigInteger("" + INT_MAX_VALUE), NumberUtils.toBigInteger(INT_MAX_VALUE));
assertEquals(new BigInteger("" + LONG_MIN_VALUE), NumberUtils.toBigInteger(LONG_MIN_VALUE));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(LONG_ZERO));
assertEquals(new BigInteger("" + LONG_MAX_VALUE), NumberUtils.toBigInteger(LONG_MAX_VALUE));
try {
NumberUtils.toBigInteger(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toBigInteger(FLOAT_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(FLOAT_MZERO));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(FLOAT_ZERO));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(FLOAT_MIN_VALUE));
assertEquals(new BigDecimal("" + FLOAT_MAX_VALUE).toBigInteger(), NumberUtils.toBigInteger(FLOAT_MAX_VALUE));
try {
NumberUtils.toBigInteger(FLOAT_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toBigInteger(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toBigInteger(DOUBLE_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(DOUBLE_MZERO));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(DOUBLE_ZERO));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(DOUBLE_MIN_VALUE));
assertEquals(new BigDecimal("" + DOUBLE_MAX_VALUE).toBigInteger(), NumberUtils.toBigInteger(DOUBLE_MAX_VALUE));
try {
NumberUtils.toBigInteger(DOUBLE_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(BIGINT_ZERO));
assertEquals(BIGINT_ZERO, NumberUtils.toBigInteger(BIGDEC_ZERO));
}
public void testToBigDecimal() {
assertNull(NumberUtils.toBigDecimal(null));
assertEquals(new BigDecimal("" + BYTE_MIN_VALUE), NumberUtils.toBigDecimal(BYTE_MIN_VALUE));
assertEquals(BIGDEC_ZERO, NumberUtils.toBigDecimal(BYTE_ZERO));
assertEquals(new BigDecimal("" + BYTE_MAX_VALUE), NumberUtils.toBigDecimal(BYTE_MAX_VALUE));
assertEquals(new BigDecimal("" + SHORT_MIN_VALUE), NumberUtils.toBigDecimal(SHORT_MIN_VALUE));
assertEquals(BIGDEC_ZERO, NumberUtils.toBigDecimal(SHORT_ZERO));
assertEquals(new BigDecimal("" + SHORT_MAX_VALUE), NumberUtils.toBigDecimal(SHORT_MAX_VALUE));
assertEquals(new BigDecimal("" + INT_MIN_VALUE), NumberUtils.toBigDecimal(INT_MIN_VALUE));
assertEquals(BIGDEC_ZERO, NumberUtils.toBigDecimal(INT_ZERO));
assertEquals(new BigDecimal("" + INT_MAX_VALUE), NumberUtils.toBigDecimal(INT_MAX_VALUE));
assertEquals(new BigDecimal("" + LONG_MIN_VALUE), NumberUtils.toBigDecimal(LONG_MIN_VALUE));
assertEquals(BIGDEC_ZERO, NumberUtils.toBigDecimal(LONG_ZERO));
assertEquals(new BigDecimal("" + LONG_MAX_VALUE), NumberUtils.toBigDecimal(LONG_MAX_VALUE));
try {
NumberUtils.toBigDecimal(FLOAT_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toBigDecimal(FLOAT_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertTrue(BIGDEC_ZERO.compareTo(NumberUtils.toBigDecimal(FLOAT_MZERO)) == 0);
assertTrue(BIGDEC_ZERO.compareTo(NumberUtils.toBigDecimal(FLOAT_ZERO)) == 0);
assertEquals(new BigDecimal("" + FLOAT_MIN_VALUE), NumberUtils.toBigDecimal(FLOAT_MIN_VALUE));
assertEquals(new BigDecimal("" + FLOAT_MAX_VALUE), NumberUtils.toBigDecimal(FLOAT_MAX_VALUE));
try {
NumberUtils.toBigDecimal(FLOAT_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toBigDecimal(DOUBLE_NAN);
fail("Exception expected");
} catch(Exception e) {}
try {
NumberUtils.toBigDecimal(DOUBLE_NEG_INF);
fail("Exception expected");
} catch(Exception e) {}
assertTrue(BIGDEC_ZERO.compareTo(NumberUtils.toBigDecimal(DOUBLE_MZERO)) == 0);
assertTrue(BIGDEC_ZERO.compareTo(NumberUtils.toBigDecimal(DOUBLE_ZERO)) == 0);
assertEquals(new BigDecimal("" + DOUBLE_MIN_VALUE), NumberUtils.toBigDecimal(DOUBLE_MIN_VALUE));
assertEquals(new BigDecimal("" + DOUBLE_MAX_VALUE), NumberUtils.toBigDecimal(DOUBLE_MAX_VALUE));
try {
NumberUtils.toBigDecimal(DOUBLE_POS_INF);
fail("Exception expected");
} catch(Exception e) {}
assertEquals(BIGDEC_ZERO, NumberUtils.toBigDecimal(BIGINT_ZERO));
assertEquals(BIGDEC_ZERO, NumberUtils.toBigDecimal(BIGDEC_ZERO));
}
public void testCompare() {
Map sizes = new HashMap();
sizes.put(null, null);
sizes.put(FLOAT_NAN, null);
sizes.put(DOUBLE_NAN, null);
sizes.put(FLOAT_NEG_INF, "a");
sizes.put(DOUBLE_NEG_INF, "a");
sizes.put(LONG_MIN_VALUE, "c");
sizes.put(INT_MIN_VALUE, "e");
sizes.put(SHORT_MIN_VALUE, "g");
sizes.put(BYTE_MIN_VALUE, "i");
sizes.put(BYTE_ZERO, "n");
sizes.put(SHORT_ZERO, "n");
sizes.put(INT_ZERO, "n");
sizes.put(LONG_ZERO, "n");
sizes.put(FLOAT_MZERO, "n");
sizes.put(FLOAT_ZERO, "n");
sizes.put(DOUBLE_MZERO, "n");
sizes.put(DOUBLE_ZERO, "n");
sizes.put(BIGINT_ZERO, "n");
sizes.put(BIGDEC_ZERO, "n");
sizes.put(DOUBLE_MIN_VALUE, "o");
sizes.put(FLOAT_MIN_VALUE, "p");
sizes.put(BYTE_MAX_VALUE, "r");
sizes.put(SHORT_MAX_VALUE, "s");
sizes.put(INT_MAX_VALUE, "t");
sizes.put(LONG_MAX_VALUE, "u");
sizes.put(FLOAT_MAX_VALUE, "v");
sizes.put(DOUBLE_MAX_VALUE, "w");
sizes.put(FLOAT_POS_INF, "z");
sizes.put(DOUBLE_POS_INF, "z");
int count = 0;
Iterator firstNumbers = sizes.keySet().iterator();
while (firstNumbers.hasNext()) {
Number first = (Number)firstNumbers.next();
String firstSize = (String)sizes.get(first);
Iterator secondNumbers = sizes.keySet().iterator();
while (secondNumbers.hasNext()) {
Number second = (Number)secondNumbers.next();
String secondSize = (String)sizes.get(second);
count++;
if (firstSize == null || secondSize == null)
try {
NumberUtils.compare(first, second);
fail("Exception expected");
} catch(Exception e) {}
else
assertSameSignum(first, second, firstSize.compareTo(secondSize), NumberUtils.compare(first, second));
}
}
assertEquals(sizes.size() * sizes.size(), count);
// assert transitivity for a constructed triple (d, b and l)
long m = Long.MAX_VALUE - 1000; // 9223372036854774807
Double d = new Double(m); // 9.2233720368547748E18, (long)d.doubleValue(): 9223372036854774784
BigInteger b = BigInteger.valueOf(m + 1); // 9223372036854774808
Long l = new Long(b.longValue() + 1); // 9223372036854774809
if (NumberUtils.compare(d, b) == -1 && NumberUtils.compare(b, l) == -1)
assertEquals(-1, NumberUtils.compare(d, l));
// this test is used to argue against the usage of the comparison
// operators (<, == and >) when comparing doubles and longs
// (for the values above the assertion fails, since d == l,
// whereas the 'correct' result is achieved by converting both
// to BigDecimals)
// of course, this does not mean that there might not be other
// examples, to argue against the current implementation ...
}
private void assertSameSignum(Number first, Number second, int sizeCompare, int numberCompare) {
if((sizeCompare < 0) == (numberCompare < 0) && (sizeCompare > 0) == (numberCompare > 0))
return;
fail("Comparison between " + first + " (" + first.getClass() + ") and " + second + " (" + second.getClass() + ") failed: " + numberCompare + " instead of " + sizeCompare);
}
public void test() {
BigInteger doubleMaxValue = NumberUtils.toBigInteger(DOUBLE_MAX_VALUE);
BigInteger doubleMaxValueInc = doubleMaxValue.add(BigInteger.ONE);
BigInteger doubleMaxValueDec = doubleMaxValue.subtract(BigInteger.ONE);
assertEquals(-1, NumberUtils.compare(doubleMaxValueDec, DOUBLE_MAX_VALUE));
assertEquals(0, NumberUtils.compare(doubleMaxValue, DOUBLE_MAX_VALUE));
assertEquals(1, NumberUtils.compare(doubleMaxValueInc, DOUBLE_MAX_VALUE));
BigDecimal doubleMinValue = NumberUtils.toBigDecimal(DOUBLE_MIN_VALUE);
BigDecimal doubleMinValueDouble = doubleMinValue.multiply(new BigDecimal("2"));
BigDecimal doubleMinValueHalf = doubleMinValue.multiply(new BigDecimal("0.5"));
assertEquals(-1, NumberUtils.compare(doubleMinValueHalf, DOUBLE_MIN_VALUE));
assertEquals(0, NumberUtils.compare(doubleMinValue, DOUBLE_MIN_VALUE));
assertEquals(1, NumberUtils.compare(doubleMinValueDouble, DOUBLE_MIN_VALUE));
}
// public static void main(String[] args) {
// int count = args.length == 0 ? 10 : Integer.valueOf(args[0]).intValue();
// double d = Double.MAX_VALUE;
// for (long n = Long.MAX_VALUE, l = n; count > 0; n--) {
// if ((double)n < d) {
// System.out.println(
// n + " -> " + (double)n + " -> " + (long)(double)n +
// ", delta=" + (l - n) + "/" + ((double)l - (double)n) + "/" + ((long)(double)l - (long)(double)n) +
// ", #=" + count
// );
// l = n;
// d = (double)n;
// count--;
// }
// }
// }
}