/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.harmony.tests.java.math;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.math.RoundingMode;


public class BigDecimalTest extends junit.framework.TestCase {
	BigInteger value = new BigInteger("12345908");

	BigInteger value2 = new BigInteger("12334560000");

	/**
	 * @tests java.math.BigDecimal#BigDecimal(java.math.BigInteger)
	 */
	public void test_ConstructorLjava_math_BigInteger() {
		BigDecimal big = new BigDecimal(value);
		assertTrue("the BigDecimal value is not initialized properly", big
				.unscaledValue().equals(value)
				&& big.scale() == 0);
	}

	/**
	 * @tests java.math.BigDecimal#BigDecimal(java.math.BigInteger, int)
	 */
	public void test_ConstructorLjava_math_BigIntegerI() {
		BigDecimal big = new BigDecimal(value2, 5);
		assertTrue("the BigDecimal value is not initialized properly", big
				.unscaledValue().equals(value2)
				&& big.scale() == 5);
		assertTrue("the BigDecimal value is not represented properly", big
				.toString().equals("123345.60000"));
	}

	/**
	 * @tests java.math.BigDecimal#BigDecimal(double)
	 */
	public void test_ConstructorD() {
		BigDecimal big = new BigDecimal(123E04);
		assertTrue(
				"the BigDecimal value taking a double argument is not initialized properly",
				big.toString().equals("1230000"));
		big = new BigDecimal(1.2345E-12);
		assertTrue("the double representation is not correct", big
				.doubleValue() == 1.2345E-12);
		big = new BigDecimal(-12345E-3);
		assertTrue("the double representation is not correct", big
				.doubleValue() == -12.345);
		big = new BigDecimal(5.1234567897654321e138);
		assertTrue("the double representation is not correct", big
				.doubleValue() == 5.1234567897654321E138
				&& big.scale() == 0);
		big = new BigDecimal(0.1);
		assertTrue(
				"the double representation of 0.1 bigDecimal is not correct",
				big.doubleValue() == 0.1);
		big = new BigDecimal(0.00345);
		assertTrue(
				"the double representation of 0.00345 bigDecimal is not correct",
				big.doubleValue() == 0.00345);
        // regression test for HARMONY-2429
        big = new BigDecimal(-0.0);
        assertTrue(
        		"the double representation of -0.0 bigDecimal is not correct",
        		big.scale() == 0);
	}

	/**
	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
	 */
	public void test_ConstructorLjava_lang_String() throws NumberFormatException {
		BigDecimal big = new BigDecimal("345.23499600293850");
		assertTrue("the BigDecimal value is not initialized properly", big
				.toString().equals("345.23499600293850")
				&& big.scale() == 14);
		big = new BigDecimal("-12345");
		assertTrue("the BigDecimal value is not initialized properly", big
				.toString().equals("-12345")
				&& big.scale() == 0);
		big = new BigDecimal("123.");
		assertTrue("the BigDecimal value is not initialized properly", big
				.toString().equals("123")
				&& big.scale() == 0);

		new BigDecimal("1.234E02");
	}

	/**
	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
	 */
	public void test_constructor_String_plus_exp() {
		/*
		 * BigDecimal does not support a + sign in the exponent when converting
		 * from a String
		 */
		new BigDecimal(+23e-0);
		new BigDecimal(-23e+0);
	}

	/**
	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
	 */
	public void test_constructor_String_empty() {
		try {
			new BigDecimal("");			
            fail("NumberFormatException expected");
		} catch (NumberFormatException e) {
		}
	}
	
	/**
	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
	 */
	public void test_constructor_String_plus_minus_exp() {
		try {
			new BigDecimal("+35e+-2");			
            fail("NumberFormatException expected");
		} catch (NumberFormatException e) {
		}
		
		try {
			new BigDecimal("-35e-+2");			
            fail("NumberFormatException expected");
		} catch (NumberFormatException e) {
		}
	}
    
    /**
     * @tests java.math.BigDecimal#BigDecimal(char[])
     */
    public void test_constructor_CC_plus_minus_exp() {
        try {
            new BigDecimal("+35e+-2".toCharArray());          
            fail("NumberFormatException expected");
        } catch (NumberFormatException e) {
        }
        
        try {
            new BigDecimal("-35e-+2".toCharArray());          
            fail("NumberFormatException expected");
        } catch (NumberFormatException e) {
        }
    }

	/**
	 * @tests java.math.BigDecimal#abs()
	 */
	public void test_abs() {
		BigDecimal big = new BigDecimal("-1234");
		BigDecimal bigabs = big.abs();
		assertTrue("the absolute value of -1234 is not 1234", bigabs.toString()
				.equals("1234"));
		big = new BigDecimal(new BigInteger("2345"), 2);
		bigabs = big.abs();
		assertTrue("the absolute value of 23.45 is not 23.45", bigabs
				.toString().equals("23.45"));
	}

	/**
	 * @tests java.math.BigDecimal#add(java.math.BigDecimal)
	 */
	public void test_addLjava_math_BigDecimal() {
		BigDecimal add1 = new BigDecimal("23.456");
		BigDecimal add2 = new BigDecimal("3849.235");
		BigDecimal sum = add1.add(add2);
		assertTrue("the sum of 23.456 + 3849.235 is wrong", sum.unscaledValue()
				.toString().equals("3872691")
				&& sum.scale() == 3);
		assertTrue("the sum of 23.456 + 3849.235 is not printed correctly", sum
				.toString().equals("3872.691"));
		BigDecimal add3 = new BigDecimal(12.34E02D);
		assertTrue("the sum of 23.456 + 12.34E02 is not printed correctly",
				(add1.add(add3)).toString().equals("1257.456"));
	}

	/**
	 * @tests java.math.BigDecimal#compareTo(java.math.BigDecimal)
	 */
	public void test_compareToLjava_math_BigDecimal() {
		BigDecimal comp1 = new BigDecimal("1.00");
		BigDecimal comp2 = new BigDecimal(1.000000D);
		assertTrue("1.00 and 1.000000 should be equal",
				comp1.compareTo(comp2) == 0);
		BigDecimal comp3 = new BigDecimal("1.02");
		assertTrue("1.02 should be bigger than 1.00",
				comp3.compareTo(comp1) == 1);
		BigDecimal comp4 = new BigDecimal(0.98D);
		assertTrue("0.98 should be less than 1.00",
				comp4.compareTo(comp1) == -1);
	}

	/**
	 * @tests java.math.BigDecimal#divide(java.math.BigDecimal, int)
	 */
	public void test_divideLjava_math_BigDecimalI() {
		BigDecimal divd1 = new BigDecimal(value, 2);
		BigDecimal divd2 = new BigDecimal("2.335");
		BigDecimal divd3 = divd1.divide(divd2, BigDecimal.ROUND_UP);
		assertTrue("123459.08/2.335 is not correct", divd3.toString().equals(
				"52873.27")
				&& divd3.scale() == divd1.scale());
		assertTrue(
				"the unscaledValue representation of 123459.08/2.335 is not correct",
				divd3.unscaledValue().toString().equals("5287327"));
		divd2 = new BigDecimal(123.4D);
		divd3 = divd1.divide(divd2, BigDecimal.ROUND_DOWN);
		assertTrue("123459.08/123.4  is not correct", divd3.toString().equals(
				"1000.47")
				&& divd3.scale() == 2);
		divd2 = new BigDecimal(000D);

		try {
			divd1.divide(divd2, BigDecimal.ROUND_DOWN);
            fail("divide by zero is not caught");
		} catch (ArithmeticException e) {
		}
	}

	/**
	 * @tests java.math.BigDecimal#divide(java.math.BigDecimal, int, int)
	 */
	public void test_divideLjava_math_BigDecimalII() {
		BigDecimal divd1 = new BigDecimal(value2, 4);
		BigDecimal divd2 = new BigDecimal("0.0023");
		BigDecimal divd3 = divd1.divide(divd2, 3, BigDecimal.ROUND_HALF_UP);
		assertTrue("1233456/0.0023 is not correct", divd3.toString().equals(
				"536285217.391")
				&& divd3.scale() == 3);
		divd2 = new BigDecimal(1345.5E-02D);
		divd3 = divd1.divide(divd2, 0, BigDecimal.ROUND_DOWN);
		assertTrue(
				"1233456/13.455 is not correct or does not have the correct scale",
				divd3.toString().equals("91672") && divd3.scale() == 0);
		divd2 = new BigDecimal(0000D);

		try {
			divd1.divide(divd2, 4, BigDecimal.ROUND_DOWN);
            fail("divide by zero is not caught");
		} catch (ArithmeticException e) {
		}
	}

	/**
	 * @tests java.math.BigDecimal#doubleValue()
	 */
	public void test_doubleValue() {
		BigDecimal bigDB = new BigDecimal(-1.234E-112);
//		Commenting out this part because it causes an endless loop (see HARMONY-319 and HARMONY-329)
//		assertTrue(
//				"the double representation of this BigDecimal is not correct",
//				bigDB.doubleValue() == -1.234E-112);
		bigDB = new BigDecimal(5.00E-324);
		assertTrue("the double representation of bigDecimal is not correct",
				bigDB.doubleValue() == 5.00E-324);
		bigDB = new BigDecimal(1.79E308);
		assertTrue("the double representation of bigDecimal is not correct",
				bigDB.doubleValue() == 1.79E308 && bigDB.scale() == 0);
		bigDB = new BigDecimal(-2.33E102);
		assertTrue(
				"the double representation of bigDecimal -2.33E102 is not correct",
				bigDB.doubleValue() == -2.33E102 && bigDB.scale() == 0);
		bigDB = new BigDecimal(Double.MAX_VALUE);
		bigDB = bigDB.add(bigDB);
		assertTrue(
				"a  + number out of the double range should return infinity",
				bigDB.doubleValue() == Double.POSITIVE_INFINITY);
		bigDB = new BigDecimal(-Double.MAX_VALUE);
		bigDB = bigDB.add(bigDB);
		assertTrue(
				"a  - number out of the double range should return neg infinity",
				bigDB.doubleValue() == Double.NEGATIVE_INFINITY);
	}

	/**
	 * @tests java.math.BigDecimal#equals(java.lang.Object)
	 */
	public void test_equalsLjava_lang_Object() {
		BigDecimal equal1 = new BigDecimal(1.00D);
		BigDecimal equal2 = new BigDecimal("1.0");
		assertFalse("1.00 and 1.0 should not be equal",
				equal1.equals(equal2));
		equal2 = new BigDecimal(1.01D);
		assertFalse("1.00 and 1.01 should not be equal",
				equal1.equals(equal2));
		equal2 = new BigDecimal("1.00");
		assertFalse("1.00D and 1.00 should not be equal",
				equal1.equals(equal2));
		BigInteger val = new BigInteger("100");
		equal1 = new BigDecimal("1.00");
		equal2 = new BigDecimal(val, 2);
		assertTrue("1.00(string) and 1.00(bigInteger) should be equal", equal1
				.equals(equal2));
		equal1 = new BigDecimal(100D);
		equal2 = new BigDecimal("2.34576");
		assertFalse("100D and 2.34576 should not be equal", equal1
				.equals(equal2));
		assertFalse("bigDecimal 100D does not equal string 23415", equal1
				.equals("23415"));
	}

	/**
	 * @tests java.math.BigDecimal#floatValue()
	 */
	public void test_floatValue() {
		BigDecimal fl1 = new BigDecimal("234563782344567");
		assertTrue("the float representation of bigDecimal 234563782344567",
				fl1.floatValue() == 234563782344567f);
		BigDecimal fl2 = new BigDecimal(2.345E37);
		assertTrue("the float representation of bigDecimal 2.345E37", fl2
				.floatValue() == 2.345E37F);
		fl2 = new BigDecimal(-1.00E-44);
		assertTrue("the float representation of bigDecimal -1.00E-44", fl2
				.floatValue() == -1.00E-44F);
		fl2 = new BigDecimal(-3E12);
		assertTrue("the float representation of bigDecimal -3E12", fl2
				.floatValue() == -3E12F);
		fl2 = new BigDecimal(Double.MAX_VALUE);
		assertTrue(
				"A number can't be represented by float should return infinity",
				fl2.floatValue() == Float.POSITIVE_INFINITY);
		fl2 = new BigDecimal(-Double.MAX_VALUE);
		assertTrue(
				"A number can't be represented by float should return infinity",
				fl2.floatValue() == Float.NEGATIVE_INFINITY);

	}

	/**
	 * @tests java.math.BigDecimal#hashCode()
	 */
	public void test_hashCode() {
		// anything that is equal must have the same hashCode
		BigDecimal hash = new BigDecimal("1.00");
		BigDecimal hash2 = new BigDecimal(1.00D);
		assertTrue("the hashCode of 1.00 and 1.00D is equal",
				hash.hashCode() != hash2.hashCode() && !hash.equals(hash2));
		hash2 = new BigDecimal("1.0");
		assertTrue("the hashCode of 1.0 and 1.00 is equal",
				hash.hashCode() != hash2.hashCode() && !hash.equals(hash2));
		BigInteger val = new BigInteger("100");
		hash2 = new BigDecimal(val, 2);
		assertTrue("hashCode of 1.00 and 1.00(bigInteger) is not equal", hash
				.hashCode() == hash2.hashCode()
				&& hash.equals(hash2));
		hash = new BigDecimal(value, 2);
		hash2 = new BigDecimal("-1233456.0000");
		assertTrue("hashCode of 123459.08 and -1233456.0000 is not equal", hash
				.hashCode() != hash2.hashCode()
				&& !hash.equals(hash2));
		hash2 = new BigDecimal(value.negate(), 2);
		assertTrue("hashCode of 123459.08 and -123459.08 is not equal", hash
				.hashCode() != hash2.hashCode()
				&& !hash.equals(hash2));
	}

	/**
	 * @tests java.math.BigDecimal#intValue()
	 */
	public void test_intValue() {
		BigDecimal int1 = new BigDecimal(value, 3);
		assertTrue("the int value of 12345.908 is not 12345",
				int1.intValue() == 12345);
		int1 = new BigDecimal("1.99");
		assertTrue("the int value of 1.99 is not 1", int1.intValue() == 1);
		int1 = new BigDecimal("23423419083091823091283933");
		// ran JDK and found representation for the above was -249268259
		assertTrue("the int value of 23423419083091823091283933 is wrong", int1
				.intValue() == -249268259);
		int1 = new BigDecimal(-1235D);
		assertTrue("the int value of -1235 is not -1235",
				int1.intValue() == -1235);
	}

	/**
	 * @tests java.math.BigDecimal#longValue()
	 */
	public void test_longValue() {
		BigDecimal long1 = new BigDecimal(value2.negate(), 0);
		assertTrue("the long value of 12334560000 is not 12334560000", long1
				.longValue() == -12334560000L);
		long1 = new BigDecimal(-1345.348E-123D);
		assertTrue("the long value of -1345.348E-123D is not zero", long1
				.longValue() == 0);
		long1 = new BigDecimal("31323423423419083091823091283933");
		// ran JDK and found representation for the above was
		// -5251313250005125155
		assertTrue(
				"the long value of 31323423423419083091823091283933 is wrong",
				long1.longValue() == -5251313250005125155L);
	}

	/**
	 * @tests java.math.BigDecimal#max(java.math.BigDecimal)
	 */
	public void test_maxLjava_math_BigDecimal() {
		BigDecimal max1 = new BigDecimal(value2, 1);
		BigDecimal max2 = new BigDecimal(value2, 4);
		assertTrue("1233456000.0 is not greater than 1233456", max1.max(max2)
				.equals(max1));
		max1 = new BigDecimal(-1.224D);
		max2 = new BigDecimal(-1.2245D);
		assertTrue("-1.224 is not greater than -1.2245", max1.max(max2).equals(
				max1));
		max1 = new BigDecimal(123E18);
		max2 = new BigDecimal(123E19);
		assertTrue("123E19 is the not the max", max1.max(max2).equals(max2));
	}

	/**
	 * @tests java.math.BigDecimal#min(java.math.BigDecimal)
	 */
	public void test_minLjava_math_BigDecimal() {
		BigDecimal min1 = new BigDecimal(-12345.4D);
		BigDecimal min2 = new BigDecimal(-12345.39D);
		assertTrue("-12345.39 should have been returned", min1.min(min2)
				.equals(min1));
		min1 = new BigDecimal(value2, 5);
		min2 = new BigDecimal(value2, 0);
		assertTrue("123345.6 should have been returned", min1.min(min2).equals(
				min1));
	}

	/**
	 * @tests java.math.BigDecimal#movePointLeft(int)
	 */
	public void test_movePointLeftI() {
		BigDecimal movePtLeft = new BigDecimal("123456265.34");
		BigDecimal alreadyMoved = movePtLeft.movePointLeft(5);
		assertTrue("move point left 5 failed", alreadyMoved.scale() == 7
				&& alreadyMoved.toString().equals("1234.5626534"));
		movePtLeft = new BigDecimal(value2.negate(), 0);
		alreadyMoved = movePtLeft.movePointLeft(12);
		assertTrue("move point left 12 failed", alreadyMoved.scale() == 12
				&& alreadyMoved.toString().equals("-0.012334560000"));
		movePtLeft = new BigDecimal(123E18);
		alreadyMoved = movePtLeft.movePointLeft(2);
		assertTrue("move point left 2 failed",
				alreadyMoved.scale() == movePtLeft.scale() + 2
						&& alreadyMoved.doubleValue() == 1.23E18);
		movePtLeft = new BigDecimal(1.123E-12);
		alreadyMoved = movePtLeft.movePointLeft(3);
		assertTrue("move point left 3 failed",
				alreadyMoved.scale() == movePtLeft.scale() + 3
						&& alreadyMoved.doubleValue() == 1.123E-15);
		movePtLeft = new BigDecimal(value, 2);
		alreadyMoved = movePtLeft.movePointLeft(-2);
		assertTrue("move point left -2 failed",
				alreadyMoved.scale() == movePtLeft.scale() - 2
						&& alreadyMoved.toString().equals("12345908"));
	}

	/**
	 * @tests java.math.BigDecimal#movePointRight(int)
	 */
	public void test_movePointRightI() {
		BigDecimal movePtRight = new BigDecimal("-1.58796521458");
		BigDecimal alreadyMoved = movePtRight.movePointRight(8);
		assertTrue("move point right 8 failed", alreadyMoved.scale() == 3
				&& alreadyMoved.toString().equals("-158796521.458"));
		movePtRight = new BigDecimal(value, 2);
		alreadyMoved = movePtRight.movePointRight(4);
		assertTrue("move point right 4 failed", alreadyMoved.scale() == 0
				&& alreadyMoved.toString().equals("1234590800"));
		movePtRight = new BigDecimal(134E12);
		alreadyMoved = movePtRight.movePointRight(2);
		assertTrue("move point right 2 failed", alreadyMoved.scale() == 0
				&& alreadyMoved.toString().equals("13400000000000000"));
		movePtRight = new BigDecimal(-3.4E-10);
		alreadyMoved = movePtRight.movePointRight(5);
		assertTrue("move point right 5 failed",
				alreadyMoved.scale() == movePtRight.scale() - 5
						&& alreadyMoved.doubleValue() == -0.000034);
		alreadyMoved = alreadyMoved.movePointRight(-5);
		assertTrue("move point right -5 failed", alreadyMoved
				.equals(movePtRight));
	}

	/**
	 * @tests java.math.BigDecimal#multiply(java.math.BigDecimal)
	 */
	public void test_multiplyLjava_math_BigDecimal() {
		BigDecimal multi1 = new BigDecimal(value, 5);
		BigDecimal multi2 = new BigDecimal(2.345D);
		BigDecimal result = multi1.multiply(multi2);
		assertTrue("123.45908 * 2.345 is not correct: " + result, result
				.toString().startsWith("289.51154260")
				&& result.scale() == multi1.scale() + multi2.scale());
		multi1 = new BigDecimal("34656");
		multi2 = new BigDecimal("-2");
		result = multi1.multiply(multi2);
		assertTrue("34656 * 2 is not correct", result.toString().equals(
				"-69312")
				&& result.scale() == 0);
		multi1 = new BigDecimal(-2.345E-02);
		multi2 = new BigDecimal(-134E130);
		result = multi1.multiply(multi2);
		assertTrue("-2.345E-02 * -134E130 is not correct " + result.doubleValue(),
				result.doubleValue() == 3.1422999999999997E130
						&& result.scale() == multi1.scale() + multi2.scale());
		multi1 = new BigDecimal("11235");
		multi2 = new BigDecimal("0");
		result = multi1.multiply(multi2);
		assertTrue("11235 * 0 is not correct", result.doubleValue() == 0
				&& result.scale() == 0);
		multi1 = new BigDecimal("-0.00234");
		multi2 = new BigDecimal(13.4E10);
		result = multi1.multiply(multi2);
		assertTrue("-0.00234 * 13.4E10 is not correct",
				result.doubleValue() == -313560000
						&& result.scale() == multi1.scale() + multi2.scale());
	}

	/**
	 * @tests java.math.BigDecimal#negate()
	 */
	public void test_negate() {
		BigDecimal negate1 = new BigDecimal(value2, 7);
		assertTrue("the negate of 1233.4560000 is not -1233.4560000", negate1
				.negate().toString().equals("-1233.4560000"));
		negate1 = new BigDecimal("-23465839");
		assertTrue("the negate of -23465839 is not 23465839", negate1.negate()
				.toString().equals("23465839"));
		negate1 = new BigDecimal(-3.456E6);
		assertTrue("the negate of -3.456E6 is not 3.456E6", negate1.negate()
				.negate().equals(negate1));
	}

	/**
	 * @tests java.math.BigDecimal#scale()
	 */
	public void test_scale() {
		BigDecimal scale1 = new BigDecimal(value2, 8);
		assertTrue("the scale of the number 123.34560000 is wrong", scale1
				.scale() == 8);
		BigDecimal scale2 = new BigDecimal("29389.");
		assertTrue("the scale of the number 29389. is wrong",
				scale2.scale() == 0);
		BigDecimal scale3 = new BigDecimal(3.374E13);
		assertTrue("the scale of the number 3.374E13 is wrong",
				scale3.scale() == 0);
		BigDecimal scale4 = new BigDecimal("-3.45E-203");
		// note the scale is calculated as 15 digits of 345000.... + exponent -
		// 1. -1 for the 3
		assertTrue("the scale of the number -3.45E-203 is wrong: "
				+ scale4.scale(), scale4.scale() == 205);
		scale4 = new BigDecimal("-345.4E-200");
		assertTrue("the scale of the number -345.4E-200 is wrong", scale4
				.scale() == 201);
	}

	/**
	 * @tests java.math.BigDecimal#setScale(int)
	 */
	public void test_setScaleI() {
		// rounding mode defaults to zero
		BigDecimal setScale1 = new BigDecimal(value, 3);
		BigDecimal setScale2 = setScale1.setScale(5);
		BigInteger setresult = new BigInteger("1234590800");
		assertTrue("the number 12345.908 after setting scale is wrong",
				setScale2.unscaledValue().equals(setresult)
						&& setScale2.scale() == 5);

		try {
			setScale2 = setScale1.setScale(2, BigDecimal.ROUND_UNNECESSARY);
            fail("arithmetic Exception not caught as a result of loosing precision");
		} catch (ArithmeticException e) {
		}
	}

	/**
	 * @tests java.math.BigDecimal#setScale(int, int)
	 */
	public void test_setScaleII() {
		BigDecimal setScale1 = new BigDecimal(2.323E102);
		BigDecimal setScale2 = setScale1.setScale(4);
		assertTrue("the number 2.323E102 after setting scale is wrong",
				setScale2.scale() == 4);
		assertTrue("the representation of the number 2.323E102 is wrong",
				setScale2.doubleValue() == 2.323E102);
		setScale1 = new BigDecimal("-1.253E-12");
		setScale2 = setScale1.setScale(17, BigDecimal.ROUND_CEILING);
		assertTrue("the number -1.253E-12 after setting scale is wrong",
				setScale2.scale() == 17);
		assertTrue(
				"the representation of the number -1.253E-12 after setting scale is wrong, " + setScale2.toString(),
				setScale2.toString().equals("-1.25300E-12"));

		// testing rounding Mode ROUND_CEILING
		setScale1 = new BigDecimal(value, 4);
		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_CEILING);
		assertTrue(
				"the number 1234.5908 after setting scale to 1/ROUND_CEILING is wrong",
				setScale2.toString().equals("1234.6") && setScale2.scale() == 1);
		BigDecimal setNeg = new BigDecimal(value.negate(), 4);
		setScale2 = setNeg.setScale(1, BigDecimal.ROUND_CEILING);
		assertTrue(
				"the number -1234.5908 after setting scale to 1/ROUND_CEILING is wrong",
				setScale2.toString().equals("-1234.5")
						&& setScale2.scale() == 1);

		// testing rounding Mode ROUND_DOWN
		setScale2 = setNeg.setScale(1, BigDecimal.ROUND_DOWN);
		assertTrue(
				"the number -1234.5908 after setting scale to 1/ROUND_DOWN is wrong",
				setScale2.toString().equals("-1234.5")
						&& setScale2.scale() == 1);
		setScale1 = new BigDecimal(value, 4);
		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_DOWN);
		assertTrue(
				"the number 1234.5908 after setting scale to 1/ROUND_DOWN is wrong",
				setScale2.toString().equals("1234.5") && setScale2.scale() == 1);

		// testing rounding Mode ROUND_FLOOR
		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_FLOOR);
		assertTrue(
				"the number 1234.5908 after setting scale to 1/ROUND_FLOOR is wrong",
				setScale2.toString().equals("1234.5") && setScale2.scale() == 1);
		setScale2 = setNeg.setScale(1, BigDecimal.ROUND_FLOOR);
		assertTrue(
				"the number -1234.5908 after setting scale to 1/ROUND_FLOOR is wrong",
				setScale2.toString().equals("-1234.6")
						&& setScale2.scale() == 1);

		// testing rounding Mode ROUND_HALF_DOWN
		setScale2 = setScale1.setScale(3, BigDecimal.ROUND_HALF_DOWN);
		assertTrue(
				"the number 1234.5908 after setting scale to 3/ROUND_HALF_DOWN is wrong",
				setScale2.toString().equals("1234.591")
						&& setScale2.scale() == 3);
		setScale1 = new BigDecimal(new BigInteger("12345000"), 5);
		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_HALF_DOWN);
		assertTrue(
				"the number 123.45908 after setting scale to 1/ROUND_HALF_DOWN is wrong",
				setScale2.toString().equals("123.4") && setScale2.scale() == 1);
		setScale2 = new BigDecimal("-1234.5000").setScale(0,
				BigDecimal.ROUND_HALF_DOWN);
		assertTrue(
				"the number -1234.5908 after setting scale to 0/ROUND_HALF_DOWN is wrong",
				setScale2.toString().equals("-1234") && setScale2.scale() == 0);

		// testing rounding Mode ROUND_HALF_EVEN
		setScale1 = new BigDecimal(1.2345789D);
		setScale2 = setScale1.setScale(4, BigDecimal.ROUND_HALF_EVEN);
		assertTrue(
				"the number 1.2345789 after setting scale to 4/ROUND_HALF_EVEN is wrong",
				setScale2.doubleValue() == 1.2346D && setScale2.scale() == 4);
		setNeg = new BigDecimal(-1.2335789D);
		setScale2 = setNeg.setScale(2, BigDecimal.ROUND_HALF_EVEN);
		assertTrue(
				"the number -1.2335789 after setting scale to 2/ROUND_HALF_EVEN is wrong",
				setScale2.doubleValue() == -1.23D && setScale2.scale() == 2);
		setScale2 = new BigDecimal("1.2345000").setScale(3,
				BigDecimal.ROUND_HALF_EVEN);
		assertTrue(
				"the number 1.2345789 after setting scale to 3/ROUND_HALF_EVEN is wrong",
				setScale2.doubleValue() == 1.234D && setScale2.scale() == 3);
		setScale2 = new BigDecimal("-1.2345000").setScale(3,
				BigDecimal.ROUND_HALF_EVEN);
		assertTrue(
				"the number -1.2335789 after setting scale to 3/ROUND_HALF_EVEN is wrong",
				setScale2.doubleValue() == -1.234D && setScale2.scale() == 3);

		// testing rounding Mode ROUND_HALF_UP
		setScale1 = new BigDecimal("134567.34650");
		setScale2 = setScale1.setScale(3, BigDecimal.ROUND_HALF_UP);
		assertTrue(
				"the number 134567.34658 after setting scale to 3/ROUND_HALF_UP is wrong",
				setScale2.toString().equals("134567.347")
						&& setScale2.scale() == 3);
		setNeg = new BigDecimal("-1234.4567");
		setScale2 = setNeg.setScale(0, BigDecimal.ROUND_HALF_UP);
		assertTrue(
				"the number -1234.4567 after setting scale to 0/ROUND_HALF_UP is wrong",
				setScale2.toString().equals("-1234") && setScale2.scale() == 0);

		// testing rounding Mode ROUND_UNNECESSARY
		try {
			setScale1.setScale(3, BigDecimal.ROUND_UNNECESSARY);
            fail("arithmetic Exception not caught for round unnecessary");
		} catch (ArithmeticException e) {
		}

		// testing rounding Mode ROUND_UP
		setScale1 = new BigDecimal("100000.374");
		setScale2 = setScale1.setScale(2, BigDecimal.ROUND_UP);
		assertTrue(
				"the number 100000.374 after setting scale to 2/ROUND_UP is wrong",
				setScale2.toString().equals("100000.38")
						&& setScale2.scale() == 2);
		setNeg = new BigDecimal(-134.34589D);
		setScale2 = setNeg.setScale(2, BigDecimal.ROUND_UP);
		assertTrue(
				"the number -134.34589 after setting scale to 2/ROUND_UP is wrong",
				setScale2.doubleValue() == -134.35D && setScale2.scale() == 2);

		// testing invalid rounding modes
		try {
			setScale2 = setScale1.setScale(0, -123);
            fail("IllegalArgumentException is not caught for wrong rounding mode");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * @tests java.math.BigDecimal#signum()
	 */
	public void test_signum() {
		BigDecimal sign = new BigDecimal(123E-104);
		assertTrue("123E-104 is not positive in signum()", sign.signum() == 1);
		sign = new BigDecimal("-1234.3959");
		assertTrue("-1234.3959 is not negative in signum()",
				sign.signum() == -1);
		sign = new BigDecimal(000D);
		assertTrue("000D is not zero in signum()", sign.signum() == 0);
	}

	/**
	 * @tests java.math.BigDecimal#subtract(java.math.BigDecimal)
	 */
	public void test_subtractLjava_math_BigDecimal() {
		BigDecimal sub1 = new BigDecimal("13948");
		BigDecimal sub2 = new BigDecimal("2839.489");
		BigDecimal result = sub1.subtract(sub2);
		assertTrue("13948 - 2839.489 is wrong: " + result, result.toString()
				.equals("11108.511")
				&& result.scale() == 3);
		BigDecimal result2 = sub2.subtract(sub1);
		assertTrue("2839.489 - 13948 is wrong", result2.toString().equals(
				"-11108.511")
				&& result2.scale() == 3);
		assertTrue("13948 - 2839.489 is not the negative of 2839.489 - 13948",
				result.equals(result2.negate()));
		sub1 = new BigDecimal(value, 1);
		sub2 = new BigDecimal("0");
		result = sub1.subtract(sub2);
		assertTrue("1234590.8 - 0 is wrong", result.equals(sub1));
		sub1 = new BigDecimal(1.234E-03);
		sub2 = new BigDecimal(3.423E-10);
		result = sub1.subtract(sub2);
		assertTrue("1.234E-03 - 3.423E-10 is wrong, " + result.doubleValue(),
				result.doubleValue() == 0.0012339996577);
		sub1 = new BigDecimal(1234.0123);
		sub2 = new BigDecimal(1234.0123000);
		result = sub1.subtract(sub2);
		assertTrue("1234.0123 - 1234.0123000 is wrong, " + result.doubleValue(),
				result.doubleValue() == 0.0);
	}

	/**
	 * @tests java.math.BigDecimal#toBigInteger()
	 */
	public void test_toBigInteger() {
		BigDecimal sub1 = new BigDecimal("-29830.989");
		BigInteger result = sub1.toBigInteger();

		assertTrue("the bigInteger equivalent of -29830.989 is wrong", result
				.toString().equals("-29830"));
		sub1 = new BigDecimal(-2837E10);
		result = sub1.toBigInteger();
		assertTrue("the bigInteger equivalent of -2837E10 is wrong", result
				.doubleValue() == -2837E10);
		sub1 = new BigDecimal(2.349E-10);
		result = sub1.toBigInteger();
		assertTrue("the bigInteger equivalent of 2.349E-10 is wrong", result
				.equals(BigInteger.ZERO));
		sub1 = new BigDecimal(value2, 6);
		result = sub1.toBigInteger();
		assertTrue("the bigInteger equivalent of 12334.560000 is wrong", result
				.toString().equals("12334"));
	}

	/**
	 * @tests java.math.BigDecimal#toString()
	 */
	public void test_toString() {
		BigDecimal toString1 = new BigDecimal("1234.000");
		assertTrue("the toString representation of 1234.000 is wrong",
				toString1.toString().equals("1234.000"));
		toString1 = new BigDecimal("-123.4E-5");
		assertTrue("the toString representation of -123.4E-5 is wrong: "
				+ toString1, toString1.toString().equals("-0.001234"));
		toString1 = new BigDecimal("-1.455E-20");
		assertTrue("the toString representation of -1.455E-20 is wrong",
				toString1.toString().equals("-1.455E-20"));
		toString1 = new BigDecimal(value2, 4);
		assertTrue("the toString representation of 1233456.0000 is wrong",
				toString1.toString().equals("1233456.0000"));
	}

	/**
	 * @tests java.math.BigDecimal#unscaledValue()
	 */
	public void test_unscaledValue() {
		BigDecimal unsVal = new BigDecimal("-2839485.000");
		assertTrue("the unscaledValue of -2839485.000 is wrong", unsVal
				.unscaledValue().toString().equals("-2839485000"));
		unsVal = new BigDecimal(123E10);
		assertTrue("the unscaledValue of 123E10 is wrong", unsVal
				.unscaledValue().toString().equals("1230000000000"));
		unsVal = new BigDecimal("-4.56E-13");
		assertTrue("the unscaledValue of -4.56E-13 is wrong: "
				+ unsVal.unscaledValue(), unsVal.unscaledValue().toString()
				.equals("-456"));
		unsVal = new BigDecimal(value, 3);
		assertTrue("the unscaledValue of 12345.908 is wrong", unsVal
				.unscaledValue().toString().equals("12345908"));

	}

	/**
	 * @tests java.math.BigDecimal#valueOf(long)
	 */
	public void test_valueOfJ() {
		BigDecimal valueOfL = BigDecimal.valueOf(9223372036854775806L);
		assertTrue("the bigDecimal equivalent of 9223372036854775806 is wrong",
				valueOfL.unscaledValue().toString().equals(
						"9223372036854775806")
						&& valueOfL.scale() == 0);
		assertTrue(
				"the toString representation of 9223372036854775806 is wrong",
				valueOfL.toString().equals("9223372036854775806"));
		valueOfL = BigDecimal.valueOf(0L);
		assertTrue("the bigDecimal equivalent of 0 is wrong", valueOfL
				.unscaledValue().toString().equals("0")
				&& valueOfL.scale() == 0);
	}

	/**
	 * @tests java.math.BigDecimal#valueOf(long, int)
	 */
	public void test_valueOfJI() {
		BigDecimal valueOfJI = BigDecimal.valueOf(9223372036854775806L, 5);
		assertTrue(
				"the bigDecimal equivalent of 92233720368547.75806 is wrong",
				valueOfJI.unscaledValue().toString().equals(
						"9223372036854775806")
						&& valueOfJI.scale() == 5);
		assertTrue(
				"the toString representation of 9223372036854775806 is wrong",
				valueOfJI.toString().equals("92233720368547.75806"));
		valueOfJI = BigDecimal.valueOf(1234L, 8);
		assertTrue(
				"the bigDecimal equivalent of 92233720368547.75806 is wrong",
				valueOfJI.unscaledValue().toString().equals("1234")
						&& valueOfJI.scale() == 8);
		assertTrue(
				"the toString representation of 9223372036854775806 is wrong",
				valueOfJI.toString().equals("0.00001234"));
		valueOfJI = BigDecimal.valueOf(0, 3);
		assertTrue(
				"the bigDecimal equivalent of 92233720368547.75806 is wrong",
				valueOfJI.unscaledValue().toString().equals("0")
						&& valueOfJI.scale() == 3);
		assertTrue(
				"the toString representation of 9223372036854775806 is wrong",
				valueOfJI.toString().equals("0.000"));

	}

	public void test_BigDecimal_serialization() throws Exception {
        // Regression for HARMONY-1896
        char[] in = { '1', '5', '6', '7', '8', '7', '.', '0', '0' };
        BigDecimal bd = new BigDecimal(in, 0, 9);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(bd);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        BigDecimal nbd = (BigDecimal) ois.readObject();

        assertEquals(bd.intValue(), nbd.intValue());
        assertEquals(bd.doubleValue(), nbd.doubleValue(), 0.0);
        assertEquals(bd.toString(), nbd.toString());
    }
	
	/**
	 * @tests java.math.BigDecimal#stripTrailingZero(long)
	 */
	public void test_stripTrailingZero() {
		BigDecimal sixhundredtest = new BigDecimal("600.0");
		assertTrue("stripTrailingZero failed for 600.0",
				((sixhundredtest.stripTrailingZeros()).scale() == -2)
				);
		
		/* Single digit, no trailing zero, odd number */
		BigDecimal notrailingzerotest = new BigDecimal("1");
		assertTrue("stripTrailingZero failed for 1",
				((notrailingzerotest.stripTrailingZeros()).scale() == 0)
				);
		
                // BEGIN android-changed: preserve RI compatibility, so BigDecimal.equals (which checks
                // value *and* scale) continues to work. https://issues.apache.org/jira/browse/HARMONY-4623
		/* Zero */
		BigDecimal zerotest = new BigDecimal("0.0000");
                assertEquals("stripTrailingZero failed for 0.0000", 4, zerotest.stripTrailingZeros().scale());
	}	

	public void testMathContextConstruction() {
        String a = "-12380945E+61";
        BigDecimal aNumber = new BigDecimal(a);
        int precision = 6;
        RoundingMode rm = RoundingMode.HALF_DOWN;
        MathContext mcIntRm = new MathContext(precision, rm);
        MathContext mcStr = new MathContext("precision=6 roundingMode=HALF_DOWN");
        MathContext mcInt = new MathContext(precision);
        BigDecimal res = aNumber.abs(mcInt);
        assertEquals("MathContext Constructer with int precision failed",
                res, 
                new BigDecimal("1.23809E+68"));
        
        assertEquals("Equal MathContexts are not Equal ",
                mcIntRm,
                mcStr);
        
        assertEquals("Different MathContext are reported as Equal ",
        		mcInt.equals(mcStr),
                false);
        
        assertEquals("Equal MathContexts have different hashcodes ",
                mcIntRm.hashCode(),
                mcStr.hashCode());
       
        assertEquals("MathContext.toString() returning incorrect value",
                mcIntRm.toString(),
                "precision=6 roundingMode=HALF_DOWN");
	}

}