user/test/com/google/gwt/emultest/java/math/BigDecimalConvertTest.java

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