http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/ebb39b84/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilTest.java ---------------------------------------------------------------------- diff --git a/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilTest.java b/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilTest.java deleted file mode 100644 index 37e4726..0000000 --- a/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilTest.java +++ /dev/null @@ -1,585 +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.freemarker.core.model.impl; - -import java.math.BigDecimal; -import java.math.BigInteger; - -import junit.framework.TestCase; - -@SuppressWarnings("boxing") -public class OverloadedNumberUtilTest extends TestCase { - - public OverloadedNumberUtilTest(String name) { - super(name); - } - - public void testIntegerCoercions() { - cipEqu(Byte.valueOf(Byte.MAX_VALUE)); - cipEqu(Byte.valueOf((byte) 0)); - cipEqu(Byte.valueOf(Byte.MIN_VALUE)); - - cipEqu(Short.valueOf(Byte.MAX_VALUE), - new OverloadedNumberUtil.ShortOrByte((short) Byte.MAX_VALUE, Byte.MAX_VALUE)); - cipEqu(Short.valueOf((short) 0), - new OverloadedNumberUtil.ShortOrByte((short) 0, (byte) 0)); - cipEqu(Short.valueOf(Byte.MIN_VALUE), - new OverloadedNumberUtil.ShortOrByte((short) Byte.MIN_VALUE, Byte.MIN_VALUE)); - - cipEqu(Short.valueOf((short) (Byte.MAX_VALUE + 1))); - cipEqu(Short.valueOf((short) (Byte.MIN_VALUE - 1))); - cipEqu(Short.valueOf(Short.MAX_VALUE)); - cipEqu(Short.valueOf(Short.MIN_VALUE)); - - cipEqu(Integer.valueOf(Byte.MAX_VALUE), - new OverloadedNumberUtil.IntegerOrByte((int) Byte.MAX_VALUE, Byte.MAX_VALUE)); - cipEqu(Integer.valueOf(0), - new OverloadedNumberUtil.IntegerOrByte(0, (byte) 0)); - cipEqu(Integer.valueOf(Byte.MIN_VALUE), - new OverloadedNumberUtil.IntegerOrByte((int) Byte.MIN_VALUE, Byte.MIN_VALUE)); - - cipEqu(Integer.valueOf(Byte.MAX_VALUE + 1), - new OverloadedNumberUtil.IntegerOrShort(Byte.MAX_VALUE + 1, (short) (Byte.MAX_VALUE + 1))); - cipEqu(Integer.valueOf(Byte.MIN_VALUE - 1), - new OverloadedNumberUtil.IntegerOrShort(Byte.MIN_VALUE - 1, (short) (Byte.MIN_VALUE - 1))); - cipEqu(Integer.valueOf(Short.MAX_VALUE), - new OverloadedNumberUtil.IntegerOrShort((int) Short.MAX_VALUE, Short.MAX_VALUE)); - cipEqu(Integer.valueOf(Short.MIN_VALUE), - new OverloadedNumberUtil.IntegerOrShort((int) Short.MIN_VALUE, Short.MIN_VALUE)); - - cipEqu(Integer.valueOf(Short.MAX_VALUE + 1)); - cipEqu(Integer.valueOf(Short.MIN_VALUE - 1)); - cipEqu(Integer.valueOf(Integer.MAX_VALUE)); - cipEqu(Integer.valueOf(Integer.MIN_VALUE)); - - cipEqu(Long.valueOf(Byte.MAX_VALUE), - new OverloadedNumberUtil.LongOrByte((long) Byte.MAX_VALUE, Byte.MAX_VALUE)); - cipEqu(Long.valueOf(0), - new OverloadedNumberUtil.LongOrByte((long) 0, (byte) 0)); - cipEqu(Long.valueOf(Byte.MIN_VALUE), - new OverloadedNumberUtil.LongOrByte((long) Byte.MIN_VALUE, Byte.MIN_VALUE)); - - cipEqu(Long.valueOf(Byte.MAX_VALUE + 1), - new OverloadedNumberUtil.LongOrShort((long) (Byte.MAX_VALUE + 1), (short) (Byte.MAX_VALUE + 1))); - cipEqu(Long.valueOf(Byte.MIN_VALUE - 1), - new OverloadedNumberUtil.LongOrShort((long) (Byte.MIN_VALUE - 1), (short) (Byte.MIN_VALUE - 1))); - cipEqu(Long.valueOf(Short.MAX_VALUE), - new OverloadedNumberUtil.LongOrShort((long) Short.MAX_VALUE, Short.MAX_VALUE)); - cipEqu(Long.valueOf(Short.MIN_VALUE), - new OverloadedNumberUtil.LongOrShort((long) Short.MIN_VALUE, Short.MIN_VALUE)); - - cipEqu(Long.valueOf(Short.MAX_VALUE + 1), - new OverloadedNumberUtil.LongOrInteger((long) Short.MAX_VALUE + 1, Short.MAX_VALUE + 1)); - cipEqu(Long.valueOf(Short.MIN_VALUE - 1), - new OverloadedNumberUtil.LongOrInteger((long) Short.MIN_VALUE - 1, Short.MIN_VALUE - 1)); - cipEqu(Long.valueOf(Integer.MAX_VALUE), - new OverloadedNumberUtil.LongOrInteger((long) Integer.MAX_VALUE, Integer.MAX_VALUE)); - cipEqu(Long.valueOf(Integer.MIN_VALUE), - new OverloadedNumberUtil.LongOrInteger((long) Integer.MIN_VALUE, Integer.MIN_VALUE)); - - cipEqu(Long.valueOf(Integer.MAX_VALUE + 1L)); - cipEqu(Long.valueOf(Integer.MIN_VALUE - 1L)); - cipEqu(Long.valueOf(Long.MAX_VALUE)); - cipEqu(Long.valueOf(Long.MIN_VALUE)); - } - - public void testIntegerNoCoercions() { - cipEqu(Integer.valueOf(Byte.MAX_VALUE), Integer.valueOf(Byte.MAX_VALUE), 0); - cipEqu(Integer.valueOf(0), Integer.valueOf(0), 0); - cipEqu(Integer.valueOf(Byte.MIN_VALUE), Integer.valueOf(Byte.MIN_VALUE), 0); - } - - public void testIntegerLimitedCoercions() { - cipEqu(Integer.valueOf(Byte.MAX_VALUE), Integer.valueOf(Byte.MAX_VALUE), TypeFlags.INTEGER); - cipEqu(Integer.valueOf(0), Integer.valueOf(0), TypeFlags.INTEGER); - cipEqu(Integer.valueOf(Byte.MIN_VALUE), Integer.valueOf(Byte.MIN_VALUE), TypeFlags.INTEGER); - - cipEqu(Long.valueOf(Integer.MAX_VALUE + 1L), Long.valueOf(Integer.MAX_VALUE + 1L), TypeFlags.INTEGER); - - for (int n = -1; n < 2; n++) { - final Long longN = Long.valueOf(n); - cipEqu(longN, new OverloadedNumberUtil.LongOrInteger(longN, n), TypeFlags.INTEGER); - cipEqu(longN, new OverloadedNumberUtil.LongOrShort(longN, (short) n), TypeFlags.SHORT); - cipEqu(longN, new OverloadedNumberUtil.LongOrByte(longN, (byte) n), TypeFlags.BYTE); - cipEqu(longN, new OverloadedNumberUtil.LongOrShort(longN, (short) n), - TypeFlags.SHORT | TypeFlags.INTEGER); - } - } - - public void testBigDecimalCoercions() { - cipEqu(new BigDecimal(123), new OverloadedNumberUtil.IntegerBigDecimal(new BigDecimal(123))); - cipEqu(new BigDecimal(123), new OverloadedNumberUtil.IntegerBigDecimal(new BigDecimal(123)), - TypeFlags.DOUBLE | TypeFlags.INTEGER); - cipEqu(new BigDecimal(123), TypeFlags.INTEGER); - cipEqu(new BigDecimal(123), TypeFlags.INTEGER | TypeFlags.LONG); - cipEqu(new BigDecimal(123), TypeFlags.DOUBLE); - cipEqu(new BigDecimal(123), TypeFlags.DOUBLE | TypeFlags.FLOAT); - - cipEqu(new BigDecimal(123.5)); - // Not wasting time with check if it's a whole number if we only have integer-only or non-integer-only targets: - cipEqu(new BigDecimal(123.5), TypeFlags.INTEGER | TypeFlags.LONG); - cipEqu(new BigDecimal(123.5), TypeFlags.DOUBLE | TypeFlags.FLOAT); - - cipEqu(new BigDecimal("0.01")); - cipEqu(new BigDecimal("-0.01")); - cipEqu(BigDecimal.ZERO, new OverloadedNumberUtil.IntegerBigDecimal(BigDecimal.ZERO)); - } - - public void testUnknownNumberCoercion() { - cipEqu(new RationalNumber(2, 3)); - } - - @SuppressWarnings("boxing") - public void testDoubleCoercion() { - cipEqu(Double.valueOf(1.5), new OverloadedNumberUtil.DoubleOrFloat(1.5)); - cipEqu(Double.valueOf(-0.125), new OverloadedNumberUtil.DoubleOrFloat(-0.125)); - cipEqu(Double.valueOf(Float.MAX_VALUE), new OverloadedNumberUtil.DoubleOrFloat((double) Float.MAX_VALUE)); - cipEqu(Double.valueOf(-Float.MAX_VALUE), new OverloadedNumberUtil.DoubleOrFloat((double) -Float.MAX_VALUE)); - cipEqu(Double.valueOf(Float.MAX_VALUE * 10.0)); - cipEqu(Double.valueOf(-Float.MAX_VALUE * 10.0)); - - cipEqu(Double.valueOf(0), new OverloadedNumberUtil.DoubleOrByte(0.0, (byte) 0)); - cipEqu(Double.valueOf(Byte.MAX_VALUE), new OverloadedNumberUtil.DoubleOrByte((double) Byte.MAX_VALUE, Byte.MAX_VALUE)); - cipEqu(Double.valueOf(Byte.MIN_VALUE), new OverloadedNumberUtil.DoubleOrByte((double) Byte.MIN_VALUE, Byte.MIN_VALUE)); - - cipEqu(Double.valueOf(Byte.MAX_VALUE + 1), new OverloadedNumberUtil.DoubleOrShort((double) - (Byte.MAX_VALUE + 1), (short) (Byte.MAX_VALUE + 1))); - cipEqu(Double.valueOf(Byte.MIN_VALUE - 1), new OverloadedNumberUtil.DoubleOrShort((double) - (Byte.MIN_VALUE - 1), (short) (Byte.MIN_VALUE - 1))); - - cipEqu(Double.valueOf(Short.MAX_VALUE + 1), - new OverloadedNumberUtil.DoubleOrIntegerOrFloat((double) Short.MAX_VALUE + 1, Short.MAX_VALUE + 1)); - cipEqu(Double.valueOf(Short.MIN_VALUE - 1), - new OverloadedNumberUtil.DoubleOrIntegerOrFloat((double) Short.MIN_VALUE - 1, Short.MIN_VALUE - 1)); - cipEqu(Double.valueOf(16777216), new OverloadedNumberUtil.DoubleOrIntegerOrFloat(16777216.0, 16777216)); - cipEqu(Double.valueOf(-16777216), new OverloadedNumberUtil.DoubleOrIntegerOrFloat(-16777216.0, -16777216)); - - cipEqu(Double.valueOf(Integer.MAX_VALUE), - new OverloadedNumberUtil.DoubleOrInteger((double) Integer.MAX_VALUE, Integer.MAX_VALUE)); - cipEqu(Double.valueOf(Integer.MIN_VALUE), - new OverloadedNumberUtil.DoubleOrInteger((double) Integer.MIN_VALUE, Integer.MIN_VALUE)); - - cipEqu(Double.valueOf(Integer.MAX_VALUE + 1L), - new OverloadedNumberUtil.DoubleOrLong(Double.valueOf(Integer.MAX_VALUE + 1L), Integer.MAX_VALUE + 1L)); - cipEqu(Double.valueOf(Integer.MIN_VALUE - 1L), - new OverloadedNumberUtil.DoubleOrLong(Double.valueOf(Integer.MIN_VALUE - 1L), Integer.MIN_VALUE - 1L)); - cipEqu(Double.valueOf(Long.MAX_VALUE), - new OverloadedNumberUtil.DoubleOrFloat((double) Long.MAX_VALUE)); - cipEqu(Double.valueOf(Long.MIN_VALUE), - new OverloadedNumberUtil.DoubleOrFloat((double) Long.MIN_VALUE)); - - // When only certain target types are present: - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrByte(5.0, (byte) 5), TypeFlags.BYTE); - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrByte(5.0, (byte) 5), TypeFlags.BYTE | TypeFlags.SHORT); - cipEqu(Double.valueOf(-129), TypeFlags.BYTE); - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrShort(5.0, (short) 5), TypeFlags.SHORT); - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrInteger(5.0, 5), TypeFlags.INTEGER); - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrLong(5.0, 5), TypeFlags.LONG); - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrFloat(5.0), TypeFlags.FLOAT); - cipEqu(Double.valueOf(5), Double.valueOf(5), TypeFlags.DOUBLE); - cipEqu(Double.valueOf(5), new OverloadedNumberUtil.DoubleOrFloat(5.0), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(Double.valueOf(5.9), new OverloadedNumberUtil.DoubleOrFloat(5.9), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(Double.valueOf(5.9), - TypeFlags.DOUBLE | TypeFlags.INTEGER); - cipEqu(Double.valueOf(5.9), new OverloadedNumberUtil.DoubleOrFloat(5.9), - TypeFlags.FLOAT | TypeFlags.INTEGER); - cipEqu(Double.valueOf(5.9), TypeFlags.INTEGER); - cipEqu(Double.valueOf(Long.MAX_VALUE), - new OverloadedNumberUtil.DoubleOrFloat((double) Long.MAX_VALUE), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(Double.valueOf(Long.MAX_VALUE), - TypeFlags.DOUBLE | TypeFlags.LONG); - cipEqu(Double.valueOf(Long.MIN_VALUE), - new OverloadedNumberUtil.DoubleOrFloat((double) Long.MIN_VALUE), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(Double.valueOf(Float.MAX_VALUE * 10), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(Double.valueOf(-Float.MAX_VALUE * 10), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - - // Rounded values: - cipEqu(Double.valueOf(0.0000009), - new OverloadedNumberUtil.DoubleOrByte(0.0000009, (byte) 0)); - cipEqu(Double.valueOf(-0.0000009), - new OverloadedNumberUtil.DoubleOrByte(-0.0000009, (byte) 0)); - cipEqu(Double.valueOf(0.9999991), - new OverloadedNumberUtil.DoubleOrByte(0.9999991, (byte) 1)); - cipEqu(Double.valueOf(-0.9999991), - new OverloadedNumberUtil.DoubleOrByte(-0.9999991, (byte) -1)); - cipEqu(Double.valueOf(0.0000009), - new OverloadedNumberUtil.DoubleOrShort(0.0000009, (short) 0), - TypeFlags.SHORT | TypeFlags.DOUBLE); - cipEqu(Double.valueOf(0.0000009), new OverloadedNumberUtil.DoubleOrInteger(0.0000009, 0), - TypeFlags.INTEGER | TypeFlags.DOUBLE); - cipEqu(Double.valueOf(0.0000009), new OverloadedNumberUtil.DoubleOrLong(0.0000009, 0), - TypeFlags.LONG | TypeFlags.DOUBLE); - cipEqu(Double.valueOf(0.0000009), - new OverloadedNumberUtil.DoubleOrByte(0.0000009, (byte) 0), TypeFlags.BYTE); - cipEqu(Double.valueOf(0.0000009), - new OverloadedNumberUtil.DoubleOrShort(0.0000009, (short) 0), TypeFlags.SHORT); - cipEqu(Double.valueOf(0.0000009), - new OverloadedNumberUtil.DoubleOrInteger(0.0000009, 0), TypeFlags.INTEGER); - cipEqu(Double.valueOf(0.0000009), - new OverloadedNumberUtil.DoubleOrLong(0.0000009, 0L), TypeFlags.LONG); - cipEqu(Double.valueOf(0.9999999), - new OverloadedNumberUtil.DoubleOrInteger(0.9999999, 1), TypeFlags.INTEGER); - cipEqu(Double.valueOf(Byte.MAX_VALUE + 0.9e-6), - new OverloadedNumberUtil.DoubleOrByte(Byte.MAX_VALUE + 0.9e-6, Byte.MAX_VALUE)); - cipEqu(Double.valueOf(Byte.MIN_VALUE - 0.9e-6), - new OverloadedNumberUtil.DoubleOrByte(Byte.MIN_VALUE - 0.9e-6, Byte.MIN_VALUE)); - cipEqu(Double.valueOf(Byte.MAX_VALUE + 1.1e-6), - new OverloadedNumberUtil.DoubleOrFloat(Byte.MAX_VALUE + 1.1e-6)); - cipEqu(Double.valueOf(Byte.MIN_VALUE - 1.1e-6), - new OverloadedNumberUtil.DoubleOrFloat(Byte.MIN_VALUE - 1.1e-6)); - cipEqu(Double.valueOf(Byte.MAX_VALUE + 0.9999991), - new OverloadedNumberUtil.DoubleOrShort( - Byte.MAX_VALUE + 0.9999991, (short) (Byte.MAX_VALUE + 1))); - cipEqu(Double.valueOf(Byte.MIN_VALUE - 0.9999991), - new OverloadedNumberUtil.DoubleOrShort( - Byte.MIN_VALUE - 0.9999991, (short) (Byte.MIN_VALUE - 1))); - - cipEqu(Double.valueOf(Byte.MAX_VALUE + 1), new OverloadedNumberUtil.DoubleOrShort((double) - (Byte.MAX_VALUE + 1), (short) (Byte.MAX_VALUE + 1))); - cipEqu(Double.valueOf(Byte.MIN_VALUE - 1), new OverloadedNumberUtil.DoubleOrShort((double) - (Byte.MIN_VALUE - 1), (short) (Byte.MIN_VALUE - 1))); - - cipEqu(Short.MAX_VALUE + 0.9999991, - new OverloadedNumberUtil.DoubleOrIntegerOrFloat(Short.MAX_VALUE + 0.9999991, Short.MAX_VALUE + 1)); - cipEqu(Short.MIN_VALUE - 0.9999991, - new OverloadedNumberUtil.DoubleOrIntegerOrFloat(Short.MIN_VALUE - 0.9999991, Short.MIN_VALUE - 1)); - cipEqu(16777216 + 0.9e-6, - new OverloadedNumberUtil.DoubleOrIntegerOrFloat(16777216 + 0.9e-6, 16777216)); - cipEqu(-16777216 - 0.9e-6, - new OverloadedNumberUtil.DoubleOrIntegerOrFloat(-16777216 - 0.9e-6, -16777216)); - - cipEqu(Integer.MAX_VALUE + 0.9e-6, - new OverloadedNumberUtil.DoubleOrInteger(Integer.MAX_VALUE + 0.9e-6, Integer.MAX_VALUE)); - cipEqu(Integer.MIN_VALUE - 0.9e-6, - new OverloadedNumberUtil.DoubleOrInteger(Integer.MIN_VALUE - 0.9e-6, Integer.MIN_VALUE)); - - cipEqu(Integer.MAX_VALUE + 1L + 0.9e-6, - new OverloadedNumberUtil.DoubleOrFloat(Integer.MAX_VALUE + 1L + 0.9e-6)); - cipEqu(Integer.MIN_VALUE - 1L - 0.9e-6, - new OverloadedNumberUtil.DoubleOrFloat(Integer.MIN_VALUE - 1L - 0.9e-6)); - cipEqu(Long.MAX_VALUE + 0.9e-6, - new OverloadedNumberUtil.DoubleOrFloat(Long.MAX_VALUE + 0.9e-6)); - cipEqu(Long.MIN_VALUE - 0.9e-6, - new OverloadedNumberUtil.DoubleOrFloat(Long.MIN_VALUE - 0.9e-6)); - } - - @SuppressWarnings("boxing") - public void testFloatCoercion() { - cipEqu(1.00002f); - cipEqu(-1.00002f); - cipEqu(1.999989f); - cipEqu(-1.999989f); - cipEqu(16777218f); - cipEqu(-16777218f); - - cipEqu(1f, new OverloadedNumberUtil.FloatOrByte(1f, (byte) 1)); - cipEqu(-1f, new OverloadedNumberUtil.FloatOrByte(-1f, (byte) -1)); - cipEqu(1.000009f, new OverloadedNumberUtil.FloatOrByte(1.000009f, (byte) 1)); - cipEqu(-1.000009f, new OverloadedNumberUtil.FloatOrByte(-1.000009f, (byte) -1)); - cipEqu(1.999991f, new OverloadedNumberUtil.FloatOrByte(1.999991f, (byte) 2)); - cipEqu(-1.999991f, new OverloadedNumberUtil.FloatOrByte(-1.999991f, (byte) -2)); - - cipEqu(1000f, new OverloadedNumberUtil.FloatOrShort(1000f, (short) 1000)); - cipEqu(-1000f, new OverloadedNumberUtil.FloatOrShort(-1000f, (short) -1000)); - cipEqu(1000.00006f); - - cipEqu(60000f, new OverloadedNumberUtil.FloatOrInteger(60000f, 60000)); - cipEqu(-60000f, new OverloadedNumberUtil.FloatOrInteger(-60000f, -60000)); - cipEqu(60000.004f); - - cipEqu(100f, new OverloadedNumberUtil.FloatOrByte(100f, (byte) 100), TypeFlags.MASK_KNOWN_INTEGERS); - cipEqu(1000f, new OverloadedNumberUtil.FloatOrShort(1000f, (short) 1000), TypeFlags.MASK_KNOWN_INTEGERS); - cipEqu(60000f, new OverloadedNumberUtil.FloatOrInteger(60000f, 60000), TypeFlags.MASK_KNOWN_INTEGERS); - cipEqu(60000f, new OverloadedNumberUtil.FloatOrInteger(60000f, 60000), TypeFlags.LONG); - cipEqu((float) Integer.MAX_VALUE, (float) Integer.MAX_VALUE, TypeFlags.LONG); - cipEqu((float) -Integer.MAX_VALUE, (float) -Integer.MAX_VALUE); - - cipEqu(0.5f, 0.5f, TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(0.5f, 0.5f, TypeFlags.DOUBLE); - } - - public void testBigIntegerCoercion() { - BigInteger bi; - - cipEqu(BigInteger.ZERO, new OverloadedNumberUtil.BigIntegerOrByte(BigInteger.ZERO)); - bi = new BigInteger(String.valueOf(Byte.MAX_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrByte(bi)); - bi = new BigInteger(String.valueOf(Byte.MIN_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrByte(bi)); - - bi = new BigInteger(String.valueOf(Byte.MAX_VALUE + 1)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrShort(bi)); - bi = new BigInteger(String.valueOf(Byte.MIN_VALUE - 1)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrShort(bi)); - bi = new BigInteger(String.valueOf(Short.MAX_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrShort(bi)); - bi = new BigInteger(String.valueOf(Short.MIN_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrShort(bi)); - - bi = new BigInteger(String.valueOf(Short.MAX_VALUE + 1)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrInteger(bi)); - bi = new BigInteger(String.valueOf(Short.MIN_VALUE - 1)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrInteger(bi)); - bi = new BigInteger(String.valueOf(Integer.MAX_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrInteger(bi)); - bi = new BigInteger(String.valueOf(Integer.MIN_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrInteger(bi)); - - bi = new BigInteger(String.valueOf(Integer.MAX_VALUE + 1L)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrLong(bi)); - bi = new BigInteger(String.valueOf(Integer.MIN_VALUE - 1L)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrLong(bi)); - bi = new BigInteger(String.valueOf(Long.MAX_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrLong(bi)); - bi = new BigInteger(String.valueOf(Long.MIN_VALUE)); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrLong(bi)); - - cipEqu(new BigInteger(String.valueOf(Long.MAX_VALUE)).add(BigInteger.ONE)); - cipEqu(new BigInteger(String.valueOf(Long.MIN_VALUE)).subtract(BigInteger.ONE)); - - bi = new BigInteger("0"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), - TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), - TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), - TypeFlags.FLOAT); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), - TypeFlags.DOUBLE); - - bi = new BigInteger("16777215"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - bi = new BigInteger("-16777215"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - - bi = new BigInteger("16777216"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - bi = new BigInteger("-16777216"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - - bi = new BigInteger("16777217"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, TypeFlags.FLOAT); - bi = new BigInteger("-16777217"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, TypeFlags.FLOAT); - - bi = new BigInteger("9007199254740991"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); - bi = new BigInteger("-9007199254740991"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); - - bi = new BigInteger("9007199254740992"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); - bi = new BigInteger("-9007199254740992"); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, new OverloadedNumberUtil.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); - - bi = new BigInteger("9007199254740993"); - cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(bi, TypeFlags.FLOAT); - cipEqu(bi, TypeFlags.DOUBLE); - bi = new BigInteger("-9007199254740993"); - cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); - cipEqu(bi, TypeFlags.DOUBLE | TypeFlags.FLOAT); - cipEqu(bi, TypeFlags.FLOAT); - cipEqu(bi, TypeFlags.DOUBLE); - - bi = new BigInteger("9007199254740994"); - cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); - bi = new BigInteger("-9007199254740994"); - cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); - } - - private void cipEqu(Number actualAndExpected) { - cipEqu(actualAndExpected, actualAndExpected, -1); - } - - private void cipEqu(Number actual, Number expected) { - cipEqu(actual, expected, -1); - } - - private void cipEqu(Number actualAndExpected, int flags) { - cipEqu(actualAndExpected, actualAndExpected, flags); - } - - @SuppressWarnings("boxing") - private void cipEqu(Number actual, Number expected, int flags) { - Number res = OverloadedNumberUtil.addFallbackType(actual, flags); - assertEquals(expected.getClass(), res.getClass()); - assertEquals(expected, res); - - // Some number types wrap the number with multiple types and equals() only compares one of them. So we try to - // catch any inconsistency: - assertEquals(expected.byteValue(), res.byteValue()); - assertEquals(expected.shortValue(), res.shortValue()); - assertEquals(expected.intValue(), res.intValue()); - assertEquals(expected.longValue(), res.longValue()); - assertEquals(expected.floatValue(), res.floatValue()); - assertEquals(expected.doubleValue(), res.doubleValue()); - } - - public void testGetArgumentConversionPrice() { - // Unknown number types: - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - RationalNumber.class, Integer.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, RationalNumber.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - RationalNumber.class, Float.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - Float.class, RationalNumber.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - RationalNumber.class, RationalNumber.class)); - - // Fully check some rows (not all of them; the code is generated anyways): - - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, Byte.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, Short.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, Integer.class)); - assertEquals(10004, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, Long.class)); - assertEquals(10005, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, BigInteger.class)); - assertEquals(30006, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, Float.class)); - assertEquals(20007, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, Double.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, BigDecimal.class)); - - assertEquals(45001, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, Byte.class)); - assertEquals(44002, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, Short.class)); - assertEquals(41003, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, Integer.class)); - assertEquals(41004, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, Long.class)); - assertEquals(40005, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, BigInteger.class)); - assertEquals(33006, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, Float.class)); - assertEquals(32007, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, Double.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, BigDecimal.class)); - - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, Byte.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, Short.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, Integer.class)); - assertEquals(21004, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, Long.class)); - assertEquals(21005, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, BigInteger.class)); - assertEquals(40006, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, Float.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, Double.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, BigDecimal.class)); - - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, Byte.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, Short.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, Integer.class)); - assertEquals(Integer.MAX_VALUE, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, Long.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, BigInteger.class)); - assertEquals(40006, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, Float.class)); - assertEquals(20007, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, Double.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, BigDecimal.class)); - - // Check if all fromC is present: - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Byte.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Short.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Integer.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Long.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - BigInteger.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Float.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - Double.class, BigDecimal.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - BigDecimal.class, BigDecimal.class)); - assertEquals(0, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.IntegerBigDecimal.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrFloat.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.FloatOrByte.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrShort.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.FloatOrByte.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.FloatOrShort.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.FloatOrInteger.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrByte.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrIntegerOrFloat.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrInteger.class, BigDecimal.class)); - assertEquals(20008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.DoubleOrLong.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrByte.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrShort.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrInteger.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrLong.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrFloat.class, BigDecimal.class)); - assertEquals(10008, OverloadedNumberUtil.getArgumentConversionPrice( - OverloadedNumberUtil.BigIntegerOrDouble.class, BigDecimal.class)); - } - -}
http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/ebb39b84/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilsTest.java ---------------------------------------------------------------------- diff --git a/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilsTest.java b/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilsTest.java new file mode 100644 index 0000000..679ede6 --- /dev/null +++ b/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/OverloadedNumberUtilsTest.java @@ -0,0 +1,585 @@ +/* + * 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.freemarker.core.model.impl; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import junit.framework.TestCase; + +@SuppressWarnings("boxing") +public class OverloadedNumberUtilsTest extends TestCase { + + public OverloadedNumberUtilsTest(String name) { + super(name); + } + + public void testIntegerCoercions() { + cipEqu(Byte.valueOf(Byte.MAX_VALUE)); + cipEqu(Byte.valueOf((byte) 0)); + cipEqu(Byte.valueOf(Byte.MIN_VALUE)); + + cipEqu(Short.valueOf(Byte.MAX_VALUE), + new OverloadedNumberUtils.ShortOrByte((short) Byte.MAX_VALUE, Byte.MAX_VALUE)); + cipEqu(Short.valueOf((short) 0), + new OverloadedNumberUtils.ShortOrByte((short) 0, (byte) 0)); + cipEqu(Short.valueOf(Byte.MIN_VALUE), + new OverloadedNumberUtils.ShortOrByte((short) Byte.MIN_VALUE, Byte.MIN_VALUE)); + + cipEqu(Short.valueOf((short) (Byte.MAX_VALUE + 1))); + cipEqu(Short.valueOf((short) (Byte.MIN_VALUE - 1))); + cipEqu(Short.valueOf(Short.MAX_VALUE)); + cipEqu(Short.valueOf(Short.MIN_VALUE)); + + cipEqu(Integer.valueOf(Byte.MAX_VALUE), + new OverloadedNumberUtils.IntegerOrByte((int) Byte.MAX_VALUE, Byte.MAX_VALUE)); + cipEqu(Integer.valueOf(0), + new OverloadedNumberUtils.IntegerOrByte(0, (byte) 0)); + cipEqu(Integer.valueOf(Byte.MIN_VALUE), + new OverloadedNumberUtils.IntegerOrByte((int) Byte.MIN_VALUE, Byte.MIN_VALUE)); + + cipEqu(Integer.valueOf(Byte.MAX_VALUE + 1), + new OverloadedNumberUtils.IntegerOrShort(Byte.MAX_VALUE + 1, (short) (Byte.MAX_VALUE + 1))); + cipEqu(Integer.valueOf(Byte.MIN_VALUE - 1), + new OverloadedNumberUtils.IntegerOrShort(Byte.MIN_VALUE - 1, (short) (Byte.MIN_VALUE - 1))); + cipEqu(Integer.valueOf(Short.MAX_VALUE), + new OverloadedNumberUtils.IntegerOrShort((int) Short.MAX_VALUE, Short.MAX_VALUE)); + cipEqu(Integer.valueOf(Short.MIN_VALUE), + new OverloadedNumberUtils.IntegerOrShort((int) Short.MIN_VALUE, Short.MIN_VALUE)); + + cipEqu(Integer.valueOf(Short.MAX_VALUE + 1)); + cipEqu(Integer.valueOf(Short.MIN_VALUE - 1)); + cipEqu(Integer.valueOf(Integer.MAX_VALUE)); + cipEqu(Integer.valueOf(Integer.MIN_VALUE)); + + cipEqu(Long.valueOf(Byte.MAX_VALUE), + new OverloadedNumberUtils.LongOrByte((long) Byte.MAX_VALUE, Byte.MAX_VALUE)); + cipEqu(Long.valueOf(0), + new OverloadedNumberUtils.LongOrByte((long) 0, (byte) 0)); + cipEqu(Long.valueOf(Byte.MIN_VALUE), + new OverloadedNumberUtils.LongOrByte((long) Byte.MIN_VALUE, Byte.MIN_VALUE)); + + cipEqu(Long.valueOf(Byte.MAX_VALUE + 1), + new OverloadedNumberUtils.LongOrShort((long) (Byte.MAX_VALUE + 1), (short) (Byte.MAX_VALUE + 1))); + cipEqu(Long.valueOf(Byte.MIN_VALUE - 1), + new OverloadedNumberUtils.LongOrShort((long) (Byte.MIN_VALUE - 1), (short) (Byte.MIN_VALUE - 1))); + cipEqu(Long.valueOf(Short.MAX_VALUE), + new OverloadedNumberUtils.LongOrShort((long) Short.MAX_VALUE, Short.MAX_VALUE)); + cipEqu(Long.valueOf(Short.MIN_VALUE), + new OverloadedNumberUtils.LongOrShort((long) Short.MIN_VALUE, Short.MIN_VALUE)); + + cipEqu(Long.valueOf(Short.MAX_VALUE + 1), + new OverloadedNumberUtils.LongOrInteger((long) Short.MAX_VALUE + 1, Short.MAX_VALUE + 1)); + cipEqu(Long.valueOf(Short.MIN_VALUE - 1), + new OverloadedNumberUtils.LongOrInteger((long) Short.MIN_VALUE - 1, Short.MIN_VALUE - 1)); + cipEqu(Long.valueOf(Integer.MAX_VALUE), + new OverloadedNumberUtils.LongOrInteger((long) Integer.MAX_VALUE, Integer.MAX_VALUE)); + cipEqu(Long.valueOf(Integer.MIN_VALUE), + new OverloadedNumberUtils.LongOrInteger((long) Integer.MIN_VALUE, Integer.MIN_VALUE)); + + cipEqu(Long.valueOf(Integer.MAX_VALUE + 1L)); + cipEqu(Long.valueOf(Integer.MIN_VALUE - 1L)); + cipEqu(Long.valueOf(Long.MAX_VALUE)); + cipEqu(Long.valueOf(Long.MIN_VALUE)); + } + + public void testIntegerNoCoercions() { + cipEqu(Integer.valueOf(Byte.MAX_VALUE), Integer.valueOf(Byte.MAX_VALUE), 0); + cipEqu(Integer.valueOf(0), Integer.valueOf(0), 0); + cipEqu(Integer.valueOf(Byte.MIN_VALUE), Integer.valueOf(Byte.MIN_VALUE), 0); + } + + public void testIntegerLimitedCoercions() { + cipEqu(Integer.valueOf(Byte.MAX_VALUE), Integer.valueOf(Byte.MAX_VALUE), TypeFlags.INTEGER); + cipEqu(Integer.valueOf(0), Integer.valueOf(0), TypeFlags.INTEGER); + cipEqu(Integer.valueOf(Byte.MIN_VALUE), Integer.valueOf(Byte.MIN_VALUE), TypeFlags.INTEGER); + + cipEqu(Long.valueOf(Integer.MAX_VALUE + 1L), Long.valueOf(Integer.MAX_VALUE + 1L), TypeFlags.INTEGER); + + for (int n = -1; n < 2; n++) { + final Long longN = Long.valueOf(n); + cipEqu(longN, new OverloadedNumberUtils.LongOrInteger(longN, n), TypeFlags.INTEGER); + cipEqu(longN, new OverloadedNumberUtils.LongOrShort(longN, (short) n), TypeFlags.SHORT); + cipEqu(longN, new OverloadedNumberUtils.LongOrByte(longN, (byte) n), TypeFlags.BYTE); + cipEqu(longN, new OverloadedNumberUtils.LongOrShort(longN, (short) n), + TypeFlags.SHORT | TypeFlags.INTEGER); + } + } + + public void testBigDecimalCoercions() { + cipEqu(new BigDecimal(123), new OverloadedNumberUtils.IntegerBigDecimal(new BigDecimal(123))); + cipEqu(new BigDecimal(123), new OverloadedNumberUtils.IntegerBigDecimal(new BigDecimal(123)), + TypeFlags.DOUBLE | TypeFlags.INTEGER); + cipEqu(new BigDecimal(123), TypeFlags.INTEGER); + cipEqu(new BigDecimal(123), TypeFlags.INTEGER | TypeFlags.LONG); + cipEqu(new BigDecimal(123), TypeFlags.DOUBLE); + cipEqu(new BigDecimal(123), TypeFlags.DOUBLE | TypeFlags.FLOAT); + + cipEqu(new BigDecimal(123.5)); + // Not wasting time with check if it's a whole number if we only have integer-only or non-integer-only targets: + cipEqu(new BigDecimal(123.5), TypeFlags.INTEGER | TypeFlags.LONG); + cipEqu(new BigDecimal(123.5), TypeFlags.DOUBLE | TypeFlags.FLOAT); + + cipEqu(new BigDecimal("0.01")); + cipEqu(new BigDecimal("-0.01")); + cipEqu(BigDecimal.ZERO, new OverloadedNumberUtils.IntegerBigDecimal(BigDecimal.ZERO)); + } + + public void testUnknownNumberCoercion() { + cipEqu(new RationalNumber(2, 3)); + } + + @SuppressWarnings("boxing") + public void testDoubleCoercion() { + cipEqu(Double.valueOf(1.5), new OverloadedNumberUtils.DoubleOrFloat(1.5)); + cipEqu(Double.valueOf(-0.125), new OverloadedNumberUtils.DoubleOrFloat(-0.125)); + cipEqu(Double.valueOf(Float.MAX_VALUE), new OverloadedNumberUtils.DoubleOrFloat((double) Float.MAX_VALUE)); + cipEqu(Double.valueOf(-Float.MAX_VALUE), new OverloadedNumberUtils.DoubleOrFloat((double) -Float.MAX_VALUE)); + cipEqu(Double.valueOf(Float.MAX_VALUE * 10.0)); + cipEqu(Double.valueOf(-Float.MAX_VALUE * 10.0)); + + cipEqu(Double.valueOf(0), new OverloadedNumberUtils.DoubleOrByte(0.0, (byte) 0)); + cipEqu(Double.valueOf(Byte.MAX_VALUE), new OverloadedNumberUtils.DoubleOrByte((double) Byte.MAX_VALUE, Byte.MAX_VALUE)); + cipEqu(Double.valueOf(Byte.MIN_VALUE), new OverloadedNumberUtils.DoubleOrByte((double) Byte.MIN_VALUE, Byte.MIN_VALUE)); + + cipEqu(Double.valueOf(Byte.MAX_VALUE + 1), new OverloadedNumberUtils.DoubleOrShort((double) + (Byte.MAX_VALUE + 1), (short) (Byte.MAX_VALUE + 1))); + cipEqu(Double.valueOf(Byte.MIN_VALUE - 1), new OverloadedNumberUtils.DoubleOrShort((double) + (Byte.MIN_VALUE - 1), (short) (Byte.MIN_VALUE - 1))); + + cipEqu(Double.valueOf(Short.MAX_VALUE + 1), + new OverloadedNumberUtils.DoubleOrIntegerOrFloat((double) Short.MAX_VALUE + 1, Short.MAX_VALUE + 1)); + cipEqu(Double.valueOf(Short.MIN_VALUE - 1), + new OverloadedNumberUtils.DoubleOrIntegerOrFloat((double) Short.MIN_VALUE - 1, Short.MIN_VALUE - 1)); + cipEqu(Double.valueOf(16777216), new OverloadedNumberUtils.DoubleOrIntegerOrFloat(16777216.0, 16777216)); + cipEqu(Double.valueOf(-16777216), new OverloadedNumberUtils.DoubleOrIntegerOrFloat(-16777216.0, -16777216)); + + cipEqu(Double.valueOf(Integer.MAX_VALUE), + new OverloadedNumberUtils.DoubleOrInteger((double) Integer.MAX_VALUE, Integer.MAX_VALUE)); + cipEqu(Double.valueOf(Integer.MIN_VALUE), + new OverloadedNumberUtils.DoubleOrInteger((double) Integer.MIN_VALUE, Integer.MIN_VALUE)); + + cipEqu(Double.valueOf(Integer.MAX_VALUE + 1L), + new OverloadedNumberUtils.DoubleOrLong(Double.valueOf(Integer.MAX_VALUE + 1L), Integer.MAX_VALUE + 1L)); + cipEqu(Double.valueOf(Integer.MIN_VALUE - 1L), + new OverloadedNumberUtils.DoubleOrLong(Double.valueOf(Integer.MIN_VALUE - 1L), Integer.MIN_VALUE - 1L)); + cipEqu(Double.valueOf(Long.MAX_VALUE), + new OverloadedNumberUtils.DoubleOrFloat((double) Long.MAX_VALUE)); + cipEqu(Double.valueOf(Long.MIN_VALUE), + new OverloadedNumberUtils.DoubleOrFloat((double) Long.MIN_VALUE)); + + // When only certain target types are present: + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrByte(5.0, (byte) 5), TypeFlags.BYTE); + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrByte(5.0, (byte) 5), TypeFlags.BYTE | TypeFlags.SHORT); + cipEqu(Double.valueOf(-129), TypeFlags.BYTE); + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrShort(5.0, (short) 5), TypeFlags.SHORT); + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrInteger(5.0, 5), TypeFlags.INTEGER); + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrLong(5.0, 5), TypeFlags.LONG); + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrFloat(5.0), TypeFlags.FLOAT); + cipEqu(Double.valueOf(5), Double.valueOf(5), TypeFlags.DOUBLE); + cipEqu(Double.valueOf(5), new OverloadedNumberUtils.DoubleOrFloat(5.0), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(Double.valueOf(5.9), new OverloadedNumberUtils.DoubleOrFloat(5.9), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(Double.valueOf(5.9), + TypeFlags.DOUBLE | TypeFlags.INTEGER); + cipEqu(Double.valueOf(5.9), new OverloadedNumberUtils.DoubleOrFloat(5.9), + TypeFlags.FLOAT | TypeFlags.INTEGER); + cipEqu(Double.valueOf(5.9), TypeFlags.INTEGER); + cipEqu(Double.valueOf(Long.MAX_VALUE), + new OverloadedNumberUtils.DoubleOrFloat((double) Long.MAX_VALUE), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(Double.valueOf(Long.MAX_VALUE), + TypeFlags.DOUBLE | TypeFlags.LONG); + cipEqu(Double.valueOf(Long.MIN_VALUE), + new OverloadedNumberUtils.DoubleOrFloat((double) Long.MIN_VALUE), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(Double.valueOf(Float.MAX_VALUE * 10), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(Double.valueOf(-Float.MAX_VALUE * 10), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + + // Rounded values: + cipEqu(Double.valueOf(0.0000009), + new OverloadedNumberUtils.DoubleOrByte(0.0000009, (byte) 0)); + cipEqu(Double.valueOf(-0.0000009), + new OverloadedNumberUtils.DoubleOrByte(-0.0000009, (byte) 0)); + cipEqu(Double.valueOf(0.9999991), + new OverloadedNumberUtils.DoubleOrByte(0.9999991, (byte) 1)); + cipEqu(Double.valueOf(-0.9999991), + new OverloadedNumberUtils.DoubleOrByte(-0.9999991, (byte) -1)); + cipEqu(Double.valueOf(0.0000009), + new OverloadedNumberUtils.DoubleOrShort(0.0000009, (short) 0), + TypeFlags.SHORT | TypeFlags.DOUBLE); + cipEqu(Double.valueOf(0.0000009), new OverloadedNumberUtils.DoubleOrInteger(0.0000009, 0), + TypeFlags.INTEGER | TypeFlags.DOUBLE); + cipEqu(Double.valueOf(0.0000009), new OverloadedNumberUtils.DoubleOrLong(0.0000009, 0), + TypeFlags.LONG | TypeFlags.DOUBLE); + cipEqu(Double.valueOf(0.0000009), + new OverloadedNumberUtils.DoubleOrByte(0.0000009, (byte) 0), TypeFlags.BYTE); + cipEqu(Double.valueOf(0.0000009), + new OverloadedNumberUtils.DoubleOrShort(0.0000009, (short) 0), TypeFlags.SHORT); + cipEqu(Double.valueOf(0.0000009), + new OverloadedNumberUtils.DoubleOrInteger(0.0000009, 0), TypeFlags.INTEGER); + cipEqu(Double.valueOf(0.0000009), + new OverloadedNumberUtils.DoubleOrLong(0.0000009, 0L), TypeFlags.LONG); + cipEqu(Double.valueOf(0.9999999), + new OverloadedNumberUtils.DoubleOrInteger(0.9999999, 1), TypeFlags.INTEGER); + cipEqu(Double.valueOf(Byte.MAX_VALUE + 0.9e-6), + new OverloadedNumberUtils.DoubleOrByte(Byte.MAX_VALUE + 0.9e-6, Byte.MAX_VALUE)); + cipEqu(Double.valueOf(Byte.MIN_VALUE - 0.9e-6), + new OverloadedNumberUtils.DoubleOrByte(Byte.MIN_VALUE - 0.9e-6, Byte.MIN_VALUE)); + cipEqu(Double.valueOf(Byte.MAX_VALUE + 1.1e-6), + new OverloadedNumberUtils.DoubleOrFloat(Byte.MAX_VALUE + 1.1e-6)); + cipEqu(Double.valueOf(Byte.MIN_VALUE - 1.1e-6), + new OverloadedNumberUtils.DoubleOrFloat(Byte.MIN_VALUE - 1.1e-6)); + cipEqu(Double.valueOf(Byte.MAX_VALUE + 0.9999991), + new OverloadedNumberUtils.DoubleOrShort( + Byte.MAX_VALUE + 0.9999991, (short) (Byte.MAX_VALUE + 1))); + cipEqu(Double.valueOf(Byte.MIN_VALUE - 0.9999991), + new OverloadedNumberUtils.DoubleOrShort( + Byte.MIN_VALUE - 0.9999991, (short) (Byte.MIN_VALUE - 1))); + + cipEqu(Double.valueOf(Byte.MAX_VALUE + 1), new OverloadedNumberUtils.DoubleOrShort((double) + (Byte.MAX_VALUE + 1), (short) (Byte.MAX_VALUE + 1))); + cipEqu(Double.valueOf(Byte.MIN_VALUE - 1), new OverloadedNumberUtils.DoubleOrShort((double) + (Byte.MIN_VALUE - 1), (short) (Byte.MIN_VALUE - 1))); + + cipEqu(Short.MAX_VALUE + 0.9999991, + new OverloadedNumberUtils.DoubleOrIntegerOrFloat(Short.MAX_VALUE + 0.9999991, Short.MAX_VALUE + 1)); + cipEqu(Short.MIN_VALUE - 0.9999991, + new OverloadedNumberUtils.DoubleOrIntegerOrFloat(Short.MIN_VALUE - 0.9999991, Short.MIN_VALUE - 1)); + cipEqu(16777216 + 0.9e-6, + new OverloadedNumberUtils.DoubleOrIntegerOrFloat(16777216 + 0.9e-6, 16777216)); + cipEqu(-16777216 - 0.9e-6, + new OverloadedNumberUtils.DoubleOrIntegerOrFloat(-16777216 - 0.9e-6, -16777216)); + + cipEqu(Integer.MAX_VALUE + 0.9e-6, + new OverloadedNumberUtils.DoubleOrInteger(Integer.MAX_VALUE + 0.9e-6, Integer.MAX_VALUE)); + cipEqu(Integer.MIN_VALUE - 0.9e-6, + new OverloadedNumberUtils.DoubleOrInteger(Integer.MIN_VALUE - 0.9e-6, Integer.MIN_VALUE)); + + cipEqu(Integer.MAX_VALUE + 1L + 0.9e-6, + new OverloadedNumberUtils.DoubleOrFloat(Integer.MAX_VALUE + 1L + 0.9e-6)); + cipEqu(Integer.MIN_VALUE - 1L - 0.9e-6, + new OverloadedNumberUtils.DoubleOrFloat(Integer.MIN_VALUE - 1L - 0.9e-6)); + cipEqu(Long.MAX_VALUE + 0.9e-6, + new OverloadedNumberUtils.DoubleOrFloat(Long.MAX_VALUE + 0.9e-6)); + cipEqu(Long.MIN_VALUE - 0.9e-6, + new OverloadedNumberUtils.DoubleOrFloat(Long.MIN_VALUE - 0.9e-6)); + } + + @SuppressWarnings("boxing") + public void testFloatCoercion() { + cipEqu(1.00002f); + cipEqu(-1.00002f); + cipEqu(1.999989f); + cipEqu(-1.999989f); + cipEqu(16777218f); + cipEqu(-16777218f); + + cipEqu(1f, new OverloadedNumberUtils.FloatOrByte(1f, (byte) 1)); + cipEqu(-1f, new OverloadedNumberUtils.FloatOrByte(-1f, (byte) -1)); + cipEqu(1.000009f, new OverloadedNumberUtils.FloatOrByte(1.000009f, (byte) 1)); + cipEqu(-1.000009f, new OverloadedNumberUtils.FloatOrByte(-1.000009f, (byte) -1)); + cipEqu(1.999991f, new OverloadedNumberUtils.FloatOrByte(1.999991f, (byte) 2)); + cipEqu(-1.999991f, new OverloadedNumberUtils.FloatOrByte(-1.999991f, (byte) -2)); + + cipEqu(1000f, new OverloadedNumberUtils.FloatOrShort(1000f, (short) 1000)); + cipEqu(-1000f, new OverloadedNumberUtils.FloatOrShort(-1000f, (short) -1000)); + cipEqu(1000.00006f); + + cipEqu(60000f, new OverloadedNumberUtils.FloatOrInteger(60000f, 60000)); + cipEqu(-60000f, new OverloadedNumberUtils.FloatOrInteger(-60000f, -60000)); + cipEqu(60000.004f); + + cipEqu(100f, new OverloadedNumberUtils.FloatOrByte(100f, (byte) 100), TypeFlags.MASK_KNOWN_INTEGERS); + cipEqu(1000f, new OverloadedNumberUtils.FloatOrShort(1000f, (short) 1000), TypeFlags.MASK_KNOWN_INTEGERS); + cipEqu(60000f, new OverloadedNumberUtils.FloatOrInteger(60000f, 60000), TypeFlags.MASK_KNOWN_INTEGERS); + cipEqu(60000f, new OverloadedNumberUtils.FloatOrInteger(60000f, 60000), TypeFlags.LONG); + cipEqu((float) Integer.MAX_VALUE, (float) Integer.MAX_VALUE, TypeFlags.LONG); + cipEqu((float) -Integer.MAX_VALUE, (float) -Integer.MAX_VALUE); + + cipEqu(0.5f, 0.5f, TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(0.5f, 0.5f, TypeFlags.DOUBLE); + } + + public void testBigIntegerCoercion() { + BigInteger bi; + + cipEqu(BigInteger.ZERO, new OverloadedNumberUtils.BigIntegerOrByte(BigInteger.ZERO)); + bi = new BigInteger(String.valueOf(Byte.MAX_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrByte(bi)); + bi = new BigInteger(String.valueOf(Byte.MIN_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrByte(bi)); + + bi = new BigInteger(String.valueOf(Byte.MAX_VALUE + 1)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrShort(bi)); + bi = new BigInteger(String.valueOf(Byte.MIN_VALUE - 1)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrShort(bi)); + bi = new BigInteger(String.valueOf(Short.MAX_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrShort(bi)); + bi = new BigInteger(String.valueOf(Short.MIN_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrShort(bi)); + + bi = new BigInteger(String.valueOf(Short.MAX_VALUE + 1)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrInteger(bi)); + bi = new BigInteger(String.valueOf(Short.MIN_VALUE - 1)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrInteger(bi)); + bi = new BigInteger(String.valueOf(Integer.MAX_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrInteger(bi)); + bi = new BigInteger(String.valueOf(Integer.MIN_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrInteger(bi)); + + bi = new BigInteger(String.valueOf(Integer.MAX_VALUE + 1L)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrLong(bi)); + bi = new BigInteger(String.valueOf(Integer.MIN_VALUE - 1L)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrLong(bi)); + bi = new BigInteger(String.valueOf(Long.MAX_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrLong(bi)); + bi = new BigInteger(String.valueOf(Long.MIN_VALUE)); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrLong(bi)); + + cipEqu(new BigInteger(String.valueOf(Long.MAX_VALUE)).add(BigInteger.ONE)); + cipEqu(new BigInteger(String.valueOf(Long.MIN_VALUE)).subtract(BigInteger.ONE)); + + bi = new BigInteger("0"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), + TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), + TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), + TypeFlags.FLOAT); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), + TypeFlags.DOUBLE); + + bi = new BigInteger("16777215"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + bi = new BigInteger("-16777215"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + + bi = new BigInteger("16777216"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + bi = new BigInteger("-16777216"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrFloat(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + + bi = new BigInteger("16777217"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, TypeFlags.FLOAT); + bi = new BigInteger("-16777217"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, TypeFlags.FLOAT); + + bi = new BigInteger("9007199254740991"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); + bi = new BigInteger("-9007199254740991"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); + + bi = new BigInteger("9007199254740992"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); + bi = new BigInteger("-9007199254740992"); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, new OverloadedNumberUtils.BigIntegerOrDouble(bi), TypeFlags.DOUBLE); + + bi = new BigInteger("9007199254740993"); + cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(bi, TypeFlags.FLOAT); + cipEqu(bi, TypeFlags.DOUBLE); + bi = new BigInteger("-9007199254740993"); + cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); + cipEqu(bi, TypeFlags.DOUBLE | TypeFlags.FLOAT); + cipEqu(bi, TypeFlags.FLOAT); + cipEqu(bi, TypeFlags.DOUBLE); + + bi = new BigInteger("9007199254740994"); + cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); + bi = new BigInteger("-9007199254740994"); + cipEqu(bi, TypeFlags.MASK_KNOWN_NONINTEGERS); + } + + private void cipEqu(Number actualAndExpected) { + cipEqu(actualAndExpected, actualAndExpected, -1); + } + + private void cipEqu(Number actual, Number expected) { + cipEqu(actual, expected, -1); + } + + private void cipEqu(Number actualAndExpected, int flags) { + cipEqu(actualAndExpected, actualAndExpected, flags); + } + + @SuppressWarnings("boxing") + private void cipEqu(Number actual, Number expected, int flags) { + Number res = OverloadedNumberUtils.addFallbackType(actual, flags); + assertEquals(expected.getClass(), res.getClass()); + assertEquals(expected, res); + + // Some number types wrap the number with multiple types and equals() only compares one of them. So we try to + // catch any inconsistency: + assertEquals(expected.byteValue(), res.byteValue()); + assertEquals(expected.shortValue(), res.shortValue()); + assertEquals(expected.intValue(), res.intValue()); + assertEquals(expected.longValue(), res.longValue()); + assertEquals(expected.floatValue(), res.floatValue()); + assertEquals(expected.doubleValue(), res.doubleValue()); + } + + public void testGetArgumentConversionPrice() { + // Unknown number types: + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + RationalNumber.class, Integer.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, RationalNumber.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + RationalNumber.class, Float.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + Float.class, RationalNumber.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + RationalNumber.class, RationalNumber.class)); + + // Fully check some rows (not all of them; the code is generated anyways): + + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, Byte.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, Short.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, Integer.class)); + assertEquals(10004, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, Long.class)); + assertEquals(10005, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, BigInteger.class)); + assertEquals(30006, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, Float.class)); + assertEquals(20007, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, Double.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, BigDecimal.class)); + + assertEquals(45001, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, Byte.class)); + assertEquals(44002, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, Short.class)); + assertEquals(41003, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, Integer.class)); + assertEquals(41004, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, Long.class)); + assertEquals(40005, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, BigInteger.class)); + assertEquals(33006, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, Float.class)); + assertEquals(32007, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, Double.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, BigDecimal.class)); + + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, Byte.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, Short.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, Integer.class)); + assertEquals(21004, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, Long.class)); + assertEquals(21005, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, BigInteger.class)); + assertEquals(40006, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, Float.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, Double.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, BigDecimal.class)); + + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, Byte.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, Short.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, Integer.class)); + assertEquals(Integer.MAX_VALUE, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, Long.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, BigInteger.class)); + assertEquals(40006, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, Float.class)); + assertEquals(20007, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, Double.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, BigDecimal.class)); + + // Check if all fromC is present: + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Byte.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Short.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Integer.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Long.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + BigInteger.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Float.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + Double.class, BigDecimal.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + BigDecimal.class, BigDecimal.class)); + assertEquals(0, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.IntegerBigDecimal.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrFloat.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.FloatOrByte.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrShort.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.FloatOrByte.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.FloatOrShort.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.FloatOrInteger.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrByte.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrIntegerOrFloat.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrInteger.class, BigDecimal.class)); + assertEquals(20008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.DoubleOrLong.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrByte.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrShort.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrInteger.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrLong.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrFloat.class, BigDecimal.class)); + assertEquals(10008, OverloadedNumberUtils.getArgumentConversionPrice( + OverloadedNumberUtils.BigIntegerOrDouble.class, BigDecimal.class)); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/ebb39b84/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/ParameterListPreferabilityTest.java ---------------------------------------------------------------------- diff --git a/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/ParameterListPreferabilityTest.java b/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/ParameterListPreferabilityTest.java index 3e6c2ed..54461d4 100644 --- a/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/ParameterListPreferabilityTest.java +++ b/freemarker-core-test/src/test/java/org/apache/freemarker/core/model/impl/ParameterListPreferabilityTest.java @@ -27,7 +27,7 @@ import java.util.LinkedHashMap; import java.util.Map; import java.util.TreeMap; -import org.apache.freemarker.core.util._NumberUtil; +import org.apache.freemarker.core.util._NumberUtils; import junit.framework.TestCase; @@ -84,7 +84,7 @@ public class ParameterListPreferabilityTest extends TestCase { new Class[] { Serializable.class }, new Class[] { Object.class }, }, - new Object[] { new OverloadedNumberUtil.IntegerBigDecimal(new BigDecimal("1")) }); + new Object[] { new OverloadedNumberUtils.IntegerBigDecimal(new BigDecimal("1")) }); testAllCmpPermutationsInc( new Class[][] { @@ -128,7 +128,7 @@ public class ParameterListPreferabilityTest extends TestCase { new Class[] { Serializable.class }, new Class[] { Object.class }, }, - new Object[] { new OverloadedNumberUtil.FloatOrByte(1f, (byte) 1) }); + new Object[] { new OverloadedNumberUtils.FloatOrByte(1f, (byte) 1) }); testAllCmpPermutationsInc( new Class[][] { @@ -153,7 +153,7 @@ public class ParameterListPreferabilityTest extends TestCase { new Class[] { Serializable.class }, new Class[] { Object.class } }, - new Object[] { new OverloadedNumberUtil.IntegerOrShort(1, (short) 1) }); + new Object[] { new OverloadedNumberUtils.IntegerOrShort(1, (short) 1) }); testAllCmpPermutationsInc( new Class[][] { @@ -422,9 +422,9 @@ public class ParameterListPreferabilityTest extends TestCase { for (int i = 0; i < sortedSignatures.length; i++) { for (int j = 0; j < sortedSignatures.length; j++) { assertEquals("sortedSignatures[" + i + "] <==> sortedSignatures [" + j + "]", - _NumberUtil.getSignum( + _NumberUtils.getSignum( Integer.valueOf(j).compareTo(i)), - _NumberUtil.getSignum( + _NumberUtils.getSignum( argTs.compareParameterListPreferability( sortedSignatures[i], sortedSignatures[j], varargs))); } http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/ebb39b84/freemarker-core-test/src/test/java/org/apache/freemarker/core/templatesuite/models/JavaObjectInfo.java ---------------------------------------------------------------------- diff --git a/freemarker-core-test/src/test/java/org/apache/freemarker/core/templatesuite/models/JavaObjectInfo.java b/freemarker-core-test/src/test/java/org/apache/freemarker/core/templatesuite/models/JavaObjectInfo.java index aa6d618..a82665b 100644 --- a/freemarker-core-test/src/test/java/org/apache/freemarker/core/templatesuite/models/JavaObjectInfo.java +++ b/freemarker-core-test/src/test/java/org/apache/freemarker/core/templatesuite/models/JavaObjectInfo.java @@ -19,7 +19,7 @@ package org.apache.freemarker.core.templatesuite.models; -import org.apache.freemarker.core.util._StringUtil; +import org.apache.freemarker.core.util._StringUtils; public class JavaObjectInfo { @@ -29,7 +29,7 @@ public class JavaObjectInfo { public String info(Object o) { if (o == null) return "null"; - return o.getClass().getName() + " " + _StringUtil.jQuote(o.toString()); + return o.getClass().getName() + " " + _StringUtils.jQuote(o.toString()); } }