Initial Contribution

24 files changed, 14393 insertions, 0 deletions

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
new file mode 100644
index 0000000..aa0bac1
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalArithmeticTest.java
@@ -0,0 +1,1759 @@
+/*
+ *  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());
+    }
+
+    /**
+     * 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());
+    }
+
+// ANDROID ADDED
+
+    /**
+     * @tests java.math.BigDecimal#add(java.math.BigDecimal)
+     */
+    public void test_addBigDecimal() {
+        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#divide(java.math.BigDecimal,
+     *        java.math.MathContext) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeUP() {
+        String a = "-37361671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.UP;
+        String c = "-1";
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        BigDecimal result = aNumber.divide(bNumber, rm);
+        assertEquals("incorrect value", c, result.toString());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeDOWN() {
+        String a = "-37361671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.DOWN;
+        String c = "0";
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        BigDecimal result = aNumber.divide(bNumber, rm);
+        assertEquals("incorrect value", c, result.toString());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeCEILING() {
+        String a = "3736186567876876578956958765675671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.CEILING;
+        String c = "50000260373164286401361914";
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        BigDecimal result = aNumber.divide(bNumber, rm);
+        assertEquals("incorrect value", c, result.toString());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeFLOOR() {
+        String a = "3736186567876876578956958765675671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.FLOOR;
+        String c = "50000260373164286401361913";
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        BigDecimal result = aNumber.divide(bNumber, rm);
+        assertEquals("incorrect value", c, result.toString());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeHALF_UP() {
+        String a = "3736186567876876578956958765675671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.HALF_UP;
+        String c = "50000260373164286401361913";
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        BigDecimal result = aNumber.divide(bNumber, rm);
+        assertEquals("incorrect value", c, result.toString());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeHALF_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());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingModeHALF_EVEN() {
+        String a = "3736186567876876578956958765675671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.HALF_EVEN;
+        String c = "50000260373164286401361913";
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        BigDecimal result = aNumber.divide(bNumber, rm);
+        assertEquals("incorrect value", c, result.toString());
+    }
+
+    /**
+     * @tests java.math.BigDecimal#divide(java.math.BigDecimal,
+     *        java.math.RoundingMode) divide(BigDecimal, RoundingMode)
+     */
+    public void test_DivideBigDecimalRoundingExc() {
+        String a = "3736186567876876578956958765675671119238118911893939591735";
+        String b = "74723342238476237823787879183470";
+        RoundingMode rm = RoundingMode.UNNECESSARY;
+        BigDecimal aNumber = new BigDecimal(new BigInteger(a));
+        BigDecimal bNumber = new BigDecimal(new BigInteger(b));
+        try {
+            aNumber.divide(bNumber, rm);
+            fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY divider");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+        try {
+            bNumber = new BigDecimal(0);
+            aNumber.divide(bNumber, rm);
+            fail("ArithmeticException is not thrown for zero divider");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+}
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
new file mode 100644
index 0000000..b0b5e22
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalCompareTest.java
@@ -0,0 +1,504 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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());
+    }
+}
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
new file mode 100644
index 0000000..c0e30a2
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConstructorsTest.java
@@ -0,0 +1,763 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "Infinite or NaN", e
+                    .getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Infinite or NaN",
+                    e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Infinite or NaN",
+                    e.getMessage());
+        }
+    }
+
+    /**
+     * 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 {
+// BEGIN android-modified
+            BigDecimal bd = new BigDecimal(a);
+            fail("NumberFormatException has not been caught: " + bd.toString());
+// END android-modified
+        } 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) {
+           assertEquals("Improper exception message","Scale out of range.", 
+               e.getMessage());
+       }
+    }
+
+    /**
+     * 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());
+    }
+
+// ANDROID ADDED
+
+    /**
+     * @tests java.math.BigDecimal#BigDecimal(java.math.BigInteger, int)
+     */
+    public void test_Constructor_java_math_BigInteger_int() {
+        BigInteger value = new BigInteger("12345908");
+        BigDecimal big = new BigDecimal(value);
+        assertTrue("the BigDecimal value is not initialized properly", 
+                big.unscaledValue().equals(value)
+                && big.scale() == 0);
+
+        BigInteger value2 = new BigInteger("12334560000");
+        BigDecimal big2 = new BigDecimal(value2, 5);
+        assertTrue("the BigDecimal value is not initialized properly", 
+                big2.unscaledValue().equals(value2)
+                && big2.scale() == 5);
+        assertTrue("the BigDecimal value is not represented properly", big2.toString().equals(
+                "123345.60000"));
+    }
+
+    /**
+     * @tests java.math.BigDecimal#BigDecimal(double)
+     */
+    public void test_Constructor_Double() {
+        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 for 1.2345E-12",
+                big.doubleValue() == 1.2345E-12);
+        big = new BigDecimal(-12345E-3);
+        assertTrue("the double representation is not correct for -12345E-3",
+                big.doubleValue() == -12.345);
+        big = new BigDecimal(5.1234567897654321e138);
+        assertTrue("the double representation is not correct for 5.1234567897654321e138", 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_Constructor_java_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);
+
+    }
+
+}
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
new file mode 100644
index 0000000..ecc1dfa
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConvertTest.java
@@ -0,0 +1,1174 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+package org.apache.harmony.tests.java.math;
+
+import junit.framework.TestCase;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+import java.math.MathContext;
+
+/**
+ * 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;
+        }
+    }
+
+// ANDROID ADDED 
+
+    /**
+     * @tests java.math.BigDecimal#intValueExact() Integer value of a negative
+     *        BigDecimal
+     */
+    public void test_IntValueExactNeg() {
+        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.intValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#intValueExact() Integer value of a positive
+     *        BigDecimal
+     */
+    public void test_IntValueExactPos() {
+        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.intValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#intValueExact() Integer value of a negative
+     *        BigDecimal
+     */
+    public void test_IntValueExactFloatNeg() {
+        BigDecimal aNumber = new BigDecimal("-2147483647.999");
+        try {
+            aNumber.intValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#intValueExact() Integer value of a positive
+     *        BigDecimal
+     */
+    public void test_IntValueExactFloatPos() {
+        float a = 2147483646.99999F;
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.intValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#intValueExact() Integer value of a positive
+     *        BigDecimal
+     */
+    public void test_IntValueExactLongPos() {
+        long a = 2147483647L;
+        BigDecimal aNumber = new BigDecimal(a);
+        int iNumber = aNumber.intValueExact();
+        assertTrue("incorrect value", iNumber == a);
+    }
+
+    /**
+     * @tests java.math.BigDecimal#intValueExact() Integer value of a positive
+     *        BigDecimal
+     */
+    public void test_IntValueExactLongNeg() {
+        long a = -2147483648L;
+        BigDecimal aNumber = new BigDecimal(a);
+        int iNumber = aNumber.intValueExact();
+        assertTrue("incorrect value", iNumber == a);
+    }
+
+    /**
+     * @tests java.math.BigDecimal#longValueExact() Long value of a negative
+     *        BigDecimal
+     */
+    public void test_LongValueExactNeg() {
+        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.longValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#longValueExact() Long value of a positive
+     *        BigDecimal
+     */
+    public void test_LongValueExactPos() {
+        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.longValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#longValueExact() Long value of a negative
+     *        BigDecimal
+     */
+    public void test_LongValueExactFloatNeg() {
+        BigDecimal aNumber = new BigDecimal("-9223372036854775807.99999");
+        try {
+            aNumber.longValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @tests java.math.BigDecimal#longValueExact() Long value of a positive
+     *        BigDecimal
+     */
+    public void test_LongValueExactFloatPos() {
+        float a = 9223372036854775806.99999F;
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.longValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert pisitive BigDesimal
+     *       to byte type
+     */
+    public void test_ByteValueExactPos() {
+        int i = 127;
+        BigDecimal bdNumber = new BigDecimal(i);
+        byte bNumber = bdNumber.byteValueExact();
+        assertTrue("incorrect byteValueExact", i == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert negative BigDesimal
+     *       to byte type
+     */
+    public void test_ByteValueExactNeg() {
+        String sNumber = "-127.56789";
+        int iNumber = -128;
+        int iPresition = 3;
+        MathContext mc = new MathContext(iPresition, RoundingMode.UP);
+        BigDecimal bdNumber = new BigDecimal(sNumber, mc);
+        byte bNumber = bdNumber.byteValueExact();
+        assertTrue("incorrect byteValueExact", iNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from char array to byte type
+     */
+
+    public void test_ByteValueExactCharZero() {
+        char[] cNumber = {
+                '-', '0', '.', '0'
+        };
+        int iNumber = 0;
+        int iPresition = 5;
+        MathContext mc = new MathContext(iPresition, RoundingMode.HALF_DOWN);
+        BigDecimal bdNumber = new BigDecimal(cNumber, mc);
+        byte bNumber = bdNumber.byteValueExact();
+        assertTrue("incorrect byteValueExact", iNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from String to byte type
+     */
+
+    public void test_ByteValueExactStringZero() {
+        String sNumber = "00000000000000";
+        int iNumber = 0;
+        int iPresition = 0;
+        MathContext mc = new MathContext(iPresition, RoundingMode.HALF_UP);
+        BigDecimal bdNumber = new BigDecimal(sNumber, mc);
+        byte bNumber = bdNumber.byteValueExact();
+        assertTrue("incorrect byteValueExact", iNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from double to byte type
+     */
+
+    public void test_ByteValueExactDoubleMax() {
+        double dNumber = Double.MAX_VALUE;
+        BigDecimal bdNumber = new BigDecimal(dNumber);
+        try {
+            bdNumber.byteValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from double to byte type
+     */
+
+    public void test_ByteValueExactDoubleMin() {
+        double dNumber = Double.MIN_VALUE;
+        BigDecimal bdNumber = new BigDecimal(dNumber);
+        try {
+            bdNumber.byteValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from float to byte type
+     */
+
+    public void test_ByteValueExactFloatPos() {
+        float fNumber = 123.5445F;
+        BigDecimal bdNumber = new BigDecimal(fNumber);
+        try {
+            bdNumber.byteValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from float to byte type
+     */
+
+    public void test_ByteValueExactFloatNeg() {
+        float fNumber = -12.987654321F;
+        BigDecimal bdNumber = new BigDecimal(fNumber);
+        try {
+            bdNumber.byteValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from double to byte type
+     */
+
+    public void test_ByteValueExactDouble() {
+        double dNumber = 123.0000D;
+        BigDecimal bdNumber = new BigDecimal(dNumber);
+        byte bNumber = bdNumber.byteValueExact();
+        assertTrue("incorrect byteValueExact", dNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from long to byte type
+     */
+
+    public void test_ByteValueExactLongMin() {
+        long lNumber = Long.MIN_VALUE;
+        BigDecimal bdNumber = new BigDecimal(lNumber);
+        try {
+            bdNumber.byteValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValueExact() Convert BigDesimal created
+     *       from int to byte type
+     */
+
+    public void test_ByteValueExactIntMax() {
+        int iNumber = Integer.MAX_VALUE;
+        BigDecimal bdNumber = new BigDecimal(iNumber);
+        try {
+            bdNumber.byteValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert pisitive BigDesimal to
+     *       byte type
+     */
+    public void test_ByteValuePos() {
+        int i = 127;
+        BigDecimal bdNumber = new BigDecimal(i);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", i == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert negative BigDesimal to
+     *       byte type
+     */
+    public void test_ByteValueNeg() {
+        String sNumber = "-127.56789";
+        int iNumber = -128;
+        int iPresition = 3;
+        MathContext mc = new MathContext(iPresition, RoundingMode.UP);
+        BigDecimal bdNumber = new BigDecimal(sNumber, mc);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValueExact", iNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       char array to byte type
+     */
+
+    public void test_ByteValueCharZero() {
+        char[] cNumber = {
+                '-', '0', '.', '0'
+        };
+        int iNumber = 0;
+        int iPresition = 0;
+        MathContext mc = new MathContext(iPresition, RoundingMode.HALF_UP);
+        BigDecimal bdNumber = new BigDecimal(cNumber, mc);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", iNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       String to byte type
+     */
+
+    public void test_ByteValueStringZero() {
+        String sNumber = "00000";
+        int iNumber = 0;
+        int iPresition = 0;
+        MathContext mc = new MathContext(iPresition, RoundingMode.HALF_UP);
+        BigDecimal bdNumber = new BigDecimal(sNumber, mc);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", iNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       double to byte type
+     */
+
+    public void test_ByteValueDoubleMax() {
+        double dNumber = Double.MAX_VALUE;
+        BigDecimal bdNumber = new BigDecimal(dNumber);
+        int result = 0;
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", bNumber == result);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       double to byte type
+     */
+
+    public void test_ByteValueDoubleMin() {
+        double dNumber = Double.MIN_VALUE;
+        BigDecimal bdNumber = new BigDecimal(dNumber);
+        int result = 0;
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", bNumber == result);
+    }
+
+    /**
+     * @test_ java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *        float to byte type
+     */
+
+    public void test_ByteValueFloatNeg() {
+        float fNumber = -12.987654321F;
+        byte bValue = -12;
+        BigDecimal bdNumber = new BigDecimal(fNumber);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", bNumber == bValue);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       double to byte type
+     */
+
+    public void test_ByteValueDouble() {
+        double dNumber = 123.0000D;
+        BigDecimal bdNumber = new BigDecimal(dNumber);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", dNumber == bNumber);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       long to byte type
+     */
+
+    public void test_ByteValueLongMin() {
+        long lNumber = Long.MIN_VALUE;
+        int result = 0;
+        BigDecimal bdNumber = new BigDecimal(lNumber);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", bNumber == result);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       int to byte type
+     */
+
+    public void test_ByteValueIntMin() {
+        int iNumber = Integer.MIN_VALUE;
+        int result = 0;
+        BigDecimal bdNumber = new BigDecimal(iNumber);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", bNumber == result);
+    }
+
+    /**
+     * @test java.math.BigDecimal#byteValue() Convert BigDesimal created from
+     *       int to byte type
+     */
+
+    public void test_ByteValueIntMax() {
+        int iNumber = Integer.MAX_VALUE;
+        int result = -1;
+        BigDecimal bdNumber = new BigDecimal(iNumber);
+        byte bNumber = bdNumber.byteValue();
+        assertTrue("incorrect byteValue", bNumber == result);
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValue() Short value of a negative
+     *       BigDecimal
+     */
+    public void test_ShortValueNeg() {
+        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        int result = 23449;
+        assertTrue("incorrect value", aNumber.shortValue() == result);
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValue() Short value of a positive
+     *       BigDecimal
+     */
+    public void test_ShortValuePos() {
+        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        int result = -23449;
+        assertTrue("incorrect value", aNumber.shortValue() == result);
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValueExact() Short value of a negative
+     *       BigDecimal
+     */
+    public void test_ShortValueExactNeg() {
+        String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.shortValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValueExact() Short value of a positive
+     *       BigDecimal
+     */
+    public void test_ShortValueExactPos() {
+        String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.shortValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValueExact() Short value of a negative
+     *       BigDecimal
+     */
+    public void test_ShortValueExactFloatNeg() {
+        BigDecimal aNumber = new BigDecimal("-32766.99999");
+        try {
+            aNumber.shortValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValueExact() Short value of a positive
+     *       BigDecimal
+     */
+    public void test_ShortValueExactFloatPos() {
+        float a = 32767.99999F;
+        BigDecimal aNumber = new BigDecimal(a);
+        try {
+            aNumber.shortValueExact();
+            fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
+        } catch (java.lang.ArithmeticException ae) {
+            // expected;
+        }
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValueExact() Short value of a positive
+     *       BigDecimal
+     */
+    public void test_ShortValueExactLongPos() {
+        long a = 12345L;
+        BigDecimal aNumber = new BigDecimal(a);
+        short shNumber = aNumber.shortValueExact();
+        assertTrue("incorrect value", shNumber == a);
+    }
+
+    /**
+     * @test java.math.BigDecimal#shortValueExact() Short value of a positive
+     *       BigDecimal
+     */
+    public void test_ShortValueExactLongNeg() {
+        long a = -12345L;
+        BigDecimal aNumber = new BigDecimal(a);
+        int iNumber = aNumber.shortValueExact();
+        assertTrue("incorrect value", iNumber == a);
+    }
+
+    /**
+     * @tests java.math.BigDecimal#stripTrailingZeros() stripTrailingZeros() for
+     *        BigDecimal with zero
+     */
+    public void test_stripTrailingZerosZeros() {
+
+        BigDecimal bdNumber = new BigDecimal("0000000");
+        BigDecimal result = bdNumber.stripTrailingZeros();
+        assertEquals("incorrect value", result.unscaledValue(), bdNumber.unscaledValue());
+        assertTrue("incorrect value", result.scale() == 0);
+
+        bdNumber = new BigDecimal(0);
+        result = bdNumber.stripTrailingZeros();
+        assertEquals("incorrect value", result.unscaledValue(), bdNumber.unscaledValue());
+        assertTrue("incorrect value", result.scale() == 0);
+
+        bdNumber = new BigDecimal(0.000000);
+        result = bdNumber.stripTrailingZeros();
+        assertEquals("incorrect value", result.unscaledValue(), bdNumber.unscaledValue());
+        assertTrue("incorrect value", result.scale() == 0);
+    }
+
+    /**
+     * @tests java.math.BigDecimal#stripTrailingZeros() stripTrailingZeros() for
+     *        positive BigDecimal
+     */
+    public void test_stripTrailingZeros() {
+
+        String s = "00000000100000000100000000.000000000100000000";
+        int iScale = 10;
+        BigDecimal bdValue = new BigDecimal("1000000001000000000000000001");
+        BigDecimal bdNumber = new BigDecimal(s);
+        BigDecimal bdResult = bdNumber.stripTrailingZeros();
+        assertEquals("incorrect value", bdResult.unscaledValue(), bdValue.unscaledValue());
+        assertTrue("incorrect value", bdResult.scale() == iScale);
+
+        s = "1000.0";
+        iScale = -3;
+        BigDecimal bd = new BigDecimal("1");
+        bdNumber = new BigDecimal(s);
+        bdResult = bdNumber.stripTrailingZeros();
+        assertEquals("incorrect value", bdResult.unscaledValue(), bd.unscaledValue());
+        assertTrue("incorrect value", bdResult.scale() == iScale);
+    }
+}
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
new file mode 100644
index 0000000..0b0d165
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalScaleOperationsTest.java
@@ -0,0 +1,376 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "Underflow", e.getMessage());
+        }
+    }
+
+    /**
+     * 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);
+    }
+    
+/// ANDROID ADDED
+    
+    /**
+     * check that setScale with a scale greater to the existing scale does not
+     * change the value.
+     */
+    public void testSetScale() {
+        BigDecimal x1 = new BigDecimal(1.23400);
+        BigDecimal x2 = x1.setScale(75);
+        
+        assertEquals(0, x1.compareTo(x2));
+        assertEquals(0, x2.compareTo(x1));
+        
+        x1.precision();
+        
+        assertEquals(0, x1.compareTo(x2));
+        assertEquals(0, x2.compareTo(x1));
+       
+        x2.precision();
+        
+        assertEquals(0, x1.compareTo(x2));
+        assertEquals(0, x2.compareTo(x1));
+    }
+    
+
+}
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
new file mode 100644
index 0000000..7049cf4
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAddTest.java
@@ -0,0 +1,496 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..43d0556
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerAndTest.java
@@ -0,0 +1,433 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..b700d62
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerCompareTest.java
@@ -0,0 +1,534 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..ad9b118
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConstructorsTest.java
@@ -0,0 +1,857 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "Zero length BigInteger", e.getMessage());
+        }
+    }
+    
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Invalid signum value", e.getMessage());
+        }
+    }
+    
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Radix out of range", e.getMessage());
+        }
+    }
+    
+    /**
+     * 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);
+    }
+
+// Commented out as BIGNUM returns no Primes smaller than 16 bits.
+// BEGIN android-removed
+//
+//    /**
+//     * 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);
+//System.out.println(aNumber);
+//System.out.println(aNumber.bitLength());
+//        assertTrue("incorrect bitLength", aNumber.bitLength() == bitLen);
+//        int num = aNumber.intValue();
+//        assertTrue("incorrect value", num == 2 || num == 3);
+//    }
+// END android-removed
+
+// ANDROID ADDED
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrString1() {
+        String s = "0";
+        BigInteger bi_s = new BigInteger(s);
+        assertTrue("the BigInteger value is not initialized properly", bi_s.intValue() == 0);
+        assertEquals("the BigInteger value is not initialized properly", bi_s.toString(), s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrString2() {
+        String s = "-2147483648";
+        BigInteger bi_s = new BigInteger(s);
+        assertTrue("the BigInteger value is not initialized properly",
+                bi_s.intValue() == Integer.MIN_VALUE);
+        assertEquals("the BigInteger value is not initialized properly", bi_s.toString(), s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrString3() {
+        String s = "2147483647";
+        BigInteger bi_s = new BigInteger(s);
+        assertTrue("the BigInteger value is not initialized properly",
+                bi_s.intValue() == Integer.MAX_VALUE);
+        assertEquals("the BigInteger value is not initialized properly", bi_s.toString(), s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrStringExc1() {
+        try {
+            new BigInteger("01234 56");
+            fail("NumberFormatException has not been caught");
+        } catch (NumberFormatException e) {
+        }
+    }
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrStringExc2() {
+        try {
+            new BigInteger("1234#56");
+            fail("NumberFormatException has not been caught");
+        } catch (NumberFormatException e) {
+        }
+    }
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrStringExc3() {
+        try {
+            new BigInteger("1234.56");
+            fail("NumberFormatException has not been caught");
+        } catch (NumberFormatException e) {
+        }
+    }
+
+    /**
+     * @tests java.math.BigInteger#BigInteger(java.lang.String)
+     */
+    public void test_ConstrStringExc4() {
+        try {
+            new BigInteger("1E+1");
+            fail("NumberFormatException has not been caught");
+        } catch (NumberFormatException e) {
+        }
+    }
+}
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
new file mode 100644
index 0000000..70966b5
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerConvertTest.java
@@ -0,0 +1,793 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..10bf147
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerDivideTest.java
@@ -0,0 +1,671 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "BigInteger divide by zero", e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "BigInteger divide by zero", e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "BigInteger divide by zero", e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "BigInteger: modulus not positive", e.getMessage());
+        }
+    }
+
+    /**
+     * 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
new file mode 100644
index 0000000..f6c17a8
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerHashCodeTest.java
@@ -0,0 +1,81 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..b2bd801
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerModPowTest.java
@@ -0,0 +1,325 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "BigInteger: modulus not positive", e.getMessage());
+        }
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "BigInteger: modulus not positive", e.getMessage());
+        }
+    }
+    
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "BigInteger not invertible.", e.getMessage());
+        }
+    }
+
+    /**
+     * 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
new file mode 100644
index 0000000..cbd15e9
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerMultiplyTest.java
@@ -0,0 +1,390 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "Negative exponent", e.getMessage());
+        }
+    }
+
+    /**
+     * 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
new file mode 100644
index 0000000..3305571
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerNotTest.java
@@ -0,0 +1,193 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..3a05e31
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOperateBitsTest.java
@@ -0,0 +1,1452 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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) {
+            assertEquals("Improper exception message", "Negative bit address", e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Negative bit address", e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Negative bit address", e.getMessage());
+        }
+    }
+
+    /**
+     * 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) {
+            assertEquals("Improper exception message", "Negative bit address", e.getMessage());
+        }
+    }
+
+    /**
+     * 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));
+    }
+
+// ANDROID ADDED
+
+    /**
+     * @tests java.math.BigInteger#getLowestSetBit() getLowestSetBit for
+     *        negative BigInteger
+     */
+    public void test_getLowestSetBitNeg() {
+        byte aBytes[] = {
+                -1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26
+        };
+        int aSign = -1;
+        int iNumber = 1;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        int result = aNumber.getLowestSetBit();
+        assertTrue("incorrect value", result == iNumber);
+    }
+
+    /**
+     * @tests java.math.BigInteger#getLowestSetBit() getLowestSetBit for
+     *        positive BigInteger
+     */
+    public void test_getLowestSetBitPos() {
+        byte aBytes[] = {
+                -1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26
+        };
+        int aSign = 1;
+        int iNumber = 1;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        int result = aNumber.getLowestSetBit();
+        assertTrue("incorrect value", result == iNumber);
+
+        byte[] aBytes_ = {
+                127, 0, 3
+        };
+        iNumber = 0;
+        aNumber = new BigInteger(aSign, aBytes_);
+        result = aNumber.getLowestSetBit();
+        assertTrue("incorrect value", result == iNumber);
+
+        byte[] aBytes__ = {
+                -128, 0, 0
+        };
+        iNumber = 23;
+        aNumber = new BigInteger(aSign, aBytes__);
+        result = aNumber.getLowestSetBit();
+        assertTrue("incorrect value", result == iNumber);
+    }
+
+    /**
+     * @tests java.math.BigInteger#getLowestSetBit() getLowestSetBit for zero
+     *        BigInteger
+     */
+    public void test_getLowestSetBitZero() {
+        byte[] aBytes = {
+            0
+        };
+        int aSign = 0;
+        int iNumber = -1;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        int result = aNumber.getLowestSetBit();
+        assertTrue("incorrect value", result == iNumber);
+
+        byte[] aBytes_ = {
+                0, 0, 0
+        };
+        iNumber = -1;
+        aNumber = new BigInteger(aSign, aBytes_);
+        result = aNumber.getLowestSetBit();
+        assertTrue("incorrect value", result == iNumber);
+    }
+
+}
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
new file mode 100644
index 0000000..4b5ae83
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerOrTest.java
@@ -0,0 +1,420 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..f0a6332
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerSubtractTest.java
@@ -0,0 +1,548 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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
new file mode 100644
index 0000000..8a4b0e4
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerToStringTest.java
@@ -0,0 +1,228 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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));
+    }
+
+// ANDROID ADDED
+
+    /**
+     * @tests java.math.BigInteger#toString()
+     */
+    public void test_toString1() {
+
+        String s = "0000000000";
+        BigInteger bi = new BigInteger(s);
+        String sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, "0");
+    }
+
+    /**
+     * @tests java.math.BigInteger#toString()
+     */
+    public void test_toString2() {
+        String s = "1234567890987654321";
+        BigInteger bi = new BigInteger(s);
+        String sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#toString()
+     */
+    public void test_toString3() {
+        String s = "-1234567890987654321";
+        BigInteger bi = new BigInteger(s);
+        String sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#toString()
+     */
+    public void test_toString4() {
+        String s = "12345678901234";
+        long l = 12345678901234L;
+        BigInteger bi = BigInteger.valueOf(l);
+        String sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#toString()
+     */
+    public void test_toString5() {
+        String s = "-12345678901234";
+        long l = -12345678901234L;
+        BigInteger bi = BigInteger.valueOf(l);
+        String sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, s);
+    }
+
+    /**
+     * @tests java.math.BigInteger#toString()
+     */
+    public void test_toString() {
+        byte aBytes[] = {
+                12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91
+        };
+        String s = "247856948764430159964673417020251";
+        BigInteger bi = new BigInteger(aBytes);
+        String sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, s);
+        byte aBytes_[] = {
+                -12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91
+        };
+        s = "-238920881723209930210060613844133";
+        bi = new BigInteger(aBytes_);
+        sBI = bi.toString();
+        assertEquals("toString method returns incorrect value instead of " + s, sBI, s);
+    }
+}
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
new file mode 100644
index 0000000..1e87786
--- /dev/null
+++ b/math/src/test/java/org/apache/harmony/tests/java/math/BigIntegerXorTest.java
@@ -0,0 +1,278 @@
+/*
+ *  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
+ * @version $Revision$
+ */
+
+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/AllTests.java b/math/src/test/java/tests/api/java/math/AllTests.java
new file mode 100644
index 0000000..2888ba0
--- /dev/null
+++ b/math/src/test/java/tests/api/java/math/AllTests.java
@@ -0,0 +1,39 @@
+/* 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 junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Test suite that includes all tests for the Math project.
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite("Tests for java.math");
+        // $JUnit-BEGIN$
+        suite.addTestSuite(BigDecimalTest.class);
+        suite.addTestSuite(BigIntegerTest.class);
+        // $JUnit-END$
+        return suite;
+    }
+}
diff --git a/math/src/test/java/tests/api/java/math/BigDecimalTest.java b/math/src/test/java/tests/api/java/math/BigDecimalTest.java
new file mode 100644
index 0000000..ac67ac9
--- /dev/null
+++ b/math/src/test/java/tests/api/java/math/BigDecimalTest.java
@@ -0,0 +1,953 @@
+/*
+ *  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)
+				);
+		
+		/* Zero */
+        //regression for HARMONY-4623, NON-BUG DIFF with RI
+		BigDecimal zerotest = new BigDecimal("0.0000");
+		assertTrue("stripTrailingZero failed for 0.0000",
+				((zerotest.stripTrailingZeros()).scale() == 0)
+				);		
+	}	
+
+	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
new file mode 100644
index 0000000..5a4fae7
--- /dev/null
+++ b/math/src/test/java/tests/api/java/math/BigIntegerTest.java
@@ -0,0 +1,1065 @@
+/*
+ *  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));
+    }
+
+// mc: Commented out as BIGNUM returns no Primes smaller than 16 bits.
+// BEGIN android-removed
+//
+//    /**
+//     * @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);
+//            }
+//        }
+//    }
+// END android-removed
+
+    /**
+     * @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);
+    }
+
+
+// BEGIN android-added
+//    public void testModPowPerformance() {
+//        Random rnd = new Random();
+//        for (int i = 0; i < 10; i++) {
+//            BigInteger a = new BigInteger(512, rnd);
+//            BigInteger m = new BigInteger(1024, rnd);
+//            BigInteger p = new BigInteger(256, rnd);
+//            BigInteger mp = a.modPow(p, m);
+//            System.out.println(mp);
+//        }
+//    }
+
+// shows factor 20 speed up (BIGNUM to Harmony Java):
+//    public void testNextProbablePrime() {
+//        Random rnd = new Random();
+//        rnd.setSeed(0);
+//        for (int i = 1; i <= 32; i += 1) {
+//            BigInteger a = new BigInteger(i, rnd);
+//            System.out.println(a);
+//            BigInteger prime = a.nextProbablePrime();
+//            System.out.print("Next Probable Prime is ");
+//            System.out.println(prime);
+//        }
+//        for (int i = 1; i <= 32; i += 4) {
+//            BigInteger a = new BigInteger(32 * i, rnd);
+//            System.out.println(a);
+//            BigInteger prime = a.nextProbablePrime();
+//            System.out.print("Next Probable Prime is ");
+//            System.out.println(prime);
+//        }
+//    }
+
+// shows factor 20 speed up (BIGNUM to Harmony Java):
+// shows that certainty 80 is "practically aquivalent" to certainty 100
+//    public void testPrimeGenPerformance() {
+//        Random rnd = new Random();
+//        rnd.setSeed(0);
+//        for (int i = 1; i <= 32; i +=8 ) {
+//            BigInteger a = new BigInteger(32 * i, 80, rnd);
+//            System.out.println(a);
+//            System.out.println("Now testing it again:");
+//            if (a.isProbablePrime(100)) {
+//                System.out.println("************************ PASSED! **************************");
+//            } else {
+//                System.out.println("************************ FAILED!!! **************************");
+//                System.out.println("************************ FAILED!!! **************************");
+//                System.out.println("************************ FAILED!!! **************************");
+//                System.out.println("************************ FAILED!!! **************************");
+//                System.out.println("************************ FAILED!!! **************************");
+//                System.out.println("************************ FAILED!!! **************************");
+//            }
+//        }
+//    }
+// END android-added
+
+
+    /**
+     * @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));
+            }
+        }
+    }
+    
+
+     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());
+    }
+}
diff --git a/math/src/test/java/tests/math/AllTests.java b/math/src/test/java/tests/math/AllTests.java
new file mode 100644
index 0000000..20664fd
--- /dev/null
+++ b/math/src/test/java/tests/math/AllTests.java
@@ -0,0 +1,61 @@
+/* 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.math;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Test suite that includes all tests for the Math project.
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(AllTests.suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite("All Math test suites");
+
+        suite.addTest(tests.api.java.math.AllTests.suite());
+
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigDecimalArithmeticTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigDecimalCompareTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigDecimalConstructorsTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigDecimalConvertTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigDecimalScaleOperationsTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerAddTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerAndTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerCompareTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerConstructorsTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerConvertTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerDivideTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerHashCodeTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerModPowTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerMultiplyTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerNotTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerOperateBitsTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerOrTest.class);
+        // suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerProbablePrimeTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerSubtractTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerToStringTest.class);
+        suite.addTestSuite(org.apache.harmony.tests.java.math.BigIntegerXorTest.class);
+        // suite.addTestSuite(org.apache.harmony.tests.java.math.MathContextConstructorsTest.class);
+        // suite.addTestSuite(org.apache.harmony.tests.java.math.MathContextMethodsTest.class);
+        return suite;
+    }
+}