/*
 * 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);
    }
  }
}