harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject 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:01:07 GMT
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);
+    }
+}



Mime
View raw message