Merge "Lose the math tests to libcore."

23 files changed, 1 insertions, 13170 deletions

diff --git a/Android.mk b/Android.mk
index a01d2b8..16b1d9a 100644
--- a/Android.mk
+++ b/Android.mk
@@ -12,7 +12,6 @@ harmony_test_dirs := \
     beans \
     logging \
     luni \
-    math \
     nio \
     nio_char \
     prefs \
@@ -54,6 +53,7 @@ LOCAL_JAVA_LIBRARIES := core core-junit
 LOCAL_JAVACFLAGS := $(harmony_test_javac_flags)
 LOCAL_MODULE_TAGS := tests
 LOCAL_MODULE := apache-harmony-tests
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
 include $(BUILD_STATIC_JAVA_LIBRARY)
 
 ifeq ($(WITH_HOST_DALVIK),true)
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalArithmeticTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalArithmeticTest.java
deleted file mode 100644
index ba71e2c..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalArithmeticTest.java
+++ /dev/null
@@ -1,1623 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-package org.apache.harmony.tests.java.math;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-import junit.framework.TestCase;
-
-/**
- * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Add two numbers of equal positive scales using MathContext
-     */
-    public void testAddMathContextEqualScalePosPos() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 10;
-        String b = "747233429293018787918347987234564568";
-        int bScale = 10;
-        String c = "1.2313E+41";
-        int cScale = -37;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(5, RoundingMode.UP);
-        BigDecimal result = aNumber.add(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Add two numbers of equal negative scales using MathContext
-     */
-    public void testAddMathContextEqualScaleNegNeg() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = -10;
-        String b = "747233429293018787918347987234564568";
-        int bScale = -10;
-        String c = "1.2312E+61";
-        int cScale = -57;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(5, RoundingMode.FLOOR);
-        BigDecimal result = aNumber.add(bNumber, mc);
-        assertEquals("incorrect value ", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Add two numbers of different scales using MathContext; the first is positive
-     */
-    public void testAddMathContextDiffScalePosNeg() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 15;
-        String b = "747233429293018787918347987234564568";
-        int bScale = -10;
-        String c = "7.47233429416141E+45";
-        int cScale = -31;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(15, RoundingMode.CEILING);
-        BigDecimal result = aNumber.add(bNumber, mc);
-        assertEquals("incorrect value", c, c.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Subtract two numbers of equal positive scales using MathContext
-     */
-    public void testSubtractMathContextEqualScalePosPos() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 10;
-        String b = "747233429293018787918347987234564568";
-        int bScale = 10;
-        String c = "1.23121247898749E+41";
-        int cScale = -27;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(15, RoundingMode.CEILING);
-        BigDecimal result = aNumber.subtract(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Subtract two numbers of different scales using MathContext;
-     *  the first is positive
-     */
-    public void testSubtractMathContextDiffScalePosNeg() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 15;
-        String b = "747233429293018787918347987234564568";
-        int bScale = -10;
-        String c = "-7.4723342916989754E+45";
-        int cScale = -29;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(17, RoundingMode.DOWN);
-        BigDecimal result = aNumber.subtract(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Subtract two numbers of different scales using MathContext;
-     *  the first is negative
-     */
-    public void testSubtractMathContextDiffScaleNegPos() {
-        String a = "986798656676789766678767876078779810457634781384756794987";
-        int aScale = -15;
-        String b = "747233429293018787918347987234564568";
-        int bScale = 40;
-        String c = "9.867986566767897666787678760787798104576347813847567949870000000000000E+71";
-        int cScale = -2;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(70, RoundingMode.HALF_DOWN);
-        BigDecimal result = aNumber.subtract(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Multiply two numbers of positive scales using MathContext
-     */
-    public void testMultiplyMathContextScalePosPos() {
-        String a = "97665696756578755423325476545428779810457634781384756794987";
-        int aScale = -25;
-        String b = "87656965586786097685674786576598865";
-        int bScale = 10;
-        String c = "8.561078619600910561431314228543672720908E+108";
-        int cScale = -69;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(40, RoundingMode.HALF_DOWN);
-        BigDecimal result = aNumber.multiply(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Multiply two numbers of different scales using MathContext
-     */
-    public void testMultiplyMathContextDiffScalePosNeg() {
-        String a = "987667796597975765768768767866756808779810457634781384756794987";
-        int aScale = 100;
-        String b = "747233429293018787918347987234564568";
-        int bScale = -70;
-        String c = "7.3801839465418518653942222612429081498248509257207477E+68";
-        int cScale = -16;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(53, RoundingMode.HALF_UP);
-        BigDecimal result = aNumber.multiply(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * Multiply two numbers of different scales using MathContext
-     */
-    public void testMultiplyMathContextDiffScaleNegPos() {
-        String a = "488757458676796558668876576576579097029810457634781384756794987";
-        int aScale = -63;
-        String b = "747233429293018787918347987234564568";
-        int bScale = 63;
-        String c = "3.6521591193960361339707130098174381429788164316E+98";
-        int cScale = -52;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        MathContext mc = new MathContext(47, RoundingMode.HALF_UP);
-        BigDecimal result = aNumber.multiply(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * pow(int)
-     */
-    public void testPow() {
-        String a = "123121247898748298842980";
-        int aScale = 10;
-        int exp = 10;
-        String c = "8004424019039195734129783677098845174704975003788210729597" +
-                   "4875206425711159855030832837132149513512555214958035390490" +
-                   "798520842025826.594316163502809818340013610490541783276343" +
-                   "6514490899700151256484355936102754469438371850240000000000";
-        int cScale = 100;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.pow(exp);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * pow(0)
-     */
-    public void testPow0() {
-        String a = "123121247898748298842980";
-        int aScale = 10;
-        int exp = 0;
-        String c = "1";
-        int cScale = 0;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.pow(exp);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * ZERO.pow(0)
-     */
-    public void testZeroPow0() {
-        String c = "1";
-        int cScale = 0;
-        BigDecimal result = BigDecimal.ZERO.pow(0);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * pow(int, MathContext)
-     */
-    public void testPowMathContext() {
-        String a = "123121247898748298842980";
-        int aScale = 10;
-        int exp = 10;
-        String c = "8.0044E+130";
-        int cScale = -126;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        MathContext mc = new MathContext(5, RoundingMode.HALF_UP);
-        BigDecimal result = aNumber.pow(exp, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", cScale, result.scale());
-    }
-
-    /**
-     * 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 {
-            aNumber.divide(bNumber);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-            assertEquals("Improper exception message", "Division by zero", e.getMessage());
-        }
-    }
-
-    /**
-     * 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 {
-            aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-            assertEquals("Improper exception message", "Rounding necessary", e.getMessage());
-        }
-    }
-
-    /**
-     * 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 {
-            aNumber.divide(bNumber, 100);
-            fail("IllegalArgumentException has not been caught");
-        } catch (IllegalArgumentException e) {
-            assertEquals("Improper exception message", "Invalid rounding mode", e.getMessage());
-        }
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * 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);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * Divide to BigDecimal
-     */
-    public void testDivideBigDecimal1() {
-        String a = "-37361671119238118911893939591735";
-        int aScale = 10;
-        String b = "74723342238476237823787879183470";
-        int bScale = 15;
-        String c = "-5E+4";
-        int resScale = -4;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * Divide to BigDecimal
-     */
-    public void testDivideBigDecimal2() {
-        String a = "-37361671119238118911893939591735";
-        int aScale = 10;
-        String b = "74723342238476237823787879183470";
-        int bScale = -15;
-        String c = "-5E-26";
-        int resScale = 26;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeUP() {
-        String a = "-37361671119238118911893939591735";
-        int aScale = 10;
-        String b = "74723342238476237823787879183470";
-        int bScale = -15;
-        int newScale = 31;
-        RoundingMode rm = RoundingMode.UP;
-        String c = "-5.00000E-26";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeDOWN() {
-        String a = "-37361671119238118911893939591735";
-        int aScale = 10;
-        String b = "74723342238476237823787879183470";
-        int bScale = 15;
-        int newScale = 31;
-        RoundingMode rm = RoundingMode.DOWN;
-        String c = "-50000.0000000000000000000000000000000";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeCEILING() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 100;
-        String b = "74723342238476237823787879183470";
-        int bScale = 15;
-        int newScale = 45;
-        RoundingMode rm = RoundingMode.CEILING;
-        String c = "1E-45";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeFLOOR() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 100;
-        String b = "74723342238476237823787879183470";
-        int bScale = 15;
-        int newScale = 45;
-        RoundingMode rm = RoundingMode.FLOOR;
-        String c = "0E-45";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeHALF_UP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = -51;
-        String b = "74723342238476237823787879183470";
-        int bScale = 45;
-        int newScale = 3;
-        RoundingMode rm = RoundingMode.HALF_UP;
-        String c = "50000260373164286401361913262100972218038099522752460421" +
-                   "05959924024355721031761947728703598332749334086415670525" +
-                   "3761096961.670";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeHALF_DOWN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 5;
-        String b = "74723342238476237823787879183470";
-        int bScale = 15;
-        int newScale = 7;
-        RoundingMode rm = RoundingMode.HALF_DOWN;
-        String c = "500002603731642864013619132621009722.1803810";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, scale, RoundingMode)
-     */
-    public void testDivideBigDecimalScaleRoundingModeHALF_EVEN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 5;
-        String b = "74723342238476237823787879183470";
-        int bScale = 15;
-        int newScale = 7;
-        RoundingMode rm = RoundingMode.HALF_EVEN;
-        String c = "500002603731642864013619132621009722.1803810";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, newScale, rm);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", newScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextUP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 15;
-        String b = "748766876876723342238476237823787879183470";
-        int bScale = 10;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.UP;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "49897861180.2562512996";
-        int resScale = 10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextDOWN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 15;
-        String b = "748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "4.98978611802562512995E+70";
-        int resScale = -50;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextCEILING() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 15;
-        String b = "748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "4.98978611802562512996E+70";
-        int resScale = -50;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextFLOOR() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 15;
-        String b = "748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.FLOOR;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "4.98978611802562512995E+70";
-        int resScale = -50;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextHALF_UP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.HALF_UP;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "2.77923185514690367475E+26";
-        int resScale = -6;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextHALF_DOWN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.HALF_DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "2.77923185514690367475E+26";
-        int resScale = -6;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divide(BigDecimal, MathContext)
-     */
-    public void testDivideBigDecimalScaleMathContextHALF_EVEN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.HALF_EVEN;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "2.77923185514690367475E+26";
-        int resScale = -6;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divide(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-
-    /**
-     * BigDecimal.divide with a scale that's too large
-     * 
-     * Regression test for HARMONY-6271
-     */
-    public void testDivideLargeScale() {
-    	BigDecimal arg1 = new BigDecimal("320.0E+2147483647");
-		BigDecimal arg2 = new BigDecimal("6E-2147483647");
-    	try {
-    		BigDecimal result = arg1.divide(arg2, Integer.MAX_VALUE, 
-    				java.math.RoundingMode.CEILING);
-    		fail("Expected ArithmeticException when dividing with a scale that's too large");
-    	} catch (ArithmeticException e) {
-    		// expected behaviour
-    	}
-    }
-
-    /**
-     * divideToIntegralValue(BigDecimal)
-     */
-    public void testDivideToIntegralValue() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        String c = "277923185514690367474770683";
-        int resScale = 0;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divideToIntegralValue(bNumber);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divideToIntegralValue(BigDecimal, MathContext)
-     */
-    public void testDivideToIntegralValueMathContextUP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 32;
-        RoundingMode rm = RoundingMode.UP;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "277923185514690367474770683";
-        int resScale = 0;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * divideToIntegralValue(BigDecimal, MathContext)
-     */
-    public void testDivideToIntegralValueMathContextDOWN() {
-        String a = "3736186567876876578956958769675785435673453453653543654354365435675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 75;
-        RoundingMode rm = RoundingMode.DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String c = "2.7792318551469036747477068339450205874992634417590178670822889E+62";
-        int resScale = -1;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
-        assertEquals("incorrect value", c, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * divideAndRemainder(BigDecimal)
-     */
-    public void testDivideAndRemainder1() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        String res = "277923185514690367474770683";
-        int resScale = 0;
-        String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
-        int remScale = 70;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result[] = aNumber.divideAndRemainder(bNumber);
-        assertEquals("incorrect quotient value", res, result[0].toString());
-        assertEquals("incorrect quotient scale", resScale, result[0].scale());
-        assertEquals("incorrect remainder value", rem, result[1].toString());
-        assertEquals("incorrect remainder scale", remScale, result[1].scale());
-    }
-
-    /**
-     * divideAndRemainder(BigDecimal)
-     */
-    public void testDivideAndRemainder2() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = -45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        String res = "2779231855146903674747706830969461168692256919247547952" +
-                     "2608549363170374005512836303475980101168105698072946555" +
-                     "6862849";
-        int resScale = 0;
-        String rem = "3.4935796954060524114470681810486417234751682675102093970E-15";
-        int remScale = 70;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result[] = aNumber.divideAndRemainder(bNumber);
-        assertEquals("incorrect quotient value", res, result[0].toString());
-        assertEquals("incorrect quotient scale", resScale, result[0].scale());
-        assertEquals("incorrect remainder value", rem, result[1].toString());
-        assertEquals("incorrect remainder scale", remScale, result[1].scale());
-    }
-    
-    /**
-     * divideAndRemainder(BigDecimal, MathContext)
-     */
-    public void testDivideAndRemainderMathContextUP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 70;
-        int precision = 75;
-        RoundingMode rm = RoundingMode.UP;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "277923185514690367474770683";
-        int resScale = 0;
-        String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
-        int remScale = 70;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
-        assertEquals("incorrect quotient value", res, result[0].toString());
-        assertEquals("incorrect quotient scale", resScale, result[0].scale());
-        assertEquals("incorrect remainder value", rem, result[1].toString());
-        assertEquals("incorrect remainder scale", remScale, result[1].scale());
-    }
-
-    /**
-     * divideAndRemainder(BigDecimal, MathContext)
-     */
-    public void testDivideAndRemainderMathContextDOWN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 20;
-        int precision = 15;
-        RoundingMode rm = RoundingMode.DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "0E-25";
-        int resScale = 25;
-        String rem = "3736186567876.876578956958765675671119238118911893939591735";
-        int remScale = 45;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
-        assertEquals("incorrect quotient value", res, result[0].toString());
-        assertEquals("incorrect quotient scale", resScale, result[0].scale());
-        assertEquals("incorrect remainder value", rem, result[1].toString());
-        assertEquals("incorrect remainder scale", remScale, result[1].scale());
-    }
-    
-    /**
-     * remainder(BigDecimal)
-     */
-    public void testRemainder1() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 10;
-        String res = "3736186567876.876578956958765675671119238118911893939591735";
-        int resScale = 45;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.remainder(bNumber);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", resScale, result.scale());
-    }
-
-    /**
-     * remainder(BigDecimal)
-     */
-    public void testRemainder2() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = -45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 10;
-        String res = "1149310942946292909508821656680979993738625937.2065885780";
-        int resScale = 10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.remainder(bNumber);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", resScale, result.scale());
-    }
-
-    /**
-     * remainder(BigDecimal, MathContext)
-     */
-    public void testRemainderMathContextHALF_UP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 10;
-        int precision = 15;
-        RoundingMode rm = RoundingMode.HALF_UP;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "3736186567876.876578956958765675671119238118911893939591735";
-        int resScale = 45;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.remainder(bNumber, mc);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", resScale, result.scale());
-    }
-
-    /**
-     * remainder(BigDecimal, MathContext)
-     */
-    public void testRemainderMathContextHALF_DOWN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = -45;
-        String b = "134432345432345748766876876723342238476237823787879183470";
-        int bScale = 10;
-        int precision = 75;
-        RoundingMode rm = RoundingMode.HALF_DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "1149310942946292909508821656680979993738625937.2065885780";
-        int resScale = 10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        BigDecimal result = aNumber.remainder(bNumber, mc);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", resScale, result.scale());
-    }
-
-    /**
-     * round(BigDecimal, MathContext)
-     */
-    public void testRoundMathContextHALF_DOWN() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = -45;
-        int precision = 75;
-        RoundingMode rm = RoundingMode.HALF_DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "3.736186567876876578956958765675671119238118911893939591735E+102";
-        int resScale = -45;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.round(mc);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", resScale, result.scale());
-    }
-
-    /**
-     * round(BigDecimal, MathContext)
-     */
-    public void testRoundMathContextHALF_UP() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        int precision = 15;
-        RoundingMode rm = RoundingMode.HALF_UP;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "3736186567876.88";
-        int resScale = 2;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.round(mc);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", resScale, result.scale());
-    }
-
-    /**
-     * round(BigDecimal, MathContext) when precision = 0
-     */
-    public void testRoundMathContextPrecision0() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        int precision = 0;
-        RoundingMode rm = RoundingMode.HALF_UP;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "3736186567876.876578956958765675671119238118911893939591735";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.round(mc);
-        assertEquals("incorrect quotient value", res, result.toString());
-        assertEquals("incorrect quotient scale", aScale, result.scale());
-    }
-
-
-    /**
-     * ulp() of a positive BigDecimal
-     */
-    public void testUlpPos() {
-        String a = "3736186567876876578956958765675671119238118911893939591735";
-        int aScale = -45;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.ulp();
-        String res = "1E+45";
-        int resScale = -45;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * ulp() of a negative BigDecimal
-     */
-    public void testUlpNeg() {
-        String a = "-3736186567876876578956958765675671119238118911893939591735";
-        int aScale = 45;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.ulp();
-        String res = "1E-45";
-        int resScale = 45;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * ulp() of a negative BigDecimal
-     */
-    public void testUlpZero() {
-        String a = "0";
-        int aScale = 2;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.ulp();
-        String res = "0.01";
-        int resScale = 2;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalCompareTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalCompareTest.java
deleted file mode 100644
index a977250..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalCompareTest.java
+++ /dev/null
@@ -1,512 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-import junit.framework.TestCase;
-
-/**
- * Class:  java.math.BigDecimal
- * Methods: abs, compareTo, equals, hashCode, 
- * max, min, negate, signum
- */
-public class BigDecimalCompareTest extends TestCase {
-    /**
-     * Abs() of a negative BigDecimal
-     */
-    public void testAbsNeg() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "123809648392384754573567356745735635678902957849027687.87678287";
-        assertEquals("incorrect value", result, aNumber.abs().toString());
-    }
-
-    /**
-     * Abs() of a positive BigDecimal
-     */
-    public void testAbsPos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "123809648392384754573567356745735635678902957849027687.87678287";
-        assertEquals("incorrect value", result, aNumber.abs().toString());
-    }
-
-    /**
-     * Abs(MathContext) of a negative BigDecimal
-     */
-    public void testAbsMathContextNeg() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        int precision = 15;
-        RoundingMode rm = RoundingMode.HALF_DOWN;
-        MathContext mc = new MathContext(precision, rm);
-        String result = "1.23809648392385E+53";
-        int resScale = -39;
-        BigDecimal res = aNumber.abs(mc);
-        assertEquals("incorrect value", result, res.toString());
-        assertEquals("incorrect scale", resScale, res.scale());
-    }
-
-    /**
-     * Abs(MathContext) of a positive BigDecimal
-     */
-    public void testAbsMathContextPos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        int precision = 41;
-        RoundingMode rm = RoundingMode.HALF_EVEN;
-        MathContext mc = new MathContext(precision, rm);
-        String result = "1.2380964839238475457356735674573563567890E+53";
-        int resScale = -13;
-        BigDecimal res = aNumber.abs(mc);
-        assertEquals("incorrect value", result, res.toString());
-        assertEquals("incorrect scale", resScale, res.scale());
-    }
-
-    /**
-     * Compare to a number of an equal scale
-     */
-    public void testCompareEqualScale1() {
-        String a = "12380964839238475457356735674573563567890295784902768787678287";
-        int aScale = 18;
-        String b = "4573563567890295784902768787678287";
-        int bScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        int result = 1;
-        assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * Compare to a number of an equal scale
-     */
-    public void testCompareEqualScale2() {
-        String a = "12380964839238475457356735674573563567890295784902768787678287";
-        int aScale = 18;
-        String b = "4573563923487289357829759278282992758247567890295784902768787678287";
-        int bScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        int result = -1;
-        assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * Compare to a number of an greater scale
-     */
-    public void testCompareGreaterScale1() {
-        String a = "12380964839238475457356735674573563567890295784902768787678287";
-        int aScale = 28;
-        String b = "4573563567890295784902768787678287";
-        int bScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        int result = 1;
-        assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * Compare to a number of an greater scale
-     */
-    public void testCompareGreaterScale2() {
-        String a = "12380964839238475457356735674573563567890295784902768787678287";
-        int aScale = 48;
-        String b = "4573563567890295784902768787678287";
-        int bScale = 2;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        int result = -1;
-        assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * Compare to a number of an less scale
-     */
-    public void testCompareLessScale1() {
-        String a = "12380964839238475457356735674573563567890295784902768787678287";
-        int aScale = 18;
-        String b = "4573563567890295784902768787678287";
-        int bScale = 28;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        int result = 1;
-        assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * Compare to a number of an less scale
-     */
-    public void testCompareLessScale2() {
-        String a = "12380964839238475457356735674573";
-        int aScale = 36;
-        String b = "45735635948573894578349572001798379183767890295784902768787678287";
-        int bScale = 48;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-        int result = -1;
-        assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * Equals() for unequal BigDecimals
-     */
-    public void testEqualsUnequal1() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = -24;
-       String b = "7472334223847623782375469293018787918347987234564568";
-       int bScale = 13;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       assertFalse(aNumber.equals(bNumber));
-    }
-
-    /**
-     * Equals() for unequal BigDecimals
-     */
-    public void testEqualsUnequal2() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = -24;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int bScale = 13;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       assertFalse(aNumber.equals(bNumber));
-    }
-
-    /**
-     * Equals() for unequal BigDecimals
-     */
-    public void testEqualsUnequal3() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = -24;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       assertFalse(aNumber.equals(b));
-    }
-
-    /**
-     * equals() for equal BigDecimals
-     */
-    public void testEqualsEqual() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = -24;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int bScale = -24;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       assertEquals(aNumber, bNumber);
-    }
-
-    /**
-     * equals() for equal BigDecimals
-     */
-    public void testEqualsNull() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = -24;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       assertFalse(aNumber.equals(null));
-    }
-
-    /**
-     * hashCode() for equal BigDecimals
-     */
-    public void testHashCodeEqual() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = -24;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int bScale = -24;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       assertEquals("incorrect value", aNumber.hashCode(), bNumber.hashCode());
-    }
-
-    /**
-     * hashCode() for unequal BigDecimals
-     */
-    public void testHashCodeUnequal() {
-       String a = "8478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int bScale = -24;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       assertTrue("incorrect value", aNumber.hashCode() != bNumber.hashCode());
-    }
-
-    /**
-     * max() for equal BigDecimals
-     */
-    public void testMaxEqual() {
-       String a = "8478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String b = "8478231212478987482988429808779810457634781384756794987";
-       int bScale = 41;
-       String c = "8478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
-    }
-
-    /**
-     * max() for unequal BigDecimals
-     */
-    public void testMaxUnequal1() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 24;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int bScale = 41;
-       String c = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 24;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
-    }
-
-    /**
-     * max() for unequal BigDecimals
-     */
-    public void testMaxUnequal2() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String b = "94488478231212478987482988429808779810457634781384756794987";
-       int bScale = 41;
-       String c = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
-    }
-
-    /**
-     * min() for equal BigDecimals
-     */
-    public void testMinEqual() {
-       String a = "8478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String b = "8478231212478987482988429808779810457634781384756794987";
-       int bScale = 41;
-       String c = "8478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
-    }
-
-    /**
-     * min() for unequal BigDecimals
-     */
-    public void testMinUnequal1() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 24;
-       String b = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int bScale = 41;
-       String c = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
-    }
-
-    /**
-     * min() for unequal BigDecimals
-     */
-    public void testMinUnequal2() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String b = "94488478231212478987482988429808779810457634781384756794987";
-       int bScale = 41;
-       String c = "94488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
-    }
-
-    /**
-     * plus() for a positive BigDecimal
-     */
-    public void testPlusPositive() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String c = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.plus());
-    }
-
-    /**
-     * plus(MathContext) for a positive BigDecimal
-     */
-    public void testPlusMathContextPositive() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       int precision = 37;
-       RoundingMode rm = RoundingMode.FLOOR;
-       MathContext mc = new MathContext(precision, rm);
-       String c = "929487820944884782312124789.8748298842";
-       int cScale = 10;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal res = aNumber.plus(mc);
-       assertEquals("incorrect value", c, res.toString());
-       assertEquals("incorrect scale", cScale, res.scale());
-    }
-
-    /**
-     * plus() for a negative BigDecimal
-     */
-    public void testPlusNegative() {
-       String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String c = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.plus());
-    }
-
-    /**
-     * plus(MathContext) for a negative BigDecimal
-     */
-    public void testPlusMathContextNegative() {
-       String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 49;
-       int precision = 46;
-       RoundingMode rm = RoundingMode.CEILING;
-       MathContext mc = new MathContext(precision, rm);
-       String c = "-9294878209448847823.121247898748298842980877981";
-       int cScale = 27;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal res = aNumber.plus(mc);
-       assertEquals("incorrect value", c, res.toString());
-       assertEquals("incorrect scale", cScale, res.scale());
-    }
-
-    /**
-     * negate() for a positive BigDecimal
-     */
-    public void testNegatePositive() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String c = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.negate());
-    }
-
-    /**
-     * negate(MathContext) for a positive BigDecimal
-     */
-    public void testNegateMathContextPositive() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       int precision = 37;
-       RoundingMode rm = RoundingMode.FLOOR;
-       MathContext mc = new MathContext(precision, rm);
-       String c = "-929487820944884782312124789.8748298842";
-       int cScale = 10;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal res = aNumber.negate(mc);
-       assertEquals("incorrect value", c, res.toString());
-       assertEquals("incorrect scale", cScale, res.scale());
-    }
-
-    /**
-     * negate() for a negative BigDecimal
-     */
-    public void testNegateNegative() {
-       String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       String c = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int cScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
-       assertEquals("incorrect value", cNumber, aNumber.negate());
-    }
-
-    /**
-     * negate(MathContext) for a negative BigDecimal
-     */
-    public void testNegateMathContextNegative() {
-       String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 49;
-       int precision = 46;
-       RoundingMode rm = RoundingMode.CEILING;
-       MathContext mc = new MathContext(precision, rm);
-       String c = "9294878209448847823.121247898748298842980877981";
-       int cScale = 27;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       BigDecimal res = aNumber.negate(mc);
-       assertEquals("incorrect value", c, res.toString());
-       assertEquals("incorrect scale", cScale, res.scale());
-    }
-
-    /**
-     * signum() for a positive BigDecimal
-     */
-    public void testSignumPositive() {
-       String a = "92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       assertEquals("incorrect value", 1, aNumber.signum());
-    }
-
-    /**
-     * signum() for a negative BigDecimal
-     */
-    public void testSignumNegative() {
-       String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
-       int aScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       assertEquals("incorrect value", -1, aNumber.signum());
-    }
-
-    /**
-     * signum() for zero
-     */
-    public void testSignumZero() {
-       String a = "0";
-       int aScale = 41;
-       BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-       assertEquals("incorrect value", 0, aNumber.signum());
-    }
-    
-    /*
-     * Regression test for HARMONY-6406
-     */
-    public void testApproxPrecision() {
-        BigDecimal testInstance = BigDecimal.TEN.multiply(new BigDecimal("0.1"));
-        int result = testInstance.compareTo(new BigDecimal("1.00"));
-        assertEquals(0, result);
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConstructorsTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConstructorsTest.java
deleted file mode 100644
index 3838991..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConstructorsTest.java
+++ /dev/null
@@ -1,684 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-import junit.framework.TestCase;
-
-/**
- * Class:  java.math.BigDecimal
- * Methods: constructors and fields
- */
-public class BigDecimalConstructorsTest extends TestCase {
-    /**
-     * check ONE
-     */
-    public void testFieldONE() {
-        String oneS = "1";
-        double oneD = 1.0;
-        assertEquals("incorrect string value", oneS, BigDecimal.ONE.toString());
-        assertEquals("incorrect double value", oneD, BigDecimal.ONE.doubleValue(), 0);
-    }
-
-    /**
-     * check TEN
-     */
-    public void testFieldTEN() {
-        String oneS = "10";
-        double oneD = 10.0;
-        assertEquals("incorrect string value", oneS, BigDecimal.TEN.toString());
-        assertEquals("incorrect double value", oneD, BigDecimal.TEN.doubleValue(), 0);
-    }
-
-    /**
-     * check ZERO
-     */
-    public void testFieldZERO() {
-        String oneS = "0";
-        double oneD = 0.0;
-        assertEquals("incorrect string value", oneS, BigDecimal.ZERO.toString());
-        assertEquals("incorrect double value", oneD, BigDecimal.ZERO.doubleValue(), 0);
-    }
-
-    /**
-     * new BigDecimal(BigInteger value)
-     */
-    public void testConstrBI() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        BigInteger bA = new BigInteger(a);
-        BigDecimal aNumber = new BigDecimal(bA);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", 0, aNumber.scale());
-
-        try {
-            new BigDecimal((BigInteger) null);
-        	fail("No NullPointerException");
-        } catch (NullPointerException e) {
-        	//expected
-        }
-    }
-     
-    /**
-     * new BigDecimal(BigInteger value, int scale)
-     */
-    public void testConstrBIScale() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        BigInteger bA = new BigInteger(a);
-        int aScale = 10;
-        BigDecimal aNumber = new BigDecimal(bA, aScale);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(BigInteger value, MathContext)
-     */
-    public void testConstrBigIntegerMathContext() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        BigInteger bA = new BigInteger(a);
-        int precision = 46;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "1231212478987482988429808779810457634781384757";
-        int resScale = -6;
-        BigDecimal result = new BigDecimal(bA, mc);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(BigInteger value, int scale, MathContext)
-     */
-    public void testConstrBigIntegerScaleMathContext() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        BigInteger bA = new BigInteger(a);
-        int aScale = 10;
-        int precision = 46;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "1231212478987482988429808779810457634781384757";
-        int resScale = 4;
-        BigDecimal result = new BigDecimal(bA, aScale, mc);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(char[] value); 
-     */
-    public void testConstrChar() {
-        char value[] = {'-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3'};
-        BigDecimal result = new BigDecimal(value);
-        String res = "-1.23804738E-419";
-        int resScale = 427;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-        
-        try {
-            // Regression for HARMONY-783
-            new BigDecimal(new char[] {});
-            fail("NumberFormatException has not been thrown");
-        } catch (NumberFormatException e) {
-        }
-     }
-    
-    /**
-     * new BigDecimal(char[] value, int offset, int len); 
-     */
-    public void testConstrCharIntInt() {
-        char value[] = {'-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3'};
-        int offset = 3;
-        int len = 12;
-        BigDecimal result = new BigDecimal(value, offset, len);
-        String res = "3.804738E-40";
-        int resScale = 46;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-        
-        try {
-            // Regression for HARMONY-783
-            new BigDecimal(new char[] {}, 0, 0);
-            fail("NumberFormatException has not been thrown");
-        } catch (NumberFormatException e) {
-        }
-     }
-    
-    /**
-     * new BigDecimal(char[] value, int offset, int len, MathContext mc); 
-     */
-    public void testConstrCharIntIntMathContext() {
-        char value[] = {'-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3'};
-        int offset = 3;
-        int len = 12;
-        int precision = 4;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        BigDecimal result = new BigDecimal(value, offset, len, mc);
-        String res = "3.805E-40";
-        int resScale = 43;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-        
-        try {
-            // Regression for HARMONY-783
-            new BigDecimal(new char[] {}, 0, 0, MathContext.DECIMAL32);
-            fail("NumberFormatException has not been thrown");
-        } catch (NumberFormatException e) {
-        }
-     }
-    
-    /**
-     * new BigDecimal(char[] value, int offset, int len, MathContext mc); 
-     */
-    public void testConstrCharIntIntMathContextException1() {
-        char value[] = {'-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3'};
-        int offset = 3;
-        int len = 120;
-        int precision = 4;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        try {
-            new BigDecimal(value, offset, len, mc);
-            fail("NumberFormatException has not been thrown");
-        } catch (NumberFormatException e) {
-        }
-     }
-    
-    /**
-     * new BigDecimal(char[] value, int offset, int len, MathContext mc); 
-     */
-    public void testConstrCharIntIntMathContextException2() {
-        char value[] = {'-', '1', '2', '3', '8', '0', ',', '4', '7', '3', '8', 'E', '-', '4', '2', '3'};
-        int offset = 3;
-        int len = 120;
-        int precision = 4;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        try {
-            new BigDecimal(value, offset, len, mc);
-            fail("NumberFormatException has not been thrown");
-        } catch (NumberFormatException e) {
-        }
-     }
-
-    /**
-     * new BigDecimal(char[] value, MathContext mc);
-     */
-    public void testConstrCharMathContext() {
-        try {
-            // Regression for HARMONY-783
-            new BigDecimal(new char[] {}, MathContext.DECIMAL32);
-            fail("NumberFormatException has not been thrown");
-        } catch (NumberFormatException e) {
-        }
-    }
-    
-    /**
-     * new BigDecimal(double value) when value is NaN
-     */
-    public void testConstrDoubleNaN() {
-        double a = Double.NaN;
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(double value) when value is positive infinity
-     */
-    public void testConstrDoublePosInfinity() {
-        double a = Double.POSITIVE_INFINITY;
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(double value) when value is positive infinity
-     */
-    public void testConstrDoubleNegInfinity() {
-        double a = Double.NEGATIVE_INFINITY;
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(double value)
-     */
-    public void testConstrDouble() {
-        double a = 732546982374982347892379283571094797.287346782359284756;
-        int aScale = 0;
-        BigInteger bA = new BigInteger("732546982374982285073458350476230656");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(double, MathContext)
-     */
-    public void testConstrDoubleMathContext() {
-        double a = 732546982374982347892379283571094797.287346782359284756;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "732546982374982285074";
-        int resScale = -15;
-        BigDecimal result = new BigDecimal(a, mc);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(0.1)
-     */
-    public void testConstrDouble01() {
-        double a = 1.E-1;
-        int aScale = 55;
-        BigInteger bA = new BigInteger("1000000000000000055511151231257827021181583404541015625");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(0.555)
-     */
-    public void testConstrDouble02() {
-        double a = 0.555;
-        int aScale = 53;
-        BigInteger bA = new BigInteger("55500000000000004884981308350688777863979339599609375");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(-0.1)
-     */
-    public void testConstrDoubleMinus01() {
-        double a = -1.E-1;
-        int aScale = 55;
-        BigInteger bA = new BigInteger("-1000000000000000055511151231257827021181583404541015625");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(int value)
-     */
-    public void testConstrInt() {
-        int a = 732546982;
-        String res = "732546982";
-        int resScale = 0;
-        BigDecimal result = new BigDecimal(a);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(int, MathContext)
-     */
-    public void testConstrIntMathContext() {
-        int a = 732546982;
-        int precision = 21;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "732546982";
-        int resScale = 0;
-        BigDecimal result = new BigDecimal(a, mc);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(long value)
-     */
-    public void testConstrLong() {
-        long a = 4576578677732546982L;
-        String res = "4576578677732546982";
-        int resScale = 0;
-        BigDecimal result = new BigDecimal(a);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(long, MathContext)
-     */
-    public void testConstrLongMathContext() {
-        long a = 4576578677732546982L;
-        int precision = 5;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "45766";
-        int resScale = -14;
-        BigDecimal result = new BigDecimal(a, mc);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * new BigDecimal(double value) when value is denormalized
-     */
-    public void testConstrDoubleDenormalized() {
-        double a = 2.274341322658976E-309;
-        int aScale = 1073;
-        BigInteger bA = new BigInteger("227434132265897633950269241702666687639731047124115603942986140264569528085692462493371029187342478828091760934014851133733918639492582043963243759464684978401240614084312038547315281016804838374623558434472007664427140169018817050565150914041833284370702366055678057809362286455237716100382057360123091641959140448783514464639706721250400288267372238950016114583259228262046633530468551311769574111763316146065958042194569102063373243372766692713192728878701004405568459288708477607744497502929764155046100964958011009313090462293046650352146796805866786767887226278836423536035611825593567576424943331337401071583562754098901412372708947790843318760718495117047155597276492717187936854356663665005157041552436478744491526494952982062613955349661409854888916015625");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-     
-    /**
-     * new BigDecimal(String value)
-     * when value is not a valid representation of BigDecimal.
-     */
-    public void testConstrStringException() {
-        String a = "-238768.787678287a+10";
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {}
-    }
-
-    /**
-     * new BigDecimal(String value) when exponent is empty.
-     */
-    public void testConstrStringExceptionEmptyExponent1() {
-        String a = "-238768.787678287e";
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(String value) when exponent is empty.
-     */
-    public void testConstrStringExceptionEmptyExponent2() {
-        String a = "-238768.787678287e-";
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(String value) when exponent is greater than
-     * Integer.MAX_VALUE.
-     */
-    public void testConstrStringExceptionExponentGreaterIntegerMax() {
-        String a = "-238768.787678287e214748364767876";
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(String value) when exponent is less than
-     * Integer.MIN_VALUE.
-     */
-    public void testConstrStringExceptionExponentLessIntegerMin() {
-        String a = "-238768.787678287e-214748364767876";
-        try {
-            new BigDecimal(a);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * new BigDecimal(String value)
-     * when exponent is Integer.MAX_VALUE.
-     */
-    public void testConstrStringExponentIntegerMax() {
-        String a = "-238768.787678287e2147483647";
-        int aScale = -2147483638;
-        BigInteger bA = new BigInteger("-238768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value)
-     * when exponent is Integer.MIN_VALUE.
-     */
-    public void testConstrStringExponentIntegerMin() {
-        String a = ".238768e-2147483648";
-        try {
-           new BigDecimal(a);
-           fail("NumberFormatException expected");
-       } catch (NumberFormatException e) {
-       }
-    }
-
-    /**
-     * new BigDecimal(String value); value does not contain exponent
-     */
-      public void testConstrStringWithoutExpPos1() {
-        String a = "732546982374982347892379283571094797.287346782359284756";
-        int aScale = 18;
-        BigInteger bA = new BigInteger("732546982374982347892379283571094797287346782359284756");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value); value does not contain exponent
-     */
-      public void testConstrStringWithoutExpPos2() {
-        String a = "+732546982374982347892379283571094797.287346782359284756";
-        int aScale = 18;
-        BigInteger bA = new BigInteger("732546982374982347892379283571094797287346782359284756");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-       
-    /**
-     * new BigDecimal(String value); value does not contain exponent
-     */
-      public void testConstrStringWithoutExpNeg() {
-        String a = "-732546982374982347892379283571094797.287346782359284756";
-        int aScale = 18;
-        BigInteger bA = new BigInteger("-732546982374982347892379283571094797287346782359284756");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-       
-    /**
-     * new BigDecimal(String value); value does not contain exponent
-     * and decimal point
-     */
-      public void testConstrStringWithoutExpWithoutPoint() {
-        String a = "-732546982374982347892379283571094797287346782359284756";
-        int aScale = 0;
-        BigInteger bA = new BigInteger("-732546982374982347892379283571094797287346782359284756");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-       
-      /**
-       * new BigDecimal(String value); value contains exponent
-       * and does not contain decimal point
-       */
-      public void testConstrStringWithExponentWithoutPoint1() {
-          String a = "-238768787678287e214";
-          int aScale = -214;
-          BigInteger bA = new BigInteger("-238768787678287");
-          BigDecimal aNumber = new BigDecimal(a);
-          assertEquals("incorrect value", bA, aNumber.unscaledValue());
-          assertEquals("incorrect scale", aScale, aNumber.scale());
-      }
-
-    /**
-     * new BigDecimal(String value); value contains exponent
-     * and does not contain decimal point
-     */
-    public void testConstrStringWithExponentWithoutPoint2() {
-        String a = "-238768787678287e-214";
-        int aScale = 214;
-        BigInteger bA = new BigInteger("-238768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-     
-    /**
-     * new BigDecimal(String value); value contains exponent
-     * and does not contain decimal point
-     */
-    public void testConstrStringWithExponentWithoutPoint3() {
-        String a = "238768787678287e-214";
-        int aScale = 214;
-        BigInteger bA = new BigInteger("238768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value); value contains exponent
-     * and does not contain decimal point
-     */
-    public void testConstrStringWithExponentWithoutPoint4() {
-        String a = "238768787678287e+214";
-        int aScale = -214;
-        BigInteger bA = new BigInteger("238768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value); value contains exponent
-     * and does not contain decimal point
-     */
-    public void testConstrStringWithExponentWithoutPoint5() {
-        String a = "238768787678287E214";
-        int aScale = -214;
-        BigInteger bA = new BigInteger("238768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value); 
-     * value contains both exponent and decimal point
-     */
-    public void testConstrStringWithExponentWithPoint1() {
-        String a = "23985439837984782435652424523876878.7678287e+214";
-        int aScale = -207;
-        BigInteger bA = new BigInteger("239854398379847824356524245238768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value); 
-     * value contains both exponent and decimal point
-     */
-    public void testConstrStringWithExponentWithPoint2() {
-        String a = "238096483923847545735673567457356356789029578490276878.7678287e-214";
-        int aScale = 221;
-        BigInteger bA = new BigInteger("2380964839238475457356735674573563567890295784902768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-
-    /**
-     * new BigDecimal(String value); 
-     * value contains both exponent and decimal point
-     */
-    public void testConstrStringWithExponentWithPoint3() {
-        String a = "2380964839238475457356735674573563567890.295784902768787678287E+21";
-        int aScale = 0;
-        BigInteger bA = new BigInteger("2380964839238475457356735674573563567890295784902768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-     
-    /**
-     * new BigDecimal(String value); 
-     * value contains both exponent and decimal point
-     */
-    public void testConstrStringWithExponentWithPoint4() {
-        String a = "23809648392384754573567356745735635678.90295784902768787678287E+21";
-        int aScale = 2;
-        BigInteger bA = new BigInteger("2380964839238475457356735674573563567890295784902768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-     
-    /**
-     * new BigDecimal(String value); 
-     * value contains both exponent and decimal point
-     */
-    public void testConstrStringWithExponentWithPoint5() {
-        String a = "238096483923847545735673567457356356789029.5784902768787678287E+21";
-        int aScale = -2;
-        BigInteger bA = new BigInteger("2380964839238475457356735674573563567890295784902768787678287");
-        BigDecimal aNumber = new BigDecimal(a);
-        assertEquals("incorrect value", bA, aNumber.unscaledValue());
-        assertEquals("incorrect scale", aScale, aNumber.scale());
-    }
-    
-    /**
-     * new BigDecimal(String value, MathContext)
-     */
-    public void testConstrStringMathContext() {
-        String a = "-238768787678287e214";
-        int precision = 5;
-        RoundingMode rm = RoundingMode.CEILING;
-        MathContext mc = new MathContext(precision, rm);
-        String res = "-23876";
-        int resScale = -224;
-        BigDecimal result = new BigDecimal(a, mc);
-        assertEquals("incorrect value", res, result.unscaledValue().toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConvertTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConvertTest.java
deleted file mode 100644
index 67fd8b4..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConvertTest.java
+++ /dev/null
@@ -1,569 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigDecimal
- * Methods: doubleValue, floatValue, intValue, longValue,  
- * valueOf, toString, toBigInteger
- */
-public class BigDecimalConvertTest extends TestCase {
-    /**
-     * Double value of a negative BigDecimal
-     */
-    public void testDoubleValueNeg() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        double result = -1.2380964839238476E53;
-        assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
-    }
-
-    /**
-     * Double value of a positive BigDecimal
-     */
-    public void testDoubleValuePos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        double result = 1.2380964839238476E53;
-        assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
-    }
-
-    /**
-     * Double value of a large positive BigDecimal
-     */
-    public void testDoubleValuePosInfinity() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+400";
-        BigDecimal aNumber = new BigDecimal(a);
-        double result = Double.POSITIVE_INFINITY;
-        assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
-    }
-
-    /**
-     * Double value of a large negative BigDecimal
-     */
-    public void testDoubleValueNegInfinity() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+400";
-        BigDecimal aNumber = new BigDecimal(a);
-        double result = Double.NEGATIVE_INFINITY;
-        assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
-    }
-
-    /**
-     * Double value of a small negative BigDecimal
-     */
-    public void testDoubleValueMinusZero() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E-400";
-        BigDecimal aNumber = new BigDecimal(a);
-        long minusZero = -9223372036854775808L;
-        double result = aNumber.doubleValue();
-        assertTrue("incorrect value", Double.doubleToLongBits(result) == minusZero);
-    }
-
-    /**
-     * Double value of a small positive BigDecimal
-     */
-    public void testDoubleValuePlusZero() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E-400";
-        BigDecimal aNumber = new BigDecimal(a);
-        long zero = 0;
-        double result = aNumber.doubleValue();
-        assertTrue("incorrect value", Double.doubleToLongBits(result) == zero);
-    }
-
-    /**
-     * Float value of a negative BigDecimal
-     */
-    public void testFloatValueNeg() {
-        String a = "-1238096483923847.6356789029578E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        float result = -1.2380965E36F;
-        assertTrue("incorrect value", aNumber.floatValue() == result);
-    }
-
-    /**
-     * Float value of a positive BigDecimal
-     */
-    public void testFloatValuePos() {
-        String a = "1238096483923847.6356789029578E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        float result = 1.2380965E36F;
-        assertTrue("incorrect value", aNumber.floatValue() == result);
-    }
-
-    /**
-     * Float value of a large positive BigDecimal
-     */
-    public void testFloatValuePosInfinity() {
-        String a = "123809648373567356745735.6356789787678287E+200";
-        BigDecimal aNumber = new BigDecimal(a);
-        float result = Float.POSITIVE_INFINITY;
-        assertTrue("incorrect value", aNumber.floatValue() == result);
-    }
-
-    /**
-     * Float value of a large negative BigDecimal
-     */
-    public void testFloatValueNegInfinity() {
-        String a = "-123809648392384755735.63567887678287E+200";
-        BigDecimal aNumber = new BigDecimal(a);
-        float result = Float.NEGATIVE_INFINITY;
-        assertTrue("incorrect value", aNumber.floatValue() == result);
-    }
-
-    /**
-     * Float value of a small negative BigDecimal
-     */
-    public void testFloatValueMinusZero() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E-400";
-        BigDecimal aNumber = new BigDecimal(a);
-        int minusZero = -2147483648;
-        float result = aNumber.floatValue();
-        assertTrue("incorrect value", Float.floatToIntBits(result) == minusZero);
-    }
-
-    /**
-     * Float value of a small positive BigDecimal
-     */
-    public void testFloatValuePlusZero() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E-400";
-        BigDecimal aNumber = new BigDecimal(a);
-        int zero = 0;
-        float result = aNumber.floatValue();
-        assertTrue("incorrect value", Float.floatToIntBits(result) == zero);
-    }
-
-    /**
-     * Integer value of a negative BigDecimal
-     */
-    public void testIntValueNeg() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        int result = 218520473;
-        assertTrue("incorrect value", aNumber.intValue() == result);
-    }
-
-    /**
-     * Integer value of a positive BigDecimal
-     */
-    public void testIntValuePos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        int result = -218520473;
-        assertTrue("incorrect value", aNumber.intValue() == result);
-    }
-
-    /**
-     * Long value of a negative BigDecimal
-     */
-    public void testLongValueNeg() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        long result = -1246043477766677607L;
-        assertTrue("incorrect value", aNumber.longValue() == result);
-    }
-
-    /**
-     * Long value of a positive BigDecimal
-     */
-    public void testLongValuePos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigDecimal aNumber = new BigDecimal(a);
-        long result = 1246043477766677607L;
-        assertTrue("incorrect value", aNumber.longValue() == result);
-    }
-
-    /**
-     * scaleByPowerOfTen(int n)
-     */
-    public void testScaleByPowerOfTen1() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 13;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.scaleByPowerOfTen(10);
-        String res = "1231212478987482988429808779810457634781384756794.987";
-        int resScale = 3;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * scaleByPowerOfTen(int n)
-     */
-    public void testScaleByPowerOfTen2() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = -13;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.scaleByPowerOfTen(10);
-        String res = "1.231212478987482988429808779810457634781384756794987E+74";
-        int resScale = -23;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * Convert a positive BigDecimal to BigInteger
-     */
-    public void testToBigIntegerPos1() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigInteger bNumber = new BigInteger("123809648392384754573567356745735635678902957849027687");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-        assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * Convert a positive BigDecimal to BigInteger
-     */
-    public void testToBigIntegerPos2() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+15";
-        BigInteger bNumber = new BigInteger("123809648392384754573567356745735635678902957849");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-        assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * Convert a positive BigDecimal to BigInteger
-     */
-    public void testToBigIntegerPos3() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+45";
-        BigInteger bNumber = new BigInteger("123809648392384754573567356745735635678902957849027687876782870000000000000000");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-        assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * Convert a negative BigDecimal to BigInteger
-     */
-    public void testToBigIntegerNeg1() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
-        BigInteger bNumber = new BigInteger("-123809648392384754573567356745735635678902957849027687");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-        assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * Convert a negative BigDecimal to BigInteger
-     */
-    public void testToBigIntegerNeg2() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+15";
-        BigInteger bNumber = new BigInteger("-123809648392384754573567356745735635678902957849");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-        assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * Convert a negative BigDecimal to BigInteger
-     */
-    public void testToBigIntegerNeg3() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+45";
-        BigInteger bNumber = new BigInteger("-123809648392384754573567356745735635678902957849027687876782870000000000000000");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-         assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * Convert a small BigDecimal to BigInteger
-     */
-    public void testToBigIntegerZero() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E-500";
-        BigInteger bNumber = new BigInteger("0");
-        BigDecimal aNumber = new BigDecimal(a);
-        BigInteger result = aNumber.toBigInteger();
-        assertTrue("incorrect value", result.equals(bNumber));
-    }
-
-    /**
-     * toBigIntegerExact()
-     */
-    public void testToBigIntegerExact1() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+45";
-        BigDecimal aNumber = new BigDecimal(a);
-        String res = "-123809648392384754573567356745735635678902957849027687876782870000000000000000";
-        BigInteger result = aNumber.toBigIntegerExact();
-        assertEquals("incorrect value", res, result.toString());
-    }
-
-    /**
-     * toBigIntegerExact()
-     */
-    public void testToBigIntegerExactException() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E-10";
-        BigDecimal aNumber = new BigDecimal(a);
-        try {
-            aNumber.toBigIntegerExact();
-            fail("java.lang.ArithmeticException has not been thrown");
-        } catch (java.lang.ArithmeticException e) {
-            return;
-        }
-    }
-
-    /**
-     * Convert a positive BigDecimal to an engineering string representation
-     */
-    public void testToEngineeringStringPos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E-501";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "123.80964839238475457356735674573563567890295784902768787678287E-471";
-        assertEquals("incorrect value", result, aNumber.toEngineeringString());
-    }
-
-    /**
-     * Convert a negative BigDecimal to an engineering string representation
-     */
-    public void testToEngineeringStringNeg() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E-501";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "-123.80964839238475457356735674573563567890295784902768787678287E-471";
-        assertEquals("incorrect value", result, aNumber.toEngineeringString());
-    }
-
-    /**
-     * Convert a negative BigDecimal to an engineering string representation
-     */
-    public void testToEngineeringStringZeroPosExponent() {
-        String a = "0.0E+16";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "0E+15";
-        assertEquals("incorrect value", result, aNumber.toEngineeringString());
-    }
-
-    /**
-     * Convert a negative BigDecimal to an engineering string representation
-     */
-    public void testToEngineeringStringZeroNegExponent() {
-        String a = "0.0E-16";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "0.00E-15";
-        assertEquals("incorrect value", result, aNumber.toEngineeringString());
-    }
-
-    /**
-     * Convert a negative BigDecimal with a negative exponent to a plain string
-     * representation; scale == 0.
-     */
-     public void testToPlainStringNegNegExp() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E-100";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "-0.000000000000000000000000000000000000000000000000000000000000000000012380964839238475457356735674573563567890295784902768787678287";
-        assertTrue("incorrect value", aNumber.toPlainString().equals(result));
-    }
-
-    /**
-     * Convert a negative BigDecimal with a positive exponent
-     * to a plain string representation;
-     * scale == 0.
-     */
-     public void testToPlainStringNegPosExp() {
-        String a = "-123809648392384754573567356745735.63567890295784902768787678287E100";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "-1238096483923847545735673567457356356789029578490276878767828700000000000000000000000000000000000000000000000000000000000000000000000";
-        assertTrue("incorrect value", aNumber.toPlainString().equals(result));
-    }
-
-    /**
-     * Convert a positive BigDecimal with a negative exponent
-     * to a plain string representation;
-     * scale == 0.
-     */
-     public void testToPlainStringPosNegExp() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E-100";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "0.000000000000000000000000000000000000000000000000000000000000000000012380964839238475457356735674573563567890295784902768787678287";
-        assertTrue("incorrect value", aNumber.toPlainString().equals(result));
-    }
-
-    /**
-     * Convert a negative BigDecimal with a negative exponent
-     * to a plain string representation;
-     * scale == 0.
-     */
-     public void testToPlainStringPosPosExp() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E+100";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "1238096483923847545735673567457356356789029578490276878767828700000000000000000000000000000000000000000000000000000000000000000000000";
-        assertTrue("incorrect value", aNumber.toPlainString().equals(result));
-    }
-
-    /**
-     * Convert a BigDecimal to a string representation;
-     * scale == 0.
-     */
-     public void testToStringZeroScale() {
-        String a = "-123809648392384754573567356745735635678902957849027687876782870";
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
-        String result = "-123809648392384754573567356745735635678902957849027687876782870";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Convert a positive BigDecimal to a string representation
-     */
-    public void testToStringPos() {
-        String a = "123809648392384754573567356745735.63567890295784902768787678287E-500";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "1.2380964839238475457356735674573563567890295784902768787678287E-468";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Convert a negative BigDecimal to a string representation
-     */
-    public void testToStringNeg() {
-        String a = "-123.4564563673567380964839238475457356735674573563567890295784902768787678287E-5";
-        BigDecimal aNumber = new BigDecimal(a);
-        String result = "-0.001234564563673567380964839238475457356735674573563567890295784902768787678287";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a positive long value; scale == 0
-     */
-    public void testValueOfPosZeroScale() {
-        long a = 98374823947823578L;
-        BigDecimal aNumber = BigDecimal.valueOf(a);
-        String result = "98374823947823578";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a negative long value; scale is 0
-     */
-    public void testValueOfNegZeroScale() {
-        long a = -98374823947823578L;
-        BigDecimal aNumber = BigDecimal.valueOf(a);
-        String result = "-98374823947823578";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a negative long value; scale is positive
-     */
-    public void testValueOfNegScalePos() {
-        long a = -98374823947823578L;
-        int scale = 12;
-        BigDecimal aNumber = BigDecimal.valueOf(a, scale);
-        String result = "-98374.823947823578";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a negative long value; scale is negative
-     */
-    public void testValueOfNegScaleNeg() {
-        long a = -98374823947823578L;
-        int scale = -12;
-        BigDecimal aNumber = BigDecimal.valueOf(a, scale);
-        String result = "-9.8374823947823578E+28";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a negative long value; scale is positive
-     */
-    public void testValueOfPosScalePos() {
-        long a = 98374823947823578L;
-        int scale = 12;
-        BigDecimal aNumber = BigDecimal.valueOf(a, scale);
-        String result = "98374.823947823578";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a negative long value; scale is negative
-     */
-    public void testValueOfPosScaleNeg() {
-        long a = 98374823947823578L;
-        int scale = -12;
-        BigDecimal aNumber = BigDecimal.valueOf(a, scale);
-        String result = "9.8374823947823578E+28";
-        assertTrue("incorrect value", aNumber.toString().equals(result));
-    }
-
-    /**
-     * Create a BigDecimal from a negative double value
-     */
-    public void testValueOfDoubleNeg() {
-        double a = -65678765876567576.98788767;
-        BigDecimal result = BigDecimal.valueOf(a);
-        String res = "-65678765876567576";
-        int resScale = 0;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * Create a BigDecimal from a positive double value
-     */
-    public void testValueOfDoublePos1() {
-        double a = 65678765876567576.98788767;
-        BigDecimal result = BigDecimal.valueOf(a);
-        String res = "65678765876567576";
-        int resScale = 0;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * Create a BigDecimal from a positive double value
-     */
-    public void testValueOfDoublePos2() {
-        double a = 12321237576.98788767;
-        BigDecimal result = BigDecimal.valueOf(a);
-        String res = "12321237576.987888";
-        int resScale = 6;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * Create a BigDecimal from a positive double value
-     */
-    public void testValueOfDoublePos3() {
-        double a = 12321237576.9878838;
-        BigDecimal result = BigDecimal.valueOf(a);
-        String res = "12321237576.987885";
-        int resScale = 6;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-
-    /**
-     * valueOf(Double.NaN)
-     */
-    public void testValueOfDoubleNaN() {
-        double a = Double.NaN;
-        try {
-            BigDecimal.valueOf(a);
-            fail("NumberFormatException has not been thrown for Double.NaN");
-        } catch (NumberFormatException e) {
-            return;
-        }
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalScaleOperationsTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalScaleOperationsTest.java
deleted file mode 100644
index 6c74dee..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalScaleOperationsTest.java
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.*;
-
-/**
- * Class:  java.math.BigDecimal
- * Methods: movePointLeft, movePointRight, scale, setScale, unscaledValue * 
- */
-public class BigDecimalScaleOperationsTest extends TestCase {
-    /**
-     * Check the default scale
-     */
-    public void testScaleDefault() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int cScale = 0;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
-        assertTrue("incorrect scale", aNumber.scale() == cScale);
-    }
-
-    /**
-     * Check a negative scale
-     */
-    public void testScaleNeg() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = -10;
-        int cScale = -10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        assertTrue("incorrect scale", aNumber.scale() == cScale);
-    }
-
-    /**
-     * Check a positive scale
-     */
-    public void testScalePos() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 10;
-        int cScale = 10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        assertTrue("incorrect scale", aNumber.scale() == cScale);
-    }
-
-    /**
-     * Check the zero scale
-     */
-    public void testScaleZero() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 0;
-        int cScale = 0;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        assertTrue("incorrect scale", aNumber.scale() == cScale);
-    }
-
-    /**
-     * Check the unscaled value
-     */
-    public void testUnscaledValue() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 100;
-        BigInteger bNumber = new BigInteger(a);
-        BigDecimal aNumber = new BigDecimal(bNumber, aScale);
-        assertTrue("incorrect unscaled value", aNumber.unscaledValue().equals(bNumber));
-    }
-    
-    /**
-     * Set a greater new scale
-     */
-    public void testSetScaleGreater() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 18;
-        int newScale = 28;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertEquals("incorrect value", 0, bNumber.compareTo(aNumber));
-    }
-
-    /**
-     * Set a less new scale; this.scale == 8; newScale == 5.
-     */
-    public void testSetScaleLess() {
-        String a = "2.345726458768760000E+10";
-        int newScale = 5;
-        BigDecimal aNumber = new BigDecimal(a);
-        BigDecimal bNumber = aNumber.setScale(newScale);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertEquals("incorrect value", 0, bNumber.compareTo(aNumber));
-    }
-
-    /**
-     * Verify an exception when setting a new scale
-     */
-    public void testSetScaleException() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        try {
-            aNumber.setScale(newScale);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-            assertEquals("Improper exception message", "Rounding necessary", e.getMessage());
-        }
-    }
-
-    /**
-     * Set the same new scale
-     */
-    public void testSetScaleSame() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 18;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.equals(aNumber));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundUp() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478139";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_UP);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundDown() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478138";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_DOWN);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundCeiling() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478139";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_CEILING);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundFloor() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478138";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_FLOOR);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundHalfUp() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478138";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_HALF_UP);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundHalfDown() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478138";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_HALF_DOWN);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-
-    /**
-     * Set a new scale
-     */
-    public void testSetScaleRoundHalfEven() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478138";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_HALF_EVEN);
-        assertTrue("incorrect scale", bNumber.scale() == newScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-    
-    /**
-     * SetScale(int, RoundingMode)
-     */
-    public void testSetScaleIntRoundingMode() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 28;
-        int newScale = 18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal result = aNumber.setScale(newScale, RoundingMode.HALF_EVEN);
-        String res = "123121247898748298842980.877981045763478138";
-        int resScale = 18;
-        assertEquals("incorrect value", res, result.toString());
-        assertEquals("incorrect scale", resScale, result.scale());
-    }
-    
-    /**
-     * Move the decimal point to the left; the shift value is positive
-     */
-    public void testMovePointLeftPos() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 28;
-        int shift = 18;
-        int resScale = 46;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.movePointLeft(shift);
-        assertTrue("incorrect scale", bNumber.scale() == resScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
-    }
-        
-    /**
-     * Move the decimal point to the left; the shift value is positive
-     */
-    public void testMovePointLeftNeg() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 28;
-        int shift = -18;
-        int resScale = 10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.movePointLeft(shift);
-        assertTrue("incorrect scale", bNumber.scale() == resScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
-    }
-
-    /**
-     * Move the decimal point to the right; the shift value is positive
-     */
-    public void testMovePointRightPosGreater() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 28;
-        int shift = 18;
-        int resScale = 10;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.movePointRight(shift);
-        assertTrue("incorrect scale", bNumber.scale() == resScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
-    }
-        
-    /**
-     * Move the decimal point to the right; the shift value is positive
-     */
-    public void testMovePointRightPosLess() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        String b = "123121247898748298842980877981045763478138475679498700";
-        int aScale = 28;
-        int shift = 30;
-        int resScale = 0;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.movePointRight(shift);
-        assertTrue("incorrect scale", bNumber.scale() == resScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
-    }
-        
-    /**
-     * Move the decimal point to the right; the shift value is positive
-     */
-    public void testMovePointRightNeg() {
-        String a = "1231212478987482988429808779810457634781384756794987";
-        int aScale = 28;
-        int shift = -18;
-        int resScale = 46;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        BigDecimal bNumber = aNumber.movePointRight(shift);
-        assertTrue("incorrect scale", bNumber.scale() == resScale);
-        assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
-    }
-
-    /**
-     * Move the decimal point to the right when the scale overflows
-     */
-    public void testMovePointRightException() {
-        String a = "12312124789874829887348723648726347429808779810457634781384756794987";
-        int aScale = Integer.MAX_VALUE; //2147483647
-        int shift = -18;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        try {
-            aNumber.movePointRight(shift);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * precision()
-     */
-    public void testPrecision() {
-        String a = "12312124789874829887348723648726347429808779810457634781384756794987";
-        int aScale = 14;
-        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
-        int prec = aNumber.precision();
-        assertEquals(68, prec);
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAddTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAddTest.java
deleted file mode 100644
index 913eb8a..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAddTest.java
+++ /dev/null
@@ -1,495 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Method: add 
- */
-public class BigIntegerAddTest extends TestCase {
-    /**
-     * Add two positive numbers of the same length
-     */
-    public void testCase1() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two negative numbers of the same length
-     */
-    public void testCase2() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two numbers of the same length.
-     * The first one is positive and the second is negative.
-     * The first one is greater in absolute value.
-     */
-    public void testCase3() {
-        byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
-        int aSign = 1;
-        int bSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two numbers of the same length.
-     * The first one is negative and the second is positive.
-     * The first one is greater in absolute value.
-     */
-    public void testCase4() {
-        byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
-        int aSign = -1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two numbers of the same length.
-     * The first is positive and the second is negative.
-     * The first is less in absolute value.
-     */
-    public void testCase5() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
-        byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
-        int aSign = 1;
-        int bSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two numbers of the same length.
-     * The first one is negative and the second is positive.
-     * The first one is less in absolute value.
-     */
-    public void testCase6() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
-        byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
-        int aSign = -1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two positive numbers of different length.
-     * The first is longer.
-     */
-    public void testCase7() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two positive numbers of different length.
-     * The second is longer.
-     */
-    public void testCase8() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
-        BigInteger aNumber = new BigInteger(aBytes);
-        BigInteger bNumber = new BigInteger(bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two negative numbers of different length.
-     * The first is longer.
-     */
-    public void testCase9() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two negative numbers of different length.
-     * The second is longer.
-     */
-    public void testCase10() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two numbers of different length and sign.
-     * The first is positive.
-     * The first is longer.
-     */
-    public void testCase11() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two numbers of different length and sign.
-     * The first is positive.
-     * The second is longer.
-     */
-    public void testCase12() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two numbers of different length and sign.
-     * The first is negative.
-     * The first is longer.
-     */
-    public void testCase13() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Add two numbers of different length and sign.
-     * The first is negative.
-     * The second is longer.
-     */
-    public void testCase14() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * Add two equal numbers of different signs
-     */
-    public void testCase15() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {0};
-        int aSign = -1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Add zero to a number
-     */
-    public void testCase16() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {0};
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add a number to zero
-     */
-    public void testCase17() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * Add zero to zero
-     */
-    public void testCase18() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {0};
-        byte rBytes[] = {0};
-        int aSign = 1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-    
-    /**
-     * Add ZERO to a number
-     */
-    public void testCase19() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add a number to zero
-     */
-    public void testCase20() {
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int bSign = 1;
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * Add ZERO to ZERO
-     */
-    public void testCase21() {
-        byte rBytes[] = {0};
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Add ONE to ONE
-     */
-    public void testCase22() {
-        byte rBytes[] = {2};
-        BigInteger aNumber = BigInteger.ONE;
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Add two numbers so that carry is 1
-     */
-    public void testCase23() {
-        byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-        byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
-        int aSign = 1;
-        int bSign = 1;
-        byte rBytes[] = {1, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.add(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAndTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAndTest.java
deleted file mode 100644
index d057bfa..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAndTest.java
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Method: and 
- */
-public class BigIntegerAndTest extends TestCase {
-    /**
-     * And for zero and a positive number
-     */
-    public void testZeroPos() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 0;
-        int bSign = 1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * And for zero and a negative number
-     */
-    public void testZeroNeg() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 0;
-        int bSign = -1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * And for a positive number and zero 
-     */
-    public void testPosZero() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {0};
-        int aSign = 1;
-        int bSign = 0;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * And for a negative number and zero  
-     */
-    public void testNegPos() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {0};
-        int aSign = -1;
-        int bSign = 0;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * And for zero and zero
-     */
-    public void testZeroZero() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {0};
-        int aSign = 0;
-        int bSign = 0;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * And for zero and one
-     */
-    public void testZeroOne() {
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.and(bNumber);
-        assertTrue(result.equals(BigInteger.ZERO));
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * And for one and one
-     */
-    public void testOneOne() {
-        BigInteger aNumber = BigInteger.ONE;
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.and(bNumber);
-        assertTrue(result.equals(BigInteger.ONE));
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for two positive numbers of the same length
-     */
-    public void testPosPosSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -128, 56, 100, 4, 4, 17, 37, 16, 1, 64, 1, 10, 3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for two positive numbers; the first is longer
-     */
-    public void testPosPosFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for two positive numbers; the first is shorter
-     */
-    public void testPosPosFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for two negative numbers of the same length
-     */
-    public void testNegNegSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 1, 2, 3, 3, 0, 65, -96, -48, -124, -60, 12, -40, -31, 97};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * And for two negative numbers; the first is longer
-     */
-    public void testNegNegFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * And for two negative numbers; the first is shorter
-     */
-    public void testNegNegFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * And for two numbers of different signs and the same length
-     */
-    public void testPosNegSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {0, -6, -80, 72, 8, 75, 2, -79, 34, 16, -119};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for two numbers of different signs and the same length
-     */
-    public void testNegPosSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -2, 125, -60, -104, 1, 10, 6, 2, 32, 56, 2, 4, 4, 21};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for a negative and a positive numbers; the first is longer
-     */
-    public void testNegPosFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for a negative and a positive numbers; the first is shorter
-     */
-    public void testNegPosFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for a positive and a negative numbers; the first is longer
-     */
-    public void testPosNegFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * And for a positive and a negative numbers; the first is shorter
-     */
-    public void testPosNegFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Test for a special case
-     */
-    public void testSpecialCase1() {
-        byte aBytes[] = {-1, -1, -1, -1};
-        byte bBytes[] = {5, -4, -3, -2};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Test for a special case
-     */
-    public void testSpecialCase2() {
-        byte aBytes[] = {-51};
-        byte bBytes[] = {-52, -51, -50, -49, -48};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -52, -51, -50, -49, 16};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.and(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerCompareTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerCompareTest.java
deleted file mode 100644
index a65c77e..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerCompareTest.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:   java.math.BigInteger
- * Methods: abs, compareTo, equals, max, min, negate, signum
- */
-public class BigIntegerCompareTest extends TestCase {
-    /**
-     * abs() for a positive number
-     */
-    public void testAbsPositive() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.abs();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * abs() for a negative number
-     */
-    public void testAbsNegative() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = -1;
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.abs();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare two positive numbers.
-     * The first is greater.
-     */
-    public void testCompareToPosPos1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = 1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(1, aNumber.compareTo(bNumber));
-    }
-    
-    /**
-     * compareTo(BigInteger a).
-     * Compare two positive numbers.
-     * The first is less.
-     */
-    public void testCompareToPosPos2() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(-1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare two equal positive numbers.
-     */
-    public void testCompareToEqualPos() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(0, aNumber.compareTo(bNumber));
-    }
-    
-    /**
-     * compareTo(BigInteger a).
-     * Compare two negative numbers.
-     * The first is greater in absolute value.
-     */
-    public void testCompareToNegNeg1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = -1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(-1, aNumber.compareTo(bNumber));
-    }
-    
-    /**
-     * compareTo(BigInteger a).
-     * Compare two negative numbers.
-     * The first is less  in absolute value.
-     */
-    public void testCompareNegNeg2() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        int bSign = -1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare two equal negative numbers.
-     */
-    public void testCompareToEqualNeg() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        int bSign = -1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(0, aNumber.compareTo(bNumber));
-    }
-    
-    /**
-     * compareTo(BigInteger a).
-     * Compare two numbers of different signs.
-     * The first is positive.
-     */
-    public void testCompareToDiffSigns1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = -1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare two numbers of different signs.
-     * The first is negative.
-     */
-    public void testCompareToDiffSigns2() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = 1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(-1, aNumber.compareTo(bNumber));
-    }
-    
-    /**
-     * compareTo(BigInteger a).
-     * Compare a positive number to ZERO.
-     */
-    public void testCompareToPosZero() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        assertEquals(1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare ZERO to a positive number.
-     */
-    public void testCompareToZeroPos() {
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int bSign = 1;
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(-1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare a negative number to ZERO.
-     */
-    public void testCompareToNegZero() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        assertEquals(-1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare ZERO to a negative number.
-     */
-    public void testCompareToZeroNeg() {
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int bSign = -1;
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        assertEquals(1, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * compareTo(BigInteger a).
-     * Compare ZERO to ZERO.
-     */
-    public void testCompareToZeroZero() {
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = BigInteger.ZERO;
-        assertEquals(0, aNumber.compareTo(bNumber));
-    }
-
-    /**
-     * equals(Object obj).
-     * obj is not a BigInteger
-     */
-    public void testEqualsObject() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        Object obj = new Object();
-        assertFalse(aNumber.equals(obj));
-    }
-
-    /**
-     * equals(null).
-     */
-    public void testEqualsNull() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertFalse(aNumber.equals(null));
-    }
-
-    /**
-     * equals(Object obj).
-     * obj is a BigInteger.
-     * numbers are equal.
-     */
-    public void testEqualsBigIntegerTrue() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        Object bNumber = new BigInteger(bSign, bBytes);
-        assertTrue(aNumber.equals(bNumber));
-    }
-
-    /**
-     * equals(Object obj).
-     * obj is a BigInteger.
-     * numbers are not equal.
-     */
-    public void testEqualsBigIntegerFalse() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        Object bNumber = new BigInteger(bSign, bBytes);
-        assertFalse(aNumber.equals(bNumber));
-    }
-
-    /**
-     * max(BigInteger val).
-     * the first is greater.
-     */
-    public void testMaxGreater() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.max(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == 1);
-    }
-
-    /**
-     * max(BigInteger val).
-     * the first is less.
-     */
-    public void testMaxLess() {
-        byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.max(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == 1);
-    }
-
-    /**
-     * max(BigInteger val).
-     * numbers are equal.
-     */
-    public void testMaxEqual() {
-        byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.max(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * max(BigInteger val).
-     * max of negative and ZERO.
-     */
-    public void testMaxNegZero() {
-        byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.max(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == 0);
-    }
-
-    /**
-     * min(BigInteger val).
-     * the first is greater.
-     */
-    public void testMinGreater() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.min(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * min(BigInteger val).
-     * the first is less.
-     */
-    public void testMinLess() {
-        byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.min(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * min(BigInteger val).
-     * numbers are equal.
-     */
-    public void testMinEqual() {
-        byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.min(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == 1);
-    }
-
-    /**
-     * max(BigInteger val).
-     * min of positive and ZERO.
-     */
-    public void testMinPosZero() {
-        byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.min(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == 0);
-    }
-    
-    /**
-     * negate() a positive number.
-     */
-    public void testNegatePositive() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        byte rBytes[] = {-13, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -27, -4, -91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.negate();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == -1);
-    }
-
-    /**
-     * negate() a negative number.
-     */
-    public void testNegateNegative() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.negate();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertTrue("incorrect sign", result.signum() == 1);
-    }
-
-    /**
-     * negate() ZERO.
-     */
-    public void testNegateZero() {
-        byte rBytes[] = {0};
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.negate();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }    
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * signum() of a positive number.
-     */
-    public void testSignumPositive() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-    
-    /**
-     * signum() of a negative number.
-     */
-    public void testSignumNegative() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-    
-    /**
-     * signum() of ZERO.
-     */
-    public void testSignumZero() {
-        BigInteger aNumber = BigInteger.ZERO;
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConstructorsTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConstructorsTest.java
deleted file mode 100644
index 051ba5e..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConstructorsTest.java
+++ /dev/null
@@ -1,769 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-import java.util.Random;
-
-/**
- * Class:   java.math.BigInteger
- * Constructors: BigInteger(byte[] a), BigInteger(int sign, byte[] a), 
- *               BigInteger(String val, int radix)
- */
-public class BigIntegerConstructorsTest extends TestCase {
-    /**
-     * Create a number from an array of bytes.
-     * Verify an exception thrown if an array is zero bytes long
-     */
-    public void testConstructorBytesException() {
-        byte aBytes[] = {};
-        try {
-            new BigInteger(aBytes);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-    
-    /**
-     * Create a positive number from an array of bytes.
-     * The number fits in an array of integers.
-     */
-    public void testConstructorBytesPositive1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from an array of bytes.
-     * The number fits in an integer.
-     */
-    public void testConstructorBytesPositive2() {
-        byte aBytes[] = {12, 56, 100};
-        byte rBytes[] = {12, 56, 100};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from an array of bytes.
-     * The number of bytes is 4.
-     */
-    public void testConstructorBytesPositive3() {
-        byte aBytes[] = {127, 56, 100, -1};
-        byte rBytes[] = {127, 56, 100, -1};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from an array of bytes.
-     * The number of bytes is multiple of 4.
-     */
-    public void testConstructorBytesPositive() {
-        byte aBytes[] = {127, 56, 100, -1, 14, 75, -24, -100};
-        byte rBytes[] = {127, 56, 100, -1, 14, 75, -24, -100};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from an array of bytes.
-     * The number fits in an array of integers.
-     */
-    public void testConstructorBytesNegative1() {
-        byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        byte rBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from an array of bytes.
-     * The number fits in an integer.
-     */
-    public void testConstructorBytesNegative2() {
-        byte aBytes[] = {-12, 56, 100};
-        byte rBytes[] = {-12, 56, 100};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from an array of bytes.
-     * The number of bytes is 4.
-     */
-    public void testConstructorBytesNegative3() {
-        byte aBytes[] = {-128, -12, 56, 100};
-        byte rBytes[] = {-128, -12, 56, 100};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-    
-    /**
-     * Create a negative number from an array of bytes.
-     * The number of bytes is multiple of 4.
-     */
-    public void testConstructorBytesNegative4() {
-        byte aBytes[] = {-128, -12, 56, 100, -13, 56, 93, -78};
-        byte rBytes[] = {-128, -12, 56, 100, -13, 56, 93, -78};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from an array of zero bytes.
-     */
-    public void testConstructorBytesZero() {
-        byte aBytes[] = {0, 0, 0, -0, +0, 0, -0};
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a number from a sign and an array of bytes.
-     * Verify an exception thrown if a sign has improper value.
-     */
-    public void testConstructorSignBytesException1() {
-        byte aBytes[] = {123, 45, -3, -76};
-        int aSign = 3;
-        try {
-            new BigInteger(aSign, aBytes);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-    
-    /**
-     * Create a number from a sign and an array of bytes.
-     * Verify an exception thrown if the array contains non-zero bytes while the sign is 0. 
-     */
-    public void testConstructorSignBytesException2() {
-        byte aBytes[] = {123, 45, -3, -76};
-        int aSign = 0;
-        try {
-            new BigInteger(aSign, aBytes);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-            assertEquals("Improper exception message", "signum-magnitude mismatch", e.getMessage());
-        }
-    }
-
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number fits in an array of integers.
-     * The most significant byte is positive.
-     */
-    public void testConstructorSignBytesPositive1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
-        int aSign = 1;
-        byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-    
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number fits in an array of integers.
-     * The most significant byte is negative.
-     */
-    public void testConstructorSignBytesPositive2() {
-        byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
-        int aSign = 1;
-        byte rBytes[] = {0, -12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number fits in an integer.
-     */
-    public void testConstructorSignBytesPositive3() {
-        byte aBytes[] = {-12, 56, 100};
-        int aSign = 1;
-        byte rBytes[] = {0, -12, 56, 100};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number of bytes is 4.
-     * The most significant byte is positive.
-     */
-    public void testConstructorSignBytesPositive4() {
-        byte aBytes[] = {127, 56, 100, -2};
-        int aSign = 1;
-        byte rBytes[] = {127, 56, 100, -2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number of bytes is 4.
-     * The most significant byte is negative.
-     */
-    public void testConstructorSignBytesPositive5() {
-        byte aBytes[] = {-127, 56, 100, -2};
-        int aSign = 1;
-        byte rBytes[] = {0, -127, 56, 100, -2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-    
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number of bytes is multiple of 4.
-     * The most significant byte is positive.
-     */
-    public void testConstructorSignBytesPositive6() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
-        int aSign = 1;
-        byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a sign and an array of bytes.
-     * The number of bytes is multiple of 4.
-     * The most significant byte is negative.
-     */
-    public void testConstructorSignBytesPositive7() {
-        byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
-        int aSign = 1;
-        byte rBytes[] = {0, -12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-    
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number fits in an array of integers.
-     * The most significant byte is positive.
-     */
-    public void testConstructorSignBytesNegative1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
-        int aSign = -1;
-        byte rBytes[] = {-13, -57, -101, 1, 75, -90, -46, -92, -4, 15};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-    
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number fits in an array of integers.
-     * The most significant byte is negative.
-     */
-    public void testConstructorSignBytesNegative2() {
-        byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
-        int aSign = -1;
-        byte rBytes[] = {-1, 11, -57, -101, 1, 75, -90, -46, -92, -4, 15};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number fits in an integer.
-     */
-    public void testConstructorSignBytesNegative3() {
-        byte aBytes[] = {-12, 56, 100};
-        int aSign = -1;
-        byte rBytes[] = {-1, 11, -57, -100};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number of bytes is 4.
-     * The most significant byte is positive.
-     */
-    public void testConstructorSignBytesNegative4() {
-        byte aBytes[] = {127, 56, 100, -2};
-        int aSign = -1;
-        byte rBytes[] = {-128, -57, -101, 2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number of bytes is 4.
-     * The most significant byte is negative.
-     */
-    public void testConstructorSignBytesNegative5() {
-        byte aBytes[] = {-127, 56, 100, -2};
-        int aSign = -1;
-        byte rBytes[] = {-1, 126, -57, -101, 2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-    
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number of bytes is multiple of 4.
-     * The most significant byte is positive.
-     */
-    public void testConstructorSignBytesNegative6() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
-        int aSign = -1;
-        byte rBytes[] = {-13, -57, -101, 1, 75, -90, -46, -92, -4, 14, -24, 101};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from a sign and an array of bytes.
-     * The number of bytes is multiple of 4.
-     * The most significant byte is negative.
-     */
-    public void testConstructorSignBytesNegative7() {
-        byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
-        int aSign = -1;
-        byte rBytes[] = {-1, 11, -57, -101, 1, 75, -90, -46, -92, -4, 14, -24, 101};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a sign and an array of zero bytes.
-     * The sign is -1.
-     */
-    public void testConstructorSignBytesZero1() {
-        byte aBytes[] = {-0, 0, +0, 0, 0, 00, 000};
-        int aSign = -1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a sign and an array of zero bytes.
-     * The sign is 0.
-     */
-    public void testConstructorSignBytesZero2() {
-        byte aBytes[] = {-0, 0, +0, 0, 0, 00, 000};
-        int aSign = 0;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a sign and an array of zero bytes.
-     * The sign is 1.
-     */
-    public void testConstructorSignBytesZero3() {
-        byte aBytes[] = {-0, 0, +0, 0, 0, 00, 000};
-        int aSign = 1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a sign and an array of zero length.
-     * The sign is -1.
-     */
-    public void testConstructorSignBytesZeroNull1() {
-        byte aBytes[] = {};
-        int aSign = -1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a sign and an array of zero length.
-     * The sign is 0.
-     */
-    public void testConstructorSignBytesZeroNull2() {
-        byte aBytes[] = {};
-        int aSign = 0;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a sign and an array of zero length.
-     * The sign is 1.
-     */
-    public void testConstructorSignBytesZeroNull3() {
-        byte aBytes[] = {};
-        int aSign = 1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a number from a string value and radix.
-     * Verify an exception thrown if a radix is out of range
-     */
-    public void testConstructorStringException1() {
-        String value = "9234853876401";
-        int radix = 45;
-        try {
-            new BigInteger(value, radix);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-    
-    /**
-     * Create a number from a string value and radix.
-     * Verify an exception thrown if the string starts with a space.
-     */
-    public void testConstructorStringException2() {
-        String value = "   9234853876401";
-        int radix = 10;
-        try {
-            new BigInteger(value, radix);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-    
-    /**
-     * Create a number from a string value and radix.
-     * Verify an exception thrown if the string contains improper characters.
-     */
-    public void testConstructorStringException3() {
-        String value = "92348$*#78987";
-        int radix = 34;
-        try {
-            new BigInteger(value, radix);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-    
-    /**
-     * Create a number from a string value and radix.
-     * Verify an exception thrown if some digits are greater than radix.
-     */
-    public void testConstructorStringException4() {
-        String value = "98zv765hdsaiy";
-        int radix = 20;
-        try {
-            new BigInteger(value, radix);
-            fail("NumberFormatException has not been caught");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-    /**
-     * Create a positive number from a string value and radix 2.
-     */
-    public void testConstructorStringRadix2() {
-        String value = "10101010101010101";
-        int radix = 2;
-        byte rBytes[] = {1, 85, 85};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-    
-    /**
-     * Create a positive number from a string value and radix 8.
-     */
-    public void testConstructorStringRadix8() {
-        String value = "76356237071623450";
-        int radix = 8;
-        byte rBytes[] = {7, -50, -28, -8, -25, 39, 40};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a string value and radix 10.
-     */
-    public void testConstructorStringRadix10() {
-        String value = "987328901348934898";
-        int radix = 10;
-        byte rBytes[] = {13, -77, -78, 103, -103, 97, 68, -14};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a string value and radix 16.
-     */
-    public void testConstructorStringRadix16() {
-        String value = "fe2340a8b5ce790";
-        int radix = 16;
-        byte rBytes[] = {15, -30, 52, 10, -117, 92, -25, -112};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a positive number from a string value and radix 36.
-     */
-    public void testConstructorStringRadix36() {
-        String value = "skdjgocvhdjfkl20jndjkf347ejg457";
-        int radix = 36;
-        byte rBytes[] = {0, -12, -116, 112, -105, 12, -36, 66, 108, 66, -20, -37, -15, 108, -7, 52, -99, -109, -8, -45, -5};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * Create a negative number from a string value and radix 10.
-     */
-    public void testConstructorStringRadix10Negative() {
-        String value = "-234871376037";
-        int radix = 36;
-        byte rBytes[] = {-4, 48, 71, 62, -76, 93, -105, 13};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * Create a zero number from a string value and radix 36.
-     */
-    public void testConstructorStringRadix10Zero() {
-        String value = "-00000000000000";
-        int radix = 10;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(value, radix);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-
-    /**
-     * Create a random number of 75 bits length.
-     */
-    public void testConstructorRandom() {
-        int bitLen = 75;
-        Random rnd = new Random();
-        BigInteger aNumber = new BigInteger(bitLen, rnd);
-        assertTrue("incorrect bitLength", aNumber.bitLength() <= bitLen);
-    }
-
-    /**
-     * Create a prime number of 25 bits length.
-     */
-    public void testConstructorPrime() {
-        int bitLen = 25;
-        Random rnd = new Random();
-        BigInteger aNumber = new BigInteger(bitLen, 80, rnd);
-        assertTrue("incorrect bitLength", aNumber.bitLength() == bitLen);
-    }
-
-    /**
-     * Create a prime number of 2 bits length.
-     */
-    public void testConstructorPrime2() {
-        int bitLen = 2;
-        Random rnd = new Random();
-        BigInteger aNumber = new BigInteger(bitLen, 80, rnd);
-        assertTrue("incorrect bitLength", aNumber.bitLength() == bitLen);
-        int num = aNumber.intValue();
-        assertTrue("incorrect value", num == 2 || num == 3);
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConvertTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConvertTest.java
deleted file mode 100644
index d72923d..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConvertTest.java
+++ /dev/null
@@ -1,792 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:   java.math.BigInteger
- * Methods: intValue, longValue, toByteArray(), valueOf(long val),
- * floatValue(), doubleValue()
- */
-public class BigIntegerConvertTest extends TestCase {
-    /**
-     * Return the double value of ZERO. 
-     */
-    public void testDoubleValueZero() {
-        String a = "0";
-        double result = 0.0;
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The number's length is less than 64 bits.
-     */
-    public void testDoubleValuePositive1() {
-        String a = "27467238945";
-        double result = 2.7467238945E10;
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The number's bit length is inside [63, 1024].
-     */
-    public void testDoubleValuePositive2() {
-        String a = "2746723894572364578265426346273456972";
-        double result = 2.7467238945723645E36;
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a negative number to a double value. 
-     * The number's bit length is less than 64 bits.
-     */
-    public void testDoubleValueNegative1() {
-        String a = "-27467238945";
-        double result = -2.7467238945E10;
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a negative number to a double value. 
-     * The number's bit length is inside [63, 1024].
-     */
-    public void testDoubleValueNegative2() {
-        String a = "-2746723894572364578265426346273456972";
-        double result = -2.7467238945723645E36;
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * Rounding is needed.
-     * The rounding bit is 1 and the next bit to the left is 1.
-     */
-    public void testDoubleValuePosRounded1() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = 1;
-        double result = 1.54747264387948E26;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a double value. 
-     * Rounding is needed.
-     * The rounding bit is 1 and the next bit to the left is 0
-     * but some of dropped bits are 1s.
-     */
-    public void testDoubleValuePosRounded2() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5};
-        int aSign = 1;
-        double result = 1.547472643879479E26;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-        /**
-     * Convert a positive number to a double value. 
-     * Rounding is NOT needed.
-     */
-    public void testDoubleValuePosNotRounded() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5};
-        int aSign = 1;
-        double result = 1.5474726438794828E26;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a double value. 
-     * Rounding is needed.
-     */
-    public void testDoubleValueNegRounded1() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = -1;
-        double result = -1.54747264387948E26;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a double value. 
-     * Rounding is needed.
-     * The rounding bit is 1 and the next bit to the left is 0
-     * but some of dropped bits are 1s.
-     */
-    public void testDoubleValueNegRounded2() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5};
-        int aSign = -1;
-        double result = -1.547472643879479E26;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * Rounding is NOT needed.
-     */
-    public void testDoubleValueNegNotRounded() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5};
-        int aSign = -1;
-        double result = -1.5474726438794828E26;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a double value. 
-     * The exponent is 1023 and the mantissa is all 1s.
-     * The rounding bit is 0.
-     * The result is Double.MAX_VALUE.
-     */
-    public void testDoubleValuePosMaxValue() {
-        byte[] a = {0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-           };
-        int aSign = 1;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == Double.MAX_VALUE);
-    }
-
-    /**
-     * Convert a negative number to a double value. 
-     * The exponent is 1023 and the mantissa is all 1s.
-     * The result is -Double.MAX_VALUE.
-     */
-    public void testDoubleValueNegMaxValue() {
-        byte[] a = {0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-           };
-        int aSign = -1;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == -Double.MAX_VALUE);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The exponent is 1023 and the mantissa is all 1s.
-     * The rounding bit is 1.
-     * The result is Double.POSITIVE_INFINITY.
-     */
-    public void testDoubleValuePositiveInfinity1() {
-        byte[] a = {-1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
-           };
-        int aSign = 1;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == Double.POSITIVE_INFINITY);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The number's bit length is greater than 1024.
-     */
-    public void testDoubleValuePositiveInfinity2() {
-        String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == Double.POSITIVE_INFINITY);
-    }
-
-    /**
-     * Convert a negative number to a double value. 
-     * The number's bit length is greater than 1024.
-     */
-    public void testDoubleValueNegativeInfinity1() {
-        String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
-        double aNumber = new BigInteger(a).doubleValue();
-        assertTrue(aNumber == Double.NEGATIVE_INFINITY);
-    }
-
-    /**
-     * Convert a negative number to a double value. 
-     * The exponent is 1023 and the mantissa is all 0s.
-     * The rounding bit is 0.
-     * The result is Double.NEGATIVE_INFINITY.
-     */
-    public void testDoubleValueNegativeInfinity2() {
-        byte[] a = {-1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
-           };
-        int aSign = -1;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == Double.NEGATIVE_INFINITY);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The exponent is 1023 and the mantissa is all 0s
-     * but the 54th bit (implicit) is 1.
-     */
-    public void testDoubleValuePosMantissaIsZero() {
-        byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
-           };
-        int aSign = 1;
-        double result = 8.98846567431158E307;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The exponent is 1023 and the mantissa is all 0s
-     * but the 54th bit (implicit) is 1.
-     */
-    public void testDoubleValueNegMantissaIsZero() {
-        byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
-           };
-        int aSign = -1;
-        double aNumber = new BigInteger(aSign, a).doubleValue();
-        assertTrue(aNumber == -8.98846567431158E307);
-    }
-
-    /**
-     * Return the float value of ZERO. 
-     */
-    public void testFloatValueZero() {
-        String a = "0";
-        float result = 0.0f;
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * The number's length is less than 32 bits.
-     */
-    public void testFloatValuePositive1() {
-        String a = "27467238";
-        float result = 2.7467238E7f;
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * The number's bit length is inside [32, 127].
-     */
-    public void testFloatValuePositive2() {
-        String a = "27467238945723645782";
-        float result = 2.7467239E19f;
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a negative number to a float value. 
-     * The number's bit length is less than 32 bits.
-     */
-    public void testFloatValueNegative1() {
-        String a = "-27467238";
-        float result = -2.7467238E7f;
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a negative number to a doufloatble value. 
-     * The number's bit length is inside [63, 1024].
-     */
-    public void testFloatValueNegative2() {
-        String a = "-27467238945723645782";
-        float result = -2.7467239E19f;
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * Rounding is needed.
-     * The rounding bit is 1 and the next bit to the left is 1.
-     */
-    public void testFloatValuePosRounded1() {
-        byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = 1;
-        float result = 1.5475195E26f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a float value. 
-     * Rounding is needed.
-     * The rounding bit is 1 and the next bit to the left is 0
-     * but some of dropped bits are 1s.
-     */
-    public void testFloatValuePosRounded2() {
-        byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = 1;
-        float result = 1.5474728E26f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-        /**
-     * Convert a positive number to a float value. 
-     * Rounding is NOT needed.
-     */
-    public void testFloatValuePosNotRounded() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = 1;
-        float result = 1.5474726E26f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a float value. 
-     * Rounding is needed.
-     */
-    public void testFloatValueNegRounded1() {
-        byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = -1;
-        float result = -1.5475195E26f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a float value. 
-     * Rounding is needed.
-     * The rounding bit is 1 and the next bit to the left is 0
-     * but some of dropped bits are 1s.
-     */
-    public void testFloatValueNegRounded2() {
-        byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = -1;
-        float result = -1.5474728E26f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * Rounding is NOT needed.
-     */
-    public void testFloatValueNegNotRounded() {
-        byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
-        int aSign = -1;
-        float result = -1.5474726E26f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a positive number to a float value. 
-     * The exponent is 1023 and the mantissa is all 1s.
-     * The rounding bit is 0.
-     * The result is Float.MAX_VALUE.
-     */
-    public void testFloatValuePosMaxValue() {
-        byte[] a = {0, -1, -1, -1, 0, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-        int aSign = 1;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == Float.MAX_VALUE);
-    }
-
-    /**
-     * Convert a negative number to a float value. 
-     * The exponent is 1023 and the mantissa is all 1s.
-     * The rounding bit is 0.
-     * The result is -Float.MAX_VALUE.
-     */
-    public void testFloatValueNegMaxValue() {
-        byte[] a = {0, -1, -1, -1, 0, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-        int aSign = -1;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == -Float.MAX_VALUE);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * The exponent is 1023 and the mantissa is all 1s.
-     * The rounding bit is 1.
-     * The result is Float.POSITIVE_INFINITY.
-     */
-    public void testFloatValuePositiveInfinity1() {
-        byte[] a = {0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-        int aSign = 1;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == Float.POSITIVE_INFINITY);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * The number's bit length is greater than 127.
-     */
-    public void testFloatValuePositiveInfinity2() {
-        String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == Float.POSITIVE_INFINITY);
-    }
-
-    /**
-     * Convert a negative number to a float value. 
-     * The number's bit length is greater than 127.
-     */
-    public void testFloatValueNegativeInfinity1() {
-        String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == Float.NEGATIVE_INFINITY);
-    }
-
-    /**
-     * Convert a negative number to a float value. 
-     * The exponent is 1023 and the mantissa is all 0s.
-     * The rounding bit is 0.
-     * The result is Float.NEGATIVE_INFINITY.
-     */
-    public void testFloatValueNegativeInfinity2() {
-        byte[] a = {0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-        int aSign = -1;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == Float.NEGATIVE_INFINITY);
-    }
-
-    /**
-     * Convert a positive number to a float value. 
-     * The exponent is 1023 and the mantissa is all 0s
-     * but the 54th bit (implicit) is 1.
-     */
-    public void testFloatValuePosMantissaIsZero() {
-        byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = 1;
-        float result = 1.7014118E38f;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive number to a double value. 
-     * The exponent is 1023 and the mantissa is all 0s
-     * but the 54th bit (implicit) is 1.
-     */
-    public void testFloatValueNegMantissaIsZero() {
-        byte[] a = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = -1;
-        float aNumber = new BigInteger(aSign, a).floatValue();
-        assertTrue(aNumber == Float.NEGATIVE_INFINITY);
-    }
-
-    /**
-     * Convert a negative number to a float value. 
-     * The number's bit length is less than 32 bits.
-     */
-    public void testFloatValueBug2482() {
-        String a = "2147483649";
-        float result = 2.14748365E9f;
-        float aNumber = new BigInteger(a).floatValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a positive BigInteger to an integer value. 
-     * The low digit is positive
-     */
-    public void testIntValuePositive1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3};
-        int resInt = 1496144643;
-        int aNumber = new BigInteger(aBytes).intValue();
-        assertTrue(aNumber == resInt);
-    }
-
-    /**
-     * Convert a positive BigInteger to an integer value. 
-     * The low digit is positive
-     */
-    public void testIntValuePositive2() {
-        byte aBytes[] = {12, 56, 100};
-        int resInt = 800868;
-        int aNumber = new BigInteger(aBytes).intValue();
-        assertTrue(aNumber == resInt);
-    }
-
-    /**
-     * Convert a positive BigInteger to an integer value. 
-     * The low digit is negative.
-     */
-    public void testIntValuePositive3() {
-        byte aBytes[] = {56, 13, 78, -12, -5, 56, 100};
-        int sign = 1;
-        int resInt = -184862620;
-        int aNumber = new BigInteger(sign, aBytes).intValue();
-        assertTrue(aNumber == resInt);
-    }
-
-    /**
-     * Convert a negative BigInteger to an integer value.
-     * The low digit is negative.
-     */
-    public void testIntValueNegative1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, -128, 45, 91, 3};
-        int sign = -1;
-        int resInt = 2144511229;
-        int aNumber = new BigInteger(sign, aBytes).intValue();
-        assertTrue(aNumber == resInt);
-    }
-
-    /**
-     * Convert a negative BigInteger to an integer value.
-     * The low digit is negative.
-     */
-    public void testIntValueNegative2() {
-        byte aBytes[] = {-12, 56, 100};
-        int result = -771996;
-        int aNumber = new BigInteger(aBytes).intValue();
-        assertTrue(aNumber == result);
-    }
-    
-    /**
-     * Convert a negative BigInteger to an integer value. 
-     * The low digit is positive.
-     */
-    public void testIntValueNegative3() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 127, 45, 91, 3};
-        int sign = -1;
-        int resInt = -2133678851;
-        int aNumber = new BigInteger(sign, aBytes).intValue();
-        assertTrue(aNumber == resInt);
-    }
-
-    /**
-     * Convert a BigInteger to a positive long value
-     * The BigInteger is longer than int.
-     */
-    public void testLongValuePositive1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, 120, -34, -12, 45, 98};
-        long result = 3268209772258930018L;
-        long aNumber = new BigInteger(aBytes).longValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a number to a positive long value
-     * The number fits in a long.
-     */
-    public void testLongValuePositive2() {
-        byte aBytes[] = {12, 56, 100, 18, -105, 34, -18, 45};
-        long result = 880563758158769709L;
-        long aNumber = new BigInteger(aBytes).longValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a number to a negative long value
-     * The BigInteger is longer than int.
-     */
-    public void testLongValueNegative1() {
-        byte aBytes[] = {12, -1, 100, -2, -76, -128, 45, 91, 3};
-        long result = -43630045168837885L;
-        long aNumber = new BigInteger(aBytes).longValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * Convert a number to a negative long value
-     * The number fits in a long.
-     */
-    public void testLongValueNegative2() {
-        byte aBytes[] = {-12, 56, 100, 45, -101, 45, 98};
-        long result = -3315696807498398L;
-        long aNumber = new BigInteger(aBytes).longValue();
-        assertTrue(aNumber == result);
-    }
-
-    /**
-     * valueOf (long val): convert Integer.MAX_VALUE to a BigInteger.
-     */
-    public void testValueOfIntegerMax() {
-        long longVal = Integer.MAX_VALUE;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {127, -1, -1, -1};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * valueOf (long val): convert Integer.MIN_VALUE to a BigInteger.
-     */
-    public void testValueOfIntegerMin() {
-        long longVal = Integer.MIN_VALUE;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {-128, 0, 0, 0};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * valueOf (long val): convert Long.MAX_VALUE to a BigInteger.
-     */
-    public void testValueOfLongMax() {
-        long longVal = Long.MAX_VALUE;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {127, -1, -1, -1, -1, -1, -1, -1};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * valueOf (long val): convert Long.MIN_VALUE to a BigInteger.
-     */
-    public void testValueOfLongMin() {
-        long longVal = Long.MIN_VALUE;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {-128, 0, 0, 0, 0, 0, 0, 0};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * valueOf (long val): convert a positive long value to a BigInteger.
-     */
-    public void testValueOfLongPositive1() {
-        long longVal = 268209772258930018L;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {3, -72, -33, 93, -24, -56, 45, 98};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-
-    /**
-     * valueOf (long val): convert a positive long value to a BigInteger.
-     * The long value fits in integer.
-     */
-    public void testValueOfLongPositive2() {
-        long longVal = 58930018L;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {3, -125, 51, 98};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, aNumber.signum());
-    }
-    
-    /**
-     * valueOf (long val): convert a negative long value to a BigInteger.
-     */
-    public void testValueOfLongNegative1() {
-        long longVal = -268209772258930018L;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {-4, 71, 32, -94, 23, 55, -46, -98};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-
-    /**
-     * valueOf (long val): convert a negative long value to a BigInteger.
-     * The long value fits in integer.
-     */
-    public void testValueOfLongNegative2() {
-        long longVal = -58930018L;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {-4, 124, -52, -98};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, aNumber.signum());
-    }
-    /**
-     * valueOf (long val): convert a zero long value to a BigInteger.
-     */
-    public void testValueOfLongZero() {
-        long longVal = 0L;
-        BigInteger aNumber = BigInteger.valueOf(longVal);
-        byte rBytes[] = {0};
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = aNumber.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, aNumber.signum());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerDivideTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerDivideTest.java
deleted file mode 100644
index 3f2ab51..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerDivideTest.java
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:   java.math.BigInteger
- * Methods: divide, remainder, mod, and divideAndRemainder 
- */
-public class BigIntegerDivideTest extends TestCase {
-    /**
-     * Divide by zero
-     */
-    public void testCase1() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {0};
-        int aSign = 1;
-        int bSign = 0;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        try {
-            aNumber.divide(bNumber);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * Divide by ZERO
-     */
-    public void testCase2() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        try {
-            aNumber.divide(bNumber);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * Divide two equal positive numbers
-     */
-    public void testCase3() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide two equal in absolute value numbers of different signs.
-     */
-    public void testCase4() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Divide two numbers of different length and different signs.
-     * The second is longer.
-     */
-    public void testCase5() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 1, 2, 3, 4, 5};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Divide two positive numbers of the same length.
-     * The second is greater.
-     */
-    public void testCase6() {
-        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127};
-        byte bBytes[] = {15, 100, 56, 7, 98, -1, 39, -128, 127};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Divide two positive numbers.
-     */
-    public void testCase7() {
-        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
-        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {23, 115, 11, 78, 35, -11};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide a positive number by a negative one.
-     */
-    public void testCase8() {
-        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
-        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-24, -116, -12, -79, -36, 11};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Divide a negative number by a positive one.
-     */
-    public void testCase9() {
-        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
-        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-24, -116, -12, -79, -36, 11};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Divide two negative numbers.
-     */
-    public void testCase10() {
-        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
-        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {23, 115, 11, 78, 35, -11};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide zero by a negative number.
-     */
-    public void testCase11() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int aSign = 0;
-        int bSign = -1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-    
-    /**
-     * Divide ZERO by a negative number.
-     */
-    public void testCase12() {
-        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int bSign = -1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Divide a positive number by ONE.
-     */
-    public void testCase13() {
-        byte aBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        int aSign = 1;        
-        byte rBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide ONE by ONE.
-     */
-    public void testCase14() {
-        byte rBytes[] = {1};
-        BigInteger aNumber = BigInteger.ONE;
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * Verifies the case when borrow != 0 in the private divide method.
-     */
-    public void testDivisionKnuth1() {
-        byte aBytes[] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {-3, -3, -3, -3};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -5, -12, -33, -96, -36, -105, -56, 92, 15, 48, -109};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Verifies the case when the divisor is already normalized.
-     */
-    public void testDivisionKnuthIsNormalized() {
-        byte aBytes[] = {-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
-        byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {0, -9, -8, -7, -6, -5, -4, -3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Verifies the case when the first digits of the dividend
-     * and divisor equal.
-     */
-    public void testDivisionKnuthFirstDigitsEqual() {
-        byte aBytes[] = {2, -3, -4, -5, -1, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
-        byte bBytes[] = {2, -3, -4, -5, -1, -1, -1, -1};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {0, -1, -1, -1, -1, -2, -88, -60, 41};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide the number of one digit by the number of one digit 
-     */
-    public void testDivisionKnuthOneDigitByOneDigit() {
-        byte aBytes[] = {113, -83, 123, -5};
-        byte bBytes[] = {2, -3, -4, -5};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Divide the number of multi digits by the number of one digit 
-     */
-    public void testDivisionKnuthMultiDigitsByOneDigit() {
-        byte aBytes[] = {113, -83, 123, -5, 18, -34, 67, 39, -29};
-        byte bBytes[] = {2, -3, -4, -5};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-38, 2, 7, 30, 109, -43};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.divide(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Remainder of division by zero
-     */
-    public void testCase15() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {0};
-        int aSign = 1;
-        int bSign = 0;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        try {
-            aNumber.remainder(bNumber);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * Remainder of division of equal numbers
-     */
-    public void testCase16() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Remainder of division of two positive numbers
-     */
-    public void testCase17() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {12, -21, 73, 56, 27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Remainder of division of two negative numbers
-     */
-    public void testCase18() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-13, 20, -74, -57, -27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Remainder of division of two numbers of different signs.
-     * The first is positive.
-     */
-    public void testCase19() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {12, -21, 73, 56, 27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * Remainder of division of two numbers of different signs.
-     * The first is negative.
-     */
-    public void testCase20() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-13, 20, -74, -57, -27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Tests the step D6 from the Knuth algorithm
-     */
-    public void testRemainderKnuth1() {
-        byte aBytes[] = {-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1};
-        byte bBytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7, 7, 18, -89};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide the number of one digit by the number of one digit 
-     */
-    public void testRemainderKnuthOneDigitByOneDigit() {
-        byte aBytes[] = {113, -83, 123, -5};
-        byte bBytes[] = {2, -3, -4, -50};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {2, -9, -14, 53};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Divide the number of multi digits by the number of one digit 
-     */
-    public void testRemainderKnuthMultiDigitsByOneDigit() {
-        byte aBytes[] = {113, -83, 123, -5, 18, -34, 67, 39, -29};
-        byte bBytes[] = {2, -3, -4, -50};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {2, -37, -60, 59};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.remainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * divideAndRemainder of two numbers of different signs.
-     * The first is negative.
-     */
-    public void testCase21() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[][] = {
-                {-5, 94, -115, -74, -85, 84},
-                {-13, 20, -74, -57, -27}
-        };
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result[] = aNumber.divideAndRemainder(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result[0].toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            if (resBytes[i] != rBytes[0][i]) {
-                fail("Incorrect quotation");
-            }
-        }
-        assertEquals(-1, result[0].signum());
-        resBytes = result[1].toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            if (resBytes[i] != rBytes[1][i]) {
-                fail("Incorrect remainder");
-            }
-            assertEquals(-1, result[1].signum());
-        }
-    }
-    
-    /**
-     * mod when modulus is negative
-     */
-    public void testCase22() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {1, 30, 40, 56, -1, 45};
-        int aSign = 1;
-        int bSign = -1;        
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        try {
-            aNumber.mod(bNumber);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * mod when a divisor is positive
-     */
-    public void testCase23() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {12, -21, 73, 56, 27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.mod(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * mod when a divisor is negative
-     */
-    public void testCase24() {
-        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
-        byte bBytes[] = {27, -15, 65, 39, 100};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {15, 5, -9, -17, 73};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.mod(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerHashCodeTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerHashCodeTest.java
deleted file mode 100644
index 52bf56f..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerHashCodeTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import java.math.BigInteger;
-
-import junit.framework.TestCase;
-
-/**
- * Class:   java.math.BigInteger
- * Method: hashCode()
- */
-public class BigIntegerHashCodeTest extends TestCase {
-    /**
-     * Test hash codes for the same object
-     */
-    public void testSameObject() {
-        String value1 = "12378246728727834290276457386374882976782849";
-        String value2 = "-5634562095872038262928728727834290276457386374882976782849";
-        BigInteger aNumber1 = new BigInteger(value1);
-        BigInteger aNumber2 = new BigInteger(value2);
-        int code1 = aNumber1.hashCode();
-        aNumber1.add(aNumber2).shiftLeft(125);
-        aNumber1.subtract(aNumber2).shiftRight(125);
-        aNumber1.multiply(aNumber2).toByteArray();
-        aNumber1.divide(aNumber2).bitLength();
-        aNumber1.gcd(aNumber2).pow(7);
-        int code2 = aNumber1.hashCode();
-        assertTrue("hash codes for the same object differ", code1 == code2);
-    }
-
-    /**
-     * Test hash codes for equal objects.
-     */
-    public void testEqualObjects() {
-        String value1 = "12378246728727834290276457386374882976782849";
-        String value2 = "12378246728727834290276457386374882976782849";
-        BigInteger aNumber1 = new BigInteger(value1);
-        BigInteger aNumber2 = new BigInteger(value2);
-        int code1 = aNumber1.hashCode();
-        int code2 = aNumber2.hashCode();
-        if (aNumber1.equals(aNumber2)) {
-            assertTrue("hash codes for equal objects are unequal", code1 == code2);
-        }
-    }
-
-    /**
-     * Test hash codes for unequal objects.
-     * The codes are unequal.
-     */
-    public void testUnequalObjectsUnequal() {
-        String value1 = "12378246728727834290276457386374882976782849";
-        String value2 = "-5634562095872038262928728727834290276457386374882976782849";
-        BigInteger aNumber1 = new BigInteger(value1);
-        BigInteger aNumber2 = new BigInteger(value2);
-        int code1 = aNumber1.hashCode();
-        int code2 = aNumber2.hashCode();
-        if (!aNumber1.equals(aNumber2)) {
-            assertTrue("hash codes for unequal objects are equal", code1 != code2);
-        }
-    }      
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerModPowTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerModPowTest.java
deleted file mode 100644
index 4af4d9d..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerModPowTest.java
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:   java.math.BigInteger
- * Methods: modPow, modInverse, and gcd 
- */
-public class BigIntegerModPowTest extends TestCase {
-	/**
-	 * modPow: non-positive modulus
-	 */
-	public void testModPowException() {
-		byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-		byte eBytes[] = {1, 2, 3, 4, 5};
-		byte mBytes[] = {1, 2, 3};
-		int aSign = 1;
-		int eSign = 1;		
-		int mSign = -1;		
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger exp = new BigInteger(eSign, eBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		try {
-			aNumber.modPow(exp, modulus);
-			fail("ArithmeticException has not been caught");
-		} catch (ArithmeticException e) {
-		}
-
-        try {
-            BigInteger.ZERO.modPow(new BigInteger("-1"), new BigInteger("10"));
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-            // expected
-        }
-	}
-
-	/**
-	 * modPow: positive exponent
-	 */
-	public void testModPowPosExp() {
-		byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75, 48, -7};
-		byte eBytes[] = {27, -15, 65, 39};
-		byte mBytes[] = {-128, 2, 3, 4, 5};
-		int aSign = 1;
-		int eSign = 1;		
-		int mSign = 1;		
-		byte rBytes[] = {113, 100, -84, -28, -85};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger exp = 	 new BigInteger(eSign, eBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		BigInteger result = aNumber.modPow(exp, modulus);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-	
-	/**
-	 * modPow: negative exponent
-	 */
-	public void testModPowNegExp() {
-		byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75, 48, -7};
-		byte eBytes[] = {27, -15, 65, 39};
-		byte mBytes[] = {-128, 2, 3, 4, 5};
-		int aSign = 1;
-		int eSign = -1;		
-		int mSign = 1;		
-		byte rBytes[] = {12, 118, 46, 86, 92};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger exp = 	 new BigInteger(eSign, eBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		BigInteger result = aNumber.modPow(exp, modulus);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-    public void testModPowZeroExp() {
-        BigInteger exp = new BigInteger("0");
-        BigInteger[] base = new BigInteger[] {new BigInteger("-1"), new BigInteger("0"), new BigInteger("1")};
-        BigInteger[] mod = new BigInteger[] {new BigInteger("2"), new BigInteger("10"), new BigInteger("2147483648")};
-
-        for (int i = 0; i < base.length; ++i) {
-            for (int j = 0; j < mod.length; ++j) {
-                assertEquals(base[i] + " modePow(" + exp + ", " + mod[j]
-                        + ") should be " + BigInteger.ONE, BigInteger.ONE,
-                        base[i].modPow(exp, mod[j]));
-            }
-        }
-
-        mod = new BigInteger[] {new BigInteger("1")};
-        for (int i = 0; i < base.length; ++i) {
-            for (int j = 0; j < mod.length; ++j) {
-                assertEquals(base[i] + " modePow(" + exp + ", " + mod[j]
-                        + ") should be " + BigInteger.ZERO, BigInteger.ZERO,
-                        base[i].modPow(exp, mod[j]));
-            }
-        }
-    }
-
-	/**
-	 * modInverse: non-positive modulus
-	 */
-	public void testmodInverseException() {
-		byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-		byte mBytes[] = {1, 2, 3};
-		int aSign = 1;
-		int mSign = -1;		
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		try {
-			aNumber.modInverse(modulus);
-			fail("ArithmeticException has not been caught");
-		} catch (ArithmeticException e) {
-		}
-	}
-	
-	/**
-	 * modInverse: non-invertible number
-	 */
-	public void testmodInverseNonInvertible() {
-		byte aBytes[] = {-15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
-		byte mBytes[] = {-12, 1, 0, 0, 0, 23, 44, 55, 66};
-		int aSign = 1;
-		int mSign = 1;		
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		try {
-			aNumber.modInverse(modulus);
-			fail("ArithmeticException has not been caught");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * modInverse: positive number
-	 */
-	public void testmodInversePos1() {
-		byte aBytes[] = {24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
-		byte mBytes[] = {122, 45, 36, 100, 122, 45};
-		int aSign = 1;
-		int mSign = 1;		
-		byte rBytes[] = {47, 3, 96, 62, 87, 19};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		BigInteger result = aNumber.modInverse(modulus);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-	/**
-	 * modInverse: positive number (another case: a < 0)
-	 */
-	public void testmodInversePos2() {
-		byte aBytes[] = {15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
-		byte mBytes[] = {2, 122, 45, 36, 100};
-		int aSign = 1;
-		int mSign = 1;		
-		byte rBytes[] = {1, -93, 40, 127, 73};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		BigInteger result = aNumber.modInverse(modulus);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-	/**
-	 * modInverse: negative number
-	 */
-	public void testmodInverseNeg1() {
-		byte aBytes[] = {15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
-		byte mBytes[] = {2, 122, 45, 36, 100};
-		int aSign = -1;
-		int mSign = 1;		
-		byte rBytes[] = {0, -41, 4, -91, 27};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger modulus = new BigInteger(mSign, mBytes);
-		BigInteger result = aNumber.modInverse(modulus);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-	/**
-	 * modInverse: negative number (another case: x < 0)
-	 */
-	public void testmodInverseNeg2() {
-		byte aBytes[] = {-15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		byte mBytes[] = {122, 2, 4, 122, 2, 4};
-		byte rBytes[] = {85, 47, 127, 4, -128, 45};
-		BigInteger aNumber = new BigInteger(aBytes);
-		BigInteger modulus = new BigInteger(mBytes);
-		BigInteger result = aNumber.modInverse(modulus);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-	
-	/**
-	 * gcd: the second number is zero
-	 */
-	public void testGcdSecondZero() {
-		byte aBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		byte bBytes[] = {0};
-		int aSign = 1;
-		int bSign = 1;
-		byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger bNumber = new BigInteger(bSign, bBytes);
-		BigInteger result = aNumber.gcd(bNumber);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-	/**
-	 * gcd: the first number is zero
-	 */
-	public void testGcdFirstZero() {
-		byte aBytes[] = {0};
-		byte bBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		int aSign = 1;
-		int bSign = 1;
-		byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger bNumber = new BigInteger(bSign, bBytes);
-		BigInteger result = aNumber.gcd(bNumber);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-	
-	/**
-	 * gcd: the first number is ZERO
-	 */
-	public void testGcdFirstZERO() {
-		byte bBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		int bSign = 1;
-		byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
-		BigInteger aNumber = BigInteger.ZERO;
-		BigInteger bNumber = new BigInteger(bSign, bBytes);
-		BigInteger result = aNumber.gcd(bNumber);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-	/**
-	 * gcd: both numbers are zeros
-	 */
-	public void testGcdBothZeros() {
-		byte rBytes[] = {0};
-		BigInteger aNumber = new BigInteger("0");
-		BigInteger bNumber = BigInteger.valueOf(0L);
-		BigInteger result = aNumber.gcd(bNumber);
-		byte resBytes[] = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 0, result.signum());
-	}
-
-	/**
-	 * gcd: the first number is longer
-	 */
-	public void testGcdFirstLonger() {
-		byte aBytes[] = {-15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
-		byte bBytes[] = {-12, 1, 0, 0, 0, 23, 44, 55, 66};
-		int aSign = 1;
-		int bSign = 1;
-		byte rBytes[] = {7};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger bNumber = new BigInteger(bSign, bBytes);
-		BigInteger result = aNumber.gcd(bNumber);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-
-	/**
-	 * gcd: the second number is longer
-	 */
-	public void testGcdSecondLonger() {
-		byte aBytes[] = {-12, 1, 0, 0, 0, 23, 44, 55, 66};
-		byte bBytes[] = {-15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
-		int aSign = 1;
-		int bSign = 1;
-		byte rBytes[] = {7};
-		BigInteger aNumber = new BigInteger(aSign, aBytes);
-		BigInteger bNumber = new BigInteger(bSign, bBytes);
-		BigInteger result = aNumber.gcd(bNumber);
-		byte resBytes[] = new byte[rBytes.length];
-		resBytes = result.toByteArray();
-		for(int i = 0; i < resBytes.length; i++) {
-			assertTrue(resBytes[i] == rBytes[i]);
-		}
-		assertEquals("incorrect sign", 1, result.signum());
-	}
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerMultiplyTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerMultiplyTest.java
deleted file mode 100644
index 0bfcbf0..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerMultiplyTest.java
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Method: multiply 
- */
-public class BigIntegerMultiplyTest extends TestCase {
-    /**
-     * Multiply two negative numbers of the same length
-     */
-    public void testCase1() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {10, 40, 100, -55, 96, 51, 76, 40, -45, 85, 105, 4, 28, -86, -117, -52, 100, 120, 90};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Multiply two numbers of the same length and different signs.
-     * The first is negative.
-     */
-    public void testCase2() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-11, -41, -101, 54, -97, -52, -77, -41, 44, -86, -106, -5, -29, 85, 116, 51, -101, -121, -90};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Multiply two positive numbers of different length.
-     * The first is longer.
-     */
-    public void testCase3() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {10, 40, 100, -55, 96, 51, 76, 40, -45, 85, 115, 44, -127, 
-                         115, -21, -62, -15, 85, 64, -87, -2, -36, -36, -106};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Multiply two positive numbers of different length.
-     * The second is longer.
-     */
-    public void testCase4() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {10, 40, 100, -55, 96, 51, 76, 40, -45, 85, 115, 44, -127, 
-                         115, -21, -62, -15, 85, 64, -87, -2, -36, -36, -106};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Multiply two numbers of different length and different signs.
-     * The first is positive.
-     * The first is longer.
-     */
-    public void testCase5() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-11, -41, -101, 54, -97, -52, -77, -41, 44, -86, -116, -45, 126,
-                         -116, 20, 61, 14, -86, -65, 86, 1, 35, 35, 106};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Multiply two numbers of different length and different signs.
-     * The first is positive.
-     * The second is longer.
-     */
-    public void testCase6() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-11, -41, -101, 54, -97, -52, -77, -41, 44, -86, -116, -45, 126,
-                         -116, 20, 61, 14, -86, -65, 86, 1, 35, 35, 106};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Multiply a number by zero.
-     */
-    public void testCase7() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        byte bBytes[] = {0};
-        int aSign = 1;
-        int bSign = 0;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Multiply a number by ZERO.
-     */
-    public void testCase8() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        int aSign = 1;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Multiply a positive number by ONE.
-     */
-    public void testCase9() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        int aSign = 1;
-        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Multiply a negative number by ONE.
-     */
-    public void testCase10() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
-        int aSign = -1;
-        byte rBytes[] = {-2, -3, -4, -5, -6, -7, -8, -2, -3, -4, -2, -3, -4, -5, -5};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * Multiply two numbers of 4 bytes length.
-     */
-    public void testIntbyInt1() {
-        byte aBytes[] = {10, 20, 30, 40};
-        byte bBytes[] = {1, 2, 3, 4};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-11, -41, -101, 55, 5, 15, 96};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * Multiply two numbers of 4 bytes length.
-     */
-    public void testIntbyInt2() {
-        byte aBytes[] = {-1, -1, -1, -1};
-        byte bBytes[] = {-1, -1, -1, -1};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -1, -1, -1, -2, 0, 0, 0, 1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.multiply(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * Negative exponent.
-     */
-    public void testPowException() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        int exp = -5;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        try {
-            aNumber.pow(exp);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * Exponentiation of a negative number to an odd exponent.
-     */
-    public void testPowNegativeNumToOddExp() {
-        byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
-        int aSign = -1;
-        int exp = 5;
-        byte rBytes[] = {-21, -94, -42, -15, -127, 113, -50, -88, 115, -35, 3,
-            59, -92, 111, -75, 103, -42, 41, 34, -114, 99, -32, 105, -59, 127,
-            45, 108, 74, -93, 105, 33, 12, -5, -20, 17, -21, -119, -127, -115,
-            27, -122, 26, -67, 109, -125, 16, 91, -70, 109};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.pow(exp);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Exponentiation of a negative number to an even exponent.
-     */
-    public void testPowNegativeNumToEvenExp() {
-        byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
-        int aSign = -1;
-        int exp = 4;
-        byte rBytes[] = {102, 107, -122, -43, -52, -20, -27, 25, -9, 88, -13,
-            75, 78, 81, -33, -77, 39, 27, -37, 106, 121, -73, 108, -47, -101,
-            80, -25, 71, 13, 94, -7, -33, 1, -17, -65, -70, -61, -3, -47};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.pow(exp);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Exponentiation of a negative number to zero exponent.
-     */
-    public void testPowNegativeNumToZeroExp() {
-        byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
-        int aSign = -1;
-        int exp = 0;
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.pow(exp);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Exponentiation of a positive number.
-     */
-    public void testPowPositiveNum() {
-        byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
-        int aSign = 1;
-        int exp = 5;
-        byte rBytes[] = {20, 93, 41, 14, 126, -114, 49, 87, -116, 34, -4, -60,
-            91, -112, 74, -104, 41, -42, -35, 113, -100, 31, -106, 58, -128,
-            -46, -109, -75, 92, -106, -34, -13, 4, 19, -18, 20, 118, 126, 114,
-            -28, 121, -27, 66, -110, 124, -17, -92, 69, -109};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.pow(exp);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Exponentiation of a negative number to zero exponent.
-     */
-    public void testPowPositiveNumToZeroExp() {
-        byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
-        int aSign = 1;
-        int exp = 0;
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.pow(exp);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerNotTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerNotTest.java
deleted file mode 100644
index 615afc1..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerNotTest.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Methods: and, andNot
- */
-public class BigIntegerNotTest extends TestCase {
-    /**
-     * andNot for two positive numbers; the first is longer
-     */
-    public void testAndNotPosPosFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -96};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.andNot(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * andNot for two positive numbers; the first is shorter
-     */
-    public void testAndNotPosPosFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.andNot(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * andNot for two negative numbers; the first is longer
-     */
-    public void testAndNotNegNegFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 2};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.andNot(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * andNot for a negative and a positive numbers; the first is longer
-     */
-    public void testNegPosFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 72};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.andNot(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Not for ZERO 
-     */
-    public void testNotZero() {
-        byte rBytes[] = {-1};
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.not();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Not for ONE
-     */
-    public void testNotOne() {
-        byte rBytes[] = {-2};
-        BigInteger aNumber = BigInteger.ONE;
-        BigInteger result = aNumber.not();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Not for a positive number
-     */
-    public void testNotPos() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        int aSign = 1;
-        byte rBytes[] = {-1, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -27, 116};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.not();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Not for a negative number
-     */
-    public void testNotNeg() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        int aSign = -1;
-        byte rBytes[] = {0, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -118};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.not();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Not for a negative number
-     */
-
-    public void testNotSpecialCase() {
-        byte aBytes[] = {-1, -1, -1, -1};
-        int aSign = 1;
-        byte rBytes[] = {-1, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.not();
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-}
\ No newline at end of file
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOperateBitsTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOperateBitsTest.java
deleted file mode 100644
index 9b7c198..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOperateBitsTest.java
+++ /dev/null
@@ -1,1375 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:   java.math.BigInteger
- * Methods: bitLength, shiftLeft, shiftRight,
- * clearBit, flipBit, setBit, testBit
- */
-public class BigIntegerOperateBitsTest extends TestCase {
-    /**
-     * bitCount() of zero.
-     */
-    public void testBitCountZero() {
-        BigInteger aNumber = new BigInteger("0");
-        assertEquals(0, aNumber.bitCount());
-    }
-
-    /**
-     * bitCount() of a negative number.
-     */
-    public void testBitCountNeg() {
-        BigInteger aNumber = new BigInteger("-12378634756382937873487638746283767238657872368748726875");
-        assertEquals(87, aNumber.bitCount());
-    }
-
-    /**
-     * bitCount() of a negative number.
-     */
-    public void testBitCountPos() {
-        BigInteger aNumber = new BigInteger("12378634756343564757582937873487638746283767238657872368748726875");
-        assertEquals(107, aNumber.bitCount());
-    }
-
-    /**
-     * bitLength() of zero.
-     */
-    public void testBitLengthZero() {
-        BigInteger aNumber = new BigInteger("0");
-        assertEquals(0, aNumber.bitLength());
-    }
-
-    /**
-     * bitLength() of a positive number.
-     */
-    public void testBitLengthPositive1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals(108, aNumber.bitLength());
-    }
-
-    /**
-     * bitLength() of a positive number with the leftmost bit set
-     */
-    public void testBitLengthPositive2() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals(96, aNumber.bitLength());
-    }
-
-    /**
-     * bitLength() of a positive number which is a power of 2
-     */
-    public void testBitLengthPositive3() {
-        byte aBytes[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals(81, aNumber.bitLength());
-    }
-
-    /**
-     * bitLength() of a negative number.
-     */
-    public void testBitLengthNegative1() {
-        byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
-        int aSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals(108, aNumber.bitLength());
-    }
-
-    /**
-     * bitLength() of a negative number with the leftmost bit set
-     */
-    public void testBitLengthNegative2() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals(96, aNumber.bitLength());
-    }
-    
-    /**
-     * bitLength() of a negative number which is a power of 2
-     */
-    public void testBitLengthNegative3() {
-        byte aBytes[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertEquals(80, aNumber.bitLength());
-    }
-
-    /**
-     * clearBit(int n) of a negative n
-     */
-    public void testClearBitException() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = -7;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        try {
-            aNumber.clearBit(number);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * clearBit(int n) outside zero
-     */
-    public void testClearBitZero() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 0;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * clearBit(int n) outside zero
-     */
-    public void testClearBitZeroOutside1() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 95;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a negative number
-     */
-    public void testClearBitNegativeInside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 15;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, 92, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a negative number
-     */
-    public void testClearBitNegativeInside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 44;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -62, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * clearBit(2) in the negative number with all ones in bit representation
-     */
-    public void testClearBitNegativeInside3() {
-        String as = "-18446744073709551615";
-        int number = 2;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.clearBit(number);
-        assertEquals(as, result.toString());
-    }
-
-    /**
-     * clearBit(0) in the negative number of length 1
-     * with all ones in bit representation.
-     * the resulting number's length is 2.
-     */
-    public void testClearBitNegativeInside4() {
-        String as = "-4294967295";
-        String res = "-4294967296";
-        int number = 0;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.clearBit(number);
-        assertEquals(res, result.toString());
-    }
-
-    /**
-     * clearBit(0) in the negative number of length 2
-     * with all ones in bit representation.
-     * the resulting number's length is 3.
-     */
-    public void testClearBitNegativeInside5() {
-        String as = "-18446744073709551615";
-        String res = "-18446744073709551616";
-        int number = 0;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.clearBit(number);
-        assertEquals(res, result.toString());
-    }
-
-    /**
-     * clearBit(int n) outside a negative number
-     */
-    public void testClearBitNegativeOutside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 150;
-        byte rBytes[] = {-65, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) outside a negative number
-     */
-    public void testClearBitNegativeOutside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 165;
-        byte rBytes[] = {-33, -1, -1, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a positive number
-     */
-    public void testClearBitPositiveInside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 20;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -31, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a positive number
-     */
-    public void testClearBitPositiveInside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 17;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a positive number
-     */
-    public void testClearBitPositiveInside3() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 45;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 13, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a positive number
-     */
-    public void testClearBitPositiveInside4 () {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 50;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) inside a positive number
-     */
-    public void testClearBitPositiveInside5 () {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 63;
-        byte rBytes[] = {1, -128, 56, 100, -2, 52, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) outside a positive number
-     */
-    public void testClearBitPositiveOutside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 150;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) outside a positive number
-     */
-    public void testClearBitPositiveOutside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 191;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * clearBit(int n) the leftmost bit in a negative number
-     */
-    public void testClearBitTopNegative() {
-        byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
-        int aSign = -1;
-        int number = 63;
-        byte rBytes[] = {-1, 127, -2, 127, -57, -101, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.clearBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) of a negative n
-     */
-    public void testFlipBitException() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = -7;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        try {
-            aNumber.flipBit(number);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * flipBit(int n) zero
-     */
-    public void testFlipBitZero() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 0;
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) outside zero
-     */
-    public void testFlipBitZeroOutside1() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 62;
-        byte rBytes[] = {64, 0, 0, 0, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue("incorrect value", resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) outside zero
-     */
-    public void testFlipBitZeroOutside2() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 63;
-        byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue("incorrect value", resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) the leftmost bit in a negative number
-     */
-    public void testFlipBitLeftmostNegative() {
-        byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
-        int aSign = -1;
-        int number = 48;
-        byte rBytes[] = {-1, 127, -57, -101, 14, -36, -26, 49};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * flipBit(int n) the leftmost bit in a positive number
-     */
-    public void testFlipBitLeftmostPositive() {
-        byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
-        int aSign = 1;
-        int number = 48;
-        byte rBytes[] = {0, -128, 56, 100, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) inside a negative number
-     */
-    public void testFlipBitNegativeInside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 15;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, 92, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) inside a negative number
-     */
-    public void testFlipBitNegativeInside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 45;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -14, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) inside a negative number with all ones in bit representation 
-     */
-    public void testFlipBitNegativeInside3() {
-        String as = "-18446744073709551615";
-        String res = "-18446744073709551611";
-        int number = 2;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.flipBit(number);
-        assertEquals(res, result.toString());
-    }
-
-    /**
-     * flipBit(0) in the negative number of length 1
-     * with all ones in bit representation.
-     * the resulting number's length is 2.
-     */
-    public void testFlipBitNegativeInside4() {
-        String as = "-4294967295";
-        String res = "-4294967296";
-        int number = 0;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.flipBit(number);
-        assertEquals(res, result.toString());
-    }
-
-    /**
-     * flipBit(0) in the negative number of length 2
-     * with all ones in bit representation.
-     * the resulting number's length is 3.
-     */
-    public void testFlipBitNegativeInside5() {
-        String as = "-18446744073709551615";
-        String res = "-18446744073709551616";
-        int number = 0;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.flipBit(number);
-        assertEquals(res, result.toString());
-    }
-
-    /**
-     * flipBit(int n) outside a negative number
-     */
-    public void testFlipBitNegativeOutside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 150;
-        byte rBytes[] = {-65, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * flipBit(int n) outside a negative number
-     */
-    public void testFlipBitNegativeOutside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 191;
-        byte rBytes[] = {-1, 127, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * flipBit(int n) inside a positive number
-     */
-    public void testFlipBitPositiveInside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 15;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, -93, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) inside a positive number
-     */
-    public void testFlipBitPositiveInside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 45;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 13, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) outside a positive number
-     */
-    public void testFlipBitPositiveOutside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 150;
-        byte rBytes[] = {64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * flipBit(int n) outside a positive number
-     */
-    public void testFlipBitPositiveOutside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 191;
-        byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.flipBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) of a negative n
-     */
-    public void testSetBitException() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = -7;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        try {
-            aNumber.setBit(number);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * setBit(int n) outside zero
-     */
-    public void testSetBitZero() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 0;
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) outside zero
-     */
-    public void testSetBitZeroOutside1() {
-        byte aBytes[] = {0};
-        int aSign = 0;
-        int number = 95;
-        byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) inside a positive number
-     */
-    public void testSetBitPositiveInside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 20;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) inside a positive number
-     */
-    public void testSetBitPositiveInside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 17;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -13, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) inside a positive number
-     */
-    public void testSetBitPositiveInside3() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 45;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) inside a positive number
-     */
-    public void testSetBitPositiveInside4 () {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 50;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 93, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) outside a positive number
-     */
-    public void testSetBitPositiveOutside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 150;
-        byte rBytes[] = {64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) outside a positive number
-     */
-    public void testSetBitPositiveOutside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 223;
-        byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) the leftmost bit in a positive number
-     */
-    public void testSetBitTopPositive() {
-        byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
-        int aSign = 1;
-        int number = 63;
-        byte rBytes[] = {0, -128, 1, -128, 56, 100, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * setBit(int n) the leftmost bit in a negative number
-     */
-    public void testSetBitLeftmostNegative() {
-        byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
-        int aSign = -1;
-        int number = 48;
-        byte rBytes[] = {-1, 127, -57, -101, 14, -36, -26, 49};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * setBit(int n) inside a negative number
-     */
-    public void testSetBitNegativeInside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 15;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * setBit(int n) inside a negative number
-     */
-    public void testSetBitNegativeInside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 44;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * setBit(int n) inside a negative number with all ones in bit representation
-     */
-    public void testSetBitNegativeInside3() {
-        String as = "-18446744073709551615";
-        String res = "-18446744073709551611";
-        int number = 2;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.setBit(number);
-        assertEquals(res, result.toString());
-    }
-
-    /**
-     * setBit(0) in the negative number of length 1
-     * with all ones in bit representation.
-     * the resulting number's length is 2.
-     */
-    public void testSetBitNegativeInside4() {
-        String as = "-4294967295";
-        int number = 0;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.setBit(number);
-        assertEquals(as, result.toString());
-    }
-
-    /**
-     * setBit(0) in the negative number of length 2
-     * with all ones in bit representation.
-     * the resulting number's length is 3.
-     */
-    public void testSetBitNegativeInside5() {
-        String as = "-18446744073709551615";
-        int number = 0;
-        BigInteger aNumber = new BigInteger(as);
-        BigInteger result = aNumber.setBit(number);
-        assertEquals(as, result.toString());
-    }
-
-    /**
-     * setBit(int n) outside a negative number
-     */
-    public void testSetBitNegativeOutside1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 150;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * setBit(int n) outside a negative number
-     */
-    public void testSetBitNegativeOutside2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 191;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.setBit(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * setBit: check the case when the number of bit to be set can be
-     * represented as n * 32 + 31, where n is an arbitrary integer.
-     * Here 191 = 5 * 32 + 31 
-     */
-    public void testSetBitBug1331() {
-        BigInteger result = BigInteger.valueOf(0L).setBit(191);
-        assertEquals("incorrect value", "3138550867693340381917894711603833208051177722232017256448", result.toString());
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * shiftLeft(int n), n = 0
-     */
-    public void testShiftLeft1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 0;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftLeft(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * shiftLeft(int n), n < 0
-     */
-    public void testShiftLeft2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = -27;
-        byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftLeft(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * shiftLeft(int n) a positive number, n > 0
-     */
-    public void testShiftLeft3() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 27;
-        byte rBytes[] = {12, 1, -61, 39, -11, -94, -55, 106, -40, 31, -119, 24, -48, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftLeft(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * shiftLeft(int n) a positive number, n > 0
-     */
-    public void testShiftLeft4() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 45;
-        byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96, 126, 36, 99, 64, 0, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftLeft(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * shiftLeft(int n) a negative number, n > 0
-     */
-    public void testShiftLeft5() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 45;
-        byte rBytes[] = {-49, -8, -13, 96, 41, 116, -38, 84, -97, -127, -37, -100, -64, 0, 0, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftLeft(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    /**
-     * shiftRight(int n), n = 0
-     */
-    public void testShiftRight1() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 0;
-        byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * shiftRight(int n), n < 0
-     */
-    public void testShiftRight2() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = -27;
-        byte rBytes[] = {12, 1, -61, 39, -11, -94, -55, 106, -40, 31, -119, 24, -48, 0, 0, 0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * shiftRight(int n), 0 < n < 32
-     */
-    public void testShiftRight3() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 27;
-        byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-    
-    /**
-     * shiftRight(int n), n > 32
-     */
-    public void testShiftRight4() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 45;
-        byte rBytes[] = {12, 1, -61, 39, -11, -94, -55};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * shiftRight(int n), n is greater than bitLength()
-     */
-    public void testShiftRight5() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 300;
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-    
-    /**
-     * shiftRight a negative number;
-     * shift distance is multiple of 32;
-     * shifted bits are NOT zeroes. 
-     */
-    public void testShiftRightNegNonZeroesMul32() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 1, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = -1;
-        int number = 64;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * shiftRight a negative number;
-     * shift distance is NOT multiple of 32;
-     * shifted bits are NOT zeroes. 
-     */
-    public void testShiftRightNegNonZeroes() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = -1;
-        int number = 68;
-        byte rBytes[] = {-25, -4, 121, -80, 20, -70, 109, 42};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * shiftRight a negative number;
-     * shift distance is NOT multiple of 32;
-     * shifted bits are zeroes. 
-     */
-    public void testShiftRightNegZeroes() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = -1;
-        int number = 68;
-        byte rBytes[] = {-25, -4, 121, -80, 20, -70, 109, 48};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * shiftRight a negative number;
-     * shift distance is multiple of 32;
-     * shifted bits are zeroes. 
-     */
-    public void testShiftRightNegZeroesMul32() {
-        byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0};
-        int aSign = -1;
-        int number = 64;
-        byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -91};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger result = aNumber.shiftRight(number);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * testBit(int n) of a negative n
-     */
-    public void testTestBitException() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = -7;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        try {
-            aNumber.testBit(number);
-            fail("ArithmeticException has not been caught");
-        } catch (ArithmeticException e) {
-        }
-    }
-
-    /**
-     * testBit(int n) of a positive number
-     */
-    public void testTestBitPositive1() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 7;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertTrue(!aNumber.testBit(number));
-    }
-
-    /**
-     * testBit(int n) of a positive number
-     */
-    public void testTestBitPositive2() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 45;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertTrue(aNumber.testBit(number));
-    }
-    
-    /**
-     * testBit(int n) of a positive number, n > bitLength()
-     */
-    public void testTestBitPositive3() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = 1;
-        int number = 300;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertTrue(!aNumber.testBit(number));
-    }
-
-    /**
-     * testBit(int n) of a negative number
-     */
-    public void testTestBitNegative1() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 7;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertTrue(aNumber.testBit(number));
-    }
-
-    /**
-     * testBit(int n) of a positive n
-     */
-    public void testTestBitNegative2() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 45;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertTrue(!aNumber.testBit(number));
-    }
-    
-    /**
-     * testBit(int n) of a positive n, n > bitLength()
-     */
-    public void testTestBitNegative3() {
-        byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
-        int aSign = -1;
-        int number = 300;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        assertTrue(aNumber.testBit(number));
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOrTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOrTest.java
deleted file mode 100644
index 3509643..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOrTest.java
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Method: or 
- */
-public class BigIntegerOrTest extends TestCase {
-    /**
-     * Or for zero and a positive number
-     */
-    public void testZeroPos() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 0;
-        int bSign = 1;        
-        byte rBytes[] = {0, -2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for zero and a negative number
-     */
-    public void testZeroNeg() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 0;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for a positive number and zero 
-     */
-    public void testPosZero() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {0};
-        int aSign = 1;
-        int bSign = 0;        
-        byte rBytes[] = {0, -2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for a negative number and zero  
-     */
-    public void testNegPos() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {0};
-        int aSign = -1;
-        int bSign = 0;        
-        byte rBytes[] = {-1, 1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for zero and zero
-     */
-    public void testZeroZero() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {0};
-        int aSign = 0;
-        int bSign = 0;        
-        byte rBytes[] = {0};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 0, result.signum());
-    }
-
-    /**
-     * Or for zero and one
-     */
-    public void testZeroOne() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {1};
-        int aSign = 0;
-        int bSign = 1;        
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for one and one
-     */
-    public void testOneOne() {
-        byte aBytes[] = {1};
-        byte bBytes[] = {1};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {1};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for two positive numbers of the same length
-     */
-    public void testPosPosSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -2, -3, -4, -4, -1, -66, 95, 47, 123, 59, -13, 39, 30, -97};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for two positive numbers; the first is longer
-     */
-    public void testPosPosFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -128, 9, 56, 100, -2, -3, -3, -3, 95, 15, -9, 39, 58, -69, 87, 87, -17, -73};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for two positive numbers; the first is shorter
-     */
-    public void testPosPosFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {0, -128, 9, 56, 100, -2, -3, -3, -3, 95, 15, -9, 39, 58, -69, 87, 87, -17, -73};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", 1, result.signum());
-    }
-
-    /**
-     * Or for two negative numbers of the same length
-     */
-    public void testNegNegSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 127, -57, -101, -5, -5, -18, -38, -17, -2, -65, -2, -11, -3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for two negative numbers; the first is longer
-     */
-    public void testNegNegFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 1, 75, -89, -45, -2, -3, -18, -36, -17, -10, -3, -6, -7, -21};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for two negative numbers; the first is shorter
-     */
-    public void testNegNegFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 1, 75, -89, -45, -2, -3, -18, -36, -17, -10, -3, -6, -7, -21};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for two numbers of different signs and the same length
-     */
-    public void testPosNegSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 1, -126, 59, 103, -2, -11, -7, -3, -33, -57, -3, -5, -5, -21};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for two numbers of different signs and the same length
-     */
-    public void testNegPosSameLength() {
-        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-1, 5, 79, -73, -9, -76, -3, 78, -35, -17, 119};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for a negative and a positive numbers; the first is longer
-     */
-    public void testNegPosFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-1, 127, -10, -57, -101, -1, -1, -2, -2, -91, -2, 31, -1, -11, 125, -22, -83, 30, 95};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for two negative numbers; the first is shorter
-     */
-    public void testNegPosFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-74, 91, 47, -5, -13, -7, -5, -33, -49, -65, -1, -9, -3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for a positive and a negative numbers; the first is longer
-     */
-    public void testPosNegFirstLonger() {
-        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-74, 91, 47, -5, -13, -7, -5, -33, -49, -65, -1, -9, -3};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-
-    /**
-     * Or for a positive and a negative number; the first is shorter
-     */
-    public void testPosNegFirstShorter() {
-        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {-1, 127, -10, -57, -101, -1, -1, -2, -2, -91, -2, 31, -1, -11, 125, -22, -83, 30, 95};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.or(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals("incorrect sign", -1, result.signum());
-    }
-    
-    public void testRegression() {
-        // Regression test for HARMONY-1996
-        BigInteger x = new BigInteger("-1023");
-        BigInteger r1 = x.and((BigInteger.ZERO.not()).shiftLeft(32));
-        BigInteger r3 = x.and((BigInteger.ZERO.not().shiftLeft(32) ).not());
-        BigInteger result = r1.or(r3);
-        assertEquals(x, result);
-    } 
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerSubtractTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerSubtractTest.java
deleted file mode 100644
index aaddd39..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerSubtractTest.java
+++ /dev/null
@@ -1,547 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Method: subtract 
- */
-public class BigIntegerSubtractTest extends TestCase {
-    /**
-     * Subtract two positive numbers of the same length.
-     * The first is greater.
-     */
-    public void testCase1() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {9, 18, 27, 36, 45, 54, 63, 9, 18, 27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract two positive numbers of the same length.
-     * The second is greater.
-     */
-    public void testCase2() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {-10, -19, -28, -37, -46, -55, -64, -10, -19, -27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of the same length and different signs.
-     * The first is positive.
-     * The first is greater in absolute value.
-     */
-    public void testCase3() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of the same length and different signs.
-     * The first is positive.
-     * The second is greater in absolute value.
-     */
-    public void testCase4() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract two negative numbers of the same length.
-     * The first is greater in absolute value.
-     */
-    public void testCase5() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-10, -19, -28, -37, -46, -55, -64, -10, -19, -27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-
-    /**
-     * Subtract two negative numbers of the same length.
-     * The second is greater in absolute value.
-     */
-    public void testCase6() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {9, 18, 27, 36, 45, 54, 63, 9, 18, 27};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of the same length and different signs.
-     * The first is negative.
-     * The first is greater in absolute value.
-     */
-    public void testCase7() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of the same length and different signs.
-     * The first is negative.
-     * The second is greater in absolute value.
-     */
-    public void testCase8() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-    
-    /**
-     * Subtract two positive numbers of different length.
-     * The first is longer.
-     */
-    public void testCase9() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-    
-    /**
-     * Subtract two positive numbers of different length.
-     * The second is longer.
-     */
-    public void testCase10() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of different length and different signs.
-     * The first is positive.
-     * The first is greater in absolute value.
-     */
-    public void testCase11() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of the same length and different signs.
-     * The first is positive.
-     * The second is greater in absolute value.
-     */
-    public void testCase12() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        int aSign = 1;
-        int bSign = -1;        
-        byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-    
-    /**
-     * Subtract two numbers of different length and different signs.
-     * The first is negative.
-     * The first is longer.
-     */
-    public void testCase13() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-
-    /**
-     * Subtract two numbers of the same length and different signs.
-     * The first is negative.
-     * The second is longer.
-     */
-    public void testCase14() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = 1;        
-        byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-
-    /**
-     * Subtract two negative numbers of different length.
-     * The first is longer.
-     */
-    public void testCase15() {
-        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-}
-    
-    /**
-     * Subtract two negative numbers of different length.
-     * The second is longer.
-     */
-    public void testCase16() {
-        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
-        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
-        int aSign = -1;
-        int bSign = -1;        
-        byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-    
-    /**
-     * Subtract two positive equal in absolute value numbers.
-     */
-    public void testCase17() {
-        byte aBytes[] = {-120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        byte bBytes[] = {-120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        byte rBytes[] = {0};
-        int aSign = 1;
-        int bSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(0, result.signum());
-    }
-
-    /**
-     * Subtract zero from a number.
-     * The number is positive.
-     */
-    public void testCase18() {
-        byte aBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        byte bBytes[] = {0};
-        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        int aSign = 1;
-        int bSign = 0;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract a number from zero.
-     * The number is negative.
-     */
-    public void testCase19() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        int aSign = 0;
-        int bSign = -1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract zero from zero.
-     */
-    public void testCase20() {
-        byte aBytes[] = {0};
-        byte bBytes[] = {0};
-        byte rBytes[] = {0};
-        int aSign = 0;
-        int bSign = 0;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(0, result.signum());
-    }
-    
-    /**
-     * Subtract ZERO from a number.
-     * The number is positive.
-     */
-    public void testCase21() {
-        byte aBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        int aSign = 1;
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract a number from ZERO.
-     * The number is negative.
-     */
-    public void testCase22() {
-        byte bBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
-        int bSign = -1;
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(1, result.signum());
-    }
-
-    /**
-     * Subtract ZERO from ZERO.
-     */
-    public void testCase23() {
-        byte rBytes[] = {0};
-        BigInteger aNumber = BigInteger.ZERO;
-        BigInteger bNumber = BigInteger.ZERO;
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(0, result.signum());
-    }
-
-    /**
-     * Subtract ONE from ONE.
-     */
-    public void testCase24() {
-        byte rBytes[] = {0};
-        BigInteger aNumber = BigInteger.ONE;
-        BigInteger bNumber = BigInteger.ONE;
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(0, result.signum());
-    }
-
-    /**
-     * Subtract two numbers so that borrow is 1.
-     */
-    public void testCase25() {
-        byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
-        byte bBytes[] = {-128, -128, -128, -128, -128, -128, -128, -128, -128};
-        int aSign = 1;
-        int bSign = 1;        
-        byte rBytes[] = {-128, 127, 127, 127, 127, 127, 127, 127, 127};
-        BigInteger aNumber = new BigInteger(aSign, aBytes);
-        BigInteger bNumber = new BigInteger(bSign, bBytes);
-        BigInteger result = aNumber.subtract(bNumber);
-        byte resBytes[] = new byte[rBytes.length];
-        resBytes = result.toByteArray();
-        for(int i = 0; i < resBytes.length; i++) {
-            assertTrue(resBytes[i] == rBytes[i]);
-        }
-        assertEquals(-1, result.signum());
-    }
-}
-
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerToStringTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerToStringTest.java
deleted file mode 100644
index 3f20414..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerToStringTest.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import java.math.BigInteger;
-
-import junit.framework.TestCase;
-
-/**
- * Class:   java.math.BigInteger
- * Method: toString(int radix)
- */
-public class BigIntegerToStringTest extends TestCase {
-    /**
-     * If 36 < radix < 2 it should be set to 10
-     */
-    public void testRadixOutOfRange() {
-        String value = "442429234853876401";
-        int radix = 10;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(45);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test negative number of radix 2
-     */
-    public void testRadix2Neg() {
-        String value = "-101001100010010001001010101110000101010110001010010101010101010101010101010101010101010101010010101";
-        int radix = 2;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test positive number of radix 2
-     */
-    public void testRadix2Pos() {
-        String value = "101000011111000000110101010101010101010001001010101010101010010101010101010000100010010";
-        int radix = 2;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test negative number of radix 10
-     */
-    public void testRadix10Neg() {
-        String value = "-2489756308572364789878394872984";
-        int radix = 16;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test positive number of radix 10
-     */
-    public void testRadix10Pos() {
-        String value = "2387627892347567398736473476";
-        int radix = 16;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test negative number of radix 16
-     */
-    public void testRadix16Neg() {
-        String value = "-287628a883451b800865c67e8d7ff20";
-        int radix = 16;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test positive number of radix 16
-     */
-    public void testRadix16Pos() {
-        String value = "287628a883451b800865c67e8d7ff20";
-        int radix = 16;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test negative number of radix 24
-     */
-    public void testRadix24Neg() {
-        String value = "-287628a88gmn3451b8ijk00865c67e8d7ff20";
-        int radix = 24;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test positive number of radix 24
-     */
-    public void testRadix24Pos() {
-        String value = "287628a883451bg80ijhk0865c67e8d7ff20";
-        int radix = 24;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test negative number of radix 24
-     */
-    public void testRadix36Neg() {
-        String value = "-uhguweut98iu4h3478tq3985pq98yeiuth33485yq4aiuhalai485yiaehasdkr8tywi5uhslei8";
-        int radix = 36;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-
-    /**
-     * test positive number of radix 24
-     */
-    public void testRadix36Pos() {
-        String value = "23895lt45y6vhgliuwhgi45y845htsuerhsi4586ysuerhtsio5y68peruhgsil4568ypeorihtse48y6";
-        int radix = 36;
-        BigInteger aNumber = new BigInteger(value, radix);
-        String result = aNumber.toString(radix);
-        assertTrue(result.equals(value));
-    }
-}
diff --git a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerXorTest.java b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerXorTest.java
deleted file mode 100644
index 57ca78a..0000000
--- a/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerXorTest.java
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-/**
- * @author Elena Semukhina
- */
-
-package org.apache.harmony.tests.java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class:  java.math.BigInteger
- * Method: xor
- */
-public class BigIntegerXorTest extends TestCase {
-	/**
-     * Xor for zero and a positive number
-     */
-    public void testZeroPos() {
-        String numA = "0";
-        String numB = "27384627835298756289327365";
-        String res = "27384627835298756289327365";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for zero and a negative number
-     */
-    public void testZeroNeg() {
-        String numA = "0";
-        String numB = "-27384627835298756289327365";
-        String res = "-27384627835298756289327365";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for a positive number and zero 
-     */
-    public void testPosZero() {
-        String numA = "27384627835298756289327365";
-        String numB = "0";
-        String res = "27384627835298756289327365";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for a negative number and zero  
-     */
-    public void testNegPos() {
-        String numA = "-27384627835298756289327365";
-        String numB = "0";
-        String res = "-27384627835298756289327365";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for zero and zero
-     */
-    public void testZeroZero() {
-        String numA = "0";
-        String numB = "0";
-        String res = "0";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for zero and one
-     */
-    public void testZeroOne() {
-        String numA = "0";
-        String numB = "1";
-        String res = "1";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for one and one
-     */
-    public void testOneOne() {
-        String numA = "1";
-        String numB = "1";
-        String res = "0";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two positive numbers of the same length
-     */
-    public void testPosPosSameLength() {
-        String numA = "283746278342837476784564875684767";
-        String numB = "293478573489347658763745839457637";
-        String res = "71412358434940908477702819237626";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two positive numbers; the first is longer
-     */
-    public void testPosPosFirstLonger() {
-        String numA = "2837462783428374767845648748973847593874837948575684767";
-        String numB = "293478573489347658763745839457637";
-        String res = "2837462783428374767845615168483972194300564226167553530";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two positive numbers; the first is shorter
-     */
-    public void testPosPosFirstShorter() {
-        String numA = "293478573489347658763745839457637";
-        String numB = "2837462783428374767845648748973847593874837948575684767";
-        String res = "2837462783428374767845615168483972194300564226167553530";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two negative numbers of the same length
-     */
-    public void testNegNegSameLength() {
-        String numA = "-283746278342837476784564875684767";
-        String numB = "-293478573489347658763745839457637";
-        String res = "71412358434940908477702819237626";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two negative numbers; the first is longer
-     */
-    public void testNegNegFirstLonger() {
-        String numA = "-2837462783428374767845648748973847593874837948575684767";
-        String numB = "-293478573489347658763745839457637";
-        String res = "2837462783428374767845615168483972194300564226167553530";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two negative numbers; the first is shorter
-     */
-    public void testNegNegFirstShorter() {
-        String numA = "293478573489347658763745839457637";
-        String numB = "2837462783428374767845648748973847593874837948575684767";
-        String res = "2837462783428374767845615168483972194300564226167553530";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two numbers of different signs and the same length
-     */
-    public void testPosNegSameLength() {
-        String numA = "283746278342837476784564875684767";
-        String numB = "-293478573489347658763745839457637";
-        String res = "-71412358434940908477702819237628";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two numbers of different signs and the same length
-     */
-    public void testNegPosSameLength() {
-        String numA = "-283746278342837476784564875684767";
-        String numB = "293478573489347658763745839457637";
-        String res = "-71412358434940908477702819237628";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for a negative and a positive numbers; the first is longer
-     */
-    public void testNegPosFirstLonger() {
-        String numA = "-2837462783428374767845648748973847593874837948575684767";
-        String numB = "293478573489347658763745839457637";
-        String res = "-2837462783428374767845615168483972194300564226167553532";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for two negative numbers; the first is shorter
-     */
-    public void testNegPosFirstShorter() {
-        String numA = "-293478573489347658763745839457637";
-        String numB = "2837462783428374767845648748973847593874837948575684767";
-        String res = "-2837462783428374767845615168483972194300564226167553532";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for a positive and a negative numbers; the first is longer
-     */
-    public void testPosNegFirstLonger() {
-        String numA = "2837462783428374767845648748973847593874837948575684767";
-        String numB = "-293478573489347658763745839457637";
-        String res = "-2837462783428374767845615168483972194300564226167553532";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-
-    /**
-     * Xor for a positive and a negative number; the first is shorter
-     */
-    public void testPosNegFirstShorter() {
-        String numA = "293478573489347658763745839457637";
-        String numB = "-2837462783428374767845648748973847593874837948575684767";
-        String res = "-2837462783428374767845615168483972194300564226167553532";
-        BigInteger aNumber = new BigInteger(numA);
-        BigInteger bNumber = new BigInteger(numB);
-        BigInteger result = aNumber.xor(bNumber);
-        assertTrue(res.equals(result.toString()));
-    }
-}
diff --git a/math/src/test/java/tests/api/java/math/BigDecimalTest.java b/math/src/test/java/tests/api/java/math/BigDecimalTest.java
deleted file mode 100644
index 4fd27bf..0000000
--- a/math/src/test/java/tests/api/java/math/BigDecimalTest.java
+++ /dev/null
@@ -1,952 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-package tests.api.java.math;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-
-public class BigDecimalTest extends junit.framework.TestCase {
-	BigInteger value = new BigInteger("12345908");
-
-	BigInteger value2 = new BigInteger("12334560000");
-
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(java.math.BigInteger)
-	 */
-	public void test_ConstructorLjava_math_BigInteger() {
-		BigDecimal big = new BigDecimal(value);
-		assertTrue("the BigDecimal value is not initialized properly", big
-				.unscaledValue().equals(value)
-				&& big.scale() == 0);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(java.math.BigInteger, int)
-	 */
-	public void test_ConstructorLjava_math_BigIntegerI() {
-		BigDecimal big = new BigDecimal(value2, 5);
-		assertTrue("the BigDecimal value is not initialized properly", big
-				.unscaledValue().equals(value2)
-				&& big.scale() == 5);
-		assertTrue("the BigDecimal value is not represented properly", big
-				.toString().equals("123345.60000"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(double)
-	 */
-	public void test_ConstructorD() {
-		BigDecimal big = new BigDecimal(123E04);
-		assertTrue(
-				"the BigDecimal value taking a double argument is not initialized properly",
-				big.toString().equals("1230000"));
-		big = new BigDecimal(1.2345E-12);
-		assertTrue("the double representation is not correct", big
-				.doubleValue() == 1.2345E-12);
-		big = new BigDecimal(-12345E-3);
-		assertTrue("the double representation is not correct", big
-				.doubleValue() == -12.345);
-		big = new BigDecimal(5.1234567897654321e138);
-		assertTrue("the double representation is not correct", big
-				.doubleValue() == 5.1234567897654321E138
-				&& big.scale() == 0);
-		big = new BigDecimal(0.1);
-		assertTrue(
-				"the double representation of 0.1 bigDecimal is not correct",
-				big.doubleValue() == 0.1);
-		big = new BigDecimal(0.00345);
-		assertTrue(
-				"the double representation of 0.00345 bigDecimal is not correct",
-				big.doubleValue() == 0.00345);
-        // regression test for HARMONY-2429
-        big = new BigDecimal(-0.0);
-        assertTrue(
-        		"the double representation of -0.0 bigDecimal is not correct",
-        		big.scale() == 0);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
-	 */
-	public void test_ConstructorLjava_lang_String() throws NumberFormatException {
-		BigDecimal big = new BigDecimal("345.23499600293850");
-		assertTrue("the BigDecimal value is not initialized properly", big
-				.toString().equals("345.23499600293850")
-				&& big.scale() == 14);
-		big = new BigDecimal("-12345");
-		assertTrue("the BigDecimal value is not initialized properly", big
-				.toString().equals("-12345")
-				&& big.scale() == 0);
-		big = new BigDecimal("123.");
-		assertTrue("the BigDecimal value is not initialized properly", big
-				.toString().equals("123")
-				&& big.scale() == 0);
-
-		new BigDecimal("1.234E02");
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
-	 */
-	public void test_constructor_String_plus_exp() {
-		/*
-		 * BigDecimal does not support a + sign in the exponent when converting
-		 * from a String
-		 */
-		new BigDecimal(+23e-0);
-		new BigDecimal(-23e+0);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
-	 */
-	public void test_constructor_String_empty() {
-		try {
-			new BigDecimal("");			
-            fail("NumberFormatException expected");
-		} catch (NumberFormatException e) {
-		}
-	}
-	
-	/**
-	 * @tests java.math.BigDecimal#BigDecimal(java.lang.String)
-	 */
-	public void test_constructor_String_plus_minus_exp() {
-		try {
-			new BigDecimal("+35e+-2");			
-            fail("NumberFormatException expected");
-		} catch (NumberFormatException e) {
-		}
-		
-		try {
-			new BigDecimal("-35e-+2");			
-            fail("NumberFormatException expected");
-		} catch (NumberFormatException e) {
-		}
-	}
-    
-    /**
-     * @tests java.math.BigDecimal#BigDecimal(char[])
-     */
-    public void test_constructor_CC_plus_minus_exp() {
-        try {
-            new BigDecimal("+35e+-2".toCharArray());          
-            fail("NumberFormatException expected");
-        } catch (NumberFormatException e) {
-        }
-        
-        try {
-            new BigDecimal("-35e-+2".toCharArray());          
-            fail("NumberFormatException expected");
-        } catch (NumberFormatException e) {
-        }
-    }
-
-	/**
-	 * @tests java.math.BigDecimal#abs()
-	 */
-	public void test_abs() {
-		BigDecimal big = new BigDecimal("-1234");
-		BigDecimal bigabs = big.abs();
-		assertTrue("the absolute value of -1234 is not 1234", bigabs.toString()
-				.equals("1234"));
-		big = new BigDecimal(new BigInteger("2345"), 2);
-		bigabs = big.abs();
-		assertTrue("the absolute value of 23.45 is not 23.45", bigabs
-				.toString().equals("23.45"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#add(java.math.BigDecimal)
-	 */
-	public void test_addLjava_math_BigDecimal() {
-		BigDecimal add1 = new BigDecimal("23.456");
-		BigDecimal add2 = new BigDecimal("3849.235");
-		BigDecimal sum = add1.add(add2);
-		assertTrue("the sum of 23.456 + 3849.235 is wrong", sum.unscaledValue()
-				.toString().equals("3872691")
-				&& sum.scale() == 3);
-		assertTrue("the sum of 23.456 + 3849.235 is not printed correctly", sum
-				.toString().equals("3872.691"));
-		BigDecimal add3 = new BigDecimal(12.34E02D);
-		assertTrue("the sum of 23.456 + 12.34E02 is not printed correctly",
-				(add1.add(add3)).toString().equals("1257.456"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#compareTo(java.math.BigDecimal)
-	 */
-	public void test_compareToLjava_math_BigDecimal() {
-		BigDecimal comp1 = new BigDecimal("1.00");
-		BigDecimal comp2 = new BigDecimal(1.000000D);
-		assertTrue("1.00 and 1.000000 should be equal",
-				comp1.compareTo(comp2) == 0);
-		BigDecimal comp3 = new BigDecimal("1.02");
-		assertTrue("1.02 should be bigger than 1.00",
-				comp3.compareTo(comp1) == 1);
-		BigDecimal comp4 = new BigDecimal(0.98D);
-		assertTrue("0.98 should be less than 1.00",
-				comp4.compareTo(comp1) == -1);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#divide(java.math.BigDecimal, int)
-	 */
-	public void test_divideLjava_math_BigDecimalI() {
-		BigDecimal divd1 = new BigDecimal(value, 2);
-		BigDecimal divd2 = new BigDecimal("2.335");
-		BigDecimal divd3 = divd1.divide(divd2, BigDecimal.ROUND_UP);
-		assertTrue("123459.08/2.335 is not correct", divd3.toString().equals(
-				"52873.27")
-				&& divd3.scale() == divd1.scale());
-		assertTrue(
-				"the unscaledValue representation of 123459.08/2.335 is not correct",
-				divd3.unscaledValue().toString().equals("5287327"));
-		divd2 = new BigDecimal(123.4D);
-		divd3 = divd1.divide(divd2, BigDecimal.ROUND_DOWN);
-		assertTrue("123459.08/123.4  is not correct", divd3.toString().equals(
-				"1000.47")
-				&& divd3.scale() == 2);
-		divd2 = new BigDecimal(000D);
-
-		try {
-			divd1.divide(divd2, BigDecimal.ROUND_DOWN);
-            fail("divide by zero is not caught");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#divide(java.math.BigDecimal, int, int)
-	 */
-	public void test_divideLjava_math_BigDecimalII() {
-		BigDecimal divd1 = new BigDecimal(value2, 4);
-		BigDecimal divd2 = new BigDecimal("0.0023");
-		BigDecimal divd3 = divd1.divide(divd2, 3, BigDecimal.ROUND_HALF_UP);
-		assertTrue("1233456/0.0023 is not correct", divd3.toString().equals(
-				"536285217.391")
-				&& divd3.scale() == 3);
-		divd2 = new BigDecimal(1345.5E-02D);
-		divd3 = divd1.divide(divd2, 0, BigDecimal.ROUND_DOWN);
-		assertTrue(
-				"1233456/13.455 is not correct or does not have the correct scale",
-				divd3.toString().equals("91672") && divd3.scale() == 0);
-		divd2 = new BigDecimal(0000D);
-
-		try {
-			divd1.divide(divd2, 4, BigDecimal.ROUND_DOWN);
-            fail("divide by zero is not caught");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#doubleValue()
-	 */
-	public void test_doubleValue() {
-		BigDecimal bigDB = new BigDecimal(-1.234E-112);
-//		Commenting out this part because it causes an endless loop (see HARMONY-319 and HARMONY-329)
-//		assertTrue(
-//				"the double representation of this BigDecimal is not correct",
-//				bigDB.doubleValue() == -1.234E-112);
-		bigDB = new BigDecimal(5.00E-324);
-		assertTrue("the double representation of bigDecimal is not correct",
-				bigDB.doubleValue() == 5.00E-324);
-		bigDB = new BigDecimal(1.79E308);
-		assertTrue("the double representation of bigDecimal is not correct",
-				bigDB.doubleValue() == 1.79E308 && bigDB.scale() == 0);
-		bigDB = new BigDecimal(-2.33E102);
-		assertTrue(
-				"the double representation of bigDecimal -2.33E102 is not correct",
-				bigDB.doubleValue() == -2.33E102 && bigDB.scale() == 0);
-		bigDB = new BigDecimal(Double.MAX_VALUE);
-		bigDB = bigDB.add(bigDB);
-		assertTrue(
-				"a  + number out of the double range should return infinity",
-				bigDB.doubleValue() == Double.POSITIVE_INFINITY);
-		bigDB = new BigDecimal(-Double.MAX_VALUE);
-		bigDB = bigDB.add(bigDB);
-		assertTrue(
-				"a  - number out of the double range should return neg infinity",
-				bigDB.doubleValue() == Double.NEGATIVE_INFINITY);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#equals(java.lang.Object)
-	 */
-	public void test_equalsLjava_lang_Object() {
-		BigDecimal equal1 = new BigDecimal(1.00D);
-		BigDecimal equal2 = new BigDecimal("1.0");
-		assertFalse("1.00 and 1.0 should not be equal",
-				equal1.equals(equal2));
-		equal2 = new BigDecimal(1.01D);
-		assertFalse("1.00 and 1.01 should not be equal",
-				equal1.equals(equal2));
-		equal2 = new BigDecimal("1.00");
-		assertFalse("1.00D and 1.00 should not be equal",
-				equal1.equals(equal2));
-		BigInteger val = new BigInteger("100");
-		equal1 = new BigDecimal("1.00");
-		equal2 = new BigDecimal(val, 2);
-		assertTrue("1.00(string) and 1.00(bigInteger) should be equal", equal1
-				.equals(equal2));
-		equal1 = new BigDecimal(100D);
-		equal2 = new BigDecimal("2.34576");
-		assertFalse("100D and 2.34576 should not be equal", equal1
-				.equals(equal2));
-		assertFalse("bigDecimal 100D does not equal string 23415", equal1
-				.equals("23415"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#floatValue()
-	 */
-	public void test_floatValue() {
-		BigDecimal fl1 = new BigDecimal("234563782344567");
-		assertTrue("the float representation of bigDecimal 234563782344567",
-				fl1.floatValue() == 234563782344567f);
-		BigDecimal fl2 = new BigDecimal(2.345E37);
-		assertTrue("the float representation of bigDecimal 2.345E37", fl2
-				.floatValue() == 2.345E37F);
-		fl2 = new BigDecimal(-1.00E-44);
-		assertTrue("the float representation of bigDecimal -1.00E-44", fl2
-				.floatValue() == -1.00E-44F);
-		fl2 = new BigDecimal(-3E12);
-		assertTrue("the float representation of bigDecimal -3E12", fl2
-				.floatValue() == -3E12F);
-		fl2 = new BigDecimal(Double.MAX_VALUE);
-		assertTrue(
-				"A number can't be represented by float should return infinity",
-				fl2.floatValue() == Float.POSITIVE_INFINITY);
-		fl2 = new BigDecimal(-Double.MAX_VALUE);
-		assertTrue(
-				"A number can't be represented by float should return infinity",
-				fl2.floatValue() == Float.NEGATIVE_INFINITY);
-
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#hashCode()
-	 */
-	public void test_hashCode() {
-		// anything that is equal must have the same hashCode
-		BigDecimal hash = new BigDecimal("1.00");
-		BigDecimal hash2 = new BigDecimal(1.00D);
-		assertTrue("the hashCode of 1.00 and 1.00D is equal",
-				hash.hashCode() != hash2.hashCode() && !hash.equals(hash2));
-		hash2 = new BigDecimal("1.0");
-		assertTrue("the hashCode of 1.0 and 1.00 is equal",
-				hash.hashCode() != hash2.hashCode() && !hash.equals(hash2));
-		BigInteger val = new BigInteger("100");
-		hash2 = new BigDecimal(val, 2);
-		assertTrue("hashCode of 1.00 and 1.00(bigInteger) is not equal", hash
-				.hashCode() == hash2.hashCode()
-				&& hash.equals(hash2));
-		hash = new BigDecimal(value, 2);
-		hash2 = new BigDecimal("-1233456.0000");
-		assertTrue("hashCode of 123459.08 and -1233456.0000 is not equal", hash
-				.hashCode() != hash2.hashCode()
-				&& !hash.equals(hash2));
-		hash2 = new BigDecimal(value.negate(), 2);
-		assertTrue("hashCode of 123459.08 and -123459.08 is not equal", hash
-				.hashCode() != hash2.hashCode()
-				&& !hash.equals(hash2));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#intValue()
-	 */
-	public void test_intValue() {
-		BigDecimal int1 = new BigDecimal(value, 3);
-		assertTrue("the int value of 12345.908 is not 12345",
-				int1.intValue() == 12345);
-		int1 = new BigDecimal("1.99");
-		assertTrue("the int value of 1.99 is not 1", int1.intValue() == 1);
-		int1 = new BigDecimal("23423419083091823091283933");
-		// ran JDK and found representation for the above was -249268259
-		assertTrue("the int value of 23423419083091823091283933 is wrong", int1
-				.intValue() == -249268259);
-		int1 = new BigDecimal(-1235D);
-		assertTrue("the int value of -1235 is not -1235",
-				int1.intValue() == -1235);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#longValue()
-	 */
-	public void test_longValue() {
-		BigDecimal long1 = new BigDecimal(value2.negate(), 0);
-		assertTrue("the long value of 12334560000 is not 12334560000", long1
-				.longValue() == -12334560000L);
-		long1 = new BigDecimal(-1345.348E-123D);
-		assertTrue("the long value of -1345.348E-123D is not zero", long1
-				.longValue() == 0);
-		long1 = new BigDecimal("31323423423419083091823091283933");
-		// ran JDK and found representation for the above was
-		// -5251313250005125155
-		assertTrue(
-				"the long value of 31323423423419083091823091283933 is wrong",
-				long1.longValue() == -5251313250005125155L);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#max(java.math.BigDecimal)
-	 */
-	public void test_maxLjava_math_BigDecimal() {
-		BigDecimal max1 = new BigDecimal(value2, 1);
-		BigDecimal max2 = new BigDecimal(value2, 4);
-		assertTrue("1233456000.0 is not greater than 1233456", max1.max(max2)
-				.equals(max1));
-		max1 = new BigDecimal(-1.224D);
-		max2 = new BigDecimal(-1.2245D);
-		assertTrue("-1.224 is not greater than -1.2245", max1.max(max2).equals(
-				max1));
-		max1 = new BigDecimal(123E18);
-		max2 = new BigDecimal(123E19);
-		assertTrue("123E19 is the not the max", max1.max(max2).equals(max2));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#min(java.math.BigDecimal)
-	 */
-	public void test_minLjava_math_BigDecimal() {
-		BigDecimal min1 = new BigDecimal(-12345.4D);
-		BigDecimal min2 = new BigDecimal(-12345.39D);
-		assertTrue("-12345.39 should have been returned", min1.min(min2)
-				.equals(min1));
-		min1 = new BigDecimal(value2, 5);
-		min2 = new BigDecimal(value2, 0);
-		assertTrue("123345.6 should have been returned", min1.min(min2).equals(
-				min1));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#movePointLeft(int)
-	 */
-	public void test_movePointLeftI() {
-		BigDecimal movePtLeft = new BigDecimal("123456265.34");
-		BigDecimal alreadyMoved = movePtLeft.movePointLeft(5);
-		assertTrue("move point left 5 failed", alreadyMoved.scale() == 7
-				&& alreadyMoved.toString().equals("1234.5626534"));
-		movePtLeft = new BigDecimal(value2.negate(), 0);
-		alreadyMoved = movePtLeft.movePointLeft(12);
-		assertTrue("move point left 12 failed", alreadyMoved.scale() == 12
-				&& alreadyMoved.toString().equals("-0.012334560000"));
-		movePtLeft = new BigDecimal(123E18);
-		alreadyMoved = movePtLeft.movePointLeft(2);
-		assertTrue("move point left 2 failed",
-				alreadyMoved.scale() == movePtLeft.scale() + 2
-						&& alreadyMoved.doubleValue() == 1.23E18);
-		movePtLeft = new BigDecimal(1.123E-12);
-		alreadyMoved = movePtLeft.movePointLeft(3);
-		assertTrue("move point left 3 failed",
-				alreadyMoved.scale() == movePtLeft.scale() + 3
-						&& alreadyMoved.doubleValue() == 1.123E-15);
-		movePtLeft = new BigDecimal(value, 2);
-		alreadyMoved = movePtLeft.movePointLeft(-2);
-		assertTrue("move point left -2 failed",
-				alreadyMoved.scale() == movePtLeft.scale() - 2
-						&& alreadyMoved.toString().equals("12345908"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#movePointRight(int)
-	 */
-	public void test_movePointRightI() {
-		BigDecimal movePtRight = new BigDecimal("-1.58796521458");
-		BigDecimal alreadyMoved = movePtRight.movePointRight(8);
-		assertTrue("move point right 8 failed", alreadyMoved.scale() == 3
-				&& alreadyMoved.toString().equals("-158796521.458"));
-		movePtRight = new BigDecimal(value, 2);
-		alreadyMoved = movePtRight.movePointRight(4);
-		assertTrue("move point right 4 failed", alreadyMoved.scale() == 0
-				&& alreadyMoved.toString().equals("1234590800"));
-		movePtRight = new BigDecimal(134E12);
-		alreadyMoved = movePtRight.movePointRight(2);
-		assertTrue("move point right 2 failed", alreadyMoved.scale() == 0
-				&& alreadyMoved.toString().equals("13400000000000000"));
-		movePtRight = new BigDecimal(-3.4E-10);
-		alreadyMoved = movePtRight.movePointRight(5);
-		assertTrue("move point right 5 failed",
-				alreadyMoved.scale() == movePtRight.scale() - 5
-						&& alreadyMoved.doubleValue() == -0.000034);
-		alreadyMoved = alreadyMoved.movePointRight(-5);
-		assertTrue("move point right -5 failed", alreadyMoved
-				.equals(movePtRight));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#multiply(java.math.BigDecimal)
-	 */
-	public void test_multiplyLjava_math_BigDecimal() {
-		BigDecimal multi1 = new BigDecimal(value, 5);
-		BigDecimal multi2 = new BigDecimal(2.345D);
-		BigDecimal result = multi1.multiply(multi2);
-		assertTrue("123.45908 * 2.345 is not correct: " + result, result
-				.toString().startsWith("289.51154260")
-				&& result.scale() == multi1.scale() + multi2.scale());
-		multi1 = new BigDecimal("34656");
-		multi2 = new BigDecimal("-2");
-		result = multi1.multiply(multi2);
-		assertTrue("34656 * 2 is not correct", result.toString().equals(
-				"-69312")
-				&& result.scale() == 0);
-		multi1 = new BigDecimal(-2.345E-02);
-		multi2 = new BigDecimal(-134E130);
-		result = multi1.multiply(multi2);
-		assertTrue("-2.345E-02 * -134E130 is not correct " + result.doubleValue(),
-				result.doubleValue() == 3.1422999999999997E130
-						&& result.scale() == multi1.scale() + multi2.scale());
-		multi1 = new BigDecimal("11235");
-		multi2 = new BigDecimal("0");
-		result = multi1.multiply(multi2);
-		assertTrue("11235 * 0 is not correct", result.doubleValue() == 0
-				&& result.scale() == 0);
-		multi1 = new BigDecimal("-0.00234");
-		multi2 = new BigDecimal(13.4E10);
-		result = multi1.multiply(multi2);
-		assertTrue("-0.00234 * 13.4E10 is not correct",
-				result.doubleValue() == -313560000
-						&& result.scale() == multi1.scale() + multi2.scale());
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#negate()
-	 */
-	public void test_negate() {
-		BigDecimal negate1 = new BigDecimal(value2, 7);
-		assertTrue("the negate of 1233.4560000 is not -1233.4560000", negate1
-				.negate().toString().equals("-1233.4560000"));
-		negate1 = new BigDecimal("-23465839");
-		assertTrue("the negate of -23465839 is not 23465839", negate1.negate()
-				.toString().equals("23465839"));
-		negate1 = new BigDecimal(-3.456E6);
-		assertTrue("the negate of -3.456E6 is not 3.456E6", negate1.negate()
-				.negate().equals(negate1));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#scale()
-	 */
-	public void test_scale() {
-		BigDecimal scale1 = new BigDecimal(value2, 8);
-		assertTrue("the scale of the number 123.34560000 is wrong", scale1
-				.scale() == 8);
-		BigDecimal scale2 = new BigDecimal("29389.");
-		assertTrue("the scale of the number 29389. is wrong",
-				scale2.scale() == 0);
-		BigDecimal scale3 = new BigDecimal(3.374E13);
-		assertTrue("the scale of the number 3.374E13 is wrong",
-				scale3.scale() == 0);
-		BigDecimal scale4 = new BigDecimal("-3.45E-203");
-		// note the scale is calculated as 15 digits of 345000.... + exponent -
-		// 1. -1 for the 3
-		assertTrue("the scale of the number -3.45E-203 is wrong: "
-				+ scale4.scale(), scale4.scale() == 205);
-		scale4 = new BigDecimal("-345.4E-200");
-		assertTrue("the scale of the number -345.4E-200 is wrong", scale4
-				.scale() == 201);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#setScale(int)
-	 */
-	public void test_setScaleI() {
-		// rounding mode defaults to zero
-		BigDecimal setScale1 = new BigDecimal(value, 3);
-		BigDecimal setScale2 = setScale1.setScale(5);
-		BigInteger setresult = new BigInteger("1234590800");
-		assertTrue("the number 12345.908 after setting scale is wrong",
-				setScale2.unscaledValue().equals(setresult)
-						&& setScale2.scale() == 5);
-
-		try {
-			setScale2 = setScale1.setScale(2, BigDecimal.ROUND_UNNECESSARY);
-            fail("arithmetic Exception not caught as a result of loosing precision");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#setScale(int, int)
-	 */
-	public void test_setScaleII() {
-		BigDecimal setScale1 = new BigDecimal(2.323E102);
-		BigDecimal setScale2 = setScale1.setScale(4);
-		assertTrue("the number 2.323E102 after setting scale is wrong",
-				setScale2.scale() == 4);
-		assertTrue("the representation of the number 2.323E102 is wrong",
-				setScale2.doubleValue() == 2.323E102);
-		setScale1 = new BigDecimal("-1.253E-12");
-		setScale2 = setScale1.setScale(17, BigDecimal.ROUND_CEILING);
-		assertTrue("the number -1.253E-12 after setting scale is wrong",
-				setScale2.scale() == 17);
-		assertTrue(
-				"the representation of the number -1.253E-12 after setting scale is wrong, " + setScale2.toString(),
-				setScale2.toString().equals("-1.25300E-12"));
-
-		// testing rounding Mode ROUND_CEILING
-		setScale1 = new BigDecimal(value, 4);
-		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_CEILING);
-		assertTrue(
-				"the number 1234.5908 after setting scale to 1/ROUND_CEILING is wrong",
-				setScale2.toString().equals("1234.6") && setScale2.scale() == 1);
-		BigDecimal setNeg = new BigDecimal(value.negate(), 4);
-		setScale2 = setNeg.setScale(1, BigDecimal.ROUND_CEILING);
-		assertTrue(
-				"the number -1234.5908 after setting scale to 1/ROUND_CEILING is wrong",
-				setScale2.toString().equals("-1234.5")
-						&& setScale2.scale() == 1);
-
-		// testing rounding Mode ROUND_DOWN
-		setScale2 = setNeg.setScale(1, BigDecimal.ROUND_DOWN);
-		assertTrue(
-				"the number -1234.5908 after setting scale to 1/ROUND_DOWN is wrong",
-				setScale2.toString().equals("-1234.5")
-						&& setScale2.scale() == 1);
-		setScale1 = new BigDecimal(value, 4);
-		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_DOWN);
-		assertTrue(
-				"the number 1234.5908 after setting scale to 1/ROUND_DOWN is wrong",
-				setScale2.toString().equals("1234.5") && setScale2.scale() == 1);
-
-		// testing rounding Mode ROUND_FLOOR
-		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_FLOOR);
-		assertTrue(
-				"the number 1234.5908 after setting scale to 1/ROUND_FLOOR is wrong",
-				setScale2.toString().equals("1234.5") && setScale2.scale() == 1);
-		setScale2 = setNeg.setScale(1, BigDecimal.ROUND_FLOOR);
-		assertTrue(
-				"the number -1234.5908 after setting scale to 1/ROUND_FLOOR is wrong",
-				setScale2.toString().equals("-1234.6")
-						&& setScale2.scale() == 1);
-
-		// testing rounding Mode ROUND_HALF_DOWN
-		setScale2 = setScale1.setScale(3, BigDecimal.ROUND_HALF_DOWN);
-		assertTrue(
-				"the number 1234.5908 after setting scale to 3/ROUND_HALF_DOWN is wrong",
-				setScale2.toString().equals("1234.591")
-						&& setScale2.scale() == 3);
-		setScale1 = new BigDecimal(new BigInteger("12345000"), 5);
-		setScale2 = setScale1.setScale(1, BigDecimal.ROUND_HALF_DOWN);
-		assertTrue(
-				"the number 123.45908 after setting scale to 1/ROUND_HALF_DOWN is wrong",
-				setScale2.toString().equals("123.4") && setScale2.scale() == 1);
-		setScale2 = new BigDecimal("-1234.5000").setScale(0,
-				BigDecimal.ROUND_HALF_DOWN);
-		assertTrue(
-				"the number -1234.5908 after setting scale to 0/ROUND_HALF_DOWN is wrong",
-				setScale2.toString().equals("-1234") && setScale2.scale() == 0);
-
-		// testing rounding Mode ROUND_HALF_EVEN
-		setScale1 = new BigDecimal(1.2345789D);
-		setScale2 = setScale1.setScale(4, BigDecimal.ROUND_HALF_EVEN);
-		assertTrue(
-				"the number 1.2345789 after setting scale to 4/ROUND_HALF_EVEN is wrong",
-				setScale2.doubleValue() == 1.2346D && setScale2.scale() == 4);
-		setNeg = new BigDecimal(-1.2335789D);
-		setScale2 = setNeg.setScale(2, BigDecimal.ROUND_HALF_EVEN);
-		assertTrue(
-				"the number -1.2335789 after setting scale to 2/ROUND_HALF_EVEN is wrong",
-				setScale2.doubleValue() == -1.23D && setScale2.scale() == 2);
-		setScale2 = new BigDecimal("1.2345000").setScale(3,
-				BigDecimal.ROUND_HALF_EVEN);
-		assertTrue(
-				"the number 1.2345789 after setting scale to 3/ROUND_HALF_EVEN is wrong",
-				setScale2.doubleValue() == 1.234D && setScale2.scale() == 3);
-		setScale2 = new BigDecimal("-1.2345000").setScale(3,
-				BigDecimal.ROUND_HALF_EVEN);
-		assertTrue(
-				"the number -1.2335789 after setting scale to 3/ROUND_HALF_EVEN is wrong",
-				setScale2.doubleValue() == -1.234D && setScale2.scale() == 3);
-
-		// testing rounding Mode ROUND_HALF_UP
-		setScale1 = new BigDecimal("134567.34650");
-		setScale2 = setScale1.setScale(3, BigDecimal.ROUND_HALF_UP);
-		assertTrue(
-				"the number 134567.34658 after setting scale to 3/ROUND_HALF_UP is wrong",
-				setScale2.toString().equals("134567.347")
-						&& setScale2.scale() == 3);
-		setNeg = new BigDecimal("-1234.4567");
-		setScale2 = setNeg.setScale(0, BigDecimal.ROUND_HALF_UP);
-		assertTrue(
-				"the number -1234.4567 after setting scale to 0/ROUND_HALF_UP is wrong",
-				setScale2.toString().equals("-1234") && setScale2.scale() == 0);
-
-		// testing rounding Mode ROUND_UNNECESSARY
-		try {
-			setScale1.setScale(3, BigDecimal.ROUND_UNNECESSARY);
-            fail("arithmetic Exception not caught for round unnecessary");
-		} catch (ArithmeticException e) {
-		}
-
-		// testing rounding Mode ROUND_UP
-		setScale1 = new BigDecimal("100000.374");
-		setScale2 = setScale1.setScale(2, BigDecimal.ROUND_UP);
-		assertTrue(
-				"the number 100000.374 after setting scale to 2/ROUND_UP is wrong",
-				setScale2.toString().equals("100000.38")
-						&& setScale2.scale() == 2);
-		setNeg = new BigDecimal(-134.34589D);
-		setScale2 = setNeg.setScale(2, BigDecimal.ROUND_UP);
-		assertTrue(
-				"the number -134.34589 after setting scale to 2/ROUND_UP is wrong",
-				setScale2.doubleValue() == -134.35D && setScale2.scale() == 2);
-
-		// testing invalid rounding modes
-		try {
-			setScale2 = setScale1.setScale(0, -123);
-            fail("IllegalArgumentException is not caught for wrong rounding mode");
-		} catch (IllegalArgumentException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#signum()
-	 */
-	public void test_signum() {
-		BigDecimal sign = new BigDecimal(123E-104);
-		assertTrue("123E-104 is not positive in signum()", sign.signum() == 1);
-		sign = new BigDecimal("-1234.3959");
-		assertTrue("-1234.3959 is not negative in signum()",
-				sign.signum() == -1);
-		sign = new BigDecimal(000D);
-		assertTrue("000D is not zero in signum()", sign.signum() == 0);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#subtract(java.math.BigDecimal)
-	 */
-	public void test_subtractLjava_math_BigDecimal() {
-		BigDecimal sub1 = new BigDecimal("13948");
-		BigDecimal sub2 = new BigDecimal("2839.489");
-		BigDecimal result = sub1.subtract(sub2);
-		assertTrue("13948 - 2839.489 is wrong: " + result, result.toString()
-				.equals("11108.511")
-				&& result.scale() == 3);
-		BigDecimal result2 = sub2.subtract(sub1);
-		assertTrue("2839.489 - 13948 is wrong", result2.toString().equals(
-				"-11108.511")
-				&& result2.scale() == 3);
-		assertTrue("13948 - 2839.489 is not the negative of 2839.489 - 13948",
-				result.equals(result2.negate()));
-		sub1 = new BigDecimal(value, 1);
-		sub2 = new BigDecimal("0");
-		result = sub1.subtract(sub2);
-		assertTrue("1234590.8 - 0 is wrong", result.equals(sub1));
-		sub1 = new BigDecimal(1.234E-03);
-		sub2 = new BigDecimal(3.423E-10);
-		result = sub1.subtract(sub2);
-		assertTrue("1.234E-03 - 3.423E-10 is wrong, " + result.doubleValue(),
-				result.doubleValue() == 0.0012339996577);
-		sub1 = new BigDecimal(1234.0123);
-		sub2 = new BigDecimal(1234.0123000);
-		result = sub1.subtract(sub2);
-		assertTrue("1234.0123 - 1234.0123000 is wrong, " + result.doubleValue(),
-				result.doubleValue() == 0.0);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#toBigInteger()
-	 */
-	public void test_toBigInteger() {
-		BigDecimal sub1 = new BigDecimal("-29830.989");
-		BigInteger result = sub1.toBigInteger();
-
-		assertTrue("the bigInteger equivalent of -29830.989 is wrong", result
-				.toString().equals("-29830"));
-		sub1 = new BigDecimal(-2837E10);
-		result = sub1.toBigInteger();
-		assertTrue("the bigInteger equivalent of -2837E10 is wrong", result
-				.doubleValue() == -2837E10);
-		sub1 = new BigDecimal(2.349E-10);
-		result = sub1.toBigInteger();
-		assertTrue("the bigInteger equivalent of 2.349E-10 is wrong", result
-				.equals(BigInteger.ZERO));
-		sub1 = new BigDecimal(value2, 6);
-		result = sub1.toBigInteger();
-		assertTrue("the bigInteger equivalent of 12334.560000 is wrong", result
-				.toString().equals("12334"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#toString()
-	 */
-	public void test_toString() {
-		BigDecimal toString1 = new BigDecimal("1234.000");
-		assertTrue("the toString representation of 1234.000 is wrong",
-				toString1.toString().equals("1234.000"));
-		toString1 = new BigDecimal("-123.4E-5");
-		assertTrue("the toString representation of -123.4E-5 is wrong: "
-				+ toString1, toString1.toString().equals("-0.001234"));
-		toString1 = new BigDecimal("-1.455E-20");
-		assertTrue("the toString representation of -1.455E-20 is wrong",
-				toString1.toString().equals("-1.455E-20"));
-		toString1 = new BigDecimal(value2, 4);
-		assertTrue("the toString representation of 1233456.0000 is wrong",
-				toString1.toString().equals("1233456.0000"));
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#unscaledValue()
-	 */
-	public void test_unscaledValue() {
-		BigDecimal unsVal = new BigDecimal("-2839485.000");
-		assertTrue("the unscaledValue of -2839485.000 is wrong", unsVal
-				.unscaledValue().toString().equals("-2839485000"));
-		unsVal = new BigDecimal(123E10);
-		assertTrue("the unscaledValue of 123E10 is wrong", unsVal
-				.unscaledValue().toString().equals("1230000000000"));
-		unsVal = new BigDecimal("-4.56E-13");
-		assertTrue("the unscaledValue of -4.56E-13 is wrong: "
-				+ unsVal.unscaledValue(), unsVal.unscaledValue().toString()
-				.equals("-456"));
-		unsVal = new BigDecimal(value, 3);
-		assertTrue("the unscaledValue of 12345.908 is wrong", unsVal
-				.unscaledValue().toString().equals("12345908"));
-
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#valueOf(long)
-	 */
-	public void test_valueOfJ() {
-		BigDecimal valueOfL = BigDecimal.valueOf(9223372036854775806L);
-		assertTrue("the bigDecimal equivalent of 9223372036854775806 is wrong",
-				valueOfL.unscaledValue().toString().equals(
-						"9223372036854775806")
-						&& valueOfL.scale() == 0);
-		assertTrue(
-				"the toString representation of 9223372036854775806 is wrong",
-				valueOfL.toString().equals("9223372036854775806"));
-		valueOfL = BigDecimal.valueOf(0L);
-		assertTrue("the bigDecimal equivalent of 0 is wrong", valueOfL
-				.unscaledValue().toString().equals("0")
-				&& valueOfL.scale() == 0);
-	}
-
-	/**
-	 * @tests java.math.BigDecimal#valueOf(long, int)
-	 */
-	public void test_valueOfJI() {
-		BigDecimal valueOfJI = BigDecimal.valueOf(9223372036854775806L, 5);
-		assertTrue(
-				"the bigDecimal equivalent of 92233720368547.75806 is wrong",
-				valueOfJI.unscaledValue().toString().equals(
-						"9223372036854775806")
-						&& valueOfJI.scale() == 5);
-		assertTrue(
-				"the toString representation of 9223372036854775806 is wrong",
-				valueOfJI.toString().equals("92233720368547.75806"));
-		valueOfJI = BigDecimal.valueOf(1234L, 8);
-		assertTrue(
-				"the bigDecimal equivalent of 92233720368547.75806 is wrong",
-				valueOfJI.unscaledValue().toString().equals("1234")
-						&& valueOfJI.scale() == 8);
-		assertTrue(
-				"the toString representation of 9223372036854775806 is wrong",
-				valueOfJI.toString().equals("0.00001234"));
-		valueOfJI = BigDecimal.valueOf(0, 3);
-		assertTrue(
-				"the bigDecimal equivalent of 92233720368547.75806 is wrong",
-				valueOfJI.unscaledValue().toString().equals("0")
-						&& valueOfJI.scale() == 3);
-		assertTrue(
-				"the toString representation of 9223372036854775806 is wrong",
-				valueOfJI.toString().equals("0.000"));
-
-	}
-
-	public void test_BigDecimal_serialization() throws Exception {
-        // Regression for HARMONY-1896
-        char[] in = { '1', '5', '6', '7', '8', '7', '.', '0', '0' };
-        BigDecimal bd = new BigDecimal(in, 0, 9);
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        ObjectOutputStream oos = new ObjectOutputStream(bos);
-        oos.writeObject(bd);
-
-        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
-        ObjectInputStream ois = new ObjectInputStream(bis);
-        BigDecimal nbd = (BigDecimal) ois.readObject();
-
-        assertEquals(bd.intValue(), nbd.intValue());
-        assertEquals(bd.doubleValue(), nbd.doubleValue(), 0.0);
-        assertEquals(bd.toString(), nbd.toString());
-    }
-	
-	/**
-	 * @tests java.math.BigDecimal#stripTrailingZero(long)
-	 */
-	public void test_stripTrailingZero() {
-		BigDecimal sixhundredtest = new BigDecimal("600.0");
-		assertTrue("stripTrailingZero failed for 600.0",
-				((sixhundredtest.stripTrailingZeros()).scale() == -2)
-				);
-		
-		/* Single digit, no trailing zero, odd number */
-		BigDecimal notrailingzerotest = new BigDecimal("1");
-		assertTrue("stripTrailingZero failed for 1",
-				((notrailingzerotest.stripTrailingZeros()).scale() == 0)
-				);
-		
-                // BEGIN android-changed: preserve RI compatibility, so BigDecimal.equals (which checks
-                // value *and* scale) continues to work. https://issues.apache.org/jira/browse/HARMONY-4623
-		/* Zero */
-		BigDecimal zerotest = new BigDecimal("0.0000");
-                assertEquals("stripTrailingZero failed for 0.0000", 4, zerotest.stripTrailingZeros().scale());
-	}	
-
-	public void testMathContextConstruction() {
-        String a = "-12380945E+61";
-        BigDecimal aNumber = new BigDecimal(a);
-        int precision = 6;
-        RoundingMode rm = RoundingMode.HALF_DOWN;
-        MathContext mcIntRm = new MathContext(precision, rm);
-        MathContext mcStr = new MathContext("precision=6 roundingMode=HALF_DOWN");
-        MathContext mcInt = new MathContext(precision);
-        BigDecimal res = aNumber.abs(mcInt);
-        assertEquals("MathContext Constructer with int precision failed",
-                res, 
-                new BigDecimal("1.23809E+68"));
-        
-        assertEquals("Equal MathContexts are not Equal ",
-                mcIntRm,
-                mcStr);
-        
-        assertEquals("Different MathContext are reported as Equal ",
-        		mcInt.equals(mcStr),
-                false);
-        
-        assertEquals("Equal MathContexts have different hashcodes ",
-                mcIntRm.hashCode(),
-                mcStr.hashCode());
-       
-        assertEquals("MathContext.toString() returning incorrect value",
-                mcIntRm.toString(),
-                "precision=6 roundingMode=HALF_DOWN");
-	}
-
-}
diff --git a/math/src/test/java/tests/api/java/math/BigIntegerTest.java b/math/src/test/java/tests/api/java/math/BigIntegerTest.java
deleted file mode 100644
index 8cc703f..0000000
--- a/math/src/test/java/tests/api/java/math/BigIntegerTest.java
+++ /dev/null
@@ -1,1013 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-package tests.api.java.math;
-
-import java.math.BigInteger;
-import java.util.Random;
-
-public class BigIntegerTest extends junit.framework.TestCase {
-
-	BigInteger minusTwo = new BigInteger("-2", 10);
-
-	BigInteger minusOne = new BigInteger("-1", 10);
-
-	BigInteger zero = new BigInteger("0", 10);
-
-	BigInteger one = new BigInteger("1", 10);
-
-	BigInteger two = new BigInteger("2", 10);
-
-	BigInteger ten = new BigInteger("10", 10);
-
-	BigInteger sixteen = new BigInteger("16", 10);
-
-	BigInteger oneThousand = new BigInteger("1000", 10);
-
-	BigInteger aZillion = new BigInteger(
-			"100000000000000000000000000000000000000000000000000", 10);
-
-	BigInteger twoToTheTen = new BigInteger("1024", 10);
-
-	BigInteger twoToTheSeventy = two.pow(70);
-
-	Random rand = new Random();
-
-	BigInteger bi;
-
-	BigInteger bi1;
-
-	BigInteger bi2;
-
-	BigInteger bi3;
-
-	BigInteger bi11;
-
-	BigInteger bi22;
-
-	BigInteger bi33;
-
-	BigInteger bi12;
-
-	BigInteger bi23;
-
-	BigInteger bi13;
-
-	BigInteger largePos;
-
-	BigInteger smallPos;
-
-	BigInteger largeNeg;
-
-	BigInteger smallNeg;
-
-	BigInteger[][] booleanPairs;
-
-	/**
-	 * @tests java.math.BigInteger#BigInteger(int, java.util.Random)
-	 */
-	public void test_ConstructorILjava_util_Random() {
-        // regression test for HARMONY-1047
-		try {
-			new BigInteger(Integer.MAX_VALUE, (Random)null);
-			fail("NegativeArraySizeException expected");
-		} catch (NegativeArraySizeException e) {
-            // PASSED
-		}
-		
-		bi = new BigInteger(70, rand);
-		bi2 = new BigInteger(70, rand);
-		assertTrue("Random number is negative", bi.compareTo(zero) >= 0);
-		assertTrue("Random number is too big",
-				bi.compareTo(twoToTheSeventy) < 0);
-		assertTrue(
-				"Two random numbers in a row are the same (might not be a bug but it very likely is)",
-				!bi.equals(bi2));
-		assertTrue("Not zero", new BigInteger(0, rand).equals(BigInteger.ZERO));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#BigInteger(int, int, java.util.Random)
-	 */
-	public void test_ConstructorIILjava_util_Random() {
-		bi = new BigInteger(10, 5, rand);
-		bi2 = new BigInteger(10, 5, rand);
-		assertTrue("Random number one is negative", bi.compareTo(zero) >= 0);
-		assertTrue("Random number one is too big",
-				bi.compareTo(twoToTheTen) < 0);
-		assertTrue("Random number two is negative", bi2.compareTo(zero) >= 0);
-		assertTrue("Random number two is too big",
-				bi2.compareTo(twoToTheTen) < 0);
-
-		Random rand = new Random();
-		BigInteger bi;
-		int certainty[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-				Integer.MIN_VALUE, Integer.MIN_VALUE + 1, -2, -1 };
-		for (int i = 2; i <= 20; i++) {
-            for (int c = 0; c < certainty.length; c++) {
-				bi = new BigInteger(i, c, rand); // Create BigInteger
-				assertTrue("Bit length incorrect", bi.bitLength() == i);
-			}
-        }
-	}
-
-	/**
-	 * @tests java.math.BigInteger#BigInteger(byte[])
-	 */
-	public void test_Constructor$B() {
-		byte[] myByteArray;
-		myByteArray = new byte[] { (byte) 0x00, (byte) 0xFF, (byte) 0xFE };
-		bi = new BigInteger(myByteArray);
-		assertTrue("Incorrect value for pos number", bi.equals(BigInteger.ZERO
-				.setBit(16).subtract(two)));
-		myByteArray = new byte[] { (byte) 0xFF, (byte) 0xFE };
-		bi = new BigInteger(myByteArray);
-		assertTrue("Incorrect value for neg number", bi.equals(minusTwo));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#BigInteger(int, byte[])
-	 */
-	public void test_ConstructorI$B() {
-		byte[] myByteArray;
-		myByteArray = new byte[] { (byte) 0xFF, (byte) 0xFE };
-		bi = new BigInteger(1, myByteArray);
-		assertTrue("Incorrect value for pos number", bi.equals(BigInteger.ZERO
-				.setBit(16).subtract(two)));
-		bi = new BigInteger(-1, myByteArray);
-		assertTrue("Incorrect value for neg number", bi.equals(BigInteger.ZERO
-				.setBit(16).subtract(two).negate()));
-		myByteArray = new byte[] { (byte) 0, (byte) 0 };
-		bi = new BigInteger(0, myByteArray);
-		assertTrue("Incorrect value for zero", bi.equals(zero));
-		myByteArray = new byte[] { (byte) 1 };
-		try {
-			new BigInteger(0, myByteArray);
-            fail("Failed to throw NumberFormatException");
-		} catch (NumberFormatException e) {
-			// correct
-		}
-	}
-	
-	/**
-	 * @tests java.math.BigInteger#BigInteger(java.lang.String)
-	 */
-	public void test_constructor_String_empty() {
-		try {
-			new BigInteger("");			
-            fail("Expected NumberFormatException for new BigInteger(\"\")");
-		} catch (NumberFormatException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#toByteArray()
-	 */
-	public void test_toByteArray() {
-		byte[] myByteArray, anotherByteArray;
-		myByteArray = new byte[] { 97, 33, 120, 124, 50, 2, 0, 0, 0, 12, 124,
-				42 };
-		anotherByteArray = new BigInteger(myByteArray).toByteArray();
-		assertTrue("Incorrect byte array returned",
-				myByteArray.length == anotherByteArray.length);
-		for (int counter = myByteArray.length - 1; counter >= 0; counter--) {
-			assertTrue("Incorrect values in returned byte array",
-					myByteArray[counter] == anotherByteArray[counter]);
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#isProbablePrime(int)
-	 */
-	public void test_isProbablePrimeI() {
-		int fails = 0;
-		bi = new BigInteger(20, 20, rand);
-		if (!bi.isProbablePrime(17)) {
-            fails++;
-        }
-		bi = new BigInteger("4", 10);
-		if (bi.isProbablePrime(17)) {
-            fail("isProbablePrime failed for: " + bi);
-        }
-		bi = BigInteger.valueOf(17L * 13L);
-		if (bi.isProbablePrime(17)) {
-            fail("isProbablePrime failed for: " + bi);
-        }
-		for (long a = 2; a < 1000; a++) {
-            if (isPrime(a)) {
-                assertTrue("false negative on prime number <1000", BigInteger
-						.valueOf(a).isProbablePrime(5));
-            } else if (BigInteger.valueOf(a).isProbablePrime(17)) {
-				System.out.println("isProbablePrime failed for: " + a);
-				fails++;
-			}
-        }
-		for (int a = 0; a < 1000; a++) {
-			bi = BigInteger.valueOf(rand.nextInt(1000000)).multiply(
-					BigInteger.valueOf(rand.nextInt(1000000)));
-			if (bi.isProbablePrime(17)) {
-				System.out.println("isProbablePrime failed for: " + bi);
-				fails++;
-			}
-		}
-		for (int a = 0; a < 200; a++) {
-			bi = new BigInteger(70, rand).multiply(new BigInteger(70, rand));
-			if (bi.isProbablePrime(17)) {
-				System.out.println("isProbablePrime failed for: " + bi);
-				fails++;
-			}
-		}
-		assertTrue("Too many false positives - may indicate a problem",
-				fails <= 1);
-	}
-
-	/**
-	 * @tests java.math.BigInteger#equals(java.lang.Object)
-	 */
-	public void test_equalsLjava_lang_Object() {
-		assertTrue("0=0", zero.equals(BigInteger.valueOf(0)));
-		assertTrue("-123=-123", BigInteger.valueOf(-123).equals(
-				BigInteger.valueOf(-123)));
-		assertTrue("0=1", !zero.equals(one));
-		assertTrue("0=-1", !zero.equals(minusOne));
-		assertTrue("1=-1", !one.equals(minusOne));
-		assertTrue("bi3=bi3", bi3.equals(bi3));
-		assertTrue("bi3=copy of bi3", bi3.equals(bi3.negate().negate()));
-		assertTrue("bi3=bi2", !bi3.equals(bi2));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#compareTo(java.math.BigInteger)
-	 */
-	public void test_compareToLjava_math_BigInteger() {
-		assertTrue("Smaller number returned >= 0", one.compareTo(two) < 0);
-		assertTrue("Larger number returned >= 0", two.compareTo(one) > 0);
-		assertTrue("Equal numbers did not return 0", one.compareTo(one) == 0);
-		assertTrue("Neg number messed things up",
-				two.negate().compareTo(one) < 0);
-	}
-
-	/**
-	 * @tests java.math.BigInteger#intValue()
-	 */
-	public void test_intValue() {
-		assertTrue("Incorrect intValue for 2**70",
-				twoToTheSeventy.intValue() == 0);
-		assertTrue("Incorrect intValue for 2", two.intValue() == 2);
-	}
-
-	/**
-	 * @tests java.math.BigInteger#longValue()
-	 */
-	public void test_longValue() {
-		assertTrue("Incorrect longValue for 2**70",
-				twoToTheSeventy.longValue() == 0);
-		assertTrue("Incorrect longValue for 2", two.longValue() == 2);
-	}
-
-	/**
-	 * @tests java.math.BigInteger#valueOf(long)
-	 */
-	public void test_valueOfJ() {
-		assertTrue("Incurred number returned for 2", BigInteger.valueOf(2L)
-				.equals(two));
-		assertTrue("Incurred number returned for 200", BigInteger.valueOf(200L)
-				.equals(BigInteger.valueOf(139).add(BigInteger.valueOf(61))));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#add(java.math.BigInteger)
-	 */
-	public void test_addLjava_math_BigInteger() {
-		assertTrue("Incorrect sum--wanted a zillion", aZillion.add(aZillion)
-				.add(aZillion.negate()).equals(aZillion));
-		assertTrue("0+0", zero.add(zero).equals(zero));
-		assertTrue("0+1", zero.add(one).equals(one));
-		assertTrue("1+0", one.add(zero).equals(one));
-		assertTrue("1+1", one.add(one).equals(two));
-		assertTrue("0+(-1)", zero.add(minusOne).equals(minusOne));
-		assertTrue("(-1)+0", minusOne.add(zero).equals(minusOne));
-		assertTrue("(-1)+(-1)", minusOne.add(minusOne).equals(minusTwo));
-		assertTrue("1+(-1)", one.add(minusOne).equals(zero));
-		assertTrue("(-1)+1", minusOne.add(one).equals(zero));
-
-		for (int i = 0; i < 200; i++) {
-			BigInteger midbit = zero.setBit(i);
-			assertTrue("add fails to carry on bit " + i, midbit.add(midbit)
-					.equals(zero.setBit(i + 1)));
-		}
-		BigInteger bi2p3 = bi2.add(bi3);
-		BigInteger bi3p2 = bi3.add(bi2);
-		assertTrue("bi2p3=bi3p2", bi2p3.equals(bi3p2));
-
-		// add large positive + small positive
-
-		// add large positive + small negative
-
-		// add large negative + small positive
-
-		// add large negative + small negative
-	}
-
-	/**
-	 * @tests java.math.BigInteger#negate()
-	 */
-	public void test_negate() {
-		assertTrue("Single negation of zero did not result in zero", zero
-				.negate().equals(zero));
-		assertTrue("Single negation resulted in original nonzero number",
-				!aZillion.negate().equals(aZillion));
-		assertTrue("Double negation did not result in original number",
-				aZillion.negate().negate().equals(aZillion));
-
-		assertTrue("0.neg", zero.negate().equals(zero));
-		assertTrue("1.neg", one.negate().equals(minusOne));
-		assertTrue("2.neg", two.negate().equals(minusTwo));
-		assertTrue("-1.neg", minusOne.negate().equals(one));
-		assertTrue("-2.neg", minusTwo.negate().equals(two));
-		assertTrue("0x62EB40FEF85AA9EBL*2.neg", BigInteger.valueOf(
-				0x62EB40FEF85AA9EBL * 2).negate().equals(
-				BigInteger.valueOf(-0x62EB40FEF85AA9EBL * 2)));
-		for (int i = 0; i < 200; i++) {
-			BigInteger midbit = zero.setBit(i);
-			BigInteger negate = midbit.negate();
-			assertTrue("negate negate", negate.negate().equals(midbit));
-			assertTrue("neg fails on bit " + i, midbit.negate().add(midbit)
-					.equals(zero));
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#signum()
-	 */
-	public void test_signum() {
-		assertTrue("Wrong positive signum", two.signum() == 1);
-		assertTrue("Wrong zero signum", zero.signum() == 0);
-		assertTrue("Wrong neg zero signum", zero.negate().signum() == 0);
-		assertTrue("Wrong neg signum", two.negate().signum() == -1);
-	}
-
-	/**
-	 * @tests java.math.BigInteger#abs()
-	 */
-	public void test_abs() {
-		assertTrue("Invalid number returned for zillion", aZillion.negate()
-				.abs().equals(aZillion.abs()));
-		assertTrue("Invalid number returned for zero neg", zero.negate().abs()
-				.equals(zero));
-		assertTrue("Invalid number returned for zero", zero.abs().equals(zero));
-		assertTrue("Invalid number returned for two", two.negate().abs()
-				.equals(two));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#pow(int)
-	 */
-	public void test_powI() {
-		assertTrue("Incorrect exponent returned for 2**10", two.pow(10).equals(
-				twoToTheTen));
-		assertTrue("Incorrect exponent returned for 2**70", two.pow(30)
-				.multiply(two.pow(40)).equals(twoToTheSeventy));
-		assertTrue("Incorrect exponent returned for 10**50", ten.pow(50)
-				.equals(aZillion));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#modInverse(java.math.BigInteger)
-	 */
-	public void test_modInverseLjava_math_BigInteger() {
-		BigInteger a = zero, mod, inv;
-		for (int j = 3; j < 50; j++) {
-			mod = BigInteger.valueOf(j);
-			for (int i = -j + 1; i < j; i++) {
-                try {
-					a = BigInteger.valueOf(i);
-					inv = a.modInverse(mod);
-					assertTrue("bad inverse: " + a + " inv mod " + mod
-							+ " equals " + inv, one.equals(a.multiply(inv).mod(
-							mod)));
-					assertTrue("inverse greater than modulo: " + a
-							+ " inv mod " + mod + " equals " + inv, inv
-							.compareTo(mod) < 0);
-					assertTrue("inverse less than zero: " + a + " inv mod "
-							+ mod + " equals " + inv, inv
-							.compareTo(BigInteger.ZERO) >= 0);
-				} catch (ArithmeticException e) {
-					assertTrue("should have found inverse for " + a + " mod "
-							+ mod, !one.equals(a.gcd(mod)));
-				}
-            }
-		}
-		for (int j = 1; j < 10; j++) {
-			mod = bi2.add(BigInteger.valueOf(j));
-			for (int i = 0; i < 20; i++) {
-                try {
-					a = bi3.add(BigInteger.valueOf(i));
-					inv = a.modInverse(mod);
-					assertTrue("bad inverse: " + a + " inv mod " + mod
-							+ " equals " + inv, one.equals(a.multiply(inv).mod(
-							mod)));
-					assertTrue("inverse greater than modulo: " + a
-							+ " inv mod " + mod + " equals " + inv, inv
-							.compareTo(mod) < 0);
-					assertTrue("inverse less than zero: " + a + " inv mod "
-							+ mod + " equals " + inv, inv
-							.compareTo(BigInteger.ZERO) >= 0);
-				} catch (ArithmeticException e) {
-					assertTrue("should have found inverse for " + a + " mod "
-							+ mod, !one.equals(a.gcd(mod)));
-				}
-            }
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#shiftRight(int)
-	 */
-	public void test_shiftRightI() {
-		assertTrue("1 >> 0", BigInteger.valueOf(1).shiftRight(0).equals(
-				BigInteger.ONE));
-		assertTrue("1 >> 1", BigInteger.valueOf(1).shiftRight(1).equals(
-				BigInteger.ZERO));
-		assertTrue("1 >> 63", BigInteger.valueOf(1).shiftRight(63).equals(
-				BigInteger.ZERO));
-		assertTrue("1 >> 64", BigInteger.valueOf(1).shiftRight(64).equals(
-				BigInteger.ZERO));
-		assertTrue("1 >> 65", BigInteger.valueOf(1).shiftRight(65).equals(
-				BigInteger.ZERO));
-		assertTrue("1 >> 1000", BigInteger.valueOf(1).shiftRight(1000).equals(
-				BigInteger.ZERO));
-		assertTrue("-1 >> 0", BigInteger.valueOf(-1).shiftRight(0).equals(
-				minusOne));
-		assertTrue("-1 >> 1", BigInteger.valueOf(-1).shiftRight(1).equals(
-				minusOne));
-		assertTrue("-1 >> 63", BigInteger.valueOf(-1).shiftRight(63).equals(
-				minusOne));
-		assertTrue("-1 >> 64", BigInteger.valueOf(-1).shiftRight(64).equals(
-				minusOne));
-		assertTrue("-1 >> 65", BigInteger.valueOf(-1).shiftRight(65).equals(
-				minusOne));
-		assertTrue("-1 >> 1000", BigInteger.valueOf(-1).shiftRight(1000)
-				.equals(minusOne));
-
-		BigInteger a = BigInteger.ONE;
-		BigInteger c = bi3;
-		BigInteger E = bi3.negate();
-		BigInteger e = E;
-		for (int i = 0; i < 200; i++) {
-			BigInteger b = BigInteger.ZERO.setBit(i);
-			assertTrue("a==b", a.equals(b));
-			a = a.shiftLeft(1);
-			assertTrue("a non-neg", a.signum() >= 0);
-
-			BigInteger d = bi3.shiftRight(i);
-			assertTrue("c==d", c.equals(d));
-			c = c.shiftRight(1);
-			assertTrue(">>1 == /2", d.divide(two).equals(c));
-			assertTrue("c non-neg", c.signum() >= 0);
-
-			BigInteger f = E.shiftRight(i);
-			assertTrue("e==f", e.equals(f));
-			e = e.shiftRight(1);
-			assertTrue(">>1 == /2", f.subtract(one).divide(two).equals(e));
-			assertTrue("e negative", e.signum() == -1);
-
-			assertTrue("b >> i", b.shiftRight(i).equals(one));
-			assertTrue("b >> i+1", b.shiftRight(i + 1).equals(zero));
-			assertTrue("b >> i-1", b.shiftRight(i - 1).equals(two));
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#shiftLeft(int)
-	 */
-	public void test_shiftLeftI() {
-		assertTrue("1 << 0", one.shiftLeft(0).equals(one));
-		assertTrue("1 << 1", one.shiftLeft(1).equals(two));
-		assertTrue("1 << 63", one.shiftLeft(63).equals(
-				new BigInteger("8000000000000000", 16)));
-		assertTrue("1 << 64", one.shiftLeft(64).equals(
-				new BigInteger("10000000000000000", 16)));
-		assertTrue("1 << 65", one.shiftLeft(65).equals(
-				new BigInteger("20000000000000000", 16)));
-		assertTrue("-1 << 0", minusOne.shiftLeft(0).equals(minusOne));
-		assertTrue("-1 << 1", minusOne.shiftLeft(1).equals(minusTwo));
-		assertTrue("-1 << 63", minusOne.shiftLeft(63).equals(
-				new BigInteger("-9223372036854775808")));
-		assertTrue("-1 << 64", minusOne.shiftLeft(64).equals(
-				new BigInteger("-18446744073709551616")));
-		assertTrue("-1 << 65", minusOne.shiftLeft(65).equals(
-				new BigInteger("-36893488147419103232")));
-
-		BigInteger a = bi3;
-		BigInteger c = minusOne;
-		for (int i = 0; i < 200; i++) {
-			BigInteger b = bi3.shiftLeft(i);
-			assertTrue("a==b", a.equals(b));
-			assertTrue("a >> i == bi3", a.shiftRight(i).equals(bi3));
-			a = a.shiftLeft(1);
-			assertTrue("<<1 == *2", b.multiply(two).equals(a));
-			assertTrue("a non-neg", a.signum() >= 0);
-			assertTrue("a.bitCount==b.bitCount", a.bitCount() == b.bitCount());
-
-			BigInteger d = minusOne.shiftLeft(i);
-			assertTrue("c==d", c.equals(d));
-			c = c.shiftLeft(1);
-			assertTrue("<<1 == *2 negative", d.multiply(two).equals(c));
-			assertTrue("c negative", c.signum() == -1);
-			assertTrue("d >> i == minusOne", d.shiftRight(i).equals(minusOne));
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#multiply(java.math.BigInteger)
-	 */
-	public void test_multiplyLjava_math_BigInteger() {
-		assertTrue("Incorrect sum--wanted three zillion", aZillion
-				.add(aZillion).add(aZillion).equals(
-						aZillion.multiply(new BigInteger("3", 10))));
-
-		assertTrue("0*0", zero.multiply(zero).equals(zero));
-		assertTrue("0*1", zero.multiply(one).equals(zero));
-		assertTrue("1*0", one.multiply(zero).equals(zero));
-		assertTrue("1*1", one.multiply(one).equals(one));
-		assertTrue("0*(-1)", zero.multiply(minusOne).equals(zero));
-		assertTrue("(-1)*0", minusOne.multiply(zero).equals(zero));
-		assertTrue("(-1)*(-1)", minusOne.multiply(minusOne).equals(one));
-		assertTrue("1*(-1)", one.multiply(minusOne).equals(minusOne));
-		assertTrue("(-1)*1", minusOne.multiply(one).equals(minusOne));
-
-		testAllMults(bi1, bi1, bi11);
-		testAllMults(bi2, bi2, bi22);
-		testAllMults(bi3, bi3, bi33);
-		testAllMults(bi1, bi2, bi12);
-		testAllMults(bi1, bi3, bi13);
-		testAllMults(bi2, bi3, bi23);
-	}
-
-	/**
-	 * @tests java.math.BigInteger#divide(java.math.BigInteger)
-	 */
-	public void test_divideLjava_math_BigInteger() {
-		testAllDivs(bi33, bi3);
-		testAllDivs(bi22, bi2);
-		testAllDivs(bi11, bi1);
-		testAllDivs(bi13, bi1);
-		testAllDivs(bi13, bi3);
-		testAllDivs(bi12, bi1);
-		testAllDivs(bi12, bi2);
-		testAllDivs(bi23, bi2);
-		testAllDivs(bi23, bi3);
-		testAllDivs(largePos, bi1);
-		testAllDivs(largePos, bi2);
-		testAllDivs(largePos, bi3);
-		testAllDivs(largeNeg, bi1);
-		testAllDivs(largeNeg, bi2);
-		testAllDivs(largeNeg, bi3);
-		testAllDivs(largeNeg, largePos);
-		testAllDivs(largePos, largeNeg);
-		testAllDivs(bi3, bi3);
-		testAllDivs(bi2, bi2);
-		testAllDivs(bi1, bi1);
-		testDivRanges(bi1);
-		testDivRanges(bi2);
-		testDivRanges(bi3);
-		testDivRanges(smallPos);
-		testDivRanges(largePos);
-		testDivRanges(new BigInteger("62EB40FEF85AA9EB", 16));
-		testAllDivs(BigInteger.valueOf(0xCC0225953CL), BigInteger
-				.valueOf(0x1B937B765L));
-
-		try {
-			largePos.divide(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi1.divide(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi3.negate().divide(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			zero.divide(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#remainder(java.math.BigInteger)
-	 */
-	public void test_remainderLjava_math_BigInteger() {
-		try {
-			largePos.remainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi1.remainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi3.negate().remainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			zero.remainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#mod(java.math.BigInteger)
-	 */
-	public void test_modLjava_math_BigInteger() {
-		try {
-			largePos.mod(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi1.mod(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi3.negate().mod(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			zero.mod(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#divideAndRemainder(java.math.BigInteger)
-	 */
-	public void test_divideAndRemainderLjava_math_BigInteger() {
-		try {
-			largePos.divideAndRemainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi1.divideAndRemainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			bi3.negate().divideAndRemainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-
-		try {
-			zero.divideAndRemainder(zero);
-            fail("ArithmeticException expected");
-		} catch (ArithmeticException e) {
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#BigInteger(java.lang.String)
-	 */
-	public void test_ConstructorLjava_lang_String() {
-		assertTrue("new(0)", new BigInteger("0").equals(BigInteger.valueOf(0)));
-		assertTrue("new(1)", new BigInteger("1").equals(BigInteger.valueOf(1)));
-		assertTrue("new(12345678901234)", new BigInteger("12345678901234")
-				.equals(BigInteger.valueOf(12345678901234L)));
-		assertTrue("new(-1)", new BigInteger("-1").equals(BigInteger
-				.valueOf(-1)));
-		assertTrue("new(-12345678901234)", new BigInteger("-12345678901234")
-				.equals(BigInteger.valueOf(-12345678901234L)));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#BigInteger(java.lang.String, int)
-	 */
-	public void test_ConstructorLjava_lang_StringI() {
-		assertTrue("new(0,16)", new BigInteger("0", 16).equals(BigInteger
-				.valueOf(0)));
-		assertTrue("new(1,16)", new BigInteger("1", 16).equals(BigInteger
-				.valueOf(1)));
-		assertTrue("new(ABF345678901234,16)", new BigInteger("ABF345678901234",
-				16).equals(BigInteger.valueOf(0xABF345678901234L)));
-		assertTrue("new(abf345678901234,16)", new BigInteger("abf345678901234",
-				16).equals(BigInteger.valueOf(0xABF345678901234L)));
-		assertTrue("new(-1,16)", new BigInteger("-1", 16).equals(BigInteger
-				.valueOf(-1)));
-		assertTrue("new(-ABF345678901234,16)", new BigInteger(
-				"-ABF345678901234", 16).equals(BigInteger
-				.valueOf(-0xABF345678901234L)));
-		assertTrue("new(-abf345678901234,16)", new BigInteger(
-				"-abf345678901234", 16).equals(BigInteger
-				.valueOf(-0xABF345678901234L)));
-		assertTrue("new(-101010101,2)", new BigInteger("-101010101", 2)
-				.equals(BigInteger.valueOf(-341)));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#toString()
-	 */
-	public void test_toString() {
-		assertTrue("0.toString", "0".equals(BigInteger.valueOf(0).toString()));
-		assertTrue("1.toString", "1".equals(BigInteger.valueOf(1).toString()));
-		assertTrue("12345678901234.toString", "12345678901234"
-				.equals(BigInteger.valueOf(12345678901234L).toString()));
-		assertTrue("-1.toString", "-1"
-				.equals(BigInteger.valueOf(-1).toString()));
-		assertTrue("-12345678901234.toString", "-12345678901234"
-				.equals(BigInteger.valueOf(-12345678901234L).toString()));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#toString(int)
-	 */
-	public void test_toStringI() {
-		assertTrue("0.toString(16)", "0".equals(BigInteger.valueOf(0).toString(
-				16)));
-		assertTrue("1.toString(16)", "1".equals(BigInteger.valueOf(1).toString(
-				16)));
-		assertTrue("ABF345678901234.toString(16)", "abf345678901234"
-				.equals(BigInteger.valueOf(0xABF345678901234L).toString(16)));
-		assertTrue("-1.toString(16)", "-1".equals(BigInteger.valueOf(-1)
-				.toString(16)));
-		assertTrue("-ABF345678901234.toString(16)", "-abf345678901234"
-				.equals(BigInteger.valueOf(-0xABF345678901234L).toString(16)));
-		assertTrue("-101010101.toString(2)", "-101010101".equals(BigInteger
-				.valueOf(-341).toString(2)));
-	}
-
-	/**
-	 * @tests java.math.BigInteger#and(java.math.BigInteger)
-	 */
-	public void test_andLjava_math_BigInteger() {
-		for (BigInteger[] element : booleanPairs) {
-			BigInteger i1 = element[0], i2 = element[1];
-			BigInteger res = i1.and(i2);
-			assertTrue("symmetry of and", res.equals(i2.and(i1)));
-			int len = Math.max(i1.bitLength(), i2.bitLength()) + 66;
-			for (int i = 0; i < len; i++) {
-                assertTrue("and", (i1.testBit(i) && i2.testBit(i)) == res
-						.testBit(i));
-            }
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#or(java.math.BigInteger)
-	 */
-	public void test_orLjava_math_BigInteger() {
-		for (BigInteger[] element : booleanPairs) {
-			BigInteger i1 = element[0], i2 = element[1];
-			BigInteger res = i1.or(i2);
-			assertTrue("symmetry of or", res.equals(i2.or(i1)));
-			int len = Math.max(i1.bitLength(), i2.bitLength()) + 66;
-			for (int i = 0; i < len; i++) {
-                assertTrue("or", (i1.testBit(i) || i2.testBit(i)) == res
-						.testBit(i));
-            }
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#xor(java.math.BigInteger)
-	 */
-	public void test_xorLjava_math_BigInteger() {
-		for (BigInteger[] element : booleanPairs) {
-			BigInteger i1 = element[0], i2 = element[1];
-			BigInteger res = i1.xor(i2);
-			assertTrue("symmetry of xor", res.equals(i2.xor(i1)));
-			int len = Math.max(i1.bitLength(), i2.bitLength()) + 66;
-			for (int i = 0; i < len; i++) {
-                assertTrue("xor", (i1.testBit(i) ^ i2.testBit(i)) == res
-						.testBit(i));
-            }
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#not()
-	 */
-	public void test_not() {
-		for (BigInteger[] element : booleanPairs) {
-			BigInteger i1 = element[0];
-			BigInteger res = i1.not();
-			int len = i1.bitLength() + 66;
-			for (int i = 0; i < len; i++) {
-                assertTrue("not", !i1.testBit(i) == res.testBit(i));
-            }
-		}
-	}
-
-	/**
-	 * @tests java.math.BigInteger#andNot(java.math.BigInteger)
-	 */
-	public void test_andNotLjava_math_BigInteger() {
-		for (BigInteger[] element : booleanPairs) {
-			BigInteger i1 = element[0], i2 = element[1];
-			BigInteger res = i1.andNot(i2);
-			int len = Math.max(i1.bitLength(), i2.bitLength()) + 66;
-			for (int i = 0; i < len; i++) {
-                assertTrue("andNot", (i1.testBit(i) && !i2.testBit(i)) == res
-						.testBit(i));
-            }
-			// asymmetrical
-			i1 = element[1];
-			i2 = element[0];
-			res = i1.andNot(i2);
-			for (int i = 0; i < len; i++) {
-                assertTrue("andNot reversed",
-						(i1.testBit(i) && !i2.testBit(i)) == res.testBit(i));
-            }
-		}
-        //regression for HARMONY-4653
-        try{
-            BigInteger.ZERO.andNot(null);
-            fail("should throw NPE");
-        }catch(Exception e){
-            //expected
-        }
-        BigInteger bi = new BigInteger(0, new byte[]{});
-        assertEquals(BigInteger.ZERO, bi.andNot(BigInteger.ZERO));
-	}
-    
-
-     public void testClone() {
-        // Regression test for HARMONY-1770
-        MyBigInteger myBigInteger = new MyBigInteger("12345");
-        myBigInteger = (MyBigInteger) myBigInteger.clone();
-    }
-
-    static class MyBigInteger extends BigInteger implements Cloneable {
-        public MyBigInteger(String val) {
-            super(val);
-        }
-        public Object clone() {
-            try {
-                return super.clone();
-            } catch (CloneNotSupportedException e) {
-                return null;
-            }
-        }
-    }
-
-	@Override
-    protected void setUp() {
-		bi1 = new BigInteger("2436798324768978", 16);
-		bi2 = new BigInteger("4576829475724387584378543764555", 16);
-		bi3 = new BigInteger("43987298363278574365732645872643587624387563245",
-				16);
-
-		bi33 = new BigInteger(
-				"10730846694701319120609898625733976090865327544790136667944805934175543888691400559249041094474885347922769807001",
-				10);
-		bi22 = new BigInteger(
-				"33301606932171509517158059487795669025817912852219962782230629632224456249",
-				10);
-		bi11 = new BigInteger("6809003003832961306048761258711296064", 10);
-		bi23 = new BigInteger(
-				"597791300268191573513888045771594235932809890963138840086083595706565695943160293610527214057",
-				10);
-		bi13 = new BigInteger(
-				"270307912162948508387666703213038600031041043966215279482940731158968434008",
-				10);
-		bi12 = new BigInteger(
-				"15058244971895641717453176477697767050482947161656458456", 10);
-
-		largePos = new BigInteger(
-				"834759814379857314986743298675687569845986736578576375675678998612743867438632986243982098437620983476924376",
-				16);
-		smallPos = new BigInteger("48753269875973284765874598630960986276", 16);
-		largeNeg = new BigInteger(
-				"-878824397432651481891353247987891423768534321387864361143548364457698487264387568743568743265873246576467643756437657436587436",
-				16);
-		smallNeg = new BigInteger("-567863254343798609857456273458769843", 16);
-		booleanPairs = new BigInteger[][] { { largePos, smallPos },
-				{ largePos, smallNeg }, { largeNeg, smallPos },
-				{ largeNeg, smallNeg } };
-	}
-
-	private void testDiv(BigInteger i1, BigInteger i2) {
-		BigInteger q = i1.divide(i2);
-		BigInteger r = i1.remainder(i2);
-		BigInteger[] temp = i1.divideAndRemainder(i2);
-
-		assertTrue("divide and divideAndRemainder do not agree", q
-				.equals(temp[0]));
-		assertTrue("remainder and divideAndRemainder do not agree", r
-				.equals(temp[1]));
-		assertTrue("signum and equals(zero) do not agree on quotient", q
-				.signum() != 0
-				|| q.equals(zero));
-		assertTrue("signum and equals(zero) do not agree on remainder", r
-				.signum() != 0
-				|| r.equals(zero));
-		assertTrue("wrong sign on quotient", q.signum() == 0
-				|| q.signum() == i1.signum() * i2.signum());
-		assertTrue("wrong sign on remainder", r.signum() == 0
-				|| r.signum() == i1.signum());
-		assertTrue("remainder out of range", r.abs().compareTo(i2.abs()) < 0);
-		assertTrue("quotient too small", q.abs().add(one).multiply(i2.abs())
-				.compareTo(i1.abs()) > 0);
-		assertTrue("quotient too large", q.abs().multiply(i2.abs()).compareTo(
-				i1.abs()) <= 0);
-		BigInteger p = q.multiply(i2);
-		BigInteger a = p.add(r);
-		assertTrue("(a/b)*b+(a%b) != a", a.equals(i1));
-		try {
-			BigInteger mod = i1.mod(i2);
-			assertTrue("mod is negative", mod.signum() >= 0);
-			assertTrue("mod out of range", mod.abs().compareTo(i2.abs()) < 0);
-			assertTrue("positive remainder == mod", r.signum() < 0
-					|| r.equals(mod));
-			assertTrue("negative remainder == mod - divisor", r.signum() >= 0
-					|| r.equals(mod.subtract(i2)));
-		} catch (ArithmeticException e) {
-			assertTrue("mod fails on negative divisor only", i2.signum() <= 0);
-		}
-	}
-
-	private void testDivRanges(BigInteger i) {
-		BigInteger bound = i.multiply(two);
-		for (BigInteger j = bound.negate(); j.compareTo(bound) <= 0; j = j
-				.add(i)) {
-			BigInteger innerbound = j.add(two);
-			BigInteger k = j.subtract(two);
-			for (; k.compareTo(innerbound) <= 0; k = k.add(one)) {
-                testDiv(k, i);
-            }
-		}
-	}
-
-	private boolean isPrime(long b) {
-		if (b == 2) {
-            return true;
-        }
-		// check for div by 2
-		if ((b & 1L) == 0) {
-            return false;
-        }
-		long maxlen = ((long) Math.sqrt(b)) + 2;
-		for (long x = 3; x < maxlen; x += 2) {
-            if (b % x == 0) {
-                return false;
-            }
-        }
-		return true;
-	}
-
-	private void testAllMults(BigInteger i1, BigInteger i2, BigInteger ans) {
-		assertTrue("i1*i2=ans", i1.multiply(i2).equals(ans));
-		assertTrue("i2*i1=ans", i2.multiply(i1).equals(ans));
-		assertTrue("-i1*i2=-ans", i1.negate().multiply(i2).equals(ans.negate()));
-		assertTrue("-i2*i1=-ans", i2.negate().multiply(i1).equals(ans.negate()));
-		assertTrue("i1*-i2=-ans", i1.multiply(i2.negate()).equals(ans.negate()));
-		assertTrue("i2*-i1=-ans", i2.multiply(i1.negate()).equals(ans.negate()));
-		assertTrue("-i1*-i2=ans", i1.negate().multiply(i2.negate()).equals(ans));
-		assertTrue("-i2*-i1=ans", i2.negate().multiply(i1.negate()).equals(ans));
-	}
-
-	private void testAllDivs(BigInteger i1, BigInteger i2) {
-		testDiv(i1, i2);
-		testDiv(i1.negate(), i2);
-		testDiv(i1, i2.negate());
-		testDiv(i1.negate(), i2.negate());
-	}
-}