| /* |
| * 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; |
| import java.math.MathContext; |
| import java.math.RoundingMode; |
| |
| /** |
| * Class: java.math.BigDecimal Methods: constructors and fields. |
| */ |
| public class BigDecimalConstructorsTest extends EmulTestBase { |
| |
| /** |
| * new BigDecimal(BigInteger value). |
| */ |
| public void testConstrBI() { |
| String a = "1231212478987482988429808779810457634781384756794987"; |
| BigInteger bA = new BigInteger(a); |
| BigDecimal aNumber = new BigDecimal(bA); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", 0, aNumber.scale()); |
| |
| try { |
| new BigDecimal((BigInteger) null); |
| fail("No NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * new BigDecimal(BigInteger value, MathContext). |
| */ |
| public void testConstrBigIntegerMathContext() { |
| String a = "1231212478987482988429808779810457634781384756794987"; |
| BigInteger bA = new BigInteger(a); |
| int precision = 46; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| String res = "1231212478987482988429808779810457634781384757"; |
| int resScale = -6; |
| BigDecimal result = new BigDecimal(bA, mc); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(BigInteger value, int scale, MathContext). |
| */ |
| public void testConstrBigIntegerScaleMathContext() { |
| String a = "1231212478987482988429808779810457634781384756794987"; |
| BigInteger bA = new BigInteger(a); |
| int aScale = 10; |
| int precision = 46; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| String res = "1231212478987482988429808779810457634781384757"; |
| int resScale = 4; |
| BigDecimal result = new BigDecimal(bA, aScale, mc); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(BigInteger value, int scale). |
| */ |
| public void testConstrBIScale() { |
| String a = "1231212478987482988429808779810457634781384756794987"; |
| BigInteger bA = new BigInteger(a); |
| int aScale = 10; |
| BigDecimal aNumber = new BigDecimal(bA, aScale); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(char[] value). |
| */ |
| public void testConstrChar() { |
| char value[] = { |
| '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', |
| '2', '3'}; |
| BigDecimal result = new BigDecimal(value); |
| String res = "-1.23804738E-419"; |
| int resScale = 427; |
| assertEquals("incorrect value", res, result.toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| |
| try { |
| // Regression for HARMONY-783 |
| new BigDecimal(new char[] {}); |
| fail("NumberFormatException has not been thrown"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(char[] value, int offset, int len). |
| */ |
| public void testConstrCharIntInt() { |
| char value[] = { |
| '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', |
| '2', '3'}; |
| int offset = 3; |
| int len = 12; |
| BigDecimal result = new BigDecimal(value, offset, len); |
| String res = "3.804738E-40"; |
| int resScale = 46; |
| assertEquals("incorrect value", res, result.toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| |
| try { |
| // Regression for HARMONY-783 |
| new BigDecimal(new char[] {}, 0, 0); |
| fail("NumberFormatException has not been thrown"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(char[] value, int offset, int len, MathContext mc). |
| */ |
| public void testConstrCharIntIntMathContext() { |
| char value[] = { |
| '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', |
| '2', '3'}; |
| int offset = 3; |
| int len = 12; |
| int precision = 4; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| BigDecimal result = new BigDecimal(value, offset, len, mc); |
| String res = "3.805E-40"; |
| int resScale = 43; |
| assertEquals("incorrect value", res, result.toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| |
| try { |
| // Regression for HARMONY-783 |
| new BigDecimal(new char[] {}, 0, 0, MathContext.DECIMAL32); |
| fail("NumberFormatException has not been thrown"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(char[] value, int offset, int len, MathContext mc). |
| */ |
| public void testConstrCharIntIntMathContextException1() { |
| char value[] = { |
| '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', |
| '2', '3'}; |
| int offset = 3; |
| int len = 120; |
| int precision = 4; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| try { |
| new BigDecimal(value, offset, len, mc); |
| fail("NumberFormatException has not been thrown"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(char[] value, int offset, int len, MathContext mc). |
| */ |
| public void testConstrCharIntIntMathContextException2() { |
| char value[] = { |
| '-', '1', '2', '3', '8', '0', ',', '4', '7', '3', '8', 'E', '-', '4', |
| '2', '3'}; |
| int offset = 3; |
| int len = 120; |
| int precision = 4; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| try { |
| new BigDecimal(value, offset, len, mc); |
| fail("NumberFormatException has not been thrown"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(char[] value, MathContext mc). |
| */ |
| public void testConstrCharMathContext() { |
| char value[] = { |
| '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2' |
| }; |
| int precision = 4; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| BigDecimal result = new BigDecimal(value, mc); |
| String res = "3.805E-40"; |
| int resScale = 43; |
| assertEquals("incorrect value", res, result.toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| |
| // Regression for HARMONY-783 |
| try { |
| new BigDecimal(new char[] {}, MathContext.DECIMAL32); |
| fail("NumberFormatException has not been thrown"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(double value). |
| */ |
| public void testConstrDouble() { |
| double a = 732546982374982347892379283571094797.287346782359284756; |
| BigDecimal aNumber = new BigDecimal(a); |
| BigDecimal expected = new BigDecimal( |
| "732546982374982347892379283571094797.287346782359284756"); |
| assertEquals(expected, aNumber, 1e21); |
| } |
| |
| /** |
| * new BigDecimal(0.1). |
| */ |
| public void testConstrDouble01() { |
| double a = 1.E-1; |
| BigDecimal aNumber = new BigDecimal(a); |
| BigDecimal expected = new BigDecimal( |
| ".1000000000000000055511151231257827021181583404541015625"); |
| assertEquals(expected, aNumber, 1e-9); |
| } |
| |
| /** |
| * new BigDecimal(0.555). |
| */ |
| public void testConstrDouble02() { |
| double a = 0.555; |
| BigDecimal aNumber = new BigDecimal(a); |
| BigDecimal expected = new BigDecimal( |
| ".55500000000000004884981308350688777863979339599609375"); |
| assertEquals(expected, aNumber, 1e-8); |
| } |
| |
| /** |
| * new BigDecimal(double value) when value is denormalized. |
| */ |
| public void testConstrDoubleDenormalized() { |
| // HtmlUnit incorrectly converts the following double to a string |
| // Safari can't handle e-309 here |
| double a = 2.274341322658976E-304; |
| BigDecimal aNumber = new BigDecimal(a); |
| BigDecimal expected = new BigDecimal( |
| "2.274341322658976E-304"); |
| assertEquals(expected, aNumber, 1e-305); |
| } |
| |
| /** |
| * new BigDecimal(double, MathContext). |
| */ |
| public void testConstrDoubleMathContext() { |
| double a = 732546982374982347892379283571094797.287346782359284756; |
| int precision = 21; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| BigDecimal result = new BigDecimal(a, mc); |
| BigDecimal expected = new BigDecimal("732546982374982e21"); |
| assertEquals(expected, result, 1e21); |
| try { |
| new BigDecimal(Double.NaN); |
| fail("Expected NumberFormatException on NaN"); |
| } catch (NumberFormatException expectedException) { |
| } |
| try { |
| new BigDecimal(Double.POSITIVE_INFINITY); |
| fail("Expected NumberFormatException on +Infinity"); |
| } catch (NumberFormatException expectedException) { |
| } |
| try { |
| new BigDecimal(Double.NEGATIVE_INFINITY); |
| fail("Expected NumberFormatException on -Infinity"); |
| } catch (NumberFormatException expectedException) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(-0.1). |
| */ |
| public void testConstrDoubleMinus01() { |
| double a = -1.E-1; |
| BigDecimal aNumber = new BigDecimal(a); |
| BigDecimal expected = new BigDecimal( |
| "-.1000000000000000055511151231257827021181583404541015625"); |
| assertEquals(expected, aNumber, 1e-9); |
| } |
| |
| /** |
| * new BigDecimal(double value) when value is NaN. |
| */ |
| public void testConstrDoubleNaN() { |
| double a = Double.NaN; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| assertEquals("Improper exception message", "Infinite or NaN", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * new BigDecimal(double value) when value is positive infinity. |
| */ |
| public void testConstrDoubleNegInfinity() { |
| double a = Double.NEGATIVE_INFINITY; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| assertEquals("Improper exception message", "Infinite or NaN", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * new BigDecimal(double value) when value is positive infinity. |
| */ |
| public void testConstrDoublePosInfinity() { |
| double a = Double.POSITIVE_INFINITY; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| assertEquals("Improper exception message", "Infinite or NaN", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * new BigDecimal(int value). |
| */ |
| public void testConstrInt() { |
| int a = 732546982; |
| String res = "732546982"; |
| int resScale = 0; |
| BigDecimal result = new BigDecimal(a); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(int, MathContext). |
| */ |
| public void testConstrIntMathContext() { |
| int a = 732546982; |
| int precision = 21; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| String res = "732546982"; |
| int resScale = 0; |
| BigDecimal result = new BigDecimal(a, mc); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(long value). |
| */ |
| public void testConstrLong() { |
| long a = 4576578677732546982L; |
| String res = "4576578677732546982"; |
| int resScale = 0; |
| BigDecimal result = new BigDecimal(a); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(long, MathContext). |
| */ |
| public void testConstrLongMathContext() { |
| long a = 4576578677732546982L; |
| int precision = 5; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| String res = "45766"; |
| int resScale = -14; |
| BigDecimal result = new BigDecimal(a, mc); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value) when value is not a valid representation of |
| * BigDecimal. |
| */ |
| public void testConstrStringException() { |
| String a = "-238768.787678287a+10"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when exponent is empty. |
| */ |
| public void testConstrStringExceptionEmptyExponent1() { |
| String a = "-238768.787678287e"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when exponent is empty. |
| */ |
| public void testConstrStringExceptionEmptyExponent2() { |
| String a = "-238768.787678287e-"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when exponent is greater than |
| * Integer.MAX_VALUE. |
| */ |
| public void testConstrStringExceptionExponentGreaterIntegerMax() { |
| String a = "-238768.787678287e214748364767876"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when exponent is less than Integer.MIN_VALUE. |
| */ |
| public void testConstrStringExceptionExponentLessIntegerMin() { |
| String a = "-238768.787678287e-214748364767876"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException has not been caught"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when exponent is Integer.MAX_VALUE. |
| */ |
| public void testConstrStringExponentIntegerMax() { |
| String a = "-238768.787678287e2147483647"; |
| int aScale = -2147483638; |
| BigInteger bA = new BigInteger("-238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value) when exponent is Integer.MIN_VALUE. |
| */ |
| public void testConstrStringExponentIntegerMin() { |
| String a = ".238768e-2147483648"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException expected"); |
| } catch (NumberFormatException e) { |
| assertEquals("Improper exception message", "Scale out of range.", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when value has multiple signs. |
| */ |
| public void testConstrStringMultipleSignsStartWithPlus() { |
| String a = "+-3"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException expected"); |
| } catch (NumberFormatException expected) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value) when value has multiple signs. |
| */ |
| public void testConstrStringMultipleSignsStartWithMinus() { |
| String a = "-+3"; |
| try { |
| new BigDecimal(a); |
| fail("NumberFormatException expected"); |
| } catch (NumberFormatException expected) { |
| } |
| } |
| |
| /** |
| * new BigDecimal(String value, MathContext). |
| */ |
| public void testConstrStringMathContext() { |
| String a = "-238768787678287e214"; |
| int precision = 5; |
| RoundingMode rm = RoundingMode.CEILING; |
| MathContext mc = new MathContext(precision, rm); |
| String res = "-23876"; |
| int resScale = -224; |
| BigDecimal result = new BigDecimal(a, mc); |
| assertEquals("incorrect value", res, result.unscaledValue().toString()); |
| assertEquals("incorrect scale", resScale, result.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains exponent and does not contain |
| * decimal point. |
| */ |
| public void testConstrStringWithExponentWithoutPoint1() { |
| String a = "-238768787678287e214"; |
| int aScale = -214; |
| BigInteger bA = new BigInteger("-238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains exponent and does not contain |
| * decimal point. |
| */ |
| public void testConstrStringWithExponentWithoutPoint2() { |
| String a = "-238768787678287e-214"; |
| int aScale = 214; |
| BigInteger bA = new BigInteger("-238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains exponent and does not contain |
| * decimal point. |
| */ |
| public void testConstrStringWithExponentWithoutPoint3() { |
| String a = "238768787678287e-214"; |
| int aScale = 214; |
| BigInteger bA = new BigInteger("238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains exponent and does not contain |
| * decimal point. |
| */ |
| public void testConstrStringWithExponentWithoutPoint4() { |
| String a = "238768787678287e+214"; |
| int aScale = -214; |
| BigInteger bA = new BigInteger("238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains exponent and does not contain |
| * decimal point. |
| */ |
| public void testConstrStringWithExponentWithoutPoint5() { |
| String a = "238768787678287E214"; |
| int aScale = -214; |
| BigInteger bA = new BigInteger("238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains both exponent and decimal |
| * point. |
| */ |
| public void testConstrStringWithExponentWithPoint1() { |
| String a = "23985439837984782435652424523876878.7678287e+214"; |
| int aScale = -207; |
| BigInteger bA = new BigInteger("239854398379847824356524245238768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains both exponent and decimal |
| * point. |
| */ |
| public void testConstrStringWithExponentWithPoint2() { |
| String a = "238096483923847545735673567457356356789029578490276878.7678287e-214"; |
| int aScale = 221; |
| BigInteger bA = new BigInteger( |
| "2380964839238475457356735674573563567890295784902768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains both exponent and decimal |
| * point. |
| */ |
| public void testConstrStringWithExponentWithPoint3() { |
| String a = "2380964839238475457356735674573563567890.295784902768787678287E+21"; |
| int aScale = 0; |
| BigInteger bA = new BigInteger( |
| "2380964839238475457356735674573563567890295784902768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains both exponent and decimal |
| * point. |
| */ |
| public void testConstrStringWithExponentWithPoint4() { |
| String a = "23809648392384754573567356745735635678.90295784902768787678287E+21"; |
| int aScale = 2; |
| BigInteger bA = new BigInteger( |
| "2380964839238475457356735674573563567890295784902768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value contains both exponent and decimal |
| * point. |
| */ |
| public void testConstrStringWithExponentWithPoint5() { |
| String a = "238096483923847545735673567457356356789029.5784902768787678287E+21"; |
| int aScale = -2; |
| BigInteger bA = new BigInteger( |
| "2380964839238475457356735674573563567890295784902768787678287"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * Test second failing example in gwt-java-math issue 4 and variations |
| * to validate that precision is calculated correctly when leading zeros |
| * and minus signs are present. |
| */ |
| public void testConstrStringWithLeadingZeros() { |
| assertEquals("bad precision", 1, new BigDecimal("-000.1").precision()); |
| assertEquals("bad precision", 4, new BigDecimal("001234").precision()); |
| assertEquals("bad precision", 4, new BigDecimal("-5555").precision()); |
| assertEquals("bad precision", 1, new BigDecimal("0").precision()); |
| assertEquals("bad precision", 1, new BigDecimal("-0").precision()); |
| assertEquals("bad precision", 4, new BigDecimal("001234e3").precision()); |
| assertEquals("bad precision", 5, new BigDecimal("00056789e+17").precision()); |
| assertEquals("bad precision", 6, new BigDecimal("0900000e-42").precision()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value does not contain exponent. |
| */ |
| public void testConstrStringWithoutExpNeg() { |
| String a = "-732546982374982347892379283571094797.287346782359284756"; |
| int aScale = 18; |
| BigInteger bA = new BigInteger( |
| "-732546982374982347892379283571094797287346782359284756"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value does not contain exponent. |
| */ |
| public void testConstrStringWithoutExpPos1() { |
| String a = "732546982374982347892379283571094797.287346782359284756"; |
| int aScale = 18; |
| BigInteger bA = new BigInteger( |
| "732546982374982347892379283571094797287346782359284756"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value does not contain exponent. |
| */ |
| public void testConstrStringWithoutExpPos2() { |
| String a = "+732546982374982347892379283571094797.287346782359284756"; |
| int aScale = 18; |
| BigInteger bA = new BigInteger( |
| "732546982374982347892379283571094797287346782359284756"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * new BigDecimal(String value); value does not contain exponent and decimal |
| * point. |
| */ |
| public void testConstrStringWithoutExpWithoutPoint() { |
| String a = "-732546982374982347892379283571094797287346782359284756"; |
| int aScale = 0; |
| BigInteger bA = new BigInteger( |
| "-732546982374982347892379283571094797287346782359284756"); |
| BigDecimal aNumber = new BigDecimal(a); |
| assertEquals("incorrect value", bA, aNumber.unscaledValue()); |
| assertEquals("incorrect scale", aScale, aNumber.scale()); |
| } |
| |
| /** |
| * Test that constructing BigDecimals from zeros works properly. |
| */ |
| public void testConstrZero() { |
| BigDecimal bd = new BigDecimal("0"); |
| assertEquals(0, bd.intValueExact()); |
| assertEquals(1, bd.precision()); |
| assertEquals(0, bd.scale()); |
| bd = new BigDecimal("0.0"); |
| assertEquals(0, bd.intValueExact()); |
| assertEquals(1, bd.precision()); |
| assertEquals(1, bd.scale()); |
| bd = new BigDecimal("0.00"); |
| assertEquals(0, bd.intValueExact()); |
| assertEquals(1, bd.precision()); |
| assertEquals(2, bd.scale()); |
| } |
| |
| /** |
| * check ONE. |
| */ |
| public void testFieldONE() { |
| String oneS = "1"; |
| double oneD = 1.0; |
| assertEquals("incorrect string value", oneS, BigDecimal.ONE.toString()); |
| assertEquals("incorrect double value", oneD, BigDecimal.ONE.doubleValue(), |
| 0); |
| } |
| |
| /** |
| * check TEN. |
| */ |
| public void testFieldTEN() { |
| String oneS = "10"; |
| double oneD = 10.0; |
| assertEquals("incorrect string value", oneS, BigDecimal.TEN.toString()); |
| assertEquals("incorrect double value", oneD, BigDecimal.TEN.doubleValue(), |
| 0); |
| } |
| |
| /** |
| * check ZERO. |
| */ |
| public void testFieldZERO() { |
| String oneS = "0"; |
| double oneD = 0.0; |
| assertEquals("incorrect string value", oneS, BigDecimal.ZERO.toString()); |
| assertEquals("incorrect double value", oneD, BigDecimal.ZERO.doubleValue(), |
| 0); |
| } |
| |
| private void assertEquals(BigDecimal expected, BigDecimal actual, |
| double delta) { |
| BigDecimal actualDeltaDecimal = actual.subtract(expected); |
| double actualDelta = actualDeltaDecimal.abs().doubleValue(); |
| if (actualDelta >= delta) { |
| fail("expected=" + expected + " actual=" + actual + " delta=" |
| + actualDelta); |
| } |
| } |
| } |