diff options
Diffstat (limited to 'math/src/test')
27 files changed, 21117 insertions, 0 deletions
diff --git a/math/src/test/java/org/apache/harmony/math/tests/java/math/AllTests.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/AllTests.java new file mode 100644 index 0000000..318e4b6 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/AllTests.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.harmony.math.tests.java.math; + +import junit.framework.Test; +import junit.framework.TestSuite; + +/** + * This is autogenerated source file. Includes tests for package org.apache.harmony.tests.java.math; + */ + +public class AllTests { + + public static void main(String[] args) { + junit.textui.TestRunner.run(AllTests.suite()); + } + + public static Test suite() { + TestSuite suite = tests.TestSuiteFactory.createTestSuite("All tests for package org.apache.harmony.tests.java.math;"); + // $JUnit-BEGIN$ + + suite.addTestSuite(BigDecimalArithmeticTest.class); + suite.addTestSuite(BigDecimalCompareTest.class); + suite.addTestSuite(BigDecimalConstructorsTest.class); + suite.addTestSuite(BigDecimalConvertTest.class); + suite.addTestSuite(BigDecimalScaleOperationsTest.class); + suite.addTestSuite(BigIntegerAddTest.class); + suite.addTestSuite(BigIntegerAndTest.class); + suite.addTestSuite(BigIntegerCompareTest.class); + suite.addTestSuite(BigIntegerConstructorsTest.class); + suite.addTestSuite(BigIntegerConvertTest.class); + suite.addTestSuite(BigIntegerDivideTest.class); + suite.addTestSuite(BigIntegerHashCodeTest.class); + suite.addTestSuite(BigIntegerModPowTest.class); + suite.addTestSuite(BigIntegerMultiplyTest.class); + suite.addTestSuite(BigIntegerNotTest.class); + suite.addTestSuite(BigIntegerOperateBitsTest.class); + suite.addTestSuite(BigIntegerOrTest.class); + suite.addTestSuite(BigIntegerSubtractTest.class); + suite.addTestSuite(BigIntegerToStringTest.class); + suite.addTestSuite(BigIntegerXorTest.class); + + // $JUnit-END$ + return suite; + } +} diff --git a/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalArithmeticTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalArithmeticTest.java new file mode 100644 index 0000000..b2375f8 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalArithmeticTest.java @@ -0,0 +1,2965 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.KnownFailure; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargetNew; + +import junit.framework.TestCase; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.MathContext; +import java.math.RoundingMode; +@TestTargetClass(BigDecimal.class) +/** + * Class: java.math.BigDecimal + * Methods: add, subtract, multiply, divide + */ +public class BigDecimalArithmeticTest extends TestCase { + + /** + * Add two numbers of equal positive scales + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Together with all other methods including a MathContext these tests form m a complete test set.", + method = "add", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Together with all other methods including a MathContext these tests form a complete test set.", + method = "add", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Together with all other methods including a MathContext these tests form a complete test set.", + method = "add", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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, result.toString()); + assertEquals("incorrect scale", cScale, result.scale()); + } + + /** + * Add two numbers of different scales; the first is negative + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "add", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testAddMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("123456789012345.678"); + b = new BigDecimal("100000000000000.009"); + assertEquals("incorrect value", "123456789012345.67", + a.round(mc).toString()); + assertEquals("incorrect value", "100000000000000.00", + b.round(mc).toString()); + assertEquals("incorrect value", "223456789012345.67", + a.round(mc).add(b.round(mc)).toString()); + res = a.add(b, mc); + assertEquals("incorrect value", "223456789012345.68", res.toString()); + + mc = new MathContext(33, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("1000000000000000090000000000.0000005"); + res = a.add(b, mc); + assertEquals("Incorrect value!", "2234567890123456879012345678.90124", res.toString()); + assertEquals("Incorrect scale!", 5, res.scale()); + assertEquals("Incorrect precision!", 33, res.precision()); + } + + /** + * Subtract two numbers of equal positive scales + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "subtract", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "subtract", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "subtract", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "subtract", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "subtract", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "subtract", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "subtract", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "subtract", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testSubtractMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("12345678901234567.8"); + b = new BigDecimal("10000000000000000.9"); + assertEquals("incorrect value", "2345678901234567", + a.round(mc).subtract(b.round(mc)).toString()); + res = a.subtract(b, mc); + assertEquals("incorrect value", "2345678901234566.9", res.toString()); + assertEquals("Incorrect scale!", 1, res.scale()); + assertEquals("Incorrect precision!", 17, res.precision()); + + mc = new MathContext(33, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("1000000000000000090000000000.0000005"); + res = a.subtract(b, mc); + assertEquals("incorrect value", "234567890123456699012345678.901239", res.toString()); + assertEquals("Incorrect scale!", 6, res.scale()); + assertEquals("Incorrect precision!", 33, res.precision()); + } + + /** + * Multiply two numbers of positive scales + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "multiply", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "multiply", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "multiply", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "multiply", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "multiply", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method.", + method = "multiply", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "multiply", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "multiply", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testMultiplyMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("92345678901234567.8"); + b = new BigDecimal("10000000000000000.9"); + res = a.round(mc).multiply(b.round(mc)); + assertEquals("incorrect value", "923456789012345670000000000000000", res.toString()); + res = res.round(mc); + assertEquals("incorrect value", "9.2345678901234567E+32", res.toString()); + res = a.multiply(b, mc); + assertEquals("incorrect value", "9.2345678901234576E+32", res.toString()); + assertEquals("Incorrect scale!", -16, res.scale()); + assertEquals("Incorrect precision!", 17, res.precision()); + } + + /** + * pow(int) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "pow", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "pow", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "pow", + args = {int.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "pow", + args = {int.class} + ) + public void testPowNonTrivial() { + BigDecimal a, b, res; + + a = new BigDecimal("100.9"); + try { + res = a.pow(-1); + fail("ArithmeticException is not thrown for negative exponent"); + } catch (ArithmeticException e) { + // expected + } + try { + res = a.pow(-103); + fail("ArithmeticException is not thrown for negative exponent"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * pow(int, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "pow", + args = {int.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "pow", + args = {int.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testPowMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(7, RoundingMode.FLOOR); + a = new BigDecimal("1000000.9"); + assertEquals("incorrect value", "1.000000E+6000", + a.round(mc).pow(1000).round(mc).toString()); + res = a.pow(1000, mc); + assertEquals("incorrect value", "1.000900E+6000", res.toString()); + + mc = new MathContext(4, RoundingMode.FLOOR); + a = new BigDecimal("1000.9"); + assertEquals("incorrect value", "1.000E+3000", + a.round(mc).pow(1000).round(mc).toString()); + res = a.pow(1000, mc); + assertEquals("incorrect value", "2.458E+3000", res.toString()); + + mc = new MathContext(2, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234"); + try { + res = a.pow(-2, mc); + fail("ArithmeticException is not thrown"); + } catch (ArithmeticException e) { + // expected + } + + a = new BigDecimal("100"); + mc = new MathContext(4, RoundingMode.UNNECESSARY); + res = a.pow(-2, mc); + assertEquals("incorrect value", "0.0001", res.toString()); + + a = new BigDecimal("1000.9"); + try { + mc = new MathContext(0, RoundingMode.FLOOR); + res = a.pow(-1, mc); + fail("ArithmeticException is not thrown for negative exponent and precision = 0"); + } catch (ArithmeticException e) { + // expected + } + + a = new BigDecimal("000.0001"); + try { + mc = new MathContext(0, RoundingMode.FLOOR); + res = a.pow(-1, mc); + fail("ArithmeticException is not thrown for negative exponent and precision = 0"); + } catch (ArithmeticException e) { + // expected + } + + a = new BigDecimal("1E-400"); + mc = new MathContext(4, RoundingMode.UNNECESSARY); + res = a.pow(-1, mc); + assertEquals("incorrect value", "1E+400", res.toString()); + +// Doesn't succeed against JDK of Sun!: +// mc = new MathContext(3, RoundingMode.FLOOR); +// a = new BigDecimal("100.9"); +// assertEquals("incorrect value", "1.00E+2000", +// a.round(mc).pow(1000).round(mc).toString()); +// res = a.pow(1000).round(mc); +// res = a.pow(1000, mc); +// assertEquals("incorrect value", "7.783E+2003", res.toString()); + } + + /** + * Divide by zero + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "ArithmeticException checked.", + method = "divide", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException only checked.", + method = "divide", + args = {java.math.BigDecimal.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "IllegalArgumentException only checked.", + method = "divide", + args = {java.math.BigDecimal.class, int.class} + ) + 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()); + } + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divide", + args = {java.math.BigDecimal.class, int.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testDivideINonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("12345678901234567E1234"); + b = new BigDecimal("1.23456789012345679"); + assertEquals("incorrect value", "1E+1250", + a.round(mc).divide(b.round(mc)).toString()); + res = a.divide(b, BigDecimal.ROUND_FLOOR); + assertEquals("incorrect value", "9.999999999999999E+1249", res.toString()); + + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("6172839450617283945061728394.5061975"); + res = a.divide(b, BigDecimal.ROUND_UNNECESSARY); + assertEquals("incorrect value", "0.2000000", res.toString()); + + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("1000000000000000090000000000.0000005"); + try { + res = a.divide(b, BigDecimal.ROUND_UNNECESSARY); + fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * Divide: local variable exponent is less than zero + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed. Should be added checking for ArithmeticException to complete functional testing.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ROUND_UNNECESSARY and exceptions checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + public void testDivideIINonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("12345678901234567E1234"); + b = new BigDecimal("1.23456789012345679"); + res = a.divide(b, -1220, BigDecimal.ROUND_FLOOR); + assertEquals("incorrect value", "9.99999999999999927099999343899E+1249", res.toString()); + + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("6172839450617283945061728394.5061975"); + res = a.divide(b, 1, BigDecimal.ROUND_UNNECESSARY); + assertEquals("incorrect value", "0.2", res.toString()); + + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("6172839450617283945061728394.5061975"); + try { + res = a.divide(b, 0, BigDecimal.ROUND_UNNECESSARY); + fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * Divide to BigDecimal + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Common functionality checked", + method = "divide", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Common functionality checked", + method = "divide", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException and UNNECESSARY round mode checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divide", + args = {java.math.BigDecimal.class, int.class, java.math.RoundingMode.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound IS INSUFFICIENT!!!") + public void testDivideScaleRoundingModeNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("12345678901234567.1"); + b = new BigDecimal("12345678901234567.9"); + assertEquals("incorrect value", "1", + a.round(mc).divide(b.round(mc)).toString()); + res = a.divide(b, mc); + assertEquals("incorrect value", "0.99999999999999993", res.toString()); + + mc = new MathContext(13, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("6172839450617283945061728394.5061975"); + res = a.divide(b, mc); + assertEquals("incorrect value", "0.2", res.toString()); + + mc = new MathContext(33, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("1000000000000000090000000000.0000005"); + try { + res = a.divide(b, mc); + fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * divide(BigDecimal, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divide", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound IS INSUFFICIENT!!!") + public void testDivideMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + +// FAILS AGAINST RI!: +// mc = new MathContext(6, RoundingMode.FLOOR); +// a = new BigDecimal("12345.1"); +// b = new BigDecimal("12345.9"); +// assertEquals("incorrect value", "1", +// a.round(mc).divide(b.round(mc)).toString()); +// res = a.divide(b, mc); +// assertEquals("incorrect value", "0.99993", res.toString()); + + mc = new MathContext(5, RoundingMode.FLOOR); + a = new BigDecimal("12345.1"); + b = new BigDecimal("12345.9"); + assertEquals("incorrect value", "1", + a.round(mc).divide(b.round(mc)).toString()); + res = a.divide(b, mc); + assertEquals("incorrect value", "0.99993", res.toString()); + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("12345678901234567.1"); + b = new BigDecimal("12345678901234567.9"); + assertEquals("incorrect value", "1", + a.round(mc).divide(b.round(mc)).toString()); + res = a.divide(b, mc); + assertEquals("incorrect value", "0.99999999999999993", res.toString()); + assertEquals("incorrect value", res.round(mc).toString(), res.toString()); + + mc = new MathContext(13, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("6172839450617283945061728394.5061975"); + res = a.divide(b, mc); + assertEquals("incorrect value", "0.2", res.toString()); + + mc = new MathContext(33, RoundingMode.UNNECESSARY); + a = new BigDecimal("1234567890123456789012345678.9012395"); + b = new BigDecimal("1000000000000000090000000000.0000005"); + try { + res = a.divide(b, mc); + fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * divideToIntegralValue(BigDecimal) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "divideToIntegralValue", + args = {java.math.BigDecimal.class} + ) + 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()); + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "divideToIntegralValue", + args = {java.math.BigDecimal.class} + ) + public void testDivideToIntegralValueByZero() { + String a = "3736186567876876578956958765675671119238118911893939591735"; + int aScale = 45; + String b = "0"; + 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); + try { + BigDecimal result = aNumber.divideToIntegralValue(bNumber); + fail("ArithmeticException not thrown for division by 0"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * divideToIntegralValue(BigDecimal, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divideToIntegralValue", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divideToIntegralValue", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divideToIntegralValue", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testDivideToIntegralValueMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + a = new BigDecimal("92345678901234567.8"); + b = new BigDecimal("43"); + res = a.multiply(b); + assertEquals("incorrect value", "3970864192753086415.4", res.toString()); + + mc = new MathContext(20, RoundingMode.DOWN); + a = new BigDecimal("3970864192753086415.4"); + b = new BigDecimal("92345678901234567.8"); + b = new BigDecimal("92345678901234567.8001"); + assertEquals("incorrect value", "43", + a.round(mc).divideToIntegralValue(b.round(mc)).toString()); + res = a.divideToIntegralValue(b, mc); + assertEquals("incorrect value", "42", res.toString()); + +// mc = new MathContext(1, RoundingMode.DOWN); +// res = a.divideToIntegralValue(b, mc); +// assertEquals("incorrect value", "42", res.toString()); + + + mc = new MathContext(17, RoundingMode.FLOOR); + a = new BigDecimal("518518513851851830"); + b = new BigDecimal("12345678901234567.9"); + assertEquals("incorrect value", "42", + a.round(mc).divideToIntegralValue(b.round(mc)).toString()); + res = a.divideToIntegralValue(b, mc); + assertEquals("incorrect value", "41", res.toString()); + } + + /** + * divideAndRemainder(BigDecimal) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "", + method = "divideAndRemainder", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "", + method = "divideAndRemainder", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "", + method = "divideAndRemainder", + args = {java.math.BigDecimal.class} + ) + public void testDivideAndRemainderByZero() { + String a = "3736186567876876578956958765675671119238118911893939591735"; + int aScale = 45; + String b = "0"; + 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); + try { + BigDecimal result[] = aNumber.divideAndRemainder(bNumber); + fail("ArithmeticException not thrown for division by 0"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * divideAndRemainder(BigDecimal, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divideAndRemainder", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "divideAndRemainder", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divideAndRemainder", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("WHY ISN'T THE LAST VALUE ROUNDED?") + public void testDivideAndRemainderMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res[]; + + mc = new MathContext(13, RoundingMode.FLOOR); + a = new BigDecimal("12345678901234567.1"); + b = new BigDecimal("12345678901234567.9"); + assertEquals("incorrect value", "0E+4", + a.round(mc).divideAndRemainder(b.round(mc))[1].toString()); + res = a.divideAndRemainder(b, mc); + assertEquals("incorrect value", "12345678901234567.1", res[1].toString()); + + mc = new MathContext(1, RoundingMode.UNNECESSARY); + a = new BigDecimal("6172839450617283945061728394.5061976"); + b = new BigDecimal("1234567890123456789012345678.9012395"); + res = a.divideAndRemainder(b, mc); + assertEquals("incorrect value", "1E-7", res[1].toString()); + + mc = new MathContext(3, RoundingMode.UNNECESSARY); + a = new BigDecimal("6172839450617283945061728394.6000000"); + b = new BigDecimal("1234567890123456789012345678.9012395"); + try { + res = a.divideAndRemainder(b, mc); + assertEquals("incorrect value", "0.0938025", res[1].toString()); + assertEquals("incorrect value", "0.09", res[1].round(mc).toString()); +// fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * remainder(BigDecimal) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "remainder", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "remainder", + args = {java.math.BigDecimal.class} + ) + 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()); + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "remainder", + args = {java.math.BigDecimal.class} + ) + public void testRemainderByZero() { + String a = "3736186567876876578956958765675671119238118911893939591735"; + int aScale = 45; + String b = "0"; + 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); + try { + BigDecimal result = aNumber.remainder(bNumber); + fail("ArithmeticException not thrown for division by 0"); + } catch (ArithmeticException e) { + // expected + } + } + /** + * remainder(BigDecimal, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "remainder", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "remainder", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + 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()); + } + + /** + * Non-trivial tests using MathContext: + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "remainder", + args = {java.math.BigDecimal.class, java.math.MathContext.class} + ) + @KnownFailure("WHY ISN'T THE LAST VALUE ROUNDED?") + public void testRemainderMathContextNonTrivial() { + MathContext mc; + BigDecimal a, b, res; + + mc = new MathContext(13, RoundingMode.DOWN); + a = new BigDecimal("12345678901234567.1"); + b = new BigDecimal("12345678901234567.9"); + assertEquals("incorrect value", "0E+4", + a.round(mc).divideAndRemainder(b.round(mc))[1].toString()); + res = a.remainder(b, mc); + assertEquals("incorrect value", "12345678901234567.1", res.toString()); + + mc = new MathContext(1, RoundingMode.UNNECESSARY); + a = new BigDecimal("6172839450617283945061728394.5061976"); + b = new BigDecimal("1234567890123456789012345678.9012395"); + res = a.remainder(b, mc); + assertEquals("incorrect value", "1E-7", res.toString()); + + mc = new MathContext(3, RoundingMode.UNNECESSARY); + a = new BigDecimal("6172839450617283945061728394.6000000"); + b = new BigDecimal("1234567890123456789012345678.9012395"); + try { + res = a.remainder(b, mc); + assertEquals("incorrect value", "0.0938025", res.toString()); + assertEquals("incorrect value", "0.09", res.round(mc).toString()); +// fail("ArithmeticException is not thrown for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * round(BigDecimal, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "round", + args = {java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "round", + args = {java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "round", + args = {java.math.MathContext.class} + ) + 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()); + } + + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "round", + args = {java.math.MathContext.class} + ) + public void testRoundNonTrivial() { + MathContext mc; + String biStr = new String( "12345678901234567890123456789012345.0E+10"); + String nbiStr = new String("-12345678901234567890123456789012345.E+10"); + BigDecimal bd; + + mc = new MathContext(17, RoundingMode.FLOOR); + bd = new BigDecimal(new BigInteger("123456789012345678"), 3, mc); + assertEquals("incorrect value", "123456789012345.67", bd.toString()); + + mc = new MathContext(31, RoundingMode.UP); + bd = (new BigDecimal(biStr)).round(mc); + assertEquals("incorrect value", "1.234567890123456789012345678902E+44", bd.toString()); + bd = (new BigDecimal(nbiStr)).round(mc); + assertEquals("incorrect value", "-1.234567890123456789012345678902E+44", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = (new BigDecimal(biStr)).round(mc); + assertEquals("incorrect value", "1.234567890123456789012345678E+44", bd.toString()); + bd = (new BigDecimal(nbiStr)).round(mc); + assertEquals("incorrect value", "-1.234567890123456789012345678E+44", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = (new BigDecimal(biStr)).round(mc); + assertEquals("incorrect value", "1.23456789012345678901234567890124E+44", bd.toString()); + bd = (new BigDecimal(nbiStr)).round(mc); + assertEquals("incorrect value", "-1.23456789012345678901234567890123E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = (new BigDecimal(biStr)).round(mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = (new BigDecimal(nbiStr)).round(mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + + mc = new MathContext(7, RoundingMode.FLOOR); + bd = new BigDecimal("1000000.9", mc); + assertEquals("incorrect value", "1000000", bd.toString()); + } + + /** + * ulp() of a positive BigDecimal + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for ulp method.", + method = "ulp", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for ulp method.", + method = "ulp", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for ulp method.", + method = "ulp", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigDecimal.class, java.math.RoundingMode.class} + ) + 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/math/tests/java/math/BigDecimalCompareTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalCompareTest.java new file mode 100644 index 0000000..a1b3202 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalCompareTest.java @@ -0,0 +1,743 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.KnownFailure; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargetNew; + +import junit.framework.TestCase; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.MathContext; +import java.math.RoundingMode; +@TestTargetClass(BigDecimal.class) +/** + * Class: java.math.BigDecimal + * Methods: abs, compareTo, equals, hashCode, + * max, min, negate, signum + */ +public class BigDecimalCompareTest extends TestCase { + /** + * Abs() of a negative BigDecimal + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for abs method.", + method = "abs", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for abs method.", + method = "abs", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Together with all other methods including a MathContext these tests for a complete test set.", + method = "abs", + args = {java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.abs") + 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()); + + mc = new MathContext(34, RoundingMode.UP); + assertEquals("incorrect value", "1.238096483923847545735673567457357E+53", aNumber.abs(mc).toString()); + + mc = new MathContext(34, RoundingMode.DOWN); + assertEquals("incorrect value", "1.238096483923847545735673567457356E+53", aNumber.abs(mc).toString()); + + mc = new MathContext(34, RoundingMode.FLOOR); + assertEquals("incorrect value", "1.238096483923847545735673567457356E+53", aNumber.abs(mc).toString()); + + mc = new MathContext(34, RoundingMode.CEILING); + assertEquals("incorrect value", "1.238096483923847545735673567457357E+53", aNumber.abs(mc).toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + res = aNumber.abs(mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * Abs(MathContext) of a positive BigDecimal + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Together with all other methods including a MathContext these tests for a complete test set.", + method = "abs", + args = {java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for hashCode method.", + method = "hashCode", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for hashCode method.", + method = "hashCode", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for min method.", + method = "min", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for min method.", + method = "min", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for min method.", + method = "min", + args = {java.math.BigDecimal.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for plus method.", + method = "plus", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Together with all other methods including a MathContext these tests for a complete test set.", + method = "plus", + args = {java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for plus method.", + method = "plus", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Together with all other methods including a MathContext these tests for a complete test set.", + method = "plus", + args = {java.math.MathContext.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for negate method.", + method = "negate", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Together with all other methods including a MathContext these tests for a complete test set.", + method = "negate", + args = {java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.negate") + public void testNegateMathContextPositive() { + String a = "92948782094488478231212478987482988429808779810457634781384756794987"; + MathContext mc = new MathContext(37, RoundingMode.FLOOR); + BigDecimal aNumber = new BigDecimal(new BigInteger(a), 41); + BigDecimal res = aNumber.negate(mc); + assertEquals("incorrect value", "-929487820944884782312124789.8748298843", res.toString()); + assertEquals("incorrect scale", 10, res.scale()); + +// 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for negate method.", + method = "negate", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "Together with all other methods including a MathContext these tests for a complete test set.", + method = "negate", + args = {java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.negate") + 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.121247898748298842980877982"; + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for signum method.", + method = "signum", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for signum method.", + method = "signum", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for signum method.", + method = "signum", + args = {} + ) + 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/math/tests/java/math/BigDecimalConstructorsTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalConstructorsTest.java new file mode 100644 index 0000000..a428c9f --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalConstructorsTest.java @@ -0,0 +1,1603 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.KnownFailure; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargetNew; + +import junit.framework.TestCase; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.MathContext; +import java.math.RoundingMode; +@TestTargetClass(BigDecimal.class) +/** + * Class: java.math.BigDecimal + * Methods: constructors and fields + */ +public class BigDecimalConstructorsTest extends TestCase { + /** + * check ONE + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "tests BigDecimal.ONE to be 1.0d", + method = "!field:BigDecimal.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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "tests BigDecimal.TEN to be 10.0d", + method = "!field:BigDecimal.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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "tests BigDecimal.ZERO to be 0.0d", + method = "!field:BigDecimal.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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.math.BigInteger.class, int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.math.BigInteger.class, java.math.MathContext.class} + ) + 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()); + + // Now test more than just RoundingMode.CEILING: + // + BigDecimal bd; + BigInteger bi = new BigInteger( "12345678901234567890123456789012345"); + BigInteger nbi = new BigInteger("-12345678901234567890123456789012345"); + + mc = new MathContext(31, RoundingMode.UP); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.234567890123456789012345678902E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678902E+34", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.234567890123456789012345678E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678E+34", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.23456789012345678901234567890124E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.23456789012345678901234567890123E+34", bd.toString()); + + mc = new MathContext(34, RoundingMode.FLOOR); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901235E+34", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_EVEN); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+34", bd.toString()); + bd = new BigDecimal(new BigInteger("-12345678901234567890123456789012335"), mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+34", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_UP); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901235E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901235E+34", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_DOWN); + bd = new BigDecimal(bi, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+34", bd.toString()); + bd = new BigDecimal(nbi, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+34", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(bi, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(nbi, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * new BigDecimal(BigInteger value, int scale, MathContext) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "BigDecimal", + args = {java.math.BigInteger.class, int.class, java.math.MathContext.class} + ) + 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()); + + // Now test more than just RoundingMode.CEILING: + // + // ATTENTION: + // The remaining section is TEXTUALLY COPIED + // from testConstrBigIntegerMathContext + // with minor repetitive modifications. + // + BigDecimal bd; + + BigInteger bi = new BigInteger( "12345678901234567890123456789012345"); + BigInteger nbi = new BigInteger("-12345678901234567890123456789012345"); + + mc = new MathContext(31, RoundingMode.UP); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.234567890123456789012345678902E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678902E+44", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.234567890123456789012345678E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678E+44", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.23456789012345678901234567890124E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.23456789012345678901234567890123E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.FLOOR); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901235E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_EVEN); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(new BigInteger("-12345678901234567890123456789012335"), -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_UP); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901235E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901235E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_DOWN); + bd = new BigDecimal(bi, -10, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(nbi, -10, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(bi, -10, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(nbi, -10, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + + // And just TEXTUALLY COPIED again: + // + mc = new MathContext(31, RoundingMode.UP); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678902", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678902", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.67890124", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.67890123", bd.toString()); + + mc = new MathContext(34, RoundingMode.FLOOR); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678901234", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678901235", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_EVEN); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678901234", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678901234", bd.toString()); + bd = new BigDecimal(new BigInteger("-12345678901234567890123456789012335"), 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678901234", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_UP); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678901235", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678901235", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_DOWN); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678901234", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.678901234", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(bi, 10, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(nbi, 10, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + + mc = new MathContext(28, RoundingMode.FLOOR); + bd = new BigDecimal(bi, 10, mc); + assertEquals("incorrect value", "1234567890123456789012345.678", bd.toString()); + bd = new BigDecimal(nbi, 10, mc); + assertEquals("incorrect value", "-1234567890123456789012345.679", bd.toString()); + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "BigDecimal", + args = {java.math.BigInteger.class, int.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testConstrBigIntegerScaleMathContext_AndroidFailure() { + MathContext mc; + BigDecimal bd; + + mc = new MathContext(17, RoundingMode.FLOOR); + bd = new BigDecimal(new BigInteger("123456789012345678"), 3, mc); + assertEquals("incorrect value", "123456789012345.67", bd.toString()); + } + + /** + * new BigDecimal(char[] value); + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {char[].class} + ) + 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); + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {char[].class, int.class, int.class} + ) + 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); + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "", + method = "BigDecimal", + args = {char[].class, int.class, int.class, java.math.MathContext.class} + ) + 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) { + } + + // Now test more than just RoundingMode.CEILING: + // + // ATTENTION: + // The remaining section is TEXTUALLY COPIED + // from testConstrBigIntegerScaleMathContext + // with minor repetitive modifications. + // + char[] biCA = "bla: 12345678901234567890123456789012345.0E+10, and more bla".toCharArray(); + char[] nbiCA = "bla: -12345678901234567890123456789012345.E+10, and more bla".toCharArray(); + BigDecimal bd; + + mc = new MathContext(31, RoundingMode.UP); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.234567890123456789012345678902E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678902E+44", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.234567890123456789012345678E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678E+44", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.23456789012345678901234567890124E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.23456789012345678901234567890123E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.FLOOR); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901235E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_EVEN); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal("-123456789012345678901234567890123350000000000".toCharArray(), 0, 46, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_UP); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901235E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901235E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.HALF_DOWN); + bd = new BigDecimal(biCA, 5, 41, mc); + assertEquals("incorrect value", "1.234567890123456789012345678901234E+44", bd.toString()); + bd = new BigDecimal(nbiCA, 5, 41, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678901234E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(biCA, 5, 41, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(nbiCA, 5, 41, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * new BigDecimal(char[] value, int offset, int len, MathContext mc); + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "", + method = "BigDecimal", + args = {char[].class, int.class, int.class, java.math.MathContext.class} + ) + 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, MathContext mc); + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {char[].class, java.math.MathContext.class} + ) + public void testConstrCharMathContext() { + try { + // Regression for HARMONY-783 + new BigDecimal(new char[] {}, MathContext.DECIMAL32); + fail("NumberFormatException has not been thrown"); + } catch (NumberFormatException e) { + } + + // Now test more than just regression + // (even if for quite sure the implementation will use the offset/len variant internally): + // + char[] biCA = "12345678901234567890123456789012345.0E+10".toCharArray(); + char[] nbiCA = "-12345678901234567890123456789012345.E+10".toCharArray(); + BigDecimal bd; + MathContext mc; + + mc = new MathContext(31, RoundingMode.UP); + bd = new BigDecimal(biCA, mc); + assertEquals("incorrect value", "1.234567890123456789012345678902E+44", bd.toString()); + bd = new BigDecimal(nbiCA, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678902E+44", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = new BigDecimal(biCA, mc); + assertEquals("incorrect value", "1.234567890123456789012345678E+44", bd.toString()); + bd = new BigDecimal(nbiCA, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678E+44", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = new BigDecimal(biCA, mc); + assertEquals("incorrect value", "1.23456789012345678901234567890124E+44", bd.toString()); + bd = new BigDecimal(nbiCA, mc); + assertEquals("incorrect value", "-1.23456789012345678901234567890123E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(biCA, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(nbiCA, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * new BigDecimal(double value) when value is NaN + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "BigDecimal", + args = {double.class, java.math.MathContext.class} + ) + 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()); + + // Now test more than just RoundingMode.CEILING + // + BigDecimal bd; + + mc = new MathContext(9, RoundingMode.UP); + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "123456790", bd.toString()); + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-123456790", bd.toString()); + + mc = new MathContext(8, RoundingMode.DOWN); + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "1.2345678E+8", bd.toString()); + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-1.2345678E+8", bd.toString()); + + mc = new MathContext(10, RoundingMode.CEILING); + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "123456789.2", bd.toString()); + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-123456789.1", bd.toString()); + + mc = new MathContext(8, RoundingMode.FLOOR); + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "1.2345678E+8", bd.toString()); + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-1.2345679E+8", bd.toString()); + + mc = new MathContext(11, RoundingMode.HALF_EVEN); + // + // VERY FUNNY: + // This works: + bd = new BigDecimal("123456789.125", mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + // But this doesn't: +// bd = new BigDecimal(123456789.125, mc); +// assertEquals("incorrect value", "123456789.12", bd.toString()); + +// bd = new BigDecimal(-123456789.125, mc); +// assertEquals("incorrect value", "-123456789.12", bd.toString()); + bd = new BigDecimal(-123456789.135, mc); + assertEquals("incorrect value", "-123456789.14", bd.toString()); + + mc = new MathContext(11, RoundingMode.HALF_UP); + bd = new BigDecimal("123456789.125", mc); + assertEquals("incorrect value", "123456789.13", bd.toString()); + + // AND HERE, TOO: +// mc = new MathContext(11, RoundingMode.HALF_UP); +// bd = new BigDecimal(123456789.125, mc); +// assertEquals("incorrect value", "123456789.13", bd.toString()); +// bd = new BigDecimal(-123456789.125, mc); +// assertEquals("incorrect value", "-123456789.13", bd.toString()); + + mc = new MathContext(11, RoundingMode.HALF_DOWN); + // + // SAME HERE: + // This works: + bd = new BigDecimal("123456789.125", mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + // But this doesn't: +// bd = new BigDecimal(123456789.125, mc); +// assertEquals("incorrect value", "123456789.12", bd.toString()); + +// bd = new BigDecimal(123456789.125, mc); +// assertEquals("incorrect value", "123456789.12", bd.toString()); +// bd = new BigDecimal(-123456789.125, mc); +// assertEquals("incorrect value", "-123456789.12", bd.toString()); + + mc = new MathContext(8, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(123456789.125, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(-123456789.125, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "BigDecimal", + args = {double.class, java.math.MathContext.class} + ) + @KnownFailure("Fix in BigDecimal.inplaceRound") + public void testConstrDoubleMathContext_AndroidFailure() { + BigDecimal bd; + MathContext mc; + + mc = new MathContext(11, RoundingMode.HALF_EVEN); + // + // VERY FUNNY: + // This works: + bd = new BigDecimal("123456789.125", mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + // But this doesn't: + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-123456789.12", bd.toString()); + + // AND HERE, TOO: + mc = new MathContext(11, RoundingMode.HALF_UP); + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "123456789.13", bd.toString()); + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-123456789.13", bd.toString()); + + mc = new MathContext(11, RoundingMode.HALF_DOWN); + // + // SAME HERE: + // This works: + bd = new BigDecimal("123456789.125", mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + // But this doesn't: + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + + bd = new BigDecimal(123456789.125, mc); + assertEquals("incorrect value", "123456789.12", bd.toString()); + bd = new BigDecimal(-123456789.125, mc); + assertEquals("incorrect value", "-123456789.12", bd.toString()); + } + + /** + * new BigDecimal(0.1) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {int.class, java.math.MathContext.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {long.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {long.class, java.math.MathContext.class} + ) + 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()); + + // Now test more than just RoundingMode.CEILING + // + BigDecimal bd; + + mc = new MathContext(15, RoundingMode.UP); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.89012345678902E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.89012345678902E+16", bd.toString()); + + mc = new MathContext(12, RoundingMode.DOWN); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.89012345678E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.89012345678E+16", bd.toString()); + + mc = new MathContext(15, RoundingMode.CEILING); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.89012345678902E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.89012345678901E+16", bd.toString()); + + mc = new MathContext(12, RoundingMode.FLOOR); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.89012345678E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.89012345679E+16", bd.toString()); + + mc = new MathContext(16, RoundingMode.HALF_EVEN); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.890123456789012E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.890123456789012E+16", bd.toString()); + bd = new BigDecimal(-78901234567890135L, mc); + assertEquals("incorrect value", "-7.890123456789014E+16", bd.toString()); + + mc = new MathContext(16, RoundingMode.HALF_UP); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.890123456789013E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.890123456789013E+16", bd.toString()); + + mc = new MathContext(16, RoundingMode.HALF_DOWN); + bd = new BigDecimal(78901234567890125L, mc); + assertEquals("incorrect value", "7.890123456789012E+16", bd.toString()); + bd = new BigDecimal(-78901234567890125L, mc); + assertEquals("incorrect value", "-7.890123456789012E+16", bd.toString()); + + mc = new MathContext(8, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(78901234567890125L, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(-78901234567890125L, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * new BigDecimal(double value) when value is denormalized + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(double) constructor.", + method = "BigDecimal", + args = {double.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigDecimal(String) constructor.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.lang.String.class, java.math.MathContext.class} + ) + 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()); + + // Now test more than just RoundingMode.CEILING: + // + String biStr = new String( "12345678901234567890123456789012345.0E+10"); + String nbiStr = new String("-12345678901234567890123456789012345.E+10"); + BigDecimal bd; + + mc = new MathContext(31, RoundingMode.UP); + bd = new BigDecimal(biStr, mc); + assertEquals("incorrect value", "1.234567890123456789012345678902E+44", bd.toString()); + bd = new BigDecimal(nbiStr, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678902E+44", bd.toString()); + + mc = new MathContext(28, RoundingMode.DOWN); + bd = new BigDecimal(biStr, mc); + assertEquals("incorrect value", "1.234567890123456789012345678E+44", bd.toString()); + bd = new BigDecimal(nbiStr, mc); + assertEquals("incorrect value", "-1.234567890123456789012345678E+44", bd.toString()); + + mc = new MathContext(33, RoundingMode.CEILING); + bd = new BigDecimal(biStr, mc); + assertEquals("incorrect value", "1.23456789012345678901234567890124E+44", bd.toString()); + bd = new BigDecimal(nbiStr, mc); + assertEquals("incorrect value", "-1.23456789012345678901234567890123E+44", bd.toString()); + + mc = new MathContext(34, RoundingMode.UNNECESSARY); + try { + bd = new BigDecimal(biStr, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + try { + bd = new BigDecimal(nbiStr, mc); + fail("No ArithmeticException for RoundingMode.UNNECESSARY"); + } catch (ArithmeticException e) { + // expected + } + + mc = new MathContext(7, RoundingMode.FLOOR); + bd = new BigDecimal("1000000.9", mc); + assertEquals("incorrect value", "1000000", bd.toString()); + } + +// ANDROID ADDED + + /** + * @tests java.math.BigDecimal#BigDecimal(java.math.BigInteger, int) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.math.BigInteger.class, int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "", + method = "BigDecimal", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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/math/tests/java/math/BigDecimalConvertTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalConvertTest.java new file mode 100644 index 0000000..5015ae0 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalConvertTest.java @@ -0,0 +1,1704 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.RoundingMode; +import java.math.MathContext; + +import junit.framework.TestCase; +@TestTargetClass(BigDecimal.class) +/** + * Class: java.math.BigDecimal + * Methods: doubleValue, floatValue, intValue, longValue, + * valueOf, toString, toBigInteger + */ +public class BigDecimalConvertTest extends TestCase { + /** + * Double value of a negative BigDecimal + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for longValue method", + method = "longValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for longValue method", + method = "longValue", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed", + method = "scaleByPowerOfTen", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed", + method = "scaleByPowerOfTen", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigInteger method", + method = "toBigInteger", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigIntegerExact method", + method = "toBigIntegerExact", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toBigIntegerExact method", + method = "toBigIntegerExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toEngineeringString method", + method = "toEngineeringString", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toEngineeringString method", + method = "toEngineeringString", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toEngineeringString method", + method = "toEngineeringString", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toEngineeringString method", + method = "toEngineeringString", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toPlainString method", + method = "toPlainString", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toPlainString method", + method = "toPlainString", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toPlainString method", + method = "toPlainString", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toPlainString method", + method = "toPlainString", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(long) method", + method = "valueOf", + args = {long.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(long) method", + method = "valueOf", + args = {long.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(long) method", + method = "valueOf", + args = {long.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(long) method", + method = "valueOf", + args = {long.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(long) method", + method = "valueOf", + args = {long.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(long) method", + method = "valueOf", + args = {long.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(double) method", + method = "valueOf", + args = {double.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(double) method", + method = "valueOf", + args = {double.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(double) method", + method = "valueOf", + args = {double.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(double) method", + method = "valueOf", + args = {double.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf(double) method", + method = "valueOf", + args = {double.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValueExact method", + method = "intValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValueExact method", + method = "intValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValueExact method", + method = "intValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValueExact method", + method = "intValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValueExact method", + method = "intValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValueExact method", + method = "intValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checked", + method = "longValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "ArithmeticException checked", + method = "longValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "ArithmeticException checked", + method = "longValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "ArithmeticException checked", + method = "longValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for byteValueExact method", + method = "byteValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "byteValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "shortValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "shortValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shortValueExact method", + method = "shortValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shortValueExact method", + method = "shortValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shortValueExact method", + method = "shortValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shortValueExact method", + method = "shortValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shortValueExact method", + method = "shortValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shortValueExact method", + method = "shortValueExact", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for stripTrailingZeros method", + method = "stripTrailingZeros", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for stripTrailingZeros method", + method = "stripTrailingZeros", + args = {} + ) + 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/math/tests/java/math/BigDecimalScaleOperationsTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalScaleOperationsTest.java new file mode 100644 index 0000000..3444a27 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigDecimalScaleOperationsTest.java @@ -0,0 +1,625 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.KnownFailure; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargetNew; + +import junit.framework.TestCase; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.RoundingMode; +@TestTargetClass(BigDecimal.class) +/** + * Class: java.math.BigDecimal + * Methods: movePointLeft, movePointRight, scale, setScale, unscaledValue * + */ +public class BigDecimalScaleOperationsTest extends TestCase { + /** + * Check the default scale + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for scale method.", + method = "scale", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for scale method.", + method = "scale", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for scale method.", + method = "scale", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for scale method.", + method = "scale", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "unscaledValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setScale method.", + method = "setScale", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setScale method.", + method = "setScale", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setScale method.", + method = "setScale", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setScale method.", + method = "setScale", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checking missed.", + method = "setScale", + args = {int.class, int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "movePointLeft", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "movePointLeft", + args = {int.class} + ) + 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)); + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "movePointLeft", + args = {int.class} + ) + public void testMovePointLeftEx() { + BigDecimal a = new BigDecimal("12345.6789012345678901234567890123456789"); + BigDecimal res = a.movePointLeft(10); + assertEquals("incorrect scale", 44, res.scale()); + assertEquals("incorrect value", "0.00000123456789012345678901234567890123456789", res.toString()); + res = a.movePointLeft(-50); + assertEquals("incorrect scale", 0, res.scale()); + assertEquals("incorrect value", "1234567890123456789012345678901234567890000000000000000", res.toString()); + try { + res = a.movePointLeft(Integer.MAX_VALUE - 2); +// assertEquals("incorrect value", "0.0938025", res[1].toString()); + fail("ArithmeticException is not thrown"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * Move the decimal point to the right; the shift value is positive + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for movePointRight method.", + method = "movePointRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for movePointRight method.", + method = "movePointRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for movePointRight method.", + method = "movePointRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for movePointRight method.", + method = "movePointRight", + args = {int.class} + ) + 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()); + } + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "movePointRight", + args = {int.class} + ) + public void testMovePointRightEx() { + BigDecimal a = new BigDecimal("12345.6789012345678901234567890123456789"); + BigDecimal res = a.movePointRight(10); + assertEquals("incorrect scale", 24, res.scale()); + assertEquals("incorrect value", "123456789012345.678901234567890123456789", res.toString()); + res = a.movePointRight(-50); + assertEquals("incorrect scale", 84, res.scale()); + assertEquals("incorrect value", "1.23456789012345678901234567890123456789E-46", res.toString()); + try { + res = a.movePointRight(Integer.MIN_VALUE + 2); + fail("ArithmeticException is not thrown"); + } catch (ArithmeticException e) { + // expected + } + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "movePointRight", + args = {int.class} + ) + @KnownFailure("Throws ArrayIndexOutOfBoundsException instead of ArithmeticException!") + public void testMovePointRightEx2() { + BigDecimal a = new BigDecimal("123456789012345678901234567890123456789E25"); + try { + BigDecimal res = a.movePointRight(Integer.MAX_VALUE - 2); + fail("ArithmeticException is not thrown"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * scaleByPowerOfTen(int n) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + method = "scaleByPowerOfTen", + args = {int.class} + ) + public void testScaleByPowerOfTenEx() { + BigDecimal a = new BigDecimal("12345.6789012345678901234567890123456789"); + BigDecimal res = a.movePointRight(10); + assertEquals("incorrect scale", 24, res.scale()); + assertEquals("incorrect value", "123456789012345.678901234567890123456789", res.toString()); + res = a.scaleByPowerOfTen(-50); + assertEquals("incorrect scale", 84, res.scale()); + assertEquals("incorrect value", "1.23456789012345678901234567890123456789E-46", res.toString()); + res = a.scaleByPowerOfTen(50); + assertEquals("incorrect scale", -16, res.scale()); + assertEquals("incorrect value", "1.23456789012345678901234567890123456789E+54", res.toString()); + try { + res = a.scaleByPowerOfTen(Integer.MIN_VALUE + 2); + fail("ArithmeticException is not thrown"); + } catch (ArithmeticException e) { + // expected + } + a = new BigDecimal("123456789012345678901234567890123456789E25"); + try { + res = a.scaleByPowerOfTen(Integer.MAX_VALUE - 2); + fail("ArithmeticException is not thrown"); + } catch (ArithmeticException e) { + // expected + } + } + + /** + * precision() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "precision", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "precision", + args = {} + ) + 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/math/tests/java/math/BigIntegerAddTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerAddTest.java new file mode 100644 index 0000000..e7041fc --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerAddTest.java @@ -0,0 +1,640 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; +import dalvik.annotation.TestTargetClass; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: add + */ +public class BigIntegerAddTest extends TestCase { + /** + * Add two positive numbers of the same length + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for add method.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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/math/tests/java/math/BigIntegerAndTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerAndTest.java new file mode 100644 index 0000000..6dc96e9 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerAndTest.java @@ -0,0 +1,565 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: and + */ +public class BigIntegerAndTest extends TestCase { + /** + * And for zero and a positive number + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for and method.", + method = "and", + args = {java.math.BigInteger.class} + ) + 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/math/tests/java/math/BigIntegerCompareTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerCompareTest.java new file mode 100644 index 0000000..ef982cb --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerCompareTest.java @@ -0,0 +1,738 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Methods: abs, compareTo, equals, max, min, negate, signum + */ +public class BigIntegerCompareTest extends TestCase { + /** + * abs() for a positive number + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for abs method.", + method = "abs", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for abs method.", + method = "abs", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for compareTo method.", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + public void testCompareToZeroZero() { + BigInteger aNumber = BigInteger.ZERO; + BigInteger bNumber = BigInteger.ZERO; + assertEquals(0, aNumber.compareTo(bNumber)); + } + + /** + * equals(Object obj). + * obj is not a BigInteger + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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). + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for equals method.", + method = "equals", + args = {java.lang.Object.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for max method.", + method = "max", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mix method.", + method = "min", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mix method.", + method = "min", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mix method.", + method = "min", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mix method.", + method = "min", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for negate method.", + method = "negate", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for negate method.", + method = "negate", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for negate method.", + method = "negate", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for signum method.", + method = "signum", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for signum method.", + method = "signum", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for signum method.", + method = "signum", + args = {} + ) + public void testSignumZero() { + BigInteger aNumber = BigInteger.ZERO; + assertEquals("incorrect sign", 0, aNumber.signum()); + } +} diff --git a/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerConstructorsTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerConstructorsTest.java new file mode 100644 index 0000000..043d278 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerConstructorsTest.java @@ -0,0 +1,1175 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; +import java.util.Random; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(byte[]) constructor.", + method = "BigInteger", + args = {byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(int, byte[]) constructor.", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String, int) constructor.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "IllegalArgumentException checking missed for negative number of bits.", + method = "BigInteger", + args = {int.class, java.util.Random.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed for incorrect bitLength parameter.", + method = "BigInteger", + args = {int.class, int.class, java.util.Random.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for BigInteger(String) constructor.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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/math/tests/java/math/BigIntegerConvertTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerConvertTest.java new file mode 100644 index 0000000..aaef132 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerConvertTest.java @@ -0,0 +1,1147 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Methods: intValue, longValue, toByteArray(), valueOf(long val), + * floatValue(), doubleValue() + */ +public class BigIntegerConvertTest extends TestCase { + /** + * Return the double value of ZERO. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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]. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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]. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for doubleValue method.", + method = "doubleValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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]. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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]. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for floatValue method.", + method = "floatValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for intValue method.", + method = "intValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for longValue method.", + method = "longValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for longValue method.", + method = "longValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for longValue method.", + method = "longValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for longValue method.", + method = "longValue", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for valueOf method.", + method = "valueOf", + args = {long.class} + ) + 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/math/tests/java/math/BigIntegerDivideTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerDivideTest.java new file mode 100644 index 0000000..f46a6ec --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerDivideTest.java @@ -0,0 +1,891 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Methods: divide, remainder, mod, and divideAndRemainder + */ +public class BigIntegerDivideTest extends TestCase { + /** + * Divide by zero + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for divide method.", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for remainder method.", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "divideAndRemainder", + args = {java.math.BigInteger.class} + ) + 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()); + } + } + + /** + * divideAndRemainder of division by zero + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + method = "divideAndRemainder", + args = {java.math.BigInteger.class} + ) + public void testCase21byZero() { + 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.divideAndRemainder(bNumber); + fail("ArithmeticException has not been caught"); + } catch (ArithmeticException e) { + assertEquals("Improper exception message", "BigInteger divide by zero", e.getMessage()); + } + } + + /** + * mod when modulus is negative + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mod method.", + method = "mod", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mod method.", + method = "mod", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for mod method.", + method = "mod", + args = {java.math.BigInteger.class} + ) + 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/math/tests/java/math/BigIntegerHashCodeTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerHashCodeTest.java new file mode 100644 index 0000000..d351fa8 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerHashCodeTest.java @@ -0,0 +1,104 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: hashCode() + */ +public class BigIntegerHashCodeTest extends TestCase { + /** + * Test hash codes for the same object + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for hashCode method.", + method = "hashCode", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for hashCode method.", + method = "hashCode", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for hashCode method.", + method = "hashCode", + args = {} + ) + 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/math/tests/java/math/BigIntegerModPowTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerModPowTest.java new file mode 100644 index 0000000..7142f16 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerModPowTest.java @@ -0,0 +1,421 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Methods: modPow, modInverse, and gcd + */ +public class BigIntegerModPowTest extends TestCase { + /** + * modPow: non-positive modulus + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modPow method.", + method = "modPow", + args = {java.math.BigInteger.class, java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modPow method.", + method = "modPow", + args = {java.math.BigInteger.class, java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modPow method.", + method = "modPow", + args = {java.math.BigInteger.class, java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modInverse method.", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modInverse method.", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modInverse method.", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modInverse method.", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modInverse method.", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for modInverse method.", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for gcd method.", + method = "gcd", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for gcd method.", + method = "gcd", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for gcd method.", + method = "gcd", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for gcd method.", + method = "gcd", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for gcd method.", + method = "gcd", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for gcd method.", + method = "gcd", + args = {java.math.BigInteger.class} + ) + 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/math/tests/java/math/BigIntegerMultiplyTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerMultiplyTest.java new file mode 100644 index 0000000..59ff3c6 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerMultiplyTest.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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: multiply + */ +public class BigIntegerMultiplyTest extends TestCase { + /** + * Multiply two negative numbers of the same length + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for multiply method.", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for pow method.", + method = "pow", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for pow method.", + method = "pow", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for pow method.", + method = "pow", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for pow method.", + method = "pow", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for pow method.", + method = "pow", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for pow method.", + method = "pow", + args = {int.class} + ) + 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/math/tests/java/math/BigIntegerNotTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerNotTest.java new file mode 100644 index 0000000..6ca350b --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerNotTest.java @@ -0,0 +1,253 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Methods: and, andNot + */ +public class BigIntegerNotTest extends TestCase { + /** + * andNot for two positive numbers; the first is longer + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for andNot method.", + method = "andNot", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for andNot method.", + method = "andNot", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for andNot method.", + method = "andNot", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for andNot method.", + method = "andNot", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for not method.", + method = "not", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for not method.", + method = "not", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for not method.", + method = "not", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for not method.", + method = "not", + args = {} + ) + 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 + */ + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for not method.", + method = "not", + args = {} + ) + 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/math/tests/java/math/BigIntegerOperateBitsTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerOperateBitsTest.java new file mode 100644 index 0000000..f28ec43 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerOperateBitsTest.java @@ -0,0 +1,1986 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Methods: bitLength, shiftLeft, shiftRight, + * clearBit, flipBit, setBit, testBit + */ +public class BigIntegerOperateBitsTest extends TestCase { + /** + * bitCount() of zero. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitCount method.", + method = "bitCount", + args = {} + ) + public void testBitCountZero() { + BigInteger aNumber = new BigInteger("0"); + assertEquals(0, aNumber.bitCount()); + } + + /** + * bitCount() of a negative number. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitCount method.", + method = "bitCount", + args = {} + ) + public void testBitCountNeg() { + BigInteger aNumber = new BigInteger("-12378634756382937873487638746283767238657872368748726875"); + assertEquals(87, aNumber.bitCount()); + } + + /** + * bitCount() of a negative number. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitCount method.", + method = "bitCount", + args = {} + ) + public void testBitCountPos() { + BigInteger aNumber = new BigInteger("12378634756343564757582937873487638746283767238657872368748726875"); + assertEquals(107, aNumber.bitCount()); + } + + /** + * bitLength() of zero. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + public void testBitLengthZero() { + BigInteger aNumber = new BigInteger("0"); + assertEquals(0, aNumber.bitLength()); + } + + /** + * bitLength() of a positive number. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for bitLength method.", + method = "bitLength", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for clearBit method.", + method = "clearBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for flipBit method.", + method = "flipBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for setBit method.", + method = "setBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftLeft method.", + method = "shiftLeft", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftLeft method.", + method = "shiftLeft", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftLeft method.", + method = "shiftLeft", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftLeft method.", + method = "shiftLeft", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftLeft method.", + method = "shiftLeft", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "shiftRight", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for shiftRight method.", + method = "testBit", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for getLowestSetBit method.", + method = "getLowestSetBit", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for getLowestSetBit method.", + method = "getLowestSetBit", + args = {} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for getLowestSetBit method.", + method = "getLowestSetBit", + args = {} + ) + 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/math/tests/java/math/BigIntegerOrTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerOrTest.java new file mode 100644 index 0000000..b3dd5fa --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerOrTest.java @@ -0,0 +1,546 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: or + */ +public class BigIntegerOrTest extends TestCase { + /** + * Or for zero and a positive number + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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()); + } + + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for or operation", + method = "or", + args = {java.math.BigInteger.class} + ) + 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/math/tests/java/math/BigIntegerSubtractTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerSubtractTest.java new file mode 100644 index 0000000..29d8405 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerSubtractTest.java @@ -0,0 +1,704 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: subtract + */ +public class BigIntegerSubtractTest extends TestCase { + /** + * Subtract two positive numbers of the same length. + * The first is greater. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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. + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for subtract method", + method = "subtract", + args = {java.math.BigInteger.class} + ) + 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/math/tests/java/math/BigIntegerToStringTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerToStringTest.java new file mode 100644 index 0000000..c405553 --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerToStringTest.java @@ -0,0 +1,335 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: toString(int radix) + */ +public class BigIntegerToStringTest extends TestCase { + /** + * If 36 < radix < 2 it should be set to 10 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {int.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "This is a complete subset of tests for toString method", + method = "toString", + args = {} + ) + 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/math/tests/java/math/BigIntegerXorTest.java b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerXorTest.java new file mode 100644 index 0000000..4e2dbcf --- /dev/null +++ b/math/src/test/java/org/apache/harmony/math/tests/java/math/BigIntegerXorTest.java @@ -0,0 +1,398 @@ +/* + * 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.math.tests.java.math; + +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; + +import java.math.BigInteger; + +import junit.framework.TestCase; +@TestTargetClass(BigInteger.class) +/** + * Class: java.math.BigInteger + * Method: xor + */ +public class BigIntegerXorTest extends TestCase { + /** + * Xor for zero and a positive number + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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 + */ + @TestTargetNew( + level = TestLevel.PARTIAL_COMPLETE, + notes = "This is a complete subset of tests for xor operation.", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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..483e08a --- /dev/null +++ b/math/src/test/java/tests/api/java/math/AllTests.java @@ -0,0 +1,41 @@ +/* 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 = tests.TestSuiteFactory.createTestSuite("Tests for java.math"); + // $JUnit-BEGIN$ + suite.addTestSuite(BigDecimalTest.class); + suite.addTestSuite(BigIntegerTest.class); + suite.addTestSuite(RoundingModeTest.class); + suite.addTestSuite(MathContextTest.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..47e5b31 --- /dev/null +++ b/math/src/test/java/tests/api/java/math/BigDecimalTest.java @@ -0,0 +1,1315 @@ +/* + * 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 dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.AndroidOnly; + +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.RoundingMode; + +@TestTargetClass(BigDecimal.class) +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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.math.BigInteger.class, int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = ".", + method = "BigDecimal", + args = {double.class} + ) + public void test_ConstructorD() { + // + // These numbers have an exact representation as doubles: + // + BigDecimal big = new BigDecimal(123E04); + assertTrue( + "the BigDecimal value taking a double argument is not initialized properly", + big.toString().equals("1230000")); + big = new BigDecimal(123.375); + assertTrue("init(D) failed for 123.375; became " + big, + big.toString().equals("123.375") ); + big = new BigDecimal(Math.pow(2, -33)); + assertTrue("init(D) failed for 2^(-33) = 1.16415321826934814453125E-10; became " + big, + big.toString().equals("1.16415321826934814453125E-10") ); + big = new BigDecimal(123456 * Math.pow(2, -33)); + assertTrue("init(D) failed for 123456 * 2^(-33) = 0.000014372169971466064453125; became " + big, + big.toString().equals("0.000014372169971466064453125") ); + big = new BigDecimal(-123456 * Math.pow(2, -33)); + assertTrue("init(D) failed for 123456 * 2^(-33) = -0.000014372169971466064453125; became " + big, + big.toString().equals("-0.000014372169971466064453125") ); + + // Following numbers can't: + // + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "", + method = "BigDecimal", + args = {double.class} + ) + public void test_constructor_String_plus_exp() { + /* + * BigDecimal does not support a + sign in the exponent when converting + * from a String. + * + * mc 081106: who says so?!? + */ + BigDecimal bd; + bd = new BigDecimal("+23e-0"); + assertEquals("incorrect value", "23", bd.toString()); + bd = new BigDecimal("-23e+0"); + assertEquals("incorrect value", "-23", bd.toString()); + } + + /** + * @tests java.math.BigDecimal#BigDecimal(java.lang.String) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checked.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + public void test_constructor_String_empty() { + try { + new BigDecimal(""); + fail("NumberFormatException expected"); + } catch (NumberFormatException e) { + } + } + + /** + * @tests java.math.BigDecimal#BigDecimal(java.lang.String) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checked.", + method = "BigDecimal", + args = {java.lang.String.class} + ) + 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[]) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Exception checked.", + method = "BigDecimal", + args = {char[].class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "abs", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "add", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "compareTo", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "IllegalArgumentException checking missed. Used only ROUND_UP & ROUND_DOWN round modes.", + method = "divide", + args = {java.math.BigDecimal.class, int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "IllegalArgumentException checking missed. Used only ROUND_UP & ROUND_DOWN round modes.", + method = "divide", + args = {java.math.BigDecimal.class, int.class, int.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Narrowing limitations of double representation are not checked.", + method = "doubleValue", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "equals", + args = {java.lang.Object.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Narrowing limitations of float representation are not checked.", + method = "floatValue", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "hashCode", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "intValue", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "longValue", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "max", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "min", + args = {java.math.BigDecimal.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "movePointLeft", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed.", + method = "movePointRight", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "multiply", + args = {java.math.BigDecimal.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "negate", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "scale", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "setScale", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "setScale", + args = {int.class, int.class} + ) + 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 scale of 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#setScale(int, java.math.RoundingMode) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "setScale", + args = {int.class, java.math.RoundingMode.class} + ) + public void test_setScaleILjava_math_RoundingMode() { + 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, RoundingMode.CEILING); + assertTrue("the scale of 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 RoundingMode.CEILING + setScale1 = new BigDecimal(value, 4); + setScale2 = setScale1.setScale(1, RoundingMode.CEILING); + assertTrue( + "the number 1234.5908 after setting scale to 1/RoundingMode.CEILING is wrong", + setScale2.toString().equals("1234.6") && setScale2.scale() == 1); + BigDecimal setNeg = new BigDecimal(value.negate(), 4); + setScale2 = setNeg.setScale(1, RoundingMode.CEILING); + assertTrue( + "the number -1234.5908 after setting scale to 1/RoundingMode.CEILING is wrong", + setScale2.toString().equals("-1234.5") + && setScale2.scale() == 1); + + // testing rounding Mode RoundingMode.DOWN + setScale2 = setNeg.setScale(1, RoundingMode.DOWN); + assertTrue( + "the number -1234.5908 after setting scale to 1/RoundingMode.DOWN is wrong", + setScale2.toString().equals("-1234.5") + && setScale2.scale() == 1); + setScale1 = new BigDecimal(value, 4); + setScale2 = setScale1.setScale(1, RoundingMode.DOWN); + assertTrue( + "the number 1234.5908 after setting scale to 1/RoundingMode.DOWN is wrong", + setScale2.toString().equals("1234.5") && setScale2.scale() == 1); + + // testing rounding Mode RoundingMode.FLOOR + setScale2 = setScale1.setScale(1, RoundingMode.FLOOR); + assertTrue( + "the number 1234.5908 after setting scale to 1/RoundingMode.FLOOR is wrong", + setScale2.toString().equals("1234.5") && setScale2.scale() == 1); + setScale2 = setNeg.setScale(1, RoundingMode.FLOOR); + assertTrue( + "the number -1234.5908 after setting scale to 1/RoundingMode.FLOOR is wrong", + setScale2.toString().equals("-1234.6") + && setScale2.scale() == 1); + + // testing rounding Mode RoundingMode.HALF_DOWN + setScale2 = setScale1.setScale(3, RoundingMode.HALF_DOWN); + assertTrue( + "the number 1234.5908 after setting scale to 3/RoundingMode.HALF_DOWN is wrong", + setScale2.toString().equals("1234.591") + && setScale2.scale() == 3); + setScale1 = new BigDecimal(new BigInteger("12345000"), 5); + setScale2 = setScale1.setScale(1, RoundingMode.HALF_DOWN); + assertTrue( + "the number 123.45908 after setting scale to 1/RoundingMode.HALF_DOWN is wrong", + setScale2.toString().equals("123.4") && setScale2.scale() == 1); + setScale2 = new BigDecimal("-1234.5000").setScale(0, + RoundingMode.HALF_DOWN); + assertTrue( + "the number -1234.5908 after setting scale to 0/RoundingMode.HALF_DOWN is wrong", + setScale2.toString().equals("-1234") && setScale2.scale() == 0); + + // testing rounding Mode RoundingMode.HALF_EVEN + setScale1 = new BigDecimal(1.2345789D); + setScale2 = setScale1.setScale(4, RoundingMode.HALF_EVEN); + assertTrue( + "the number 1.2345789 after setting scale to 4/RoundingMode.HALF_EVEN is wrong", + setScale2.doubleValue() == 1.2346D && setScale2.scale() == 4); + setNeg = new BigDecimal(-1.2335789D); + setScale2 = setNeg.setScale(2, RoundingMode.HALF_EVEN); + assertTrue( + "the number -1.2335789 after setting scale to 2/RoundingMode.HALF_EVEN is wrong", + setScale2.doubleValue() == -1.23D && setScale2.scale() == 2); + setScale2 = new BigDecimal("1.2345000").setScale(3, + RoundingMode.HALF_EVEN); + assertTrue( + "the number 1.2345789 after setting scale to 3/RoundingMode.HALF_EVEN is wrong", + setScale2.doubleValue() == 1.234D && setScale2.scale() == 3); + setScale2 = new BigDecimal("-1.2345000").setScale(3, + RoundingMode.HALF_EVEN); + assertTrue( + "the number -1.2335789 after setting scale to 3/RoundingMode.HALF_EVEN is wrong", + setScale2.doubleValue() == -1.234D && setScale2.scale() == 3); + + // testing rounding Mode RoundingMode.HALF_UP + setScale1 = new BigDecimal("134567.34650"); + setScale2 = setScale1.setScale(3, RoundingMode.HALF_UP); + assertTrue( + "the number 134567.34658 after setting scale to 3/RoundingMode.HALF_UP is wrong", + setScale2.toString().equals("134567.347") + && setScale2.scale() == 3); + setNeg = new BigDecimal("-1234.4567"); + setScale2 = setNeg.setScale(0, RoundingMode.HALF_UP); + assertTrue( + "the number -1234.4567 after setting scale to 0/RoundingMode.HALF_UP is wrong", + setScale2.toString().equals("-1234") && setScale2.scale() == 0); + + // testing rounding Mode RoundingMode.UNNECESSARY + try { + setScale1.setScale(3, RoundingMode.UNNECESSARY); + fail("arithmetic Exception not caught for round unnecessary"); + } catch (ArithmeticException e) { + } + + // testing rounding Mode RoundingMode.UP + setScale1 = new BigDecimal("100000.374"); + setScale2 = setScale1.setScale(2, RoundingMode.UP); + assertTrue( + "the number 100000.374 after setting scale to 2/RoundingMode.UP is wrong", + setScale2.toString().equals("100000.38") + && setScale2.scale() == 2); + setNeg = new BigDecimal(-134.34589D); + setScale2 = setNeg.setScale(2, RoundingMode.UP); + assertTrue( + "the number -134.34589 after setting scale to 2/RoundingMode.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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "signum", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "subtract", + args = {java.math.BigDecimal.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "toBigInteger", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "toString", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "unscaledValue", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "valueOf", + args = {long.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "valueOf", + args = {long.class, int.class} + ) + 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")); + + } + + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "Checks serialization", + method = "!SerializationSelf", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "The RI fails the Zero Test: has scale 4 for BigDecimal('0.0000')", + method = "stripTrailingZeros", + args = {} + ) + @AndroidOnly("Stripping trailing zeroes from 0.000 value doesn't work on RI. See below") + 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"); + assertEquals("stripTrailingZero failed for 0.0000", + 0, (zerotest.stripTrailingZeros()).scale() ); + } + +} 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..c640638 --- /dev/null +++ b/math/src/test/java/tests/api/java/math/BigIntegerTest.java @@ -0,0 +1,1419 @@ +/* + * 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 dalvik.annotation.KnownFailure; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetClass; +import dalvik.annotation.TestTargetNew; +import dalvik.annotation.TestTargets; + +import java.math.BigInteger; +import java.util.Random; + +@TestTargetClass(BigInteger.class) +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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigInteger", + args = {int.class, java.util.Random.class} + ) + 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)); + + try { + new BigInteger(-1, (Random)null); + fail("IllegalArgumentException expected"); + } catch (IllegalArgumentException e) { + // PASSED + } + } + + /** + * @tests java.math.BigInteger#BigInteger(int, int, java.util.Random) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + method = "BigInteger", + args = {int.class, int.class, java.util.Random.class} + ) + @KnownFailure("BIGNUM returns no Primes smaller than 16 bits.") + 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); + } + } + + try { + new BigInteger(1, 80, (Random)null); + fail("ArithmeticException expected"); + } catch (ArithmeticException e) { + // PASSED + } + + try { + new BigInteger(-1, (Random)null); + fail("IllegalArgumentException expected"); + } catch (IllegalArgumentException e) { + // PASSED + } + } + + /** + * @tests java.math.BigInteger#BigInteger(byte[]) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "NumberFormatException checking missed", + method = "BigInteger", + args = {byte[].class} + ) + 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[]) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "BigInteger", + args = {int.class, byte[].class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Checks NumberFormatException", + method = "BigInteger", + args = {java.lang.String.class} + ) + public void test_constructor_String_empty() { + try { + new BigInteger(""); + fail("Expected NumberFormatException for new BigInteger(\"\")"); + } catch (NumberFormatException e) { + } + } + + /** + * @tests java.math.BigInteger#toByteArray() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "toByteArray", + args = {} + ) + 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]); + } + } + +// public void test_SpecialPrimes() { +// System.out.println("test_SpecialPrimes"); +// final BigInteger TWO = BigInteger.valueOf(2); +// BigInteger p, q; +// for (;;) { +// p = new BigInteger(1024, 23, new Random()); +// q = p.subtract(BigInteger.ONE).divide(TWO); +// if (q.isProbablePrime(20)) { +// System.out.println(q); +// System.out.println(p); +// break; +// } +// System.out.print("."); +// } +// fail("isProbablePrime failed for: " + bi); +// } + + /** + * @tests java.math.BigInteger#isProbablePrime(int) + */ + @TestTargets({ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "isProbablePrime", + args = {int.class} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "probablePrime", + args = {int.class, java.util.Random.class} + ) + }) + 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); + + // + // And now some tests on real big integers: + // + bi = new BigInteger("153890972191202256150310830154922163807316525358455215516067727076235016932726922093888770552128767458882963869421440585369743", 10); + if (!bi.isProbablePrime(80)) { + fail("isProbablePrime failed for: " + bi); + } + bi = new BigInteger("2090575416269141767246491983797422123741252476560371649798066134123893524014911825188890458270426076468664046568752890122415061377308817346303546688282957897504000216241497550243010257911214329646877810655164658470278901030511157372440751259674247310396158238588463284702737181653", 10); + if (!bi.isProbablePrime(80)) { + fail("isProbablePrime failed for: " + bi); + } + // + for (int bitLength = 100; bitLength <= 600; bitLength += 100) { + BigInteger a = BigInteger.probablePrime(bitLength, rand); + BigInteger b = BigInteger.probablePrime(bitLength, rand); + BigInteger c = a.multiply(b); + assertFalse("isProbablePrime failed for product of two large primes" + + a + " * " + b + " = " + c + + " (bitLength = " + bitLength + ")", + c.isProbablePrime(80) ); + } + } + + /** + * @tests java.math.BigInteger#nextProbablePrime() + */ + @TestTargets({ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "nextProbablePrime", + args = {} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "isProbablePrime", + args = {int.class} + ) + }) + public void test_nextProbablePrime() { + largePrimesProduct( + new BigInteger("2537895984043447429238717358455377929009126353874925049325287329295635198252046158619999217453233889378619619008359011789"), + new BigInteger("1711501451602688337873833423534849678524059393231999670806585630179374689152366029939952735718718709436427337762082614710093"), + "4343612660706993434504106787562106084038357258130862545477481433639575850237346784798851102536616749334772541987502120552264920040629526028540204698334741815536099373917351194423681128374184971846099257056996626343051832131340568120612204287123" + ); + + largePrimesProduct( + new BigInteger("4617974730611208463200675282934641082129817404749925308887287017217158545765190433369842932770197341032031682222405074564586462802072184047198214312142847809259437477387527466762251087500170588962277514858557309036550499896961735701485020851"), + new BigInteger("4313158964405728158057980867015758419530142215799386331265837224051830838583266274443105715022196238165196727467066901495701708590167750818040112544031694506528759169669442493029999154074962566165293254671176670719518898684698255068313216294333"), + "19918059106734861363335842730108905466210762564765297409619920041621379008685530738918145604092111306972524565803236031571858280032420140331838737621152630780261815015157696362550138161774466814661069892975003440654998880587960037013294137372709096788892473385003457361736563927256562678181177287998121131179907762285048659075843995525830945659905573174849006768920618442371027575308854641789533211132313916836205357976988977849024687805212304038260207820679964201211309384057458137851" + ); + } + + static void largePrimesProduct(BigInteger a, BigInteger b, String c) { + BigInteger wp = a.multiply(b); + assertFalse("isProbablePrime failed for product of two large primes" + + a + " * " + b + " = " + c, + wp.isProbablePrime(80) ); + BigInteger wpMinusOne = wp.subtract(BigInteger.ONE); + BigInteger next = wpMinusOne.nextProbablePrime(); +// System.out.println(c); +// System.out.println(next); + assertTrue("nextProbablePrime returns wrong number: " + next + + "instead of expected: " + c, + next.toString().equals(c) ); + } + + /** + * @tests java.math.BigInteger#probablePrime(int, java.util.Random) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "probablePrime", + args = {int.class, java.util.Random.class} + ) + public void test_probablePrime() { + for (int bitLength = 50; bitLength <= 1050; bitLength += 100) { + BigInteger a = BigInteger.probablePrime(bitLength, rand); + assertTrue("isProbablePrime(probablePrime()) failed for: " + bi, + a.isProbablePrime(80)); +// System.out.println(a); +// BigInteger prime = a.nextProbablePrime(); +// System.out.print("Next Probable Prime is "); +// System.out.println(prime); + } + } + +// 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "equals", + args = {java.lang.Object.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "compareTo", + args = {java.math.BigInteger.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "intValue", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "longValue", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "valueOf", + args = {long.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Test is OK, but some cases listed below can be reasonable.", + method = "add", + args = {java.math.BigInteger.class} + ) + 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)); + + + // BESSER UEBERGREIFENDE TESTS MACHEN IN FORM VON STRESS TEST. + // add large positive + small positive + BigInteger sum = aZillion; + BigInteger increment = one; + for (int i = 0; i < 20; i++) { + + } + + // add large positive + small negative + + // add large negative + small positive + + // add large negative + small negative + } + + /** + * @tests java.math.BigInteger#negate() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "negate", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "signum", + args = {} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "abs", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checking missed", + method = "pow", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "modInverse", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "shiftRight", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "shiftLeft", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "multiply", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "divide", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checked", + method = "remainder", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checked", + method = "mod", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "ArithmeticException checked", + method = "divideAndRemainder", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "NumberFormatException checking missed.", + method = "BigInteger", + args = {java.lang.String.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "NumberFormatException checking missed.", + method = "BigInteger", + args = {java.lang.String.class, int.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "toString", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "toString", + args = {int.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "and", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "or", + args = {java.math.BigInteger.class} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "xor", + args = {java.math.BigInteger.class} + ) + 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() + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "not", + args = {} + ) + 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) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "andNot", + args = {java.math.BigInteger.class} + ) + 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)); + } + } + } + + + @TestTargetNew( + level = TestLevel.PARTIAL, + notes = "Regression test", + method = "clone", + args = {} + ) + 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/api/java/math/MathContextTest.java b/math/src/test/java/tests/api/java/math/MathContextTest.java new file mode 100644 index 0000000..0051b44 --- /dev/null +++ b/math/src/test/java/tests/api/java/math/MathContextTest.java @@ -0,0 +1,135 @@ +/* + * 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 dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; +import dalvik.annotation.TestTargetClass; + +import java.math.BigDecimal; +import java.math.MathContext; +import java.math.RoundingMode; + +@TestTargetClass(MathContext.class) +public class MathContextTest extends junit.framework.TestCase { + + /** + * @tests java.math.MathContext#MathContext(...) + */ + @TestTargets({ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "MathContext", + args = {int.class} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "MathContext", + args = {int.class, java.math.RoundingMode.class} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "MathContext", + args = {java.lang.String.class} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "getPrecision", + args = {} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "getRoundingMode", + args = {} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "equals", + args = {java.lang.Object.class} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "hashCode", + args = {} + ), + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "toString", + args = {} + ) + }) + public void test_MathContextConstruction() { + String a = "-12380945E+61"; + BigDecimal aNumber = new BigDecimal(a); + MathContext mcIntRm6hd = new MathContext(6, RoundingMode.HALF_DOWN); + MathContext mcStr6hd = new MathContext("precision=6 roundingMode=HALF_DOWN"); + MathContext mcInt6 = new MathContext(6); + MathContext mcInt134 = new MathContext(134); + + // getPrecision() + assertEquals("MathContext.getPrecision() returns incorrect value", + 6, mcIntRm6hd.getPrecision() ); + assertEquals("MathContext.getPrecision() returns incorrect value", + 134, mcInt134.getPrecision() ); + + // getRoundingMode() + assertEquals("MathContext.getRoundingMode() returns incorrect value", + RoundingMode.HALF_UP, + mcInt6.getRoundingMode()); + assertEquals("MathContext.getRoundingMode() returns incorrect value", + RoundingMode.HALF_DOWN, mcIntRm6hd.getRoundingMode() ); + + // toString() + assertEquals("MathContext.toString() returning incorrect value", + "precision=6 roundingMode=HALF_DOWN", mcIntRm6hd.toString() ); + assertEquals("MathContext.toString() returning incorrect value", + "precision=6 roundingMode=HALF_UP", mcInt6.toString() ); + + // equals(.) + assertEquals("Equal MathContexts are not equal ", + mcIntRm6hd, mcStr6hd ); + assertFalse("Different MathContexts are reported as equal ", + mcInt6.equals(mcStr6hd) ); + assertFalse("Different MathContexts are reported as equal ", + mcInt6.equals(mcInt134) ); + + // hashCode(.) + assertEquals("Equal MathContexts have different hashcodes ", + mcIntRm6hd.hashCode(), mcStr6hd.hashCode() ); + assertFalse("Different MathContexts have equal hashcodes ", + mcInt6.hashCode() == mcStr6hd.hashCode() ); + assertFalse("Different MathContexts have equal hashcodes ", + mcInt6.hashCode() == mcInt134.hashCode() ); + + // other: + BigDecimal res = aNumber.abs(mcInt6); + assertEquals("MathContext Constructor with int precision failed", + new BigDecimal("1.23809E+68"), + res); + } + +}
\ No newline at end of file diff --git a/math/src/test/java/tests/api/java/math/RoundingModeTest.java b/math/src/test/java/tests/api/java/math/RoundingModeTest.java new file mode 100644 index 0000000..e0946b3 --- /dev/null +++ b/math/src/test/java/tests/api/java/math/RoundingModeTest.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.api.java.math; + +import dalvik.annotation.TestTargets; +import dalvik.annotation.TestLevel; +import dalvik.annotation.TestTargetNew; +import dalvik.annotation.TestTargetClass; + +import java.math.BigDecimal; +import java.math.RoundingMode; + +@TestTargetClass(RoundingMode.class) +public class RoundingModeTest extends junit.framework.TestCase { + + /** + * @tests java.math.RoundingMode#valueOf(int) + */ + @TestTargetNew( + level = TestLevel.COMPLETE, + notes = "", + method = "valueOf", + args = {int.class} + ) + public void test_valueOfI() { + assertEquals("valueOf failed for ROUND_CEILING", RoundingMode.valueOf(BigDecimal.ROUND_CEILING), RoundingMode.CEILING); + assertEquals("valueOf failed for ROUND_DOWN", RoundingMode.valueOf(BigDecimal.ROUND_DOWN), RoundingMode.DOWN); + assertEquals("valueOf failed for ROUND_FLOOR", RoundingMode.valueOf(BigDecimal.ROUND_FLOOR), RoundingMode.FLOOR); + assertEquals("valueOf failed for ROUND_HALF_DOWN", RoundingMode.valueOf(BigDecimal.ROUND_HALF_DOWN), RoundingMode.HALF_DOWN); + assertEquals("valueOf failed for ROUND_HALF_EVEN", RoundingMode.valueOf(BigDecimal.ROUND_HALF_EVEN), RoundingMode.HALF_EVEN); + assertEquals("valueOf failed for ROUND_HALF_UP", RoundingMode.valueOf(BigDecimal.ROUND_HALF_UP), RoundingMode.HALF_UP); + assertEquals("valueOf failed for ROUND_UNNECESSARY", RoundingMode.valueOf(BigDecimal.ROUND_UNNECESSARY), RoundingMode.UNNECESSARY); + assertEquals("valueOf failed for ROUND_UP", RoundingMode.valueOf(BigDecimal.ROUND_UP), RoundingMode.UP); + try { + RoundingMode.valueOf(13); + fail("IllegalArgumentException expected for RoundingMode(13)"); + } catch (IllegalArgumentException e) { + } + try { + RoundingMode.valueOf(-1); + fail("IllegalArgumentException expected for RoundingMode(-1)"); + } catch (IllegalArgumentException e) { + } + } + +} 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..2773ad6 --- /dev/null +++ b/math/src/test/java/tests/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.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 = tests.TestSuiteFactory.createTestSuite("All Math test suites"); + + suite.addTest(tests.api.java.math.AllTests.suite()); + suite.addTest(org.apache.harmony.math.tests.java.math.AllTests.suite()); + + return suite; + } +} |