| /* |
| * 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} |
| ) |
| 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} |
| ) |
| 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} |
| ) |
| 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} |
| ) |
| 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} |
| ) |
| 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("Has a rounding problem. seems like the precision is" |
| + " 1 too small and cuts off the last digit. also this test might" |
| + "not be correct. The name implies that scale should be used.") |
| 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("The same test and the same problem like " |
| + "testDivideScaleRoundingModeNonTrivial") |
| 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} |
| ) |
| 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} |
| ) |
| 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} |
| ) |
| 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 |
| } |
| } |
| |
| } |