harmony-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Tim Ellison <t.p.elli...@gmail.com>
Subject Re: svn commit: r389715 [1/12] - in /incubator/harmony/enhanced/classlib/trunk: make/ modules/math/META-INF/ modules/math/make/ modules/math/make/common/ modules/math/src/main/java/java/math/ modules/math/src/test/java/org/ modules/math/src/test/java/org/a...
Date Wed, 29 Mar 2006 09:15:46 GMT
FYI: this 'big commit' is simply a restructuring of existing math code
into its own module.  It is not new code.

Regards,
Tim

tellison@apache.org wrote:
> Author: tellison
> Date: Wed Mar 29 01:01:04 2006
> New Revision: 389715
> 
> URL: http://svn.apache.org/viewcvs?rev=389715&view=rev
> Log:
> Apply patch HARMONY-243 (new math implementation needs to be integrated)
> 
> Added:
>     incubator/harmony/enhanced/classlib/trunk/modules/math/make/
>     incubator/harmony/enhanced/classlib/trunk/modules/math/make/build.xml
>     incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/
>     incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/build.xml
>     incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/hyproperties.xml
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigDecimal.java
>       - copied unchanged from r389571, incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/math/BigDecimal.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigInteger.java
>       - copied unchanged from r389571, incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/math/BigInteger.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/
>       - copied from r389571, incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/
> Removed:
>     incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/math/BigDecimal.java
>     incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/math/BigInteger.java
>     incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/
> Modified:
>     incubator/harmony/enhanced/classlib/trunk/make/build-test.xml
>     incubator/harmony/enhanced/classlib/trunk/modules/math/META-INF/MANIFEST.MF
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalArithmeticTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalCompareTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalConstructorsTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalConvertTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalScaleOperationsTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAddTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAndTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerCompareTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerConstructorsTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerConvertTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerDivideTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerHashCodeTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerModPowTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerMultiplyTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerNotTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerOperateBitsTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerOrTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerSubtractTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerToStringTest.java
>     incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerXorTest.java
> 
> Modified: incubator/harmony/enhanced/classlib/trunk/make/build-test.xml
> URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/make/build-test.xml?rev=389715&r1=389714&r2=389715&view=diff
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/make/build-test.xml (original)
> +++ incubator/harmony/enhanced/classlib/trunk/make/build-test.xml Wed Mar 29 01:01:04 2006
> @@ -43,7 +43,7 @@
>  
>  	<!-- this list of components to test will grow to eventually be all modules -->
>  	<target name="test-all"
> -		depends="clean, test-luni, test-archive, test-text, test-nio, test-xnet, test-nio_char, test-jndi, test-sql, test-prefs, test-beans, gen-report">
> +		depends="clean, test-luni, test-archive, test-text, test-nio, test-xnet, test-nio_char, test-jndi, test-sql, test-prefs, test-beans, test-math, gen-report">
>  	</target>
>  
>  	<target name="clean">
> @@ -138,7 +138,14 @@
>              <echo message="=================================="/>
>              <ant antfile="make/build.xml" dir="modules/beans" target="test" />
>  	</target>
> -		
> +
> +	<target name="test-math">
> +            <echo message="=================================="/>
> +            <echo message="Running tests for module math"/>
> +            <echo message="=================================="/>
> +            <ant antfile="make/build.xml" dir="modules/math" target="test" />
> +	</target>
> +
>  	<target name="test-security">
>  	
>          <echo message="=================================="/>
> 
> Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/META-INF/MANIFEST.MF
> URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/META-INF/MANIFEST.MF?rev=389715&r1=389714&r2=389715&view=diff
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/modules/math/META-INF/MANIFEST.MF (original)
> +++ incubator/harmony/enhanced/classlib/trunk/modules/math/META-INF/MANIFEST.MF Wed Mar 29 01:01:04 2006
> @@ -7,4 +7,6 @@
>  Eclipse-JREBundle: true
>  Export-Package: java.math
>  Import-Package: java.util,
> - java.lang
> + java.lang,
> + java.io
> +
> 
> Added: incubator/harmony/enhanced/classlib/trunk/modules/math/make/build.xml
> URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/make/build.xml?rev=389715&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/modules/math/make/build.xml (added)
> +++ incubator/harmony/enhanced/classlib/trunk/modules/math/make/build.xml Wed Mar 29 01:01:04 2006
> @@ -0,0 +1,114 @@
> +<?xml version="1.0" encoding="UTF-8"?>
> +<!--
> +    Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
> +  
> +    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.
> +-->
> +
> +<project name="MATH Build" default="build" basedir="..">
> +	<description>Build for MATH component</description>
> +
> +	<!-- set global properties for this build. -->
> +	<xmlproperty file="make/common/hyproperties.xml" semanticAttributes="true"/>
> +	<property environment="env"/>
> +
> +	<!-- Determine the (normalized) operating system family -->
> +	<condition property="if.win">
> +		<os family="Windows" />
> +	</condition>
> +	<condition property="hy.os_family" value="windows">
> +		<isset property="if.win"/>
> +	</condition>
> +
> +	<condition property="if.linux">
> +		<and>
> +			<os name="linux" />
> +			<os family="unix" />
> +		</and>
> +	</condition>
> +	<condition property="hy.os_family" value="linux">
> +		<isset property="if.linux"/>
> +	</condition>
> +
> +
> +	<!-- Determine the (normalized) processor family -->
> +	<condition property="if.x86_64">
> +		<contains string="${os.arch}" substring="x86_64"/>
> +	</condition>
> +	<condition property="hy.cpu_family" value="x86_64">
> +		<isset property="if.x86_64"/>
> +	</condition>
> +	
> +	<condition property="if.x86">
> +		<and>
> +			<contains string="${os.arch}" substring="86"/>
> +			<not>
> +				<isset property="if.x86_64"/>
> +			</not>
> +		</and>
> +	</condition>
> +	<condition property="hy.cpu_family" value="x86">
> +		<isset property="if.x86"/>
> +	</condition>
> +	
> +	<condition property="if.ipf">
> +		<contains string="${os.arch}" substring="ia64"/>
> +	</condition>
> +	<condition property="hy.cpu_family" value="ipf">
> +		<isset property="if.ipf"/>
> +	</condition>
> +
> +	<!-- Define the platform property dependant upon the OS and platform -->
> +	<property name="hy.platform" value="${hy.os_family}.${hy.cpu_family}"/>
> +
> +	<!-- Set the java compiler to be the Eclipse Java compiler -->
> +	<property name="build.compiler" value="org.eclipse.jdt.core.JDTCompilerAdapter" />
> +
> +
> +	<target name="init">
> +		<tstamp>
> +			<format property="build-date" pattern="yyyyMMdd" locale="en" />
> +		</tstamp>
> +		<tstamp>
> +			<format property="build-time" pattern="yyyyMMdd_HHmm" />
> +		</tstamp>
> +		<echo message="build-date=${build-date}" />
> +		<echo message="build-time=${build-time}" />
> +		<echo message="on platform=${os.name} version=${os.version} arch=${os.arch}" />
> +
> +		<property name="java.debug.option" value="on" />
> +		<property name="native.debug.option" value="on" />
> +
> +		<property name="source.ver" value="1.4" />
> +	</target>
> +	
> +	<!-- MATH TARGETS -->
> +
> +	<target name="build" depends="init">
> +		<ant dir="make/common" target="compile.java" />
> +		<ant dir="make/common" target="build.jar" />
> +		<ant dir="make/common" target="copy.resources" />
> +	</target>
> +
> +
> +	<target name="test" depends="build">
> +		<ant dir="make/common" target="compile.tests" />
> +		<ant dir="make/common" target="run.tests" />
> +	</target>
> +
> +	<target name="clean">
> +		<delete dir="${hy.math.bin.main}"/>
> +		<delete dir="${hy.math.bin.test}"/>
> +	</target>
> +
> +</project>
> 
> Added: incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/build.xml
> URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/build.xml?rev=389715&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/build.xml (added)
> +++ incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/build.xml Wed Mar 29 01:01:04 2006
> @@ -0,0 +1,108 @@
> +<?xml version="1.0" encoding="UTF-8"?>
> +<!--
> +    Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
> +  
> +    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.
> +-->
> +
> +<project name="Common_MATH_Build">
> +	
> +	<target name="compile.java" description="Compile MATH java code">
> +		<echo message="Compiling MATH classes from ${hy.math.src.main.java}" />
> +		
> +		<mkdir dir="${hy.math.bin.main}" />
> +
> +		<javac sourcepath=""
> +			srcdir="${hy.math.src.main.java}"
> +			destdir="${hy.math.bin.main}"
> +			source="${source.ver}"
> +			debug="${java.debug.option}">
> +
> +			<bootclasspath>
> +				<fileset dir="${hy.target}/jre/lib/boot">
> +					<include name="*.jar" />
> +				</fileset>
> +			</bootclasspath>
> +		</javac>
> +	</target>
> +	
> +	<target name="build.jar">
> +		<jar destfile="${hy.target}/jre/lib/boot/math.jar"
> +			manifest="${hy.math}/META-INF/MANIFEST.MF">
> +			<fileset dir="${hy.math.bin.main}" />
> +		</jar>
> +	</target>
> +
> +	
> +	<target name="compile.tests">
> +		<echo message="Compiling MATH tests from ${hy.math.src.test.java}" />
> +
> +		<mkdir dir="${hy.math.bin.test}" />
> +
> +		<javac srcdir="${hy.math.src.test.java}"
> +			destdir="${hy.math.bin.test}"
> +			sourcepath=""
> +			source="${source.ver}"
> +			debug="${java.debug.option}">
> +
> +			<bootclasspath>
> +				<fileset dir="${hy.target}/jre/lib/boot">
> +					<include name="*.jar" />
> +				</fileset>
> +			</bootclasspath>
> +                        <classpath location="../../../../build/tests" />
> +		</javac>
> +	</target>
> +
> +
> +	<target name="run.tests">
> +		
> +	        <mkdir dir="${hy.tests.reports}" />
> +
> +	        <junit fork="yes"
> +			forkmode="once"
> +			printsummary="withOutAndErr"
> +			errorproperty="test.error"
> +			showoutput="on"
> +			dir="${hy.math.bin.test}"
> +			jvm="${hy.target}/jre/bin/java">
> +
> +			<jvmarg value="-showversion"/>
> +
> +			<env key="JAVA_HOME" value="${hy.target}/jre"/>
> +
> +			<classpath>
> +				<pathelement path="${hy.math.bin.test}"/>
> +			</classpath>
> +                        <classpath location="../../../../build/tests" />
> +
> +			<formatter type="xml" />
> +
> +			<batchtest todir="${hy.tests.reports}" haltonfailure="no">
> +				<fileset dir="${hy.math.src.test.java}">
> +					<include name="**/*Test.java" />
> +    <!-- This test seems to loop -->
> +    <exclude name="**/api/java/math/BigDecimalTest.java" />
> +    <!-- This test fails -->
> +    <exclude name="**/api/java/math/BigIntegerTest.java" />
> +				</fileset>
> +			</batchtest>
> +		</junit>
> +	</target>
> +	
> +	
> +	<target name="copy.resources">
> +		<!-- Nothing for MATH -->
> +	</target>
> +</project>
> +
> 
> Added: incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/hyproperties.xml
> URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/hyproperties.xml?rev=389715&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/hyproperties.xml (added)
> +++ incubator/harmony/enhanced/classlib/trunk/modules/math/make/common/hyproperties.xml Wed Mar 29 01:01:04 2006
> @@ -0,0 +1,44 @@
> +<?xml version="1.0" encoding="UTF-8"?>
> +<!--
> +    Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
> +  
> +    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.
> +-->
> +
> +<hy>
> +   <math location=".">
> +      <src>
> +         <main>
> +            <java location="src/main/java" />
> +        	<resources location="src/main/resources" />
> +         </main>
> +         <test>
> +            <java location="src/test/java" />
> +            <resources location="src/main/resources" />
> +         </test>
> +         <natives location="src/natives" />
> +      </src>
> +      <bin>
> +        <main location="bin/main" />
> +        <test location="bin/test" />
> +      </bin>
> +      <packaging>
> +      </packaging>
> +   </math>
> +
> +   <target location="../../deploy" />
> +
> +   <tests>
> +      <reports location="../../build/test_report" />
> +   </tests>
> +</hy>
> 
> Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalArithmeticTest.java
> URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalArithmeticTest.java?rev=389715&r1=389571&r2=389715&view=diff
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalArithmeticTest.java (original)
> +++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigDecimalArithmeticTest.java Wed Mar 29 01:01:04 2006
> @@ -1,762 +1,763 @@
> -/*
> - *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
> - *
> - *  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.
> - */
> -/**
> - * @author Elena Semukhina
> - * @version $Revision: 1.3.6.3 $
> - */
> -
> -package java.math;
> -
> -import junit.framework.TestCase;
> -import java.math.BigInteger;
> -
> -/**
> - * Class:  java.math.BigDecimal
> - * Methods: add, subtract, multiply, divide 
> - */
> -public class BigDecimalArithmeticTest extends TestCase {
> -    /**
> -     * Add two numbers of equal positive scales
> -     */
> -    public void testAddEqualScalePosPos() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 10;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "123121247898748373566323807282924555312937.1991359555";
> -        int cScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.add(bNumber);
> -        assertTrue("incorrect value " + result.toString(), result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Add two numbers of equal negative scales
> -     */
> -    public void testAddEqualScaleNegNeg() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -10;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = -10;
> -        String c = "1.231212478987483735663238072829245553129371991359555E+61";
> -        int cScale = -10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.add(bNumber);
> -        assertTrue("incorrect value " + result.toString(), result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Add two numbers of different scales; the first is positive
> -     */
> -    public void testAddDiffScalePosNeg() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = -10;
> -        String c = "7472334294161400358170962860775454459810457634.781384756794987";
> -        int cScale = 15;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.add(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Add two numbers of different scales; the first is negative
> -     */
> -    public void testAddDiffScaleNegPos() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "1231212478987482988429808779810457634781459480137916301878791834798.7234564568";
> -        int cScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.add(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Add two zeroes of different scales; the first is negative
> -     */
> -    public void testAddDiffScaleZeroZero() {
> -        String a = "0";
> -        int aScale = -15;
> -        String b = "0";
> -        int bScale = 10;
> -        String c = "0E-10";
> -        int cScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.add(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Subtract two numbers of equal positive scales
> -     */
> -    public void testSubtractEqualScalePosPos() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 10;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "123121247898748224119637948679166971643339.7522230419";
> -        int cScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.subtract(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Subtract two numbers of equal negative scales
> -     */
> -    public void testSubtractEqualScaleNegNeg() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -10;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = -10;
> -        String c = "1.231212478987482241196379486791669716433397522230419E+61";
> -        int cScale = -10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.subtract(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Subtract two numbers of different scales; the first is positive
> -     */
> -    public void testSubtractDiffScalePosNeg() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = -10;
> -        String c = "-7472334291698975400195996883915836900189542365.218615243205013";
> -        int cScale = 15;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.subtract(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Subtract two numbers of different scales; the first is negative
> -     */
> -    public void testSubtractDiffScaleNegPos() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "1231212478987482988429808779810457634781310033452057698121208165201.2765435432";
> -        int cScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.subtract(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Multiply two numbers of positive scales
> -     */
> -    public void testMultiplyScalePosPos() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "92000312286217574978643009574114545567010139156902666284589309.1880727173060570190220616";
> -        int cScale = 25;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.multiply(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Multiply two numbers of negative scales
> -     */
> -    public void testMultiplyEqualScaleNegNeg() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = -10;
> -        String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+111";
> -        int cScale = -25;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.multiply(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Multiply two numbers of different scales
> -     */
> -    public void testMultiplyDiffScalePosNeg() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 10;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = -10;
> -        String c = "920003122862175749786430095741145455670101391569026662845893091880727173060570190220616";
> -        int cScale = 0;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.multiply(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Multiply two numbers of different scales
> -     */
> -    public void testMultiplyDiffScaleNegPos() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+91";
> -        int cScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.multiply(bNumber);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == cScale);
> -    }
> -
> -    /**
> -     * Divide by zero
> -     */
> -    public void testDivideByZero() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = BigDecimal.valueOf(0L);
> -        try {
> -            BigDecimal result = aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
> -            fail("ArithmeticException has not been caught");
> -        } catch (ArithmeticException e) {
> -            assertTrue("Improper exception message", e.getMessage().equals("division by zero"));
> -        }
> -    }
> -
> -    /**
> -     * Divide with ROUND_UNNECESSARY
> -     */
> -    public void testDivideExceptionRM() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        try {
> -            BigDecimal result = aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
> -            fail("ArithmeticException has not been caught");
> -        } catch (ArithmeticException e) {
> -            assertTrue("Improper exception message", e.getMessage().equals("rounding mode is ROUND_UNNECESSARY but the result is not exact"));
> -        }
> -    }
> -
> -    /**
> -     * Divide with invalid rounding mode
> -     */
> -    public void testDivideExceptionInvalidRM() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        try {
> -            BigDecimal result = aNumber.divide(bNumber, 100);
> -            fail("IllegalArgumentException has not been caught");
> -        } catch (IllegalArgumentException e) {
> -            assertTrue("Improper exception message", e.getMessage().equals("invalid rounding mode"));
> -        }
> -    }
> -
> -    /**
> -     * Divide: local variable exponent is less than zero
> -     */
> -    public void testDivideExpLessZero() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = 15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "1.64770E+10";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: local variable exponent is equal to zero
> -     */
> -    public void testDivideExpEqualsZero() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 10;
> -        String c = "1.64769459009933764189139568605273529E+40";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: local variable exponent is greater than zero
> -     */
> -    public void testDivideExpGreaterZero() {
> -        String a = "1231212478987482988429808779810457634781384756794987";
> -        int aScale = -15;
> -        String b = "747233429293018787918347987234564568";
> -        int bScale = 20;
> -        String c = "1.647694590099337641891395686052735285121058381E+50";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: remainder is zero
> -     */
> -    public void testDivideRemainderIsZero() {
> -        String a = "8311389578904553209874735431110";
> -        int aScale = -15;
> -        String b = "237468273682987234567849583746";
> -        int bScale = 20;
> -        String c = "3.5000000000000000000000000000000E+36";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_UP, result is negative
> -     */
> -    public void testDivideRoundUpNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_UP, result is positive
> -     */
> -    public void testDivideRoundUpPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_DOWN, result is negative
> -     */
> -    public void testDivideRoundDownNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799283E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_DOWN, result is positive
> -     */
> -    public void testDivideRoundDownPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799283E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_FLOOR, result is positive
> -     */
> -    public void testDivideRoundFloorPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799283E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_FLOOR);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_FLOOR, result is negative
> -     */
> -    public void testDivideRoundFloorNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_FLOOR);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_CEILING, result is positive
> -     */
> -    public void testDivideRoundCeilingPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_CEILING, result is negative
> -     */
> -    public void testDivideRoundCeilingNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799283E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = -1
> -     */
> -    public void testDivideRoundHalfUpPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = -1
> -     */
> -    public void testDivideRoundHalfUpNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = 1
> -     */
> -    public void testDivideRoundHalfUpPos1() {
> -        String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> -        int aScale = -24;
> -        String b = "74723342238476237823754692930187879183479";
> -        int bScale = 13;
> -        String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = 1
> -     */
> -    public void testDivideRoundHalfUpNeg1() {
> -        String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> -        int aScale = -24;
> -        String b = "74723342238476237823754692930187879183479";
> -        int bScale = 13;
> -        String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
> -     */
> -    public void testDivideRoundHalfUpNeg2() {
> -        String a = "-37361671119238118911893939591735";
> -        int aScale = 10;
> -        String b = "74723342238476237823787879183470";
> -        int bScale = 15;
> -        String c = "-1E+5";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = -1
> -     */
> -    public void testDivideRoundHalfDownPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = -1
> -     */
> -    public void testDivideRoundHalfDownNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = 1
> -     */
> -    public void testDivideRoundHalfDownPos1() {
> -        String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> -        int aScale = -24;
> -        String b = "74723342238476237823754692930187879183479";
> -        int bScale = 13;
> -        String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = 1
> -     */
> -    public void testDivideRoundHalfDownNeg1() {
> -        String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> -        int aScale = -24;
> -        String b = "74723342238476237823754692930187879183479";
> -        int bScale = 13;
> -        String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
> -     */
> -    public void testDivideRoundHalfDownNeg2() {
> -        String a = "-37361671119238118911893939591735";
> -        int aScale = 10;
> -        String b = "74723342238476237823787879183470";
> -        int bScale = 15;
> -        String c = "0E+5";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = -1
> -     */
> -    public void testDivideRoundHalfEvenPos() {
> -        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = -1
> -     */
> -    public void testDivideRoundHalfEvenNeg() {
> -        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> -        int aScale = -24;
> -        String b = "7472334223847623782375469293018787918347987234564568";
> -        int bScale = 13;
> -        String c = "-1.24390557635720517122423359799284E+53";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -    
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = 1
> -     */
> -    public void testDivideRoundHalfEvenPos1() {
> -        String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> -        int aScale = -24;
> -        String b = "74723342238476237823754692930187879183479";
> -        int bScale = 13;
> -        String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = 1
> -     */
> -    public void testDivideRoundHalfEvenNeg1() {
> -        String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> -        int aScale = -24;
> -        String b = "74723342238476237823754692930187879183479";
> -        int bScale = 13;
> -        String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
> -        int resScale = -21;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -
> -    /**
> -     * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; equidistant
> -     */
> -    public void testDivideRoundHalfEvenNeg2() {
> -        String a = "-37361671119238118911893939591735";
> -        int aScale = 10;
> -        String b = "74723342238476237823787879183470";
> -        int bScale = 15;
> -        String c = "0E+5";
> -        int resScale = -5;
> -        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> -        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> -        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> -        assertTrue("incorrect value", result.toString().equals(c));
> -        assertTrue("incorrect scale", result.scale() == resScale);
> -    }
> -}
> +/*
> + *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
> + *
> + *  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.
> + */
> +/**
> + * @author Elena Semukhina
> + * @version $Revision: 1.3.6.3 $
> + */
> +
> +package org.apache.harmony.tests.math;
> +
> +import junit.framework.TestCase;
> +import java.math.BigDecimal;
> +import java.math.BigInteger;
> +
> +/**
> + * Class:  java.math.BigDecimal
> + * Methods: add, subtract, multiply, divide 
> + */
> +public class BigDecimalArithmeticTest extends TestCase {
> +    /**
> +     * Add two numbers of equal positive scales
> +     */
> +    public void testAddEqualScalePosPos() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 10;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "123121247898748373566323807282924555312937.1991359555";
> +        int cScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.add(bNumber);
> +        assertTrue("incorrect value " + result.toString(), result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Add two numbers of equal negative scales
> +     */
> +    public void testAddEqualScaleNegNeg() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -10;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = -10;
> +        String c = "1.231212478987483735663238072829245553129371991359555E+61";
> +        int cScale = -10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.add(bNumber);
> +        assertTrue("incorrect value " + result.toString(), result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Add two numbers of different scales; the first is positive
> +     */
> +    public void testAddDiffScalePosNeg() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = -10;
> +        String c = "7472334294161400358170962860775454459810457634.781384756794987";
> +        int cScale = 15;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.add(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Add two numbers of different scales; the first is negative
> +     */
> +    public void testAddDiffScaleNegPos() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "1231212478987482988429808779810457634781459480137916301878791834798.7234564568";
> +        int cScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.add(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Add two zeroes of different scales; the first is negative
> +     */
> +    public void testAddDiffScaleZeroZero() {
> +        String a = "0";
> +        int aScale = -15;
> +        String b = "0";
> +        int bScale = 10;
> +        String c = "0E-10";
> +        int cScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.add(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Subtract two numbers of equal positive scales
> +     */
> +    public void testSubtractEqualScalePosPos() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 10;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "123121247898748224119637948679166971643339.7522230419";
> +        int cScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.subtract(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Subtract two numbers of equal negative scales
> +     */
> +    public void testSubtractEqualScaleNegNeg() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -10;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = -10;
> +        String c = "1.231212478987482241196379486791669716433397522230419E+61";
> +        int cScale = -10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.subtract(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Subtract two numbers of different scales; the first is positive
> +     */
> +    public void testSubtractDiffScalePosNeg() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = -10;
> +        String c = "-7472334291698975400195996883915836900189542365.218615243205013";
> +        int cScale = 15;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.subtract(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Subtract two numbers of different scales; the first is negative
> +     */
> +    public void testSubtractDiffScaleNegPos() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "1231212478987482988429808779810457634781310033452057698121208165201.2765435432";
> +        int cScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.subtract(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Multiply two numbers of positive scales
> +     */
> +    public void testMultiplyScalePosPos() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "92000312286217574978643009574114545567010139156902666284589309.1880727173060570190220616";
> +        int cScale = 25;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.multiply(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Multiply two numbers of negative scales
> +     */
> +    public void testMultiplyEqualScaleNegNeg() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = -10;
> +        String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+111";
> +        int cScale = -25;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.multiply(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Multiply two numbers of different scales
> +     */
> +    public void testMultiplyDiffScalePosNeg() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 10;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = -10;
> +        String c = "920003122862175749786430095741145455670101391569026662845893091880727173060570190220616";
> +        int cScale = 0;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.multiply(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Multiply two numbers of different scales
> +     */
> +    public void testMultiplyDiffScaleNegPos() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+91";
> +        int cScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.multiply(bNumber);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == cScale);
> +    }
> +
> +    /**
> +     * Divide by zero
> +     */
> +    public void testDivideByZero() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = BigDecimal.valueOf(0L);
> +        try {
> +            BigDecimal result = aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
> +            fail("ArithmeticException has not been caught");
> +        } catch (ArithmeticException e) {
> +            assertTrue("Improper exception message", e.getMessage().equals("division by zero"));
> +        }
> +    }
> +
> +    /**
> +     * Divide with ROUND_UNNECESSARY
> +     */
> +    public void testDivideExceptionRM() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        try {
> +            BigDecimal result = aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
> +            fail("ArithmeticException has not been caught");
> +        } catch (ArithmeticException e) {
> +            assertTrue("Improper exception message", e.getMessage().equals("rounding mode is ROUND_UNNECESSARY but the result is not exact"));
> +        }
> +    }
> +
> +    /**
> +     * Divide with invalid rounding mode
> +     */
> +    public void testDivideExceptionInvalidRM() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        try {
> +            BigDecimal result = aNumber.divide(bNumber, 100);
> +            fail("IllegalArgumentException has not been caught");
> +        } catch (IllegalArgumentException e) {
> +            assertTrue("Improper exception message", e.getMessage().equals("invalid rounding mode"));
> +        }
> +    }
> +
> +    /**
> +     * Divide: local variable exponent is less than zero
> +     */
> +    public void testDivideExpLessZero() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = 15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "1.64770E+10";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: local variable exponent is equal to zero
> +     */
> +    public void testDivideExpEqualsZero() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 10;
> +        String c = "1.64769459009933764189139568605273529E+40";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: local variable exponent is greater than zero
> +     */
> +    public void testDivideExpGreaterZero() {
> +        String a = "1231212478987482988429808779810457634781384756794987";
> +        int aScale = -15;
> +        String b = "747233429293018787918347987234564568";
> +        int bScale = 20;
> +        String c = "1.647694590099337641891395686052735285121058381E+50";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: remainder is zero
> +     */
> +    public void testDivideRemainderIsZero() {
> +        String a = "8311389578904553209874735431110";
> +        int aScale = -15;
> +        String b = "237468273682987234567849583746";
> +        int bScale = 20;
> +        String c = "3.5000000000000000000000000000000E+36";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_UP, result is negative
> +     */
> +    public void testDivideRoundUpNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_UP, result is positive
> +     */
> +    public void testDivideRoundUpPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_DOWN, result is negative
> +     */
> +    public void testDivideRoundDownNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799283E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_DOWN, result is positive
> +     */
> +    public void testDivideRoundDownPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799283E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_FLOOR, result is positive
> +     */
> +    public void testDivideRoundFloorPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799283E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_FLOOR);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_FLOOR, result is negative
> +     */
> +    public void testDivideRoundFloorNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_FLOOR);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_CEILING, result is positive
> +     */
> +    public void testDivideRoundCeilingPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_CEILING, result is negative
> +     */
> +    public void testDivideRoundCeilingNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799283E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = -1
> +     */
> +    public void testDivideRoundHalfUpPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = -1
> +     */
> +    public void testDivideRoundHalfUpNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = 1
> +     */
> +    public void testDivideRoundHalfUpPos1() {
> +        String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> +        int aScale = -24;
> +        String b = "74723342238476237823754692930187879183479";
> +        int bScale = 13;
> +        String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = 1
> +     */
> +    public void testDivideRoundHalfUpNeg1() {
> +        String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> +        int aScale = -24;
> +        String b = "74723342238476237823754692930187879183479";
> +        int bScale = 13;
> +        String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
> +     */
> +    public void testDivideRoundHalfUpNeg2() {
> +        String a = "-37361671119238118911893939591735";
> +        int aScale = 10;
> +        String b = "74723342238476237823787879183470";
> +        int bScale = 15;
> +        String c = "-1E+5";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = -1
> +     */
> +    public void testDivideRoundHalfDownPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = -1
> +     */
> +    public void testDivideRoundHalfDownNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = 1
> +     */
> +    public void testDivideRoundHalfDownPos1() {
> +        String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> +        int aScale = -24;
> +        String b = "74723342238476237823754692930187879183479";
> +        int bScale = 13;
> +        String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = 1
> +     */
> +    public void testDivideRoundHalfDownNeg1() {
> +        String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> +        int aScale = -24;
> +        String b = "74723342238476237823754692930187879183479";
> +        int bScale = 13;
> +        String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
> +     */
> +    public void testDivideRoundHalfDownNeg2() {
> +        String a = "-37361671119238118911893939591735";
> +        int aScale = 10;
> +        String b = "74723342238476237823787879183470";
> +        int bScale = 15;
> +        String c = "0E+5";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = -1
> +     */
> +    public void testDivideRoundHalfEvenPos() {
> +        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = -1
> +     */
> +    public void testDivideRoundHalfEvenNeg() {
> +        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
> +        int aScale = -24;
> +        String b = "7472334223847623782375469293018787918347987234564568";
> +        int bScale = 13;
> +        String c = "-1.24390557635720517122423359799284E+53";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +    
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = 1
> +     */
> +    public void testDivideRoundHalfEvenPos1() {
> +        String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> +        int aScale = -24;
> +        String b = "74723342238476237823754692930187879183479";
> +        int bScale = 13;
> +        String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = 1
> +     */
> +    public void testDivideRoundHalfEvenNeg1() {
> +        String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
> +        int aScale = -24;
> +        String b = "74723342238476237823754692930187879183479";
> +        int bScale = 13;
> +        String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
> +        int resScale = -21;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +
> +    /**
> +     * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; equidistant
> +     */
> +    public void testDivideRoundHalfEvenNeg2() {
> +        String a = "-37361671119238118911893939591735";
> +        int aScale = 10;
> +        String b = "74723342238476237823787879183470";
> +        int bScale = 15;
> +        String c = "0E+5";
> +        int resScale = -5;
> +        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
> +        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
> +        BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN);
> +        assertTrue("incorrect value", result.toString().equals(c));
> +        assertTrue("incorrect scale", result.scale() == resScale);
> +    }
> +}
> 
> 
> 

-- 

Tim Ellison (t.p.ellison@gmail.com)
IBM Java technology centre, UK.

Mime
View raw message