0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one or more
0003: * contributor license agreements. See the NOTICE file distributed with
0004: * this work for additional information regarding copyright ownership.
0005: * The ASF licenses this file to You under the Apache License, Version 2.0
0006: * (the "License"); you may not use this file except in compliance with
0007: * the License. You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: */
0017:
0018: package org.apache.harmony.tests.java.math;
0019:
0020: import java.math.BigDecimal;
0021: import java.math.BigInteger;
0022: import java.math.MathContext;
0023: import java.math.RoundingMode;
0024:
0025: import junit.framework.TestCase;
0026:
0027: /**
0028: * Class: java.math.BigDecimal
0029: * Methods: add, subtract, multiply, divide
0030: */
0031: public class BigDecimalArithmeticTest extends TestCase {
0032: /**
0033: * Add two numbers of equal positive scales
0034: */
0035: public void testAddEqualScalePosPos() {
0036: String a = "1231212478987482988429808779810457634781384756794987";
0037: int aScale = 10;
0038: String b = "747233429293018787918347987234564568";
0039: int bScale = 10;
0040: String c = "123121247898748373566323807282924555312937.1991359555";
0041: int cScale = 10;
0042: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0043: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0044: BigDecimal result = aNumber.add(bNumber);
0045: assertEquals("incorrect value", c, result.toString());
0046: assertEquals("incorrect scale", cScale, result.scale());
0047: }
0048:
0049: /**
0050: * Add two numbers of equal positive scales using MathContext
0051: */
0052: public void testAddMathContextEqualScalePosPos() {
0053: String a = "1231212478987482988429808779810457634781384756794987";
0054: int aScale = 10;
0055: String b = "747233429293018787918347987234564568";
0056: int bScale = 10;
0057: String c = "1.2313E+41";
0058: int cScale = -37;
0059: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0060: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0061: MathContext mc = new MathContext(5, RoundingMode.UP);
0062: BigDecimal result = aNumber.add(bNumber, mc);
0063: assertEquals("incorrect value", c, result.toString());
0064: assertEquals("incorrect scale", cScale, result.scale());
0065: }
0066:
0067: /**
0068: * Add two numbers of equal negative scales
0069: */
0070: public void testAddEqualScaleNegNeg() {
0071: String a = "1231212478987482988429808779810457634781384756794987";
0072: int aScale = -10;
0073: String b = "747233429293018787918347987234564568";
0074: int bScale = -10;
0075: String c = "1.231212478987483735663238072829245553129371991359555E+61";
0076: int cScale = -10;
0077: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0078: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0079: BigDecimal result = aNumber.add(bNumber);
0080: assertEquals("incorrect value", c, result.toString());
0081: assertEquals("incorrect scale", cScale, result.scale());
0082: }
0083:
0084: /**
0085: * Add two numbers of equal negative scales using MathContext
0086: */
0087: public void testAddMathContextEqualScaleNegNeg() {
0088: String a = "1231212478987482988429808779810457634781384756794987";
0089: int aScale = -10;
0090: String b = "747233429293018787918347987234564568";
0091: int bScale = -10;
0092: String c = "1.2312E+61";
0093: int cScale = -57;
0094: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0095: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0096: MathContext mc = new MathContext(5, RoundingMode.FLOOR);
0097: BigDecimal result = aNumber.add(bNumber, mc);
0098: assertEquals("incorrect value ", c, result.toString());
0099: assertEquals("incorrect scale", cScale, result.scale());
0100: }
0101:
0102: /**
0103: * Add two numbers of different scales; the first is positive
0104: */
0105: public void testAddDiffScalePosNeg() {
0106: String a = "1231212478987482988429808779810457634781384756794987";
0107: int aScale = 15;
0108: String b = "747233429293018787918347987234564568";
0109: int bScale = -10;
0110: String c = "7472334294161400358170962860775454459810457634.781384756794987";
0111: int cScale = 15;
0112: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0113: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0114: BigDecimal result = aNumber.add(bNumber);
0115: assertEquals("incorrect value", c, result.toString());
0116: assertEquals("incorrect scale", cScale, result.scale());
0117: }
0118:
0119: /**
0120: * Add two numbers of different scales using MathContext; the first is positive
0121: */
0122: public void testAddMathContextDiffScalePosNeg() {
0123: String a = "1231212478987482988429808779810457634781384756794987";
0124: int aScale = 15;
0125: String b = "747233429293018787918347987234564568";
0126: int bScale = -10;
0127: String c = "7.47233429416141E+45";
0128: int cScale = -31;
0129: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0130: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0131: MathContext mc = new MathContext(15, RoundingMode.CEILING);
0132: BigDecimal result = aNumber.add(bNumber, mc);
0133: assertEquals("incorrect value", c, c.toString());
0134: assertEquals("incorrect scale", cScale, result.scale());
0135: }
0136:
0137: /**
0138: * Add two numbers of different scales; the first is negative
0139: */
0140: public void testAddDiffScaleNegPos() {
0141: String a = "1231212478987482988429808779810457634781384756794987";
0142: int aScale = -15;
0143: String b = "747233429293018787918347987234564568";
0144: int bScale = 10;
0145: String c = "1231212478987482988429808779810457634781459480137916301878791834798.7234564568";
0146: int cScale = 10;
0147: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0148: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0149: BigDecimal result = aNumber.add(bNumber);
0150: assertEquals("incorrect value", c, result.toString());
0151: assertEquals("incorrect scale", cScale, result.scale());
0152: }
0153:
0154: /**
0155: * Add two zeroes of different scales; the first is negative
0156: */
0157: public void testAddDiffScaleZeroZero() {
0158: String a = "0";
0159: int aScale = -15;
0160: String b = "0";
0161: int bScale = 10;
0162: String c = "0E-10";
0163: int cScale = 10;
0164: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0165: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0166: BigDecimal result = aNumber.add(bNumber);
0167: assertEquals("incorrect value", c, result.toString());
0168: assertEquals("incorrect scale", cScale, result.scale());
0169: }
0170:
0171: /**
0172: * Subtract two numbers of equal positive scales
0173: */
0174: public void testSubtractEqualScalePosPos() {
0175: String a = "1231212478987482988429808779810457634781384756794987";
0176: int aScale = 10;
0177: String b = "747233429293018787918347987234564568";
0178: int bScale = 10;
0179: String c = "123121247898748224119637948679166971643339.7522230419";
0180: int cScale = 10;
0181: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0182: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0183: BigDecimal result = aNumber.subtract(bNumber);
0184: assertEquals("incorrect value", c, result.toString());
0185: assertEquals("incorrect scale", cScale, result.scale());
0186: }
0187:
0188: /**
0189: * Subtract two numbers of equal positive scales using MathContext
0190: */
0191: public void testSubtractMathContextEqualScalePosPos() {
0192: String a = "1231212478987482988429808779810457634781384756794987";
0193: int aScale = 10;
0194: String b = "747233429293018787918347987234564568";
0195: int bScale = 10;
0196: String c = "1.23121247898749E+41";
0197: int cScale = -27;
0198: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0199: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0200: MathContext mc = new MathContext(15, RoundingMode.CEILING);
0201: BigDecimal result = aNumber.subtract(bNumber, mc);
0202: assertEquals("incorrect value", c, result.toString());
0203: assertEquals("incorrect scale", cScale, result.scale());
0204: }
0205:
0206: /**
0207: * Subtract two numbers of equal negative scales
0208: */
0209: public void testSubtractEqualScaleNegNeg() {
0210: String a = "1231212478987482988429808779810457634781384756794987";
0211: int aScale = -10;
0212: String b = "747233429293018787918347987234564568";
0213: int bScale = -10;
0214: String c = "1.231212478987482241196379486791669716433397522230419E+61";
0215: int cScale = -10;
0216: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0217: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0218: BigDecimal result = aNumber.subtract(bNumber);
0219: assertEquals("incorrect value", c, result.toString());
0220: assertEquals("incorrect scale", cScale, result.scale());
0221: }
0222:
0223: /**
0224: * Subtract two numbers of different scales; the first is positive
0225: */
0226: public void testSubtractDiffScalePosNeg() {
0227: String a = "1231212478987482988429808779810457634781384756794987";
0228: int aScale = 15;
0229: String b = "747233429293018787918347987234564568";
0230: int bScale = -10;
0231: String c = "-7472334291698975400195996883915836900189542365.218615243205013";
0232: int cScale = 15;
0233: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0234: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0235: BigDecimal result = aNumber.subtract(bNumber);
0236: assertEquals("incorrect value", c, result.toString());
0237: assertEquals("incorrect scale", cScale, result.scale());
0238: }
0239:
0240: /**
0241: * Subtract two numbers of different scales using MathContext;
0242: * the first is positive
0243: */
0244: public void testSubtractMathContextDiffScalePosNeg() {
0245: String a = "1231212478987482988429808779810457634781384756794987";
0246: int aScale = 15;
0247: String b = "747233429293018787918347987234564568";
0248: int bScale = -10;
0249: String c = "-7.4723342916989754E+45";
0250: int cScale = -29;
0251: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0252: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0253: MathContext mc = new MathContext(17, RoundingMode.DOWN);
0254: BigDecimal result = aNumber.subtract(bNumber, mc);
0255: assertEquals("incorrect value", c, result.toString());
0256: assertEquals("incorrect scale", cScale, result.scale());
0257: }
0258:
0259: /**
0260: * Subtract two numbers of different scales; the first is negative
0261: */
0262: public void testSubtractDiffScaleNegPos() {
0263: String a = "1231212478987482988429808779810457634781384756794987";
0264: int aScale = -15;
0265: String b = "747233429293018787918347987234564568";
0266: int bScale = 10;
0267: String c = "1231212478987482988429808779810457634781310033452057698121208165201.2765435432";
0268: int cScale = 10;
0269: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0270: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0271: BigDecimal result = aNumber.subtract(bNumber);
0272: assertEquals("incorrect value", c, result.toString());
0273: assertEquals("incorrect scale", cScale, result.scale());
0274: }
0275:
0276: /**
0277: * Subtract two numbers of different scales using MathContext;
0278: * the first is negative
0279: */
0280: public void testSubtractMathContextDiffScaleNegPos() {
0281: String a = "986798656676789766678767876078779810457634781384756794987";
0282: int aScale = -15;
0283: String b = "747233429293018787918347987234564568";
0284: int bScale = 40;
0285: String c = "9.867986566767897666787678760787798104576347813847567949870000000000000E+71";
0286: int cScale = -2;
0287: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0288: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0289: MathContext mc = new MathContext(70, RoundingMode.HALF_DOWN);
0290: BigDecimal result = aNumber.subtract(bNumber, mc);
0291: assertEquals("incorrect value", c, result.toString());
0292: assertEquals("incorrect scale", cScale, result.scale());
0293: }
0294:
0295: /**
0296: * Multiply two numbers of positive scales
0297: */
0298: public void testMultiplyScalePosPos() {
0299: String a = "1231212478987482988429808779810457634781384756794987";
0300: int aScale = 15;
0301: String b = "747233429293018787918347987234564568";
0302: int bScale = 10;
0303: String c = "92000312286217574978643009574114545567010139156902666284589309.1880727173060570190220616";
0304: int cScale = 25;
0305: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0306: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0307: BigDecimal result = aNumber.multiply(bNumber);
0308: assertEquals("incorrect value", c, result.toString());
0309: assertEquals("incorrect scale", cScale, result.scale());
0310: }
0311:
0312: /**
0313: * Multiply two numbers of positive scales using MathContext
0314: */
0315: public void testMultiplyMathContextScalePosPos() {
0316: String a = "97665696756578755423325476545428779810457634781384756794987";
0317: int aScale = -25;
0318: String b = "87656965586786097685674786576598865";
0319: int bScale = 10;
0320: String c = "8.561078619600910561431314228543672720908E+108";
0321: int cScale = -69;
0322: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0323: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0324: MathContext mc = new MathContext(40, RoundingMode.HALF_DOWN);
0325: BigDecimal result = aNumber.multiply(bNumber, mc);
0326: assertEquals("incorrect value", c, result.toString());
0327: assertEquals("incorrect scale", cScale, result.scale());
0328: }
0329:
0330: /**
0331: * Multiply two numbers of negative scales
0332: */
0333: public void testMultiplyEqualScaleNegNeg() {
0334: String a = "1231212478987482988429808779810457634781384756794987";
0335: int aScale = -15;
0336: String b = "747233429293018787918347987234564568";
0337: int bScale = -10;
0338: String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+111";
0339: int cScale = -25;
0340: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0341: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0342: BigDecimal result = aNumber.multiply(bNumber);
0343: assertEquals("incorrect value", c, result.toString());
0344: assertEquals("incorrect scale", cScale, result.scale());
0345: }
0346:
0347: /**
0348: * Multiply two numbers of different scales
0349: */
0350: public void testMultiplyDiffScalePosNeg() {
0351: String a = "1231212478987482988429808779810457634781384756794987";
0352: int aScale = 10;
0353: String b = "747233429293018787918347987234564568";
0354: int bScale = -10;
0355: String c = "920003122862175749786430095741145455670101391569026662845893091880727173060570190220616";
0356: int cScale = 0;
0357: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0358: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0359: BigDecimal result = aNumber.multiply(bNumber);
0360: assertEquals("incorrect value", c, result.toString());
0361: assertEquals("incorrect scale", cScale, result.scale());
0362: }
0363:
0364: /**
0365: * Multiply two numbers of different scales using MathContext
0366: */
0367: public void testMultiplyMathContextDiffScalePosNeg() {
0368: String a = "987667796597975765768768767866756808779810457634781384756794987";
0369: int aScale = 100;
0370: String b = "747233429293018787918347987234564568";
0371: int bScale = -70;
0372: String c = "7.3801839465418518653942222612429081498248509257207477E+68";
0373: int cScale = -16;
0374: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0375: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0376: MathContext mc = new MathContext(53, RoundingMode.HALF_UP);
0377: BigDecimal result = aNumber.multiply(bNumber, mc);
0378: assertEquals("incorrect value", c, result.toString());
0379: assertEquals("incorrect scale", cScale, result.scale());
0380: }
0381:
0382: /**
0383: * Multiply two numbers of different scales
0384: */
0385: public void testMultiplyDiffScaleNegPos() {
0386: String a = "1231212478987482988429808779810457634781384756794987";
0387: int aScale = -15;
0388: String b = "747233429293018787918347987234564568";
0389: int bScale = 10;
0390: String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+91";
0391: int cScale = -5;
0392: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0393: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0394: BigDecimal result = aNumber.multiply(bNumber);
0395: assertEquals("incorrect value", c, result.toString());
0396: assertEquals("incorrect scale", cScale, result.scale());
0397: }
0398:
0399: /**
0400: * Multiply two numbers of different scales using MathContext
0401: */
0402: public void testMultiplyMathContextDiffScaleNegPos() {
0403: String a = "488757458676796558668876576576579097029810457634781384756794987";
0404: int aScale = -63;
0405: String b = "747233429293018787918347987234564568";
0406: int bScale = 63;
0407: String c = "3.6521591193960361339707130098174381429788164316E+98";
0408: int cScale = -52;
0409: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0410: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0411: MathContext mc = new MathContext(47, RoundingMode.HALF_UP);
0412: BigDecimal result = aNumber.multiply(bNumber, mc);
0413: assertEquals("incorrect value", c, result.toString());
0414: assertEquals("incorrect scale", cScale, result.scale());
0415: }
0416:
0417: /**
0418: * pow(int)
0419: */
0420: public void testPow() {
0421: String a = "123121247898748298842980";
0422: int aScale = 10;
0423: int exp = 10;
0424: String c = "8004424019039195734129783677098845174704975003788210729597"
0425: + "4875206425711159855030832837132149513512555214958035390490"
0426: + "798520842025826.594316163502809818340013610490541783276343"
0427: + "6514490899700151256484355936102754469438371850240000000000";
0428: int cScale = 100;
0429: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0430: BigDecimal result = aNumber.pow(exp);
0431: assertEquals("incorrect value", c, result.toString());
0432: assertEquals("incorrect scale", cScale, result.scale());
0433: }
0434:
0435: /**
0436: * pow(0)
0437: */
0438: public void testPow0() {
0439: String a = "123121247898748298842980";
0440: int aScale = 10;
0441: int exp = 0;
0442: String c = "1";
0443: int cScale = 0;
0444: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0445: BigDecimal result = aNumber.pow(exp);
0446: assertEquals("incorrect value", c, result.toString());
0447: assertEquals("incorrect scale", cScale, result.scale());
0448: }
0449:
0450: /**
0451: * ZERO.pow(0)
0452: */
0453: public void testZeroPow0() {
0454: String c = "1";
0455: int cScale = 0;
0456: BigDecimal result = BigDecimal.ZERO.pow(0);
0457: assertEquals("incorrect value", c, result.toString());
0458: assertEquals("incorrect scale", cScale, result.scale());
0459: }
0460:
0461: /**
0462: * pow(int, MathContext)
0463: */
0464: public void testPowMathContext() {
0465: String a = "123121247898748298842980";
0466: int aScale = 10;
0467: int exp = 10;
0468: String c = "8.0044E+130";
0469: int cScale = -126;
0470: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0471: MathContext mc = new MathContext(5, RoundingMode.HALF_UP);
0472: BigDecimal result = aNumber.pow(exp, mc);
0473: assertEquals("incorrect value", c, result.toString());
0474: assertEquals("incorrect scale", cScale, result.scale());
0475: }
0476:
0477: /**
0478: * Divide by zero
0479: */
0480: public void testDivideByZero() {
0481: String a = "1231212478987482988429808779810457634781384756794987";
0482: int aScale = 15;
0483: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0484: BigDecimal bNumber = BigDecimal.valueOf(0L);
0485: try {
0486: aNumber.divide(bNumber);
0487: fail("ArithmeticException has not been caught");
0488: } catch (ArithmeticException e) {
0489: assertEquals("Improper exception message",
0490: "Division by zero", e.getMessage());
0491: }
0492: }
0493:
0494: /**
0495: * Divide with ROUND_UNNECESSARY
0496: */
0497: public void testDivideExceptionRM() {
0498: String a = "1231212478987482988429808779810457634781384756794987";
0499: int aScale = 15;
0500: String b = "747233429293018787918347987234564568";
0501: int bScale = 10;
0502: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0503: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0504: try {
0505: aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
0506: fail("ArithmeticException has not been caught");
0507: } catch (ArithmeticException e) {
0508: assertEquals("Improper exception message",
0509: "Rounding necessary", e.getMessage());
0510: }
0511: }
0512:
0513: /**
0514: * Divide with invalid rounding mode
0515: */
0516: public void testDivideExceptionInvalidRM() {
0517: String a = "1231212478987482988429808779810457634781384756794987";
0518: int aScale = 15;
0519: String b = "747233429293018787918347987234564568";
0520: int bScale = 10;
0521: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0522: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0523: try {
0524: aNumber.divide(bNumber, 100);
0525: fail("IllegalArgumentException has not been caught");
0526: } catch (IllegalArgumentException e) {
0527: assertEquals("Improper exception message",
0528: "Invalid rounding mode", e.getMessage());
0529: }
0530: }
0531:
0532: /**
0533: * Divide: local variable exponent is less than zero
0534: */
0535: public void testDivideExpLessZero() {
0536: String a = "1231212478987482988429808779810457634781384756794987";
0537: int aScale = 15;
0538: String b = "747233429293018787918347987234564568";
0539: int bScale = 10;
0540: String c = "1.64770E+10";
0541: int resScale = -5;
0542: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0543: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0544: BigDecimal result = aNumber.divide(bNumber, resScale,
0545: BigDecimal.ROUND_CEILING);
0546: assertEquals("incorrect value", c, result.toString());
0547: assertEquals("incorrect scale", resScale, result.scale());
0548: }
0549:
0550: /**
0551: * Divide: local variable exponent is equal to zero
0552: */
0553: public void testDivideExpEqualsZero() {
0554: String a = "1231212478987482988429808779810457634781384756794987";
0555: int aScale = -15;
0556: String b = "747233429293018787918347987234564568";
0557: int bScale = 10;
0558: String c = "1.64769459009933764189139568605273529E+40";
0559: int resScale = -5;
0560: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0561: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0562: BigDecimal result = aNumber.divide(bNumber, resScale,
0563: BigDecimal.ROUND_CEILING);
0564: assertEquals("incorrect value", c, result.toString());
0565: assertEquals("incorrect scale", resScale, result.scale());
0566: }
0567:
0568: /**
0569: * Divide: local variable exponent is greater than zero
0570: */
0571: public void testDivideExpGreaterZero() {
0572: String a = "1231212478987482988429808779810457634781384756794987";
0573: int aScale = -15;
0574: String b = "747233429293018787918347987234564568";
0575: int bScale = 20;
0576: String c = "1.647694590099337641891395686052735285121058381E+50";
0577: int resScale = -5;
0578: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0579: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0580: BigDecimal result = aNumber.divide(bNumber, resScale,
0581: BigDecimal.ROUND_CEILING);
0582: assertEquals("incorrect value", c, result.toString());
0583: assertEquals("incorrect scale", resScale, result.scale());
0584: }
0585:
0586: /**
0587: * Divide: remainder is zero
0588: */
0589: public void testDivideRemainderIsZero() {
0590: String a = "8311389578904553209874735431110";
0591: int aScale = -15;
0592: String b = "237468273682987234567849583746";
0593: int bScale = 20;
0594: String c = "3.5000000000000000000000000000000E+36";
0595: int resScale = -5;
0596: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0597: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0598: BigDecimal result = aNumber.divide(bNumber, resScale,
0599: BigDecimal.ROUND_CEILING);
0600: assertEquals("incorrect value", c, result.toString());
0601: assertEquals("incorrect scale", resScale, result.scale());
0602: }
0603:
0604: /**
0605: * Divide: rounding mode is ROUND_UP, result is negative
0606: */
0607: public void testDivideRoundUpNeg() {
0608: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0609: int aScale = -24;
0610: String b = "7472334223847623782375469293018787918347987234564568";
0611: int bScale = 13;
0612: String c = "-1.24390557635720517122423359799284E+53";
0613: int resScale = -21;
0614: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0615: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0616: BigDecimal result = aNumber.divide(bNumber, resScale,
0617: BigDecimal.ROUND_UP);
0618: assertEquals("incorrect value", c, result.toString());
0619: assertEquals("incorrect scale", resScale, result.scale());
0620: }
0621:
0622: /**
0623: * Divide: rounding mode is ROUND_UP, result is positive
0624: */
0625: public void testDivideRoundUpPos() {
0626: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0627: int aScale = -24;
0628: String b = "7472334223847623782375469293018787918347987234564568";
0629: int bScale = 13;
0630: String c = "1.24390557635720517122423359799284E+53";
0631: int resScale = -21;
0632: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0633: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0634: BigDecimal result = aNumber.divide(bNumber, resScale,
0635: BigDecimal.ROUND_UP);
0636: assertEquals("incorrect value", c, result.toString());
0637: assertEquals("incorrect scale", resScale, result.scale());
0638: }
0639:
0640: /**
0641: * Divide: rounding mode is ROUND_DOWN, result is negative
0642: */
0643: public void testDivideRoundDownNeg() {
0644: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0645: int aScale = -24;
0646: String b = "7472334223847623782375469293018787918347987234564568";
0647: int bScale = 13;
0648: String c = "-1.24390557635720517122423359799283E+53";
0649: int resScale = -21;
0650: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0651: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0652: BigDecimal result = aNumber.divide(bNumber, resScale,
0653: BigDecimal.ROUND_DOWN);
0654: assertEquals("incorrect value", c, result.toString());
0655: assertEquals("incorrect scale", resScale, result.scale());
0656: }
0657:
0658: /**
0659: * Divide: rounding mode is ROUND_DOWN, result is positive
0660: */
0661: public void testDivideRoundDownPos() {
0662: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0663: int aScale = -24;
0664: String b = "7472334223847623782375469293018787918347987234564568";
0665: int bScale = 13;
0666: String c = "1.24390557635720517122423359799283E+53";
0667: int resScale = -21;
0668: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0669: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0670: BigDecimal result = aNumber.divide(bNumber, resScale,
0671: BigDecimal.ROUND_DOWN);
0672: assertEquals("incorrect value", c, result.toString());
0673: assertEquals("incorrect scale", resScale, result.scale());
0674: }
0675:
0676: /**
0677: * Divide: rounding mode is ROUND_FLOOR, result is positive
0678: */
0679: public void testDivideRoundFloorPos() {
0680: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0681: int aScale = -24;
0682: String b = "7472334223847623782375469293018787918347987234564568";
0683: int bScale = 13;
0684: String c = "1.24390557635720517122423359799283E+53";
0685: int resScale = -21;
0686: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0687: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0688: BigDecimal result = aNumber.divide(bNumber, resScale,
0689: BigDecimal.ROUND_FLOOR);
0690: assertEquals("incorrect value", c, result.toString());
0691: assertEquals("incorrect scale", resScale, result.scale());
0692: }
0693:
0694: /**
0695: * Divide: rounding mode is ROUND_FLOOR, result is negative
0696: */
0697: public void testDivideRoundFloorNeg() {
0698: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0699: int aScale = -24;
0700: String b = "7472334223847623782375469293018787918347987234564568";
0701: int bScale = 13;
0702: String c = "-1.24390557635720517122423359799284E+53";
0703: int resScale = -21;
0704: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0705: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0706: BigDecimal result = aNumber.divide(bNumber, resScale,
0707: BigDecimal.ROUND_FLOOR);
0708: assertEquals("incorrect value", c, result.toString());
0709: assertEquals("incorrect scale", resScale, result.scale());
0710: }
0711:
0712: /**
0713: * Divide: rounding mode is ROUND_CEILING, result is positive
0714: */
0715: public void testDivideRoundCeilingPos() {
0716: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0717: int aScale = -24;
0718: String b = "7472334223847623782375469293018787918347987234564568";
0719: int bScale = 13;
0720: String c = "1.24390557635720517122423359799284E+53";
0721: int resScale = -21;
0722: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0723: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0724: BigDecimal result = aNumber.divide(bNumber, resScale,
0725: BigDecimal.ROUND_CEILING);
0726: assertEquals("incorrect value", c, result.toString());
0727: assertEquals("incorrect scale", resScale, result.scale());
0728: }
0729:
0730: /**
0731: * Divide: rounding mode is ROUND_CEILING, result is negative
0732: */
0733: public void testDivideRoundCeilingNeg() {
0734: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0735: int aScale = -24;
0736: String b = "7472334223847623782375469293018787918347987234564568";
0737: int bScale = 13;
0738: String c = "-1.24390557635720517122423359799283E+53";
0739: int resScale = -21;
0740: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0741: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0742: BigDecimal result = aNumber.divide(bNumber, resScale,
0743: BigDecimal.ROUND_CEILING);
0744: assertEquals("incorrect value", c, result.toString());
0745: assertEquals("incorrect scale", resScale, result.scale());
0746: }
0747:
0748: /**
0749: * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = -1
0750: */
0751: public void testDivideRoundHalfUpPos() {
0752: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0753: int aScale = -24;
0754: String b = "7472334223847623782375469293018787918347987234564568";
0755: int bScale = 13;
0756: String c = "1.24390557635720517122423359799284E+53";
0757: int resScale = -21;
0758: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0759: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0760: BigDecimal result = aNumber.divide(bNumber, resScale,
0761: BigDecimal.ROUND_HALF_UP);
0762: assertEquals("incorrect value", c, result.toString());
0763: assertEquals("incorrect scale", resScale, result.scale());
0764: }
0765:
0766: /**
0767: * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = -1
0768: */
0769: public void testDivideRoundHalfUpNeg() {
0770: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0771: int aScale = -24;
0772: String b = "7472334223847623782375469293018787918347987234564568";
0773: int bScale = 13;
0774: String c = "-1.24390557635720517122423359799284E+53";
0775: int resScale = -21;
0776: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0777: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0778: BigDecimal result = aNumber.divide(bNumber, resScale,
0779: BigDecimal.ROUND_HALF_UP);
0780: assertEquals("incorrect value", c, result.toString());
0781: assertEquals("incorrect scale", resScale, result.scale());
0782: }
0783:
0784: /**
0785: * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = 1
0786: */
0787: public void testDivideRoundHalfUpPos1() {
0788: String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
0789: int aScale = -24;
0790: String b = "74723342238476237823754692930187879183479";
0791: int bScale = 13;
0792: String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
0793: int resScale = -21;
0794: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0795: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0796: BigDecimal result = aNumber.divide(bNumber, resScale,
0797: BigDecimal.ROUND_HALF_UP);
0798: assertEquals("incorrect value", c, result.toString());
0799: assertEquals("incorrect scale", resScale, result.scale());
0800: }
0801:
0802: /**
0803: * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = 1
0804: */
0805: public void testDivideRoundHalfUpNeg1() {
0806: String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
0807: int aScale = -24;
0808: String b = "74723342238476237823754692930187879183479";
0809: int bScale = 13;
0810: String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
0811: int resScale = -21;
0812: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0813: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0814: BigDecimal result = aNumber.divide(bNumber, resScale,
0815: BigDecimal.ROUND_HALF_UP);
0816: assertEquals("incorrect value", c, result.toString());
0817: assertEquals("incorrect scale", resScale, result.scale());
0818: }
0819:
0820: /**
0821: * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
0822: */
0823: public void testDivideRoundHalfUpNeg2() {
0824: String a = "-37361671119238118911893939591735";
0825: int aScale = 10;
0826: String b = "74723342238476237823787879183470";
0827: int bScale = 15;
0828: String c = "-1E+5";
0829: int resScale = -5;
0830: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0831: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0832: BigDecimal result = aNumber.divide(bNumber, resScale,
0833: BigDecimal.ROUND_HALF_UP);
0834: assertEquals("incorrect value", c, result.toString());
0835: assertEquals("incorrect scale", resScale, result.scale());
0836: }
0837:
0838: /**
0839: * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = -1
0840: */
0841: public void testDivideRoundHalfDownPos() {
0842: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0843: int aScale = -24;
0844: String b = "7472334223847623782375469293018787918347987234564568";
0845: int bScale = 13;
0846: String c = "1.24390557635720517122423359799284E+53";
0847: int resScale = -21;
0848: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0849: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0850: BigDecimal result = aNumber.divide(bNumber, resScale,
0851: BigDecimal.ROUND_HALF_DOWN);
0852: assertEquals("incorrect value", c, result.toString());
0853: assertEquals("incorrect scale", resScale, result.scale());
0854: }
0855:
0856: /**
0857: * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = -1
0858: */
0859: public void testDivideRoundHalfDownNeg() {
0860: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0861: int aScale = -24;
0862: String b = "7472334223847623782375469293018787918347987234564568";
0863: int bScale = 13;
0864: String c = "-1.24390557635720517122423359799284E+53";
0865: int resScale = -21;
0866: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0867: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0868: BigDecimal result = aNumber.divide(bNumber, resScale,
0869: BigDecimal.ROUND_HALF_DOWN);
0870: assertEquals("incorrect value", c, result.toString());
0871: assertEquals("incorrect scale", resScale, result.scale());
0872: }
0873:
0874: /**
0875: * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = 1
0876: */
0877: public void testDivideRoundHalfDownPos1() {
0878: String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
0879: int aScale = -24;
0880: String b = "74723342238476237823754692930187879183479";
0881: int bScale = 13;
0882: String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
0883: int resScale = -21;
0884: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0885: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0886: BigDecimal result = aNumber.divide(bNumber, resScale,
0887: BigDecimal.ROUND_HALF_DOWN);
0888: assertEquals("incorrect value", c, result.toString());
0889: assertEquals("incorrect scale", resScale, result.scale());
0890: }
0891:
0892: /**
0893: * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = 1
0894: */
0895: public void testDivideRoundHalfDownNeg1() {
0896: String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
0897: int aScale = -24;
0898: String b = "74723342238476237823754692930187879183479";
0899: int bScale = 13;
0900: String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
0901: int resScale = -21;
0902: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0903: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0904: BigDecimal result = aNumber.divide(bNumber, resScale,
0905: BigDecimal.ROUND_HALF_DOWN);
0906: assertEquals("incorrect value", c, result.toString());
0907: assertEquals("incorrect scale", resScale, result.scale());
0908: }
0909:
0910: /**
0911: * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
0912: */
0913: public void testDivideRoundHalfDownNeg2() {
0914: String a = "-37361671119238118911893939591735";
0915: int aScale = 10;
0916: String b = "74723342238476237823787879183470";
0917: int bScale = 15;
0918: String c = "0E+5";
0919: int resScale = -5;
0920: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0921: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0922: BigDecimal result = aNumber.divide(bNumber, resScale,
0923: BigDecimal.ROUND_HALF_DOWN);
0924: assertEquals("incorrect value", c, result.toString());
0925: assertEquals("incorrect scale", resScale, result.scale());
0926: }
0927:
0928: /**
0929: * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = -1
0930: */
0931: public void testDivideRoundHalfEvenPos() {
0932: String a = "92948782094488478231212478987482988429808779810457634781384756794987";
0933: int aScale = -24;
0934: String b = "7472334223847623782375469293018787918347987234564568";
0935: int bScale = 13;
0936: String c = "1.24390557635720517122423359799284E+53";
0937: int resScale = -21;
0938: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0939: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0940: BigDecimal result = aNumber.divide(bNumber, resScale,
0941: BigDecimal.ROUND_HALF_EVEN);
0942: assertEquals("incorrect value", c, result.toString());
0943: assertEquals("incorrect scale", resScale, result.scale());
0944: }
0945:
0946: /**
0947: * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = -1
0948: */
0949: public void testDivideRoundHalfEvenNeg() {
0950: String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
0951: int aScale = -24;
0952: String b = "7472334223847623782375469293018787918347987234564568";
0953: int bScale = 13;
0954: String c = "-1.24390557635720517122423359799284E+53";
0955: int resScale = -21;
0956: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0957: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0958: BigDecimal result = aNumber.divide(bNumber, resScale,
0959: BigDecimal.ROUND_HALF_EVEN);
0960: assertEquals("incorrect value", c, result.toString());
0961: assertEquals("incorrect scale", resScale, result.scale());
0962: }
0963:
0964: /**
0965: * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = 1
0966: */
0967: public void testDivideRoundHalfEvenPos1() {
0968: String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
0969: int aScale = -24;
0970: String b = "74723342238476237823754692930187879183479";
0971: int bScale = 13;
0972: String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
0973: int resScale = -21;
0974: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0975: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0976: BigDecimal result = aNumber.divide(bNumber, resScale,
0977: BigDecimal.ROUND_HALF_EVEN);
0978: assertEquals("incorrect value", c, result.toString());
0979: assertEquals("incorrect scale", resScale, result.scale());
0980: }
0981:
0982: /**
0983: * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = 1
0984: */
0985: public void testDivideRoundHalfEvenNeg1() {
0986: String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
0987: int aScale = -24;
0988: String b = "74723342238476237823754692930187879183479";
0989: int bScale = 13;
0990: String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
0991: int resScale = -21;
0992: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
0993: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
0994: BigDecimal result = aNumber.divide(bNumber, resScale,
0995: BigDecimal.ROUND_HALF_EVEN);
0996: assertEquals("incorrect value", c, result.toString());
0997: assertEquals("incorrect scale", resScale, result.scale());
0998: }
0999:
1000: /**
1001: * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; equidistant
1002: */
1003: public void testDivideRoundHalfEvenNeg2() {
1004: String a = "-37361671119238118911893939591735";
1005: int aScale = 10;
1006: String b = "74723342238476237823787879183470";
1007: int bScale = 15;
1008: String c = "0E+5";
1009: int resScale = -5;
1010: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1011: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1012: BigDecimal result = aNumber.divide(bNumber, resScale,
1013: BigDecimal.ROUND_HALF_EVEN);
1014: assertEquals("incorrect value", c, result.toString());
1015: assertEquals("incorrect scale", resScale, result.scale());
1016: }
1017:
1018: /**
1019: * Divide to BigDecimal
1020: */
1021: public void testDivideBigDecimal1() {
1022: String a = "-37361671119238118911893939591735";
1023: int aScale = 10;
1024: String b = "74723342238476237823787879183470";
1025: int bScale = 15;
1026: String c = "-5E+4";
1027: int resScale = -4;
1028: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1029: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1030: BigDecimal result = aNumber.divide(bNumber);
1031: assertEquals("incorrect value", c, result.toString());
1032: assertEquals("incorrect scale", resScale, result.scale());
1033: }
1034:
1035: /**
1036: * Divide to BigDecimal
1037: */
1038: public void testDivideBigDecimal2() {
1039: String a = "-37361671119238118911893939591735";
1040: int aScale = 10;
1041: String b = "74723342238476237823787879183470";
1042: int bScale = -15;
1043: String c = "-5E-26";
1044: int resScale = 26;
1045: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1046: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1047: BigDecimal result = aNumber.divide(bNumber);
1048: assertEquals("incorrect value", c, result.toString());
1049: assertEquals("incorrect scale", resScale, result.scale());
1050: }
1051:
1052: /**
1053: * divide(BigDecimal, scale, RoundingMode)
1054: */
1055: public void testDivideBigDecimalScaleRoundingModeUP() {
1056: String a = "-37361671119238118911893939591735";
1057: int aScale = 10;
1058: String b = "74723342238476237823787879183470";
1059: int bScale = -15;
1060: int newScale = 31;
1061: RoundingMode rm = RoundingMode.UP;
1062: String c = "-5.00000E-26";
1063: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1064: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1065: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1066: assertEquals("incorrect value", c, result.toString());
1067: assertEquals("incorrect scale", newScale, result.scale());
1068: }
1069:
1070: /**
1071: * divide(BigDecimal, scale, RoundingMode)
1072: */
1073: public void testDivideBigDecimalScaleRoundingModeDOWN() {
1074: String a = "-37361671119238118911893939591735";
1075: int aScale = 10;
1076: String b = "74723342238476237823787879183470";
1077: int bScale = 15;
1078: int newScale = 31;
1079: RoundingMode rm = RoundingMode.DOWN;
1080: String c = "-50000.0000000000000000000000000000000";
1081: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1082: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1083: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1084: assertEquals("incorrect value", c, result.toString());
1085: assertEquals("incorrect scale", newScale, result.scale());
1086: }
1087:
1088: /**
1089: * divide(BigDecimal, scale, RoundingMode)
1090: */
1091: public void testDivideBigDecimalScaleRoundingModeCEILING() {
1092: String a = "3736186567876876578956958765675671119238118911893939591735";
1093: int aScale = 100;
1094: String b = "74723342238476237823787879183470";
1095: int bScale = 15;
1096: int newScale = 45;
1097: RoundingMode rm = RoundingMode.CEILING;
1098: String c = "1E-45";
1099: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1100: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1101: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1102: assertEquals("incorrect value", c, result.toString());
1103: assertEquals("incorrect scale", newScale, result.scale());
1104: }
1105:
1106: /**
1107: * divide(BigDecimal, scale, RoundingMode)
1108: */
1109: public void testDivideBigDecimalScaleRoundingModeFLOOR() {
1110: String a = "3736186567876876578956958765675671119238118911893939591735";
1111: int aScale = 100;
1112: String b = "74723342238476237823787879183470";
1113: int bScale = 15;
1114: int newScale = 45;
1115: RoundingMode rm = RoundingMode.FLOOR;
1116: String c = "0E-45";
1117: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1118: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1119: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1120: assertEquals("incorrect value", c, result.toString());
1121: assertEquals("incorrect scale", newScale, result.scale());
1122: }
1123:
1124: /**
1125: * divide(BigDecimal, scale, RoundingMode)
1126: */
1127: public void testDivideBigDecimalScaleRoundingModeHALF_UP() {
1128: String a = "3736186567876876578956958765675671119238118911893939591735";
1129: int aScale = -51;
1130: String b = "74723342238476237823787879183470";
1131: int bScale = 45;
1132: int newScale = 3;
1133: RoundingMode rm = RoundingMode.HALF_UP;
1134: String c = "50000260373164286401361913262100972218038099522752460421"
1135: + "05959924024355721031761947728703598332749334086415670525"
1136: + "3761096961.670";
1137: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1138: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1139: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1140: assertEquals("incorrect value", c, result.toString());
1141: assertEquals("incorrect scale", newScale, result.scale());
1142: }
1143:
1144: /**
1145: * divide(BigDecimal, scale, RoundingMode)
1146: */
1147: public void testDivideBigDecimalScaleRoundingModeHALF_DOWN() {
1148: String a = "3736186567876876578956958765675671119238118911893939591735";
1149: int aScale = 5;
1150: String b = "74723342238476237823787879183470";
1151: int bScale = 15;
1152: int newScale = 7;
1153: RoundingMode rm = RoundingMode.HALF_DOWN;
1154: String c = "500002603731642864013619132621009722.1803810";
1155: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1156: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1157: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1158: assertEquals("incorrect value", c, result.toString());
1159: assertEquals("incorrect scale", newScale, result.scale());
1160: }
1161:
1162: /**
1163: * divide(BigDecimal, scale, RoundingMode)
1164: */
1165: public void testDivideBigDecimalScaleRoundingModeHALF_EVEN() {
1166: String a = "3736186567876876578956958765675671119238118911893939591735";
1167: int aScale = 5;
1168: String b = "74723342238476237823787879183470";
1169: int bScale = 15;
1170: int newScale = 7;
1171: RoundingMode rm = RoundingMode.HALF_EVEN;
1172: String c = "500002603731642864013619132621009722.1803810";
1173: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1174: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1175: BigDecimal result = aNumber.divide(bNumber, newScale, rm);
1176: assertEquals("incorrect value", c, result.toString());
1177: assertEquals("incorrect scale", newScale, result.scale());
1178: }
1179:
1180: /**
1181: * divide(BigDecimal, MathContext)
1182: */
1183: public void testDivideBigDecimalScaleMathContextUP() {
1184: String a = "3736186567876876578956958765675671119238118911893939591735";
1185: int aScale = 15;
1186: String b = "748766876876723342238476237823787879183470";
1187: int bScale = 10;
1188: int precision = 21;
1189: RoundingMode rm = RoundingMode.UP;
1190: MathContext mc = new MathContext(precision, rm);
1191: String c = "49897861180.2562512996";
1192: int resScale = 10;
1193: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1194: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1195: BigDecimal result = aNumber.divide(bNumber, mc);
1196: assertEquals("incorrect value", c, result.toString());
1197: assertEquals("incorrect scale", resScale, result.scale());
1198: }
1199:
1200: /**
1201: * divide(BigDecimal, MathContext)
1202: */
1203: public void testDivideBigDecimalScaleMathContextDOWN() {
1204: String a = "3736186567876876578956958765675671119238118911893939591735";
1205: int aScale = 15;
1206: String b = "748766876876723342238476237823787879183470";
1207: int bScale = 70;
1208: int precision = 21;
1209: RoundingMode rm = RoundingMode.DOWN;
1210: MathContext mc = new MathContext(precision, rm);
1211: String c = "4.98978611802562512995E+70";
1212: int resScale = -50;
1213: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1214: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1215: BigDecimal result = aNumber.divide(bNumber, mc);
1216: assertEquals("incorrect value", c, result.toString());
1217: assertEquals("incorrect scale", resScale, result.scale());
1218: }
1219:
1220: /**
1221: * divide(BigDecimal, MathContext)
1222: */
1223: public void testDivideBigDecimalScaleMathContextCEILING() {
1224: String a = "3736186567876876578956958765675671119238118911893939591735";
1225: int aScale = 15;
1226: String b = "748766876876723342238476237823787879183470";
1227: int bScale = 70;
1228: int precision = 21;
1229: RoundingMode rm = RoundingMode.CEILING;
1230: MathContext mc = new MathContext(precision, rm);
1231: String c = "4.98978611802562512996E+70";
1232: int resScale = -50;
1233: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1234: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1235: BigDecimal result = aNumber.divide(bNumber, mc);
1236: assertEquals("incorrect value", c, result.toString());
1237: assertEquals("incorrect scale", resScale, result.scale());
1238: }
1239:
1240: /**
1241: * divide(BigDecimal, MathContext)
1242: */
1243: public void testDivideBigDecimalScaleMathContextFLOOR() {
1244: String a = "3736186567876876578956958765675671119238118911893939591735";
1245: int aScale = 15;
1246: String b = "748766876876723342238476237823787879183470";
1247: int bScale = 70;
1248: int precision = 21;
1249: RoundingMode rm = RoundingMode.FLOOR;
1250: MathContext mc = new MathContext(precision, rm);
1251: String c = "4.98978611802562512995E+70";
1252: int resScale = -50;
1253: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1254: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1255: BigDecimal result = aNumber.divide(bNumber, mc);
1256: assertEquals("incorrect value", c, result.toString());
1257: assertEquals("incorrect scale", resScale, result.scale());
1258: }
1259:
1260: /**
1261: * divide(BigDecimal, MathContext)
1262: */
1263: public void testDivideBigDecimalScaleMathContextHALF_UP() {
1264: String a = "3736186567876876578956958765675671119238118911893939591735";
1265: int aScale = 45;
1266: String b = "134432345432345748766876876723342238476237823787879183470";
1267: int bScale = 70;
1268: int precision = 21;
1269: RoundingMode rm = RoundingMode.HALF_UP;
1270: MathContext mc = new MathContext(precision, rm);
1271: String c = "2.77923185514690367475E+26";
1272: int resScale = -6;
1273: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1274: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1275: BigDecimal result = aNumber.divide(bNumber, mc);
1276: assertEquals("incorrect value", c, result.toString());
1277: assertEquals("incorrect scale", resScale, result.scale());
1278: }
1279:
1280: /**
1281: * divide(BigDecimal, MathContext)
1282: */
1283: public void testDivideBigDecimalScaleMathContextHALF_DOWN() {
1284: String a = "3736186567876876578956958765675671119238118911893939591735";
1285: int aScale = 45;
1286: String b = "134432345432345748766876876723342238476237823787879183470";
1287: int bScale = 70;
1288: int precision = 21;
1289: RoundingMode rm = RoundingMode.HALF_DOWN;
1290: MathContext mc = new MathContext(precision, rm);
1291: String c = "2.77923185514690367475E+26";
1292: int resScale = -6;
1293: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1294: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1295: BigDecimal result = aNumber.divide(bNumber, mc);
1296: assertEquals("incorrect value", c, result.toString());
1297: assertEquals("incorrect scale", resScale, result.scale());
1298: }
1299:
1300: /**
1301: * divide(BigDecimal, MathContext)
1302: */
1303: public void testDivideBigDecimalScaleMathContextHALF_EVEN() {
1304: String a = "3736186567876876578956958765675671119238118911893939591735";
1305: int aScale = 45;
1306: String b = "134432345432345748766876876723342238476237823787879183470";
1307: int bScale = 70;
1308: int precision = 21;
1309: RoundingMode rm = RoundingMode.HALF_EVEN;
1310: MathContext mc = new MathContext(precision, rm);
1311: String c = "2.77923185514690367475E+26";
1312: int resScale = -6;
1313: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1314: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1315: BigDecimal result = aNumber.divide(bNumber, mc);
1316: assertEquals("incorrect value", c, result.toString());
1317: assertEquals("incorrect scale", resScale, result.scale());
1318: }
1319:
1320: /**
1321: * divideToIntegralValue(BigDecimal)
1322: */
1323: public void testDivideToIntegralValue() {
1324: String a = "3736186567876876578956958765675671119238118911893939591735";
1325: int aScale = 45;
1326: String b = "134432345432345748766876876723342238476237823787879183470";
1327: int bScale = 70;
1328: String c = "277923185514690367474770683";
1329: int resScale = 0;
1330: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1331: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1332: BigDecimal result = aNumber.divideToIntegralValue(bNumber);
1333: assertEquals("incorrect value", c, result.toString());
1334: assertEquals("incorrect scale", resScale, result.scale());
1335: }
1336:
1337: /**
1338: * divideToIntegralValue(BigDecimal, MathContext)
1339: */
1340: public void testDivideToIntegralValueMathContextUP() {
1341: String a = "3736186567876876578956958765675671119238118911893939591735";
1342: int aScale = 45;
1343: String b = "134432345432345748766876876723342238476237823787879183470";
1344: int bScale = 70;
1345: int precision = 32;
1346: RoundingMode rm = RoundingMode.UP;
1347: MathContext mc = new MathContext(precision, rm);
1348: String c = "277923185514690367474770683";
1349: int resScale = 0;
1350: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1351: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1352: BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
1353: assertEquals("incorrect value", c, result.toString());
1354: assertEquals("incorrect scale", resScale, result.scale());
1355: }
1356:
1357: /**
1358: * divideToIntegralValue(BigDecimal, MathContext)
1359: */
1360: public void testDivideToIntegralValueMathContextDOWN() {
1361: String a = "3736186567876876578956958769675785435673453453653543654354365435675671119238118911893939591735";
1362: int aScale = 45;
1363: String b = "134432345432345748766876876723342238476237823787879183470";
1364: int bScale = 70;
1365: int precision = 75;
1366: RoundingMode rm = RoundingMode.DOWN;
1367: MathContext mc = new MathContext(precision, rm);
1368: String c = "2.7792318551469036747477068339450205874992634417590178670822889E+62";
1369: int resScale = -1;
1370: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1371: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1372: BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
1373: assertEquals("incorrect value", c, result.toString());
1374: assertEquals("incorrect scale", resScale, result.scale());
1375: }
1376:
1377: /**
1378: * divideAndRemainder(BigDecimal)
1379: */
1380: public void testDivideAndRemainder1() {
1381: String a = "3736186567876876578956958765675671119238118911893939591735";
1382: int aScale = 45;
1383: String b = "134432345432345748766876876723342238476237823787879183470";
1384: int bScale = 70;
1385: String res = "277923185514690367474770683";
1386: int resScale = 0;
1387: String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
1388: int remScale = 70;
1389: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1390: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1391: BigDecimal result[] = aNumber.divideAndRemainder(bNumber);
1392: assertEquals("incorrect quotient value", res, result[0]
1393: .toString());
1394: assertEquals("incorrect quotient scale", resScale, result[0]
1395: .scale());
1396: assertEquals("incorrect remainder value", rem, result[1]
1397: .toString());
1398: assertEquals("incorrect remainder scale", remScale, result[1]
1399: .scale());
1400: }
1401:
1402: /**
1403: * divideAndRemainder(BigDecimal)
1404: */
1405: public void testDivideAndRemainder2() {
1406: String a = "3736186567876876578956958765675671119238118911893939591735";
1407: int aScale = -45;
1408: String b = "134432345432345748766876876723342238476237823787879183470";
1409: int bScale = 70;
1410: String res = "2779231855146903674747706830969461168692256919247547952"
1411: + "2608549363170374005512836303475980101168105698072946555"
1412: + "6862849";
1413: int resScale = 0;
1414: String rem = "3.4935796954060524114470681810486417234751682675102093970E-15";
1415: int remScale = 70;
1416: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1417: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1418: BigDecimal result[] = aNumber.divideAndRemainder(bNumber);
1419: assertEquals("incorrect quotient value", res, result[0]
1420: .toString());
1421: assertEquals("incorrect quotient scale", resScale, result[0]
1422: .scale());
1423: assertEquals("incorrect remainder value", rem, result[1]
1424: .toString());
1425: assertEquals("incorrect remainder scale", remScale, result[1]
1426: .scale());
1427: }
1428:
1429: /**
1430: * divideAndRemainder(BigDecimal, MathContext)
1431: */
1432: public void testDivideAndRemainderMathContextUP() {
1433: String a = "3736186567876876578956958765675671119238118911893939591735";
1434: int aScale = 45;
1435: String b = "134432345432345748766876876723342238476237823787879183470";
1436: int bScale = 70;
1437: int precision = 75;
1438: RoundingMode rm = RoundingMode.UP;
1439: MathContext mc = new MathContext(precision, rm);
1440: String res = "277923185514690367474770683";
1441: int resScale = 0;
1442: String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
1443: int remScale = 70;
1444: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1445: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1446: BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
1447: assertEquals("incorrect quotient value", res, result[0]
1448: .toString());
1449: assertEquals("incorrect quotient scale", resScale, result[0]
1450: .scale());
1451: assertEquals("incorrect remainder value", rem, result[1]
1452: .toString());
1453: assertEquals("incorrect remainder scale", remScale, result[1]
1454: .scale());
1455: }
1456:
1457: /**
1458: * divideAndRemainder(BigDecimal, MathContext)
1459: */
1460: public void testDivideAndRemainderMathContextDOWN() {
1461: String a = "3736186567876876578956958765675671119238118911893939591735";
1462: int aScale = 45;
1463: String b = "134432345432345748766876876723342238476237823787879183470";
1464: int bScale = 20;
1465: int precision = 15;
1466: RoundingMode rm = RoundingMode.DOWN;
1467: MathContext mc = new MathContext(precision, rm);
1468: String res = "0E-25";
1469: int resScale = 25;
1470: String rem = "3736186567876.876578956958765675671119238118911893939591735";
1471: int remScale = 45;
1472: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1473: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1474: BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
1475: assertEquals("incorrect quotient value", res, result[0]
1476: .toString());
1477: assertEquals("incorrect quotient scale", resScale, result[0]
1478: .scale());
1479: assertEquals("incorrect remainder value", rem, result[1]
1480: .toString());
1481: assertEquals("incorrect remainder scale", remScale, result[1]
1482: .scale());
1483: }
1484:
1485: /**
1486: * remainder(BigDecimal)
1487: */
1488: public void testRemainder1() {
1489: String a = "3736186567876876578956958765675671119238118911893939591735";
1490: int aScale = 45;
1491: String b = "134432345432345748766876876723342238476237823787879183470";
1492: int bScale = 10;
1493: String res = "3736186567876.876578956958765675671119238118911893939591735";
1494: int resScale = 45;
1495: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1496: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1497: BigDecimal result = aNumber.remainder(bNumber);
1498: assertEquals("incorrect quotient value", res, result.toString());
1499: assertEquals("incorrect quotient scale", resScale, result
1500: .scale());
1501: }
1502:
1503: /**
1504: * remainder(BigDecimal)
1505: */
1506: public void testRemainder2() {
1507: String a = "3736186567876876578956958765675671119238118911893939591735";
1508: int aScale = -45;
1509: String b = "134432345432345748766876876723342238476237823787879183470";
1510: int bScale = 10;
1511: String res = "1149310942946292909508821656680979993738625937.2065885780";
1512: int resScale = 10;
1513: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1514: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1515: BigDecimal result = aNumber.remainder(bNumber);
1516: assertEquals("incorrect quotient value", res, result.toString());
1517: assertEquals("incorrect quotient scale", resScale, result
1518: .scale());
1519: }
1520:
1521: /**
1522: * remainder(BigDecimal, MathContext)
1523: */
1524: public void testRemainderMathContextHALF_UP() {
1525: String a = "3736186567876876578956958765675671119238118911893939591735";
1526: int aScale = 45;
1527: String b = "134432345432345748766876876723342238476237823787879183470";
1528: int bScale = 10;
1529: int precision = 15;
1530: RoundingMode rm = RoundingMode.HALF_UP;
1531: MathContext mc = new MathContext(precision, rm);
1532: String res = "3736186567876.876578956958765675671119238118911893939591735";
1533: int resScale = 45;
1534: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1535: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1536: BigDecimal result = aNumber.remainder(bNumber, mc);
1537: assertEquals("incorrect quotient value", res, result.toString());
1538: assertEquals("incorrect quotient scale", resScale, result
1539: .scale());
1540: }
1541:
1542: /**
1543: * remainder(BigDecimal, MathContext)
1544: */
1545: public void testRemainderMathContextHALF_DOWN() {
1546: String a = "3736186567876876578956958765675671119238118911893939591735";
1547: int aScale = -45;
1548: String b = "134432345432345748766876876723342238476237823787879183470";
1549: int bScale = 10;
1550: int precision = 75;
1551: RoundingMode rm = RoundingMode.HALF_DOWN;
1552: MathContext mc = new MathContext(precision, rm);
1553: String res = "1149310942946292909508821656680979993738625937.2065885780";
1554: int resScale = 10;
1555: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1556: BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
1557: BigDecimal result = aNumber.remainder(bNumber, mc);
1558: assertEquals("incorrect quotient value", res, result.toString());
1559: assertEquals("incorrect quotient scale", resScale, result
1560: .scale());
1561: }
1562:
1563: /**
1564: * round(BigDecimal, MathContext)
1565: */
1566: public void testRoundMathContextHALF_DOWN() {
1567: String a = "3736186567876876578956958765675671119238118911893939591735";
1568: int aScale = -45;
1569: int precision = 75;
1570: RoundingMode rm = RoundingMode.HALF_DOWN;
1571: MathContext mc = new MathContext(precision, rm);
1572: String res = "3.736186567876876578956958765675671119238118911893939591735E+102";
1573: int resScale = -45;
1574: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1575: BigDecimal result = aNumber.round(mc);
1576: assertEquals("incorrect quotient value", res, result.toString());
1577: assertEquals("incorrect quotient scale", resScale, result
1578: .scale());
1579: }
1580:
1581: /**
1582: * round(BigDecimal, MathContext)
1583: */
1584: public void testRoundMathContextHALF_UP() {
1585: String a = "3736186567876876578956958765675671119238118911893939591735";
1586: int aScale = 45;
1587: int precision = 15;
1588: RoundingMode rm = RoundingMode.HALF_UP;
1589: MathContext mc = new MathContext(precision, rm);
1590: String res = "3736186567876.88";
1591: int resScale = 2;
1592: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1593: BigDecimal result = aNumber.round(mc);
1594: assertEquals("incorrect quotient value", res, result.toString());
1595: assertEquals("incorrect quotient scale", resScale, result
1596: .scale());
1597: }
1598:
1599: /**
1600: * round(BigDecimal, MathContext) when precision = 0
1601: */
1602: public void testRoundMathContextPrecision0() {
1603: String a = "3736186567876876578956958765675671119238118911893939591735";
1604: int aScale = 45;
1605: int precision = 0;
1606: RoundingMode rm = RoundingMode.HALF_UP;
1607: MathContext mc = new MathContext(precision, rm);
1608: String res = "3736186567876.876578956958765675671119238118911893939591735";
1609: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1610: BigDecimal result = aNumber.round(mc);
1611: assertEquals("incorrect quotient value", res, result.toString());
1612: assertEquals("incorrect quotient scale", aScale, result.scale());
1613: }
1614:
1615: /**
1616: * ulp() of a positive BigDecimal
1617: */
1618: public void testUlpPos() {
1619: String a = "3736186567876876578956958765675671119238118911893939591735";
1620: int aScale = -45;
1621: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1622: BigDecimal result = aNumber.ulp();
1623: String res = "1E+45";
1624: int resScale = -45;
1625: assertEquals("incorrect value", res, result.toString());
1626: assertEquals("incorrect scale", resScale, result.scale());
1627: }
1628:
1629: /**
1630: * ulp() of a negative BigDecimal
1631: */
1632: public void testUlpNeg() {
1633: String a = "-3736186567876876578956958765675671119238118911893939591735";
1634: int aScale = 45;
1635: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1636: BigDecimal result = aNumber.ulp();
1637: String res = "1E-45";
1638: int resScale = 45;
1639: assertEquals("incorrect value", res, result.toString());
1640: assertEquals("incorrect scale", resScale, result.scale());
1641: }
1642:
1643: /**
1644: * ulp() of a negative BigDecimal
1645: */
1646: public void testUlpZero() {
1647: String a = "0";
1648: int aScale = 2;
1649: BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
1650: BigDecimal result = aNumber.ulp();
1651: String res = "0.01";
1652: int resScale = 2;
1653: assertEquals("incorrect value", res, result.toString());
1654: assertEquals("incorrect scale", resScale, result.scale());
1655: }
1656: }
|