/*
* Copyright 2009 Google Inc.
*
* 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.
*/
/*
* 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.
*
* INCLUDES MODIFICATIONS BY GOOGLE.
*/
/**
* author Elena Semukhina
*/
package com.google.gwt.emultest.java.math;
import com.google.gwt.emultest.java.util.EmulTestBase;
import java.math.BigDecimal;
import java.math.BigInteger;
/**
* Class: java.math.BigDecimal. Methods: doubleValue, floatValue, intValue,
* longValue, valueOf, toString, toBigInteger
*/
public class BigDecimalConvertTest extends EmulTestBase {
public void testByteValue() {
assertEquals((byte) 1, BigDecimal.ONE.byteValue());
assertEquals((byte) -1, BigDecimal.valueOf(255).byteValue());
assertEquals((byte) 1, BigDecimal.ONE.byteValueExact());
try {
BigDecimal.valueOf(255).byteValueExact();
fail("Expected ArithmeticException on byteValueExact(255)");
} catch (ArithmeticException expected) {
}
}
/**
* Double value of a small negative BigDecimal.
*/
// TODO(jat): add back after Double.doubleToLongBits is implemented
// public void testDoubleValueMinusZero() {
// String a = "-123809648392384754573567356745735.63567890295784902768787678287E-400";
// BigDecimal aNumber = new BigDecimal(a);
// long minusZero = -9223372036854775808L;
// double result = aNumber.doubleValue();
// assertTrue("incorrect value", Double.doubleToLongBits(result) == minusZero);
// }
/**
* Double value of a negative BigDecimal.
*/
public void testDoubleValueNeg() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
BigDecimal aNumber = new BigDecimal(a);
double result = -1.2380964839238476E53;
assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
}
/**
* Double value of a large negative BigDecimal.
*/
public void testDoubleValueNegInfinity() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+400";
BigDecimal aNumber = new BigDecimal(a);
double result = Double.NEGATIVE_INFINITY;
assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
}
/**
* Double value of a small positive BigDecimal.
*/
// TODO(jat): add back after Double.doubleToLongBits is implemented
// public void testDoubleValuePlusZero() {
// String a = "123809648392384754573567356745735.63567890295784902768787678287E-400";
// BigDecimal aNumber = new BigDecimal(a);
// long zero = 0;
// double result = aNumber.doubleValue();
// assertTrue("incorrect value", Double.doubleToLongBits(result) == zero);
// }
/**
* Double value of a positive BigDecimal.
*/
public void testDoubleValuePos() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
BigDecimal aNumber = new BigDecimal(a);
double result = 1.2380964839238476E53;
assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
}
/**
* Double value of a large positive BigDecimal.
*/
public void testDoubleValuePosInfinity() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+400";
BigDecimal aNumber = new BigDecimal(a);
double result = Double.POSITIVE_INFINITY;
assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
}
/**
* Float value of a small negative BigDecimal.
*/
// TODO(jat): add back after Float.floatToIntBits is implemented
// public void testFloatValueMinusZero() {
// String a = "-123809648392384754573567356745735.63567890295784902768787678287E-400";
// BigDecimal aNumber = new BigDecimal(a);
// int minusZero = -2147483648;
// float result = aNumber.floatValue();
// assertTrue("incorrect value", Float.floatToIntBits(result) == minusZero);
// }
/**
* Float value of a negative BigDecimal.
*/
public void testFloatValueNeg() {
String a = "-1238096483923847.6356789029578E+21";
BigDecimal aNumber = new BigDecimal(a);
float result = -1.2380965E36F;
// Use range rather than exact value check, since GWT uses doubles anyway
assertEquals("incorrect value", aNumber.floatValue(), result, 1E29);
}
/**
* Float value of a large negative BigDecimal.
*/
public void testFloatValueNegInfinity() {
String a = "-123809648392384755735.63567887678287E+200";
BigDecimal aNumber = new BigDecimal(a);
float result = Float.NEGATIVE_INFINITY;
assertTrue("incorrect value", aNumber.floatValue() == result);
}
/**
* Float value of a small positive BigDecimal.
*/
// TODO(jat): add back after Float.floatToIntBits is implemented
// public void testFloatValuePlusZero() {
// String a = "123809648392384754573567356745735.63567890295784902768787678287E-400";
// BigDecimal aNumber = new BigDecimal(a);
// int zero = 0;
// float result = aNumber.floatValue();
// assertTrue("incorrect value", Float.floatToIntBits(result) == zero);
// }
/**
* Float value of a positive BigDecimal.
*/
public void testFloatValuePos() {
String a = "1238096483923847.6356789029578E+21";
BigDecimal aNumber = new BigDecimal(a);
float result = 1.2380965E36F;
// Use range rather than exact value check, since GWT uses doubles anyway
assertEquals("incorrect value", aNumber.floatValue(), result, 1E29);
}
/**
* Float value of a large positive BigDecimal.
*/
public void testFloatValuePosInfinity() {
String a = "123809648373567356745735.6356789787678287E+200";
BigDecimal aNumber = new BigDecimal(a);
float result = Float.POSITIVE_INFINITY;
assertTrue("incorrect value", aNumber.floatValue() == result);
}
/**
* Integer value of a negative BigDecimal.
*/
public void testIntValueNeg() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
BigDecimal aNumber = new BigDecimal(a);
int result = 218520473;
assertEquals("incorrect value", result, aNumber.intValue());
try {
aNumber.intValueExact();
fail("Expected ArithmeticException on intValueExact");
} catch (ArithmeticException expected) {
}
}
/**
* Integer value of a positive BigDecimal.
*/
public void testIntValuePos() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
BigDecimal aNumber = new BigDecimal(a);
int result = -218520473;
assertEquals("incorrect value", result, aNumber.intValue());
try {
aNumber.intValueExact();
fail("Expected ArithmeticException on intValueExact");
} catch (ArithmeticException expected) {
}
}
/**
* Long value of a negative BigDecimal.
*/
public void testLongValueNeg() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
BigDecimal aNumber = new BigDecimal(a);
long result = -1246043477766677607L;
assertTrue("incorrect value", aNumber.longValue() == result);
try {
aNumber.longValueExact();
fail("Expected ArithmeticException on longValueExact");
} catch (ArithmeticException expected) {
}
}
/**
* Long value of a positive BigDecimal.
*/
public void testLongValuePos() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
BigDecimal aNumber = new BigDecimal(a);
long result = 1246043477766677607L;
assertTrue("incorrect value", aNumber.longValue() == result);
try {
aNumber.longValueExact();
fail("Expected ArithmeticException on longValueExact");
} catch (ArithmeticException expected) {
}
}
/**
* scaleByPowerOfTen(int n).
*/
public void testScaleByPowerOfTen1() {
String a = "1231212478987482988429808779810457634781384756794987";
int aScale = 13;
BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
BigDecimal result = aNumber.scaleByPowerOfTen(10);
String res = "1231212478987482988429808779810457634781384756794.987";
int resScale = 3;
assertEquals("incorrect value", res, result.toString());
assertEquals("incorrect scale", resScale, result.scale());
}
/**
* scaleByPowerOfTen(int n).
*/
public void testScaleByPowerOfTen2() {
String a = "1231212478987482988429808779810457634781384756794987";
int aScale = -13;
BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
BigDecimal result = aNumber.scaleByPowerOfTen(10);
String res = "1.231212478987482988429808779810457634781384756794987E+74";
int resScale = -23;
assertEquals("incorrect value", res, result.toString());
assertEquals("incorrect scale", resScale, result.scale());
}
public void testShortValue() {
BigDecimal value = BigDecimal.valueOf(0x13fff);
assertEquals(0x3fff, value.shortValue());
try {
value.shortValueExact();
fail("Expected ArithmeticException");
} catch (ArithmeticException expected) {
}
}
/**
* toBigIntegerExact().
*/
public void testToBigIntegerExact1() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+45";
BigDecimal aNumber = new BigDecimal(a);
String res = "-123809648392384754573567356745735635678902957849027687876782870000000000000000";
BigInteger result = aNumber.toBigIntegerExact();
assertEquals("incorrect value", res, result.toString());
}
/**
* toBigIntegerExact().
*/
public void testToBigIntegerExactException() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E-10";
BigDecimal aNumber = new BigDecimal(a);
try {
aNumber.toBigIntegerExact();
fail("java.lang.ArithmeticException has not been thrown");
} catch (java.lang.ArithmeticException e) {
return;
}
}
/**
* Convert a negative BigDecimal to BigInteger.
*/
public void testToBigIntegerNeg1() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
BigInteger bNumber = new BigInteger(
"-123809648392384754573567356745735635678902957849027687");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a negative BigDecimal to BigInteger.
*/
public void testToBigIntegerNeg2() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+15";
BigInteger bNumber = new BigInteger(
"-123809648392384754573567356745735635678902957849");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a negative BigDecimal to BigInteger.
*/
public void testToBigIntegerNeg3() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E+45";
BigInteger bNumber = new BigInteger(
"-123809648392384754573567356745735635678902957849027687876782870000000000000000");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a positive BigDecimal to BigInteger.
*/
public void testToBigIntegerPos1() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
BigInteger bNumber = new BigInteger(
"123809648392384754573567356745735635678902957849027687");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a positive BigDecimal to BigInteger.
*/
public void testToBigIntegerPos2() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+15";
BigInteger bNumber = new BigInteger(
"123809648392384754573567356745735635678902957849");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a positive BigDecimal to BigInteger.
*/
public void testToBigIntegerPos3() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+45";
BigInteger bNumber = new BigInteger(
"123809648392384754573567356745735635678902957849027687876782870000000000000000");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a small BigDecimal to BigInteger.
*/
public void testToBigIntegerZero() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E-500";
BigInteger bNumber = new BigInteger("0");
BigDecimal aNumber = new BigDecimal(a);
BigInteger result = aNumber.toBigInteger();
assertTrue("incorrect value", result.equals(bNumber));
}
/**
* Convert a negative BigDecimal to an engineering string representation.
*/
public void testToEngineeringStringNeg() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E-501";
BigDecimal aNumber = new BigDecimal(a);
String result = "-123.80964839238475457356735674573563567890295784902768787678287E-471";
assertEquals("incorrect value", result, aNumber.toEngineeringString());
}
/**
* Convert a positive BigDecimal to an engineering string representation.
*/
public void testToEngineeringStringPos() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E-501";
BigDecimal aNumber = new BigDecimal(a);
String result = "123.80964839238475457356735674573563567890295784902768787678287E-471";
assertEquals("incorrect value", result, aNumber.toEngineeringString());
}
/**
* Convert a negative BigDecimal to an engineering string representation.
*/
public void testToEngineeringStringZeroNegExponent() {
String a = "0.0E-16";
BigDecimal aNumber = new BigDecimal(a);
String result = "0.00E-15";
assertEquals("incorrect value", result, aNumber.toEngineeringString());
}
/**
* Convert a negative BigDecimal to an engineering string representation.
*/
public void testToEngineeringStringZeroPosExponent() {
String a = "0.0E+16";
BigDecimal aNumber = new BigDecimal(a);
String result = "0E+15";
assertEquals("incorrect value", result, aNumber.toEngineeringString());
}
/**
* Convert a negative BigDecimal with a negative exponent to a plain string
* representation; scale == 0.
*/
public void testToPlainStringNegNegExp() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E-100";
BigDecimal aNumber = new BigDecimal(a);
String result = "-0.000000000000000000000000000000000000000000000000000000000000000000012380964839238475457356735674573563567890295784902768787678287";
assertTrue("incorrect value", aNumber.toPlainString().equals(result));
}
/**
* Convert a negative BigDecimal with a positive exponent to a plain string
* representation; scale == 0.
*/
public void testToPlainStringNegPosExp() {
String a = "-123809648392384754573567356745735.63567890295784902768787678287E100";
BigDecimal aNumber = new BigDecimal(a);
String result = "-1238096483923847545735673567457356356789029578490276878767828700000000000000000000000000000000000000000000000000000000000000000000000";
assertTrue("incorrect value", aNumber.toPlainString().equals(result));
}
/**
* Convert a positive BigDecimal with a negative exponent to a plain string
* representation; scale == 0.
*/
public void testToPlainStringPosNegExp() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E-100";
BigDecimal aNumber = new BigDecimal(a);
String result = "0.000000000000000000000000000000000000000000000000000000000000000000012380964839238475457356735674573563567890295784902768787678287";
assertTrue("incorrect value", aNumber.toPlainString().equals(result));
}
/**
* Convert a negative BigDecimal with a negative exponent to a plain string
* representation; scale == 0.
*/
public void testToPlainStringPosPosExp() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E+100";
BigDecimal aNumber = new BigDecimal(a);
String result = "1238096483923847545735673567457356356789029578490276878767828700000000000000000000000000000000000000000000000000000000000000000000000";
assertTrue("incorrect value", aNumber.toPlainString().equals(result));
}
/**
* Convert a negative BigDecimal to a string representation.
*/
public void testToStringNeg() {
String a = "-123.4564563673567380964839238475457356735674573563567890295784902768787678287E-5";
BigDecimal aNumber = new BigDecimal(a);
String result = "-0.001234564563673567380964839238475457356735674573563567890295784902768787678287";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Convert a positive BigDecimal to a string representation.
*/
public void testToStringPos() {
String a = "123809648392384754573567356745735.63567890295784902768787678287E-500";
BigDecimal aNumber = new BigDecimal(a);
String result = "1.2380964839238475457356735674573563567890295784902768787678287E-468";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Convert a BigDecimal to a string representation; scale == 0.
*/
public void testToStringZeroScale() {
String a = "-123809648392384754573567356745735635678902957849027687876782870";
BigDecimal aNumber = new BigDecimal(new BigInteger(a));
String result = "-123809648392384754573567356745735635678902957849027687876782870";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* valueOf(Double.NaN).
*/
@SuppressWarnings("ReturnValueIgnored")
public void testValueOfDoubleNaN() {
double a = Double.NaN;
try {
BigDecimal.valueOf(a);
fail("NumberFormatException has not been thrown for Double.NaN");
} catch (NumberFormatException e) {
return;
}
}
/**
* Create a BigDecimal from a negative double value.
*/
public void testValueOfDoubleNeg() {
double a = -65678765876567576.98788767;
BigDecimal result = BigDecimal.valueOf(a);
String res = "-65678765876567576";
int resScale = 0;
assertEquals("incorrect value", res, result.toString());
assertEquals("incorrect scale", resScale, result.scale());
}
/**
* Create a BigDecimal from a positive double value.
*/
public void testValueOfDoublePos1() {
double a = 65678765876567576.98788767;
BigDecimal result = BigDecimal.valueOf(a);
String res = "65678765876567576";
int resScale = 0;
assertEquals("incorrect value", res, result.toString());
assertEquals("incorrect scale", resScale, result.scale());
}
/**
* Create a BigDecimal from a positive double value.
*/
public void testValueOfDoublePos2() {
double a = 12321237576.98788767;
BigDecimal result = BigDecimal.valueOf(a);
String res = "12321237576.987888";
int resScale = 6;
assertEquals("incorrect value", res, result.toString());
assertEquals("incorrect scale", resScale, result.scale());
}
/**
* Create a BigDecimal from a positive double value.
*/
public void testValueOfDoublePos3() {
double a = 12321237576.9878838;
BigDecimal result = BigDecimal.valueOf(a);
String res = "12321237576.98788";
int resScale = 6;
assertTrue("incorrect value", result.toString().startsWith(res));
assertEquals("incorrect scale", resScale, result.scale());
}
/**
* Create a BigDecimal from a negative long value; scale is negative.
*/
public void testValueOfNegScaleNeg() {
long a = -98374823947823578L;
int scale = -12;
BigDecimal aNumber = BigDecimal.valueOf(a, scale);
String result = "-9.8374823947823578E+28";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Create a BigDecimal from a negative long value; scale is positive.
*/
public void testValueOfNegScalePos() {
long a = -98374823947823578L;
int scale = 12;
BigDecimal aNumber = BigDecimal.valueOf(a, scale);
String result = "-98374.823947823578";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Create a BigDecimal from a negative long value; scale is 0.
*/
public void testValueOfNegZeroScale() {
long a = -98374823947823578L;
BigDecimal aNumber = BigDecimal.valueOf(a);
String result = "-98374823947823578";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Create a BigDecimal from a negative long value; scale is negative.
*/
public void testValueOfPosScaleNeg() {
long a = 98374823947823578L;
int scale = -12;
BigDecimal aNumber = BigDecimal.valueOf(a, scale);
String result = "9.8374823947823578E+28";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Create a BigDecimal from a negative long value; scale is positive.
*/
public void testValueOfPosScalePos() {
long a = 98374823947823578L;
int scale = 12;
BigDecimal aNumber = BigDecimal.valueOf(a, scale);
String result = "98374.823947823578";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Create a BigDecimal from a positive long value; scale == 0.
*/
public void testValueOfPosZeroScale() {
long a = 98374823947823578L;
BigDecimal aNumber = BigDecimal.valueOf(a);
String result = "98374823947823578";
assertTrue("incorrect value", aNumber.toString().equals(result));
}
/**
* Create a BigDecimal from a zero value; with a small negative scale.
*/
public void testValueOfZeroScaleNeg() {
int scale = -2;
BigDecimal number = BigDecimal.valueOf(0L, scale);
assertEquals("incorrect value", "0E+2", number.toString());
assertEquals("bad scale", scale, number.scale());
}
/**
* Create a BigDecimal from a zero value; with a small positive scale.
*/
public void testValueOfZeroScalePos() {
int scale = 1;
BigDecimal number = BigDecimal.valueOf(0L, scale);
assertEquals("incorrect value", "0.0", number.toString());
assertEquals("bad scale", scale, number.scale());
}
}