java.math.RoundingMode

Here are the examples of the java api class java.math.RoundingMode taken from open source projects.

1. TestDecimalRoundingSuite#testEEDecimalScale()

Project: voltdb
File: TestDecimalRoundingSuite.java
public void testEEDecimalScale() throws Exception {
    Boolean roundIsEnabled = Boolean.valueOf(m_defaultRoundingEnablement);
    RoundingMode roundMode = RoundingMode.valueOf(m_defaultRoundingMode);
    assert (m_config instanceof LocalCluster);
    LocalCluster localCluster = (LocalCluster) m_config;
    Map<String, String> props = localCluster.getAdditionalProcessEnv();
    if (props != null) {
        roundIsEnabled = Boolean.valueOf(props.containsKey(m_roundingEnabledProperty) ? props.get(m_roundingEnabledProperty) : "true");
        roundMode = RoundingMode.valueOf(props.containsKey(m_roundingModeProperty) ? props.get(m_roundingModeProperty) : "HALF_UP");
    }
    doTestEEDecimalScale(roundIsEnabled, roundMode);
}

2. TestDecimalRoundingSuite#testDecimalScaleInsertion()

Project: voltdb
File: TestDecimalRoundingSuite.java
public void testDecimalScaleInsertion() throws Exception {
    Boolean roundIsEnabled = Boolean.valueOf(m_defaultRoundingEnablement);
    RoundingMode roundMode = RoundingMode.valueOf(m_defaultRoundingMode);
    assert (m_config instanceof LocalCluster);
    LocalCluster localCluster = (LocalCluster) m_config;
    Map<String, String> props = localCluster.getAdditionalProcessEnv();
    if (props != null) {
        roundIsEnabled = Boolean.valueOf(props.containsKey(m_roundingEnabledProperty) ? props.get(m_roundingEnabledProperty) : "true");
        roundMode = RoundingMode.valueOf(props.containsKey(m_roundingModeProperty) ? props.get(m_roundingModeProperty) : "HALF_UP");
        System.out.printf("Rounding is %senabled, mode is %s\n", roundIsEnabled ? "" : "not ", roundMode.toString());
    } else {
        System.out.printf("Default rounding (%s), Default Rounding mode (%s).\n", roundIsEnabled.toString(), roundMode.toString());
    }
    doTestDecimalScaleInsertion(roundIsEnabled, roundMode);
}

3. BigDecimalConstructorsTest#testConstrStringMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(String value, MathContext)
     */
@Test
public void testConstrStringMathContext() {
    String a = "-238768787678287e214";
    int precision = 5;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "-23876";
    int resScale = -224;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

4. BigDecimalConstructorsTest#testConstrLongMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(long, MathContext)
     */
@Test
public void testConstrLongMathContext() {
    long a = 4576578677732546982L;
    int precision = 5;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "45766";
    int resScale = -14;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

5. BigDecimalConstructorsTest#testConstrIntMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(int, MathContext)
     */
@Test
public void testConstrIntMathContext() {
    int a = 732546982;
    int precision = 21;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "732546982";
    int resScale = 0;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

6. BigDecimalConstructorsTest#testConstrDoubleMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(double, MathContext)
     */
@Test
public void testConstrDoubleMathContext() {
    double a = 732546982374982347892379283571094797.287346782359284756;
    int precision = 21;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "732546982374982285074";
    int resScale = -15;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

7. BigDecimalConstructorsTest#testConstrCharIntIntMathContextException2()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(char[] value, int offset, int len, MathContext mc);
     */
@Test
public void testConstrCharIntIntMathContextException2() {
    char value[] = { '-', '1', '2', '3', '8', '0', ',', '4', '7', '3', '8', 'E', '-', '4', '2', '3' };
    int offset = 3;
    int len = 120;
    int precision = 4;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    try {
        new BigDecimal(value, offset, len, mc);
        fail("NumberFormatException has not been thrown");
    } catch (NumberFormatException e) {
    }
}

8. BigDecimalConstructorsTest#testConstrCharIntIntMathContextException1()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(char[] value, int offset, int len, MathContext mc);
     */
@Test
public void testConstrCharIntIntMathContextException1() {
    char value[] = { '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3' };
    int offset = 3;
    int len = 120;
    int precision = 4;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    try {
        new BigDecimal(value, offset, len, mc);
        fail("NumberFormatException has not been thrown");
    } catch (NumberFormatException e) {
    }
}

9. BigDecimalConstructorsTest#testConstrCharIntIntMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(char[] value, int offset, int len, MathContext mc);
     */
@Test
public void testConstrCharIntIntMathContext() {
    char value[] = { '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3' };
    int offset = 3;
    int len = 12;
    int precision = 4;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    BigDecimal result = new BigDecimal(value, offset, len, mc);
    String res = "3.805E-40";
    int resScale = 43;
    assertEquals("incorrect value", res, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
    try {
        // Regression for HARMONY-783
        new BigDecimal(new char[] {}, 0, 0, MathContext.DECIMAL32);
        fail("NumberFormatException has not been thrown");
    } catch (NumberFormatException e) {
    }
}

10. BigDecimalConstructorsTest#testConstrBigIntegerScaleMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(BigInteger value, int scale, MathContext)
     */
@Test
public void testConstrBigIntegerScaleMathContext() {
    String a = "1231212478987482988429808779810457634781384756794987";
    BigInteger bA = new BigInteger(a);
    int aScale = 10;
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "1231212478987482988429808779810457634781384757";
    int resScale = 4;
    BigDecimal result = new BigDecimal(bA, aScale, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

11. BigDecimalConstructorsTest#testConstrBigIntegerMathContext()

Project: teavm
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(BigInteger value, MathContext)
     */
@Test
public void testConstrBigIntegerMathContext() {
    String a = "1231212478987482988429808779810457634781384756794987";
    BigInteger bA = new BigInteger(a);
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "1231212478987482988429808779810457634781384757";
    int resScale = -6;
    BigDecimal result = new BigDecimal(bA, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

12. BigDecimalCompareTest#testNegateMathContextNegative()

Project: teavm
File: BigDecimalCompareTest.java
/**
     * negate(MathContext) for a negative BigDecimal
     */
@Test
public void testNegateMathContextNegative() {
    String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 49;
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String c = "9294878209448847823.12124789874829884298087798";
    int cScale = 27;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.negate(mc);
    String resString = res.toString();
    assertEquals("incorrect value", c, resString.substring(0, resString.length() - 1));
    assertEquals("incorrect scale", cScale, res.scale());
}

13. BigDecimalCompareTest#testNegateMathContextPositive()

Project: teavm
File: BigDecimalCompareTest.java
/**
     * negate(MathContext) for a positive BigDecimal
     */
@Test
public void testNegateMathContextPositive() {
    String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 41;
    int precision = 37;
    RoundingMode rm = RoundingMode.FLOOR;
    MathContext mc = new MathContext(precision, rm);
    String c = "-929487820944884782312124789.874829884";
    int cScale = 10;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.negate(mc);
    String resString = res.toString();
    assertEquals("incorrect value", c, resString.substring(0, resString.length() - 1));
    assertEquals("incorrect scale", cScale, res.scale());
}

14. BigDecimalCompareTest#testPlusMathContextNegative()

Project: teavm
File: BigDecimalCompareTest.java
/**
     * plus(MathContext) for a negative BigDecimal
     */
@Test
public void testPlusMathContextNegative() {
    String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 49;
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String c = "-9294878209448847823.121247898748298842980877981";
    int cScale = 27;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.plus(mc);
    assertEquals("incorrect value", c, res.toString());
    assertEquals("incorrect scale", cScale, res.scale());
}

15. BigDecimalCompareTest#testPlusMathContextPositive()

Project: teavm
File: BigDecimalCompareTest.java
/**
     * plus(MathContext) for a positive BigDecimal
     */
@Test
public void testPlusMathContextPositive() {
    String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 41;
    int precision = 37;
    RoundingMode rm = RoundingMode.FLOOR;
    MathContext mc = new MathContext(precision, rm);
    String c = "929487820944884782312124789.8748298842";
    int cScale = 10;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.plus(mc);
    assertEquals("incorrect value", c, res.toString());
    assertEquals("incorrect scale", cScale, res.scale());
}

16. BigDecimalCompareTest#testAbsMathContextPos()

Project: teavm
File: BigDecimalCompareTest.java
/**
     * Abs(MathContext) of a positive BigDecimal
     */
@Test
public void testAbsMathContextPos() {
    String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
    BigDecimal aNumber = new BigDecimal(a);
    int precision = 41;
    RoundingMode rm = RoundingMode.HALF_EVEN;
    MathContext mc = new MathContext(precision, rm);
    String result = "1.2380964839238475457356735674573563567890E+53";
    int resScale = -13;
    BigDecimal res = aNumber.abs(mc);
    assertEquals("incorrect value", result, res.toString());
    assertEquals("incorrect scale", resScale, res.scale());
}

17. BigDecimalCompareTest#testAbsMathContextNeg()

Project: teavm
File: BigDecimalCompareTest.java
/**
     * Abs(MathContext) of a negative BigDecimal
     */
@Test
public void testAbsMathContextNeg() {
    String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
    BigDecimal aNumber = new BigDecimal(a);
    int precision = 15;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    MathContext mc = new MathContext(precision, rm);
    String result = "1.23809648392385E+53";
    int resScale = -39;
    BigDecimal res = aNumber.abs(mc);
    assertEquals("incorrect value", result, res.toString());
    assertEquals("incorrect scale", resScale, res.scale());
}

18. BigDecimalArithmeticTest#testRoundMathContextPrecision0()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * round(BigDecimal, MathContext) when precision = 0
     */
@Test
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());
}

19. BigDecimalArithmeticTest#testRoundMathContextHALF_UP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * round(BigDecimal, MathContext)
     */
@Test
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());
}

20. BigDecimalArithmeticTest#testRoundMathContextHALF_DOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * round(BigDecimal, MathContext)
     */
@Test
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());
}

21. BigDecimalArithmeticTest#testRemainderMathContextHALF_DOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * remainder(BigDecimal, MathContext)
     */
@Test
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());
}

22. BigDecimalArithmeticTest#testRemainderMathContextHALF_UP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * remainder(BigDecimal, MathContext)
     */
@Test
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());
}

23. BigDecimalArithmeticTest#testDivideAndRemainderMathContextDOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divideAndRemainder(BigDecimal, MathContext)
     */
@Test
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());
}

24. BigDecimalArithmeticTest#testDivideAndRemainderMathContextUP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divideAndRemainder(BigDecimal, MathContext)
     */
@Test
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());
}

25. BigDecimalArithmeticTest#testDivideToIntegralValueMathContextDOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divideToIntegralValue(BigDecimal, MathContext)
     */
@Test
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());
}

26. BigDecimalArithmeticTest#testDivideToIntegralValueMathContextUP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divideToIntegralValue(BigDecimal, MathContext)
     */
@Test
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());
}

27. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextHALF_EVEN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

28. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextHALF_DOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

29. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextHALF_UP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

30. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextFLOOR()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

31. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextCEILING()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

32. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextDOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

33. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextUP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
@Test
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());
}

34. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeHALF_EVEN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

35. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeHALF_DOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

36. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeHALF_UP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

37. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeFLOOR()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

38. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeCEILING()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

39. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeDOWN()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

40. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeUP()

Project: teavm
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
@Test
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());
}

41. BigDecimalConstructorsTest#testConstrCharIntIntMathContextException2()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(char[] value, int offset, int len, MathContext mc); 
     */
public void testConstrCharIntIntMathContextException2() {
    char value[] = { '-', '1', '2', '3', '8', '0', ',', '4', '7', '3', '8', 'E', '-', '4', '2', '3' };
    int offset = 3;
    int len = 120;
    int precision = 4;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    try {
        new BigDecimal(value, offset, len, mc);
        fail("NumberFormatException has not been thrown");
    } catch (NumberFormatException e) {
    }
}

42. BigDecimalConstructorsTest#testConstrCharIntIntMathContextException1()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(char[] value, int offset, int len, MathContext mc); 
     */
public void testConstrCharIntIntMathContextException1() {
    char value[] = { '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3' };
    int offset = 3;
    int len = 120;
    int precision = 4;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    try {
        new BigDecimal(value, offset, len, mc);
        fail("NumberFormatException has not been thrown");
    } catch (NumberFormatException e) {
    }
}

43. BigDecimalConstructorsTest#testConstrCharIntIntMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(char[] value, int offset, int len, MathContext mc); 
     */
public void testConstrCharIntIntMathContext() {
    char value[] = { '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2', '3' };
    int offset = 3;
    int len = 12;
    int precision = 4;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    BigDecimal result = new BigDecimal(value, offset, len, mc);
    String res = "3.805E-40";
    int resScale = 43;
    assertEquals("incorrect value", res, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
    try {
        // Regression for HARMONY-783
        new BigDecimal(new char[] {}, 0, 0, MathContext.DECIMAL32);
        fail("NumberFormatException has not been thrown");
    } catch (NumberFormatException e) {
    }
}

44. BigDecimalConstructorsTest#testConstrBigIntegerScaleMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(BigInteger value, int scale, MathContext)
     */
public void testConstrBigIntegerScaleMathContext() {
    String a = "1231212478987482988429808779810457634781384756794987";
    BigInteger bA = new BigInteger(a);
    int aScale = 10;
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "1231212478987482988429808779810457634781384757";
    int resScale = 4;
    BigDecimal result = new BigDecimal(bA, aScale, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

45. BigDecimalConstructorsTest#testConstrBigIntegerMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(BigInteger value, MathContext)
     */
public void testConstrBigIntegerMathContext() {
    String a = "1231212478987482988429808779810457634781384756794987";
    BigInteger bA = new BigInteger(a);
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "1231212478987482988429808779810457634781384757";
    int resScale = -6;
    BigDecimal result = new BigDecimal(bA, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

46. BigDecimalCompareTest#testNegateMathContextNegative()

Project: j2objc
File: BigDecimalCompareTest.java
/**
     * negate(MathContext) for a negative BigDecimal
     */
public void testNegateMathContextNegative() {
    String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 49;
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String c = "9294878209448847823.121247898748298842980877981";
    int cScale = 27;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.negate(mc);
    assertEquals("incorrect value", c, res.toString());
    assertEquals("incorrect scale", cScale, res.scale());
}

47. BigDecimalCompareTest#testNegateMathContextPositive()

Project: j2objc
File: BigDecimalCompareTest.java
/**
     * negate(MathContext) for a positive BigDecimal
     */
public void testNegateMathContextPositive() {
    String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 41;
    int precision = 37;
    RoundingMode rm = RoundingMode.FLOOR;
    MathContext mc = new MathContext(precision, rm);
    String c = "-929487820944884782312124789.8748298842";
    int cScale = 10;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.negate(mc);
    assertEquals("incorrect value", c, res.toString());
    assertEquals("incorrect scale", cScale, res.scale());
}

48. BigDecimalCompareTest#testPlusMathContextNegative()

Project: j2objc
File: BigDecimalCompareTest.java
/**
     * plus(MathContext) for a negative BigDecimal
     */
public void testPlusMathContextNegative() {
    String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 49;
    int precision = 46;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String c = "-9294878209448847823.121247898748298842980877981";
    int cScale = 27;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.plus(mc);
    assertEquals("incorrect value", c, res.toString());
    assertEquals("incorrect scale", cScale, res.scale());
}

49. BigDecimalCompareTest#testPlusMathContextPositive()

Project: j2objc
File: BigDecimalCompareTest.java
/**
     * plus(MathContext) for a positive BigDecimal
     */
public void testPlusMathContextPositive() {
    String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    int aScale = 41;
    int precision = 37;
    RoundingMode rm = RoundingMode.FLOOR;
    MathContext mc = new MathContext(precision, rm);
    String c = "929487820944884782312124789.8748298842";
    int cScale = 10;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal res = aNumber.plus(mc);
    assertEquals("incorrect value", c, res.toString());
    assertEquals("incorrect scale", cScale, res.scale());
}

50. BigDecimalCompareTest#testAbsMathContextPos()

Project: j2objc
File: BigDecimalCompareTest.java
/**
     * Abs(MathContext) of a positive BigDecimal
     */
public void testAbsMathContextPos() {
    String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
    BigDecimal aNumber = new BigDecimal(a);
    int precision = 41;
    RoundingMode rm = RoundingMode.HALF_EVEN;
    MathContext mc = new MathContext(precision, rm);
    String result = "1.2380964839238475457356735674573563567890E+53";
    int resScale = -13;
    BigDecimal res = aNumber.abs(mc);
    assertEquals("incorrect value", result, res.toString());
    assertEquals("incorrect scale", resScale, res.scale());
}

51. BigDecimalCompareTest#testAbsMathContextNeg()

Project: j2objc
File: BigDecimalCompareTest.java
/**
     * Abs(MathContext) of a negative BigDecimal
     */
public void testAbsMathContextNeg() {
    String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
    BigDecimal aNumber = new BigDecimal(a);
    int precision = 15;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    MathContext mc = new MathContext(precision, rm);
    String result = "1.23809648392385E+53";
    int resScale = -39;
    BigDecimal res = aNumber.abs(mc);
    assertEquals("incorrect value", result, res.toString());
    assertEquals("incorrect scale", resScale, res.scale());
}

52. BigDecimalArithmeticTest#testRoundMathContextPrecision0()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * round(BigDecimal, MathContext) when precision = 0
     */
public void testRoundMathContextPrecision0() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    int precision = 0;
    RoundingMode rm = RoundingMode.HALF_UP;
    MathContext mc = new MathContext(precision, rm);
    String res = "3736186567876.876578956958765675671119238118911893939591735";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal result = aNumber.round(mc);
    assertEquals("incorrect quotient value", res, result.toString());
    assertEquals("incorrect quotient scale", aScale, result.scale());
}

53. BigDecimalArithmeticTest#testRoundMathContextHALF_UP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * round(BigDecimal, MathContext)
     */
public void testRoundMathContextHALF_UP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    int precision = 15;
    RoundingMode rm = RoundingMode.HALF_UP;
    MathContext mc = new MathContext(precision, rm);
    String res = "3736186567876.88";
    int resScale = 2;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal result = aNumber.round(mc);
    assertEquals("incorrect quotient value", res, result.toString());
    assertEquals("incorrect quotient scale", resScale, result.scale());
}

54. BigDecimalArithmeticTest#testRoundMathContextHALF_DOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * round(BigDecimal, MathContext)
     */
public void testRoundMathContextHALF_DOWN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = -45;
    int precision = 75;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    MathContext mc = new MathContext(precision, rm);
    String res = "3.736186567876876578956958765675671119238118911893939591735E+102";
    int resScale = -45;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal result = aNumber.round(mc);
    assertEquals("incorrect quotient value", res, result.toString());
    assertEquals("incorrect quotient scale", resScale, result.scale());
}

55. BigDecimalArithmeticTest#testRemainderMathContextHALF_DOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * remainder(BigDecimal, MathContext)
     */
public void testRemainderMathContextHALF_DOWN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = -45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 10;
    int precision = 75;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    MathContext mc = new MathContext(precision, rm);
    String res = "1149310942946292909508821656680979993738625937.2065885780";
    int resScale = 10;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.remainder(bNumber, mc);
    assertEquals("incorrect quotient value", res, result.toString());
    assertEquals("incorrect quotient scale", resScale, result.scale());
}

56. BigDecimalArithmeticTest#testRemainderMathContextHALF_UP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * remainder(BigDecimal, MathContext)
     */
public void testRemainderMathContextHALF_UP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 10;
    int precision = 15;
    RoundingMode rm = RoundingMode.HALF_UP;
    MathContext mc = new MathContext(precision, rm);
    String res = "3736186567876.876578956958765675671119238118911893939591735";
    int resScale = 45;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.remainder(bNumber, mc);
    assertEquals("incorrect quotient value", res, result.toString());
    assertEquals("incorrect quotient scale", resScale, result.scale());
}

57. BigDecimalArithmeticTest#testDivideAndRemainderMathContextDOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divideAndRemainder(BigDecimal, MathContext)
     */
public void testDivideAndRemainderMathContextDOWN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 20;
    int precision = 15;
    RoundingMode rm = RoundingMode.DOWN;
    MathContext mc = new MathContext(precision, rm);
    String res = "0E-25";
    int resScale = 25;
    String rem = "3736186567876.876578956958765675671119238118911893939591735";
    int remScale = 45;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
    assertEquals("incorrect quotient value", res, result[0].toString());
    assertEquals("incorrect quotient scale", resScale, result[0].scale());
    assertEquals("incorrect remainder value", rem, result[1].toString());
    assertEquals("incorrect remainder scale", remScale, result[1].scale());
}

58. BigDecimalArithmeticTest#testDivideAndRemainderMathContextUP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divideAndRemainder(BigDecimal, MathContext)
     */
public void testDivideAndRemainderMathContextUP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 75;
    RoundingMode rm = RoundingMode.UP;
    MathContext mc = new MathContext(precision, rm);
    String res = "277923185514690367474770683";
    int resScale = 0;
    String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
    int remScale = 70;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
    assertEquals("incorrect quotient value", res, result[0].toString());
    assertEquals("incorrect quotient scale", resScale, result[0].scale());
    assertEquals("incorrect remainder value", rem, result[1].toString());
    assertEquals("incorrect remainder scale", remScale, result[1].scale());
}

59. BigDecimalArithmeticTest#testDivideToIntegralValueMathContextDOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divideToIntegralValue(BigDecimal, MathContext)
     */
public void testDivideToIntegralValueMathContextDOWN() {
    String a = "3736186567876876578956958769675785435673453453653543654354365435675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 75;
    RoundingMode rm = RoundingMode.DOWN;
    MathContext mc = new MathContext(precision, rm);
    String c = "2.7792318551469036747477068339450205874992634417590178670822889E+62";
    int resScale = -1;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

60. BigDecimalArithmeticTest#testDivideToIntegralValueMathContextUP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divideToIntegralValue(BigDecimal, MathContext)
     */
public void testDivideToIntegralValueMathContextUP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 32;
    RoundingMode rm = RoundingMode.UP;
    MathContext mc = new MathContext(precision, rm);
    String c = "277923185514690367474770683";
    int resScale = 0;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

61. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextHALF_EVEN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextHALF_EVEN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 21;
    RoundingMode rm = RoundingMode.HALF_EVEN;
    MathContext mc = new MathContext(precision, rm);
    String c = "2.77923185514690367475E+26";
    int resScale = -6;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

62. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextHALF_DOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextHALF_DOWN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 21;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    MathContext mc = new MathContext(precision, rm);
    String c = "2.77923185514690367475E+26";
    int resScale = -6;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

63. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextHALF_UP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextHALF_UP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 45;
    String b = "134432345432345748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 21;
    RoundingMode rm = RoundingMode.HALF_UP;
    MathContext mc = new MathContext(precision, rm);
    String c = "2.77923185514690367475E+26";
    int resScale = -6;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

64. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextFLOOR()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextFLOOR() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 15;
    String b = "748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 21;
    RoundingMode rm = RoundingMode.FLOOR;
    MathContext mc = new MathContext(precision, rm);
    String c = "4.98978611802562512995E+70";
    int resScale = -50;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

65. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextCEILING()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextCEILING() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 15;
    String b = "748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 21;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String c = "4.98978611802562512996E+70";
    int resScale = -50;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

66. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextDOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextDOWN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 15;
    String b = "748766876876723342238476237823787879183470";
    int bScale = 70;
    int precision = 21;
    RoundingMode rm = RoundingMode.DOWN;
    MathContext mc = new MathContext(precision, rm);
    String c = "4.98978611802562512995E+70";
    int resScale = -50;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

67. BigDecimalArithmeticTest#testDivideBigDecimalScaleMathContextUP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, MathContext)
     */
public void testDivideBigDecimalScaleMathContextUP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 15;
    String b = "748766876876723342238476237823787879183470";
    int bScale = 10;
    int precision = 21;
    RoundingMode rm = RoundingMode.UP;
    MathContext mc = new MathContext(precision, rm);
    String c = "49897861180.2562512996";
    int resScale = 10;
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, mc);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

68. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeHALF_EVEN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeHALF_EVEN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 5;
    String b = "74723342238476237823787879183470";
    int bScale = 15;
    int newScale = 7;
    RoundingMode rm = RoundingMode.HALF_EVEN;
    String c = "500002603731642864013619132621009722.1803810";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

69. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeHALF_DOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeHALF_DOWN() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 5;
    String b = "74723342238476237823787879183470";
    int bScale = 15;
    int newScale = 7;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    String c = "500002603731642864013619132621009722.1803810";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

70. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeHALF_UP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeHALF_UP() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = -51;
    String b = "74723342238476237823787879183470";
    int bScale = 45;
    int newScale = 3;
    RoundingMode rm = RoundingMode.HALF_UP;
    String c = "50000260373164286401361913262100972218038099522752460421" + "05959924024355721031761947728703598332749334086415670525" + "3761096961.670";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

71. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeFLOOR()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeFLOOR() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 100;
    String b = "74723342238476237823787879183470";
    int bScale = 15;
    int newScale = 45;
    RoundingMode rm = RoundingMode.FLOOR;
    String c = "0E-45";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

72. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeCEILING()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeCEILING() {
    String a = "3736186567876876578956958765675671119238118911893939591735";
    int aScale = 100;
    String b = "74723342238476237823787879183470";
    int bScale = 15;
    int newScale = 45;
    RoundingMode rm = RoundingMode.CEILING;
    String c = "1E-45";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

73. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeDOWN()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeDOWN() {
    String a = "-37361671119238118911893939591735";
    int aScale = 10;
    String b = "74723342238476237823787879183470";
    int bScale = 15;
    int newScale = 31;
    RoundingMode rm = RoundingMode.DOWN;
    String c = "-50000.0000000000000000000000000000000";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

74. BigDecimalArithmeticTest#testDivideBigDecimalScaleRoundingModeUP()

Project: j2objc
File: BigDecimalArithmeticTest.java
/**
     * divide(BigDecimal, scale, RoundingMode)
     */
public void testDivideBigDecimalScaleRoundingModeUP() {
    String a = "-37361671119238118911893939591735";
    int aScale = 10;
    String b = "74723342238476237823787879183470";
    int bScale = -15;
    int newScale = 31;
    RoundingMode rm = RoundingMode.UP;
    String c = "-5.00000E-26";
    BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    BigDecimal result = aNumber.divide(bNumber, newScale, rm);
    assertEquals("incorrect value", c, result.toString());
    assertEquals("incorrect scale", newScale, result.scale());
}

75. LoanScheduleAssembler#calculatePrepaymentAmount()

Project: incubator-fineract
File: LoanScheduleAssembler.java
public LoanRepaymentScheduleInstallment calculatePrepaymentAmount(MonetaryCurrency currency, LocalDate onDate, LoanApplicationTerms loanApplicationTerms, final Set<LoanCharge> loanCharges, final Long officeId, List<LoanTransaction> loanTransactions, final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor, final List<LoanRepaymentScheduleInstallment> repaymentScheduleInstallments) {
    final LoanScheduleGenerator loanScheduleGenerator = this.loanScheduleFactory.create(loanApplicationTerms.getInterestMethod());
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mc = new MathContext(8, roundingMode);
    final boolean isHolidayEnabled = this.configurationDomainService.isRescheduleRepaymentsOnHolidaysEnabled();
    final List<Holiday> holidays = this.holidayRepository.findByOfficeIdAndGreaterThanDate(officeId, loanApplicationTerms.getExpectedDisbursementDate().toDate(), HolidayStatusType.ACTIVE.getValue());
    final WorkingDays workingDays = this.workingDaysRepository.findOne();
    HolidayDetailDTO holidayDetailDTO = new HolidayDetailDTO(isHolidayEnabled, holidays, workingDays);
    return loanScheduleGenerator.calculatePrepaymentAmount(currency, onDate, loanApplicationTerms, mc, loanCharges, holidayDetailDTO, loanTransactions, loanRepaymentScheduleTransactionProcessor, repaymentScheduleInstallments);
}

76. LoanScheduleAssembler#assembleForInterestRecalculation()

Project: incubator-fineract
File: LoanScheduleAssembler.java
public LoanScheduleModel assembleForInterestRecalculation(final LoanApplicationTerms loanApplicationTerms, final Long officeId, List<LoanTransaction> transactions, final Set<LoanCharge> loanCharges, final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor, final List<LoanRepaymentScheduleInstallment> repaymentScheduleInstallments, final LocalDate rescheduleFrom) {
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mc = new MathContext(8, roundingMode);
    final boolean isHolidayEnabled = this.configurationDomainService.isRescheduleRepaymentsOnHolidaysEnabled();
    final List<Holiday> holidays = this.holidayRepository.findByOfficeIdAndGreaterThanDate(officeId, loanApplicationTerms.getExpectedDisbursementDate().toDate(), HolidayStatusType.ACTIVE.getValue());
    final WorkingDays workingDays = this.workingDaysRepository.findOne();
    final LoanScheduleGenerator loanScheduleGenerator = this.loanScheduleFactory.create(loanApplicationTerms.getInterestMethod());
    HolidayDetailDTO detailDTO = new HolidayDetailDTO(isHolidayEnabled, holidays, workingDays);
    return loanScheduleGenerator.rescheduleNextInstallments(mc, loanApplicationTerms, loanCharges, detailDTO, transactions, loanRepaymentScheduleTransactionProcessor, repaymentScheduleInstallments, rescheduleFrom).getLoanScheduleModel();
}

77. LoanScheduleAssembler#assembleLoanScheduleFrom()

Project: incubator-fineract
File: LoanScheduleAssembler.java
public LoanScheduleModel assembleLoanScheduleFrom(final LoanApplicationTerms loanApplicationTerms, final boolean isHolidayEnabled, final List<Holiday> holidays, final WorkingDays workingDays, final JsonElement element, Set<LoanDisbursementDetails> disbursementDetails) {
    final Set<LoanCharge> loanCharges = this.loanChargeAssembler.fromParsedJson(element, disbursementDetails);
    final LoanScheduleGenerator loanScheduleGenerator = this.loanScheduleFactory.create(loanApplicationTerms.getInterestMethod());
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mc = new MathContext(8, roundingMode);
    HolidayDetailDTO detailDTO = new HolidayDetailDTO(isHolidayEnabled, holidays, workingDays);
    return loanScheduleGenerator.generate(mc, loanApplicationTerms, loanCharges, detailDTO);
}

78. Loan#getRecalculatedSchedule()

Project: incubator-fineract
File: Loan.java
private LoanScheduleDTO getRecalculatedSchedule(final ScheduleGeneratorDTO generatorDTO) {
    if (!this.repaymentScheduleDetail().isInterestRecalculationEnabled() || isNpa) {
        return null;
    }
    final InterestMethod interestMethod = this.loanRepaymentScheduleDetail.getInterestMethod();
    final LoanScheduleGenerator loanScheduleGenerator = generatorDTO.getLoanScheduleFactory().create(interestMethod);
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mc = new MathContext(8, roundingMode);
    final LoanApplicationTerms loanApplicationTerms = constructLoanApplicationTerms(generatorDTO);
    final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor = this.transactionProcessorFactory.determineProcessor(this.transactionProcessingStrategy);
    return loanScheduleGenerator.rescheduleNextInstallments(mc, loanApplicationTerms, charges(), generatorDTO.getHolidayDetailDTO(), retreiveListOfTransactionsPostDisbursementExcludeAccruals(), loanRepaymentScheduleTransactionProcessor, getRepaymentScheduleInstallments(), generatorDTO.getRecalculateFrom());
}

79. Loan#regenerateScheduleModel()

Project: incubator-fineract
File: Loan.java
public LoanScheduleModel regenerateScheduleModel(final ScheduleGeneratorDTO scheduleGeneratorDTO) {
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mc = new MathContext(8, roundingMode);
    final InterestMethod interestMethod = this.loanRepaymentScheduleDetail.getInterestMethod();
    final LoanApplicationTerms loanApplicationTerms = constructLoanApplicationTerms(scheduleGeneratorDTO);
    final LoanScheduleGenerator loanScheduleGenerator = scheduleGeneratorDTO.getLoanScheduleFactory().create(interestMethod);
    final LoanScheduleModel loanSchedule = loanScheduleGenerator.generate(mc, loanApplicationTerms, charges(), scheduleGeneratorDTO.getHolidayDetailDTO());
    return loanSchedule;
}

80. DoubleMathTest#testRoundLog2ThrowsOnZerosInfinitiesAndNaN()

Project: guava
File: DoubleMathTest.java
// DoubleMath.log2(double, RoundingMode)
@GwtIncompatible
public void testRoundLog2ThrowsOnZerosInfinitiesAndNaN() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        for (double d : asList(0.0, -0.0, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN)) {
            try {
                DoubleMath.log2(d, mode);
                fail("Expected IllegalArgumentException");
            } catch (IllegalArgumentException expected) {
            }
        }
    }
}

81. DoubleMathTest#testRoundInfiniteToBigIntegerAlwaysFails()

Project: guava
File: DoubleMathTest.java
// DoubleMath.roundToBigInteger(double, RoundingMode)
@GwtIncompatible
public void testRoundInfiniteToBigIntegerAlwaysFails() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        try {
            DoubleMath.roundToBigInteger(Double.POSITIVE_INFINITY, mode);
            fail("Expected ArithmeticException");
        } catch (ArithmeticException expected) {
        }
        try {
            DoubleMath.roundToBigInteger(Double.NEGATIVE_INFINITY, mode);
            fail("Expected ArithmeticException");
        } catch (ArithmeticException expected) {
        }
    }
}

82. DoubleMathTest#testRoundInfiniteToLongAlwaysFails()

Project: guava
File: DoubleMathTest.java
// DoubleMath.roundToLong(double, RoundingMode)
@GwtIncompatible
public void testRoundInfiniteToLongAlwaysFails() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        try {
            DoubleMath.roundToLong(Double.POSITIVE_INFINITY, mode);
            fail("Expected ArithmeticException");
        } catch (ArithmeticException expected) {
        }
        try {
            DoubleMath.roundToLong(Double.NEGATIVE_INFINITY, mode);
            fail("Expected ArithmeticException");
        } catch (ArithmeticException expected) {
        }
    }
}

83. DoubleMathTest#testRoundInfiniteToIntAlwaysFails()

Project: guava
File: DoubleMathTest.java
// DoubleMath.roundToInt(double, RoundingMode)
@GwtIncompatible
public void testRoundInfiniteToIntAlwaysFails() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        try {
            DoubleMath.roundToInt(Double.POSITIVE_INFINITY, mode);
            fail("Expected ArithmeticException");
        } catch (ArithmeticException expected) {
        }
        try {
            DoubleMath.roundToInt(Double.NEGATIVE_INFINITY, mode);
            fail("Expected ArithmeticException");
        } catch (ArithmeticException expected) {
        }
    }
}

84. TieRoundingTest#formatOutputTestObject()

Project: openjdk
File: TieRoundingTest.java
static void formatOutputTestObject(NumberFormat nf, Object someNumber, String tiePosition, String inputDigits, String expectedOutput) {
    int mfd = nf.getMaximumFractionDigits();
    RoundingMode rm = nf.getRoundingMode();
    String result = nf.format(someNumber);
    if (!result.equals(expectedOutput)) {
        System.out.println();
        System.out.println("========================================");
        System.out.println("***Failure : error formatting value from string : " + inputDigits);
        System.out.println("NumberFormat pattern is  : " + ((DecimalFormat) nf).toPattern());
        System.out.println("Maximum number of fractional digits : " + mfd);
        System.out.println("Fractional rounding digit : " + (mfd + 1));
        System.out.println("Position of value relative to tie : " + tiePosition);
        System.out.println("Rounding Mode : " + rm);
        System.out.println("Number self output representation: " + someNumber);
        System.out.println("Error. Formatted result different from expected." + "\nExpected output is : \"" + expectedOutput + "\"" + "\nFormated output is : \"" + result + "\"");
        System.out.println("========================================");
        System.out.println();
        errorCounter++;
        allPassed = false;
    } else {
        testCounter++;
        System.out.print("Success. Number input :" + inputDigits);
        System.out.print(", rounding : " + rm);
        System.out.print(", fract digits : " + mfd);
        System.out.print(", tie position : " + tiePosition);
        System.out.println(", expected : " + expectedOutput);
    }
}

85. TieRoundingTest#formatOutputTestLong()

Project: openjdk
File: TieRoundingTest.java
static void formatOutputTestLong(NumberFormat nf, long longToTest, String tiePosition, String inputDigits, String expectedOutput) {
    int mfd = nf.getMaximumFractionDigits();
    RoundingMode rm = nf.getRoundingMode();
    String result = nf.format(longToTest);
    if (!result.equals(expectedOutput)) {
        System.out.println();
        System.out.println("========================================");
        System.out.println("***Failure : error formatting value from string : " + inputDigits);
        System.out.println("NumberFormat pattern is  : " + ((DecimalFormat) nf).toPattern());
        System.out.println("Maximum number of fractional digits : " + mfd);
        System.out.println("Fractional rounding digit : " + (mfd + 1));
        System.out.println("Position of value relative to tie : " + tiePosition);
        System.out.println("Rounding Mode : " + rm);
        System.out.println("Error. Formatted result different from expected." + "\nExpected output is : \"" + expectedOutput + "\"" + "\nFormated output is : \"" + result + "\"");
        System.out.println("========================================");
        System.out.println();
        errorCounter++;
        allPassed = false;
    } else {
        testCounter++;
        System.out.print("Success. Long input :" + inputDigits);
        System.out.print(", rounding : " + rm);
        System.out.print(", fract digits : " + mfd);
        System.out.print(", tie position : " + tiePosition);
        System.out.println(", expected : " + expectedOutput);
    }
}

86. TieRoundingTest#formatOutputTestDouble()

Project: openjdk
File: TieRoundingTest.java
static void formatOutputTestDouble(NumberFormat nf, double doubleToTest, String tiePosition, String inputDigits, String expectedOutput) {
    int mfd = nf.getMaximumFractionDigits();
    RoundingMode rm = nf.getRoundingMode();
    String result = nf.format(doubleToTest);
    if (!result.equals(expectedOutput)) {
        System.out.println();
        System.out.println("========================================");
        System.out.println("***Failure : error formatting value from string : " + inputDigits);
        System.out.println("NumberFormat pattern is  : " + ((DecimalFormat) nf).toPattern());
        System.out.println("Maximum number of fractional digits : " + mfd);
        System.out.println("Fractional rounding digit : " + (mfd + 1));
        System.out.println("Position of value relative to tie : " + tiePosition);
        System.out.println("Rounding Mode : " + rm);
        System.out.println("BigDecimal output : " + new BigDecimal(doubleToTest).toString());
        System.out.println("FloatingDecimal output : " + doubleToTest);
        System.out.println("Error. Formatted result different from expected." + "\nExpected output is : \"" + expectedOutput + "\"" + "\nFormated output is : \"" + result + "\"");
        System.out.println("========================================");
        System.out.println();
        errorCounter++;
        allPassed = false;
    } else {
        testCounter++;
        System.out.println("\nSuccess for double value : " + doubleToTest + " :");
        System.out.println(" Input digits :" + inputDigits + ", BigDecimal value : " + new BigDecimal(doubleToTest).toString());
        System.out.print(" Rounding mode: " + rm);
        System.out.print(", fract digits : " + mfd);
        System.out.print(", position : " + tiePosition + " tie");
        System.out.print(", result : " + result);
        System.out.println(", expected : " + expectedOutput);
    }
}

87. RoundingModeTests#main()

Project: openjdk
File: RoundingModeTests.java
public static void main(String[] argv) {
    for (RoundingMode rm : RoundingMode.values()) {
        if (rm != RoundingMode.valueOf(rm.toString())) {
            throw new RuntimeException("Bad roundtrip conversion of " + rm.toString());
        }
    }
    // Test that mapping of old integers to new values is correct
    if (RoundingMode.valueOf(BigDecimal.ROUND_CEILING) != RoundingMode.CEILING) {
        throw new RuntimeException("Bad mapping for ROUND_CEILING");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_DOWN) != RoundingMode.DOWN) {
        throw new RuntimeException("Bad mapping for ROUND_DOWN");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_FLOOR) != RoundingMode.FLOOR) {
        throw new RuntimeException("Bad mapping for ROUND_FLOOR");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_DOWN) != RoundingMode.HALF_DOWN) {
        throw new RuntimeException("Bad mapping for ROUND_HALF_DOWN");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_EVEN) != RoundingMode.HALF_EVEN) {
        throw new RuntimeException("Bad mapping for ROUND_HALF_EVEN");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_UP) != RoundingMode.HALF_UP) {
        throw new RuntimeException("Bad mapping for ROUND_HALF_UP");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_UNNECESSARY) != RoundingMode.UNNECESSARY) {
        throw new RuntimeException("Bad mapping for ROUND_UNNECESARY");
    }
}

88. RoundFilter#filter()

Project: jinjava
File: RoundFilter.java
@Override
public Object filter(Object var, JinjavaInterpreter interpreter, String... args) {
    BigDecimal result = BigDecimal.ZERO;
    try {
        result = new BigDecimal(Objects.toString(var));
    } catch (NumberFormatException e) {
    }
    int precision = 0;
    if (args.length > 0) {
        precision = NumberUtils.toInt(args[0]);
    }
    String method = "common";
    if (args.length > 1) {
        method = args[1];
    }
    RoundingMode roundingMode;
    switch(method) {
        case "ceil":
            roundingMode = RoundingMode.CEILING;
            break;
        case "floor":
            roundingMode = RoundingMode.FLOOR;
            break;
        case "common":
        default:
            roundingMode = RoundingMode.HALF_UP;
    }
    return result.setScale(precision, roundingMode);
}

89. RoundingModeTests#main()

Project: jdk7u-jdk
File: RoundingModeTests.java
public static void main(String[] argv) {
    for (RoundingMode rm : RoundingMode.values()) {
        if (rm != RoundingMode.valueOf(rm.toString())) {
            throw new RuntimeException("Bad roundtrip conversion of " + rm.toString());
        }
    }
    // Test that mapping of old integers to new values is correct
    if (RoundingMode.valueOf(BigDecimal.ROUND_CEILING) != RoundingMode.CEILING) {
        throw new RuntimeException("Bad mapping for ROUND_CEILING");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_DOWN) != RoundingMode.DOWN) {
        throw new RuntimeException("Bad mapping for ROUND_DOWN");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_FLOOR) != RoundingMode.FLOOR) {
        throw new RuntimeException("Bad mapping for ROUND_FLOOR");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_DOWN) != RoundingMode.HALF_DOWN) {
        throw new RuntimeException("Bad mapping for ROUND_HALF_DOWN");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_EVEN) != RoundingMode.HALF_EVEN) {
        throw new RuntimeException("Bad mapping for ROUND_HALF_EVEN");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_UP) != RoundingMode.HALF_UP) {
        throw new RuntimeException("Bad mapping for ROUND_HALF_UP");
    }
    if (RoundingMode.valueOf(BigDecimal.ROUND_UNNECESSARY) != RoundingMode.UNNECESSARY) {
        throw new RuntimeException("Bad mapping for ROUND_UNNECESARY");
    }
}

90. BigDecimalTest#testMathContextConstruction()

Project: j2objc
File: BigDecimalTest.java
public void testMathContextConstruction() {
    String a = "-12380945E+61";
    BigDecimal aNumber = new BigDecimal(a);
    int precision = 6;
    RoundingMode rm = RoundingMode.HALF_DOWN;
    MathContext mcIntRm = new MathContext(precision, rm);
    MathContext mcStr = new MathContext("precision=6 roundingMode=HALF_DOWN");
    MathContext mcInt = new MathContext(precision);
    BigDecimal res = aNumber.abs(mcInt);
    assertEquals("MathContext Constructer with int precision failed", res, new BigDecimal("1.23809E+68"));
    assertEquals("Equal MathContexts are not Equal ", mcIntRm, mcStr);
    assertEquals("Different MathContext are reported as Equal ", mcInt.equals(mcStr), false);
    assertEquals("Equal MathContexts have different hashcodes ", mcIntRm.hashCode(), mcStr.hashCode());
    assertEquals("MathContext.toString() returning incorrect value", mcIntRm.toString(), "precision=6 roundingMode=HALF_DOWN");
}

91. BigDecimalConstructorsTest#testConstrStringMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(String value, MathContext)
     */
public void testConstrStringMathContext() {
    String a = "-238768787678287e214";
    int precision = 5;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "-23876";
    int resScale = -224;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

92. BigDecimalConstructorsTest#testConstrLongMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(long, MathContext)
     */
public void testConstrLongMathContext() {
    long a = 4576578677732546982L;
    int precision = 5;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "45766";
    int resScale = -14;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

93. BigDecimalConstructorsTest#testConstrIntMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(int, MathContext)
     */
public void testConstrIntMathContext() {
    int a = 732546982;
    int precision = 21;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "732546982";
    int resScale = 0;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

94. BigDecimalConstructorsTest#testConstrDoubleMathContext()

Project: j2objc
File: BigDecimalConstructorsTest.java
/**
     * new BigDecimal(double, MathContext)
     */
public void testConstrDoubleMathContext() {
    double a = 732546982374982347892379283571094797.287346782359284756;
    int precision = 21;
    RoundingMode rm = RoundingMode.CEILING;
    MathContext mc = new MathContext(precision, rm);
    String res = "732546982374982285074";
    int resScale = -15;
    BigDecimal result = new BigDecimal(a, mc);
    assertEquals("incorrect value", res, result.unscaledValue().toString());
    assertEquals("incorrect scale", resScale, result.scale());
}

95. LoanReschedulePreviewPlatformServiceImpl#previewLoanReschedule()

Project: incubator-fineract
File: LoanReschedulePreviewPlatformServiceImpl.java
@Override
public LoanRescheduleModel previewLoanReschedule(Long requestId) {
    final LoanRescheduleRequest loanRescheduleRequest = this.loanRescheduleRequestRepository.findOne(requestId);
    if (loanRescheduleRequest == null) {
        throw new LoanRescheduleRequestNotFoundException(requestId);
    }
    Loan loan = loanRescheduleRequest.getLoan();
    final boolean isHolidayEnabled = this.configurationDomainService.isRescheduleRepaymentsOnHolidaysEnabled();
    final List<Holiday> holidays = this.holidayRepository.findByOfficeIdAndGreaterThanDate(loan.getOfficeId(), loan.getDisbursementDate().toDate(), HolidayStatusType.ACTIVE.getValue());
    final WorkingDays workingDays = this.workingDaysRepository.findOne();
    final LoanProductMinimumRepaymentScheduleRelatedDetail loanProductRelatedDetail = loan.getLoanRepaymentScheduleDetail();
    final MonetaryCurrency currency = loanProductRelatedDetail.getCurrency();
    final ApplicationCurrency applicationCurrency = this.applicationCurrencyRepository.findOneWithNotFoundDetection(currency);
    final InterestMethod interestMethod = loan.getLoanRepaymentScheduleDetail().getInterestMethod();
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mathContext = new MathContext(8, roundingMode);
    List<LoanRepaymentScheduleHistory> oldPeriods = this.loanScheduleHistoryWritePlatformService.createLoanScheduleArchive(loan.getRepaymentScheduleInstallments(), loan, loanRescheduleRequest);
    HolidayDetailDTO holidayDetailDTO = new HolidayDetailDTO(isHolidayEnabled, holidays, workingDays);
    CalendarInstance restCalendarInstance = null;
    CalendarInstance compoundingCalendarInstance = null;
    if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) {
        restCalendarInstance = calendarInstanceRepository.findCalendarInstaneByEntityId(loan.loanInterestRecalculationDetailId(), CalendarEntityType.LOAN_RECALCULATION_REST_DETAIL.getValue());
        compoundingCalendarInstance = calendarInstanceRepository.findCalendarInstaneByEntityId(loan.loanInterestRecalculationDetailId(), CalendarEntityType.LOAN_RECALCULATION_COMPOUNDING_DETAIL.getValue());
    }
    final CalendarInstance loanCalendarInstance = calendarInstanceRepository.findCalendarInstaneByEntityId(loan.getId(), CalendarEntityType.LOANS.getValue());
    Calendar loanCalendar = null;
    if (loanCalendarInstance != null) {
        loanCalendar = loanCalendarInstance.getCalendar();
    }
    final FloatingRateDTO floatingRateDTO = constructFloatingRateDTO(loan);
    Boolean isSkipRepaymentOnFirstMonth = false;
    Integer numberOfDays = 0;
    boolean isSkipRepaymentOnFirstMonthEnabled = this.configurationDomainService.isSkippingMeetingOnFirstDayOfMonthEnabled();
    if (isSkipRepaymentOnFirstMonthEnabled) {
        isSkipRepaymentOnFirstMonth = this.loanUtilService.isLoanRepaymentsSyncWithMeeting(loan.group(), loanCalendar);
        if (isSkipRepaymentOnFirstMonth) {
            numberOfDays = configurationDomainService.retreivePeroidInNumberOfDaysForSkipMeetingDate().intValue();
        }
    }
    LoanRescheduleModel loanRescheduleModel = new DefaultLoanReschedulerFactory().reschedule(mathContext, interestMethod, loanRescheduleRequest, applicationCurrency, holidayDetailDTO, restCalendarInstance, compoundingCalendarInstance, loanCalendar, floatingRateDTO, isSkipRepaymentOnFirstMonth, numberOfDays);
    LoanRescheduleModel loanRescheduleModelWithOldPeriods = LoanRescheduleModel.createWithSchedulehistory(loanRescheduleModel, oldPeriods);
    return loanRescheduleModelWithOldPeriods;
}

96. LongMathTest#testLog10TrivialOnPowerOf10()

Project: guava
File: LongMathTest.java
// TODO
@GwtIncompatible
public void testLog10TrivialOnPowerOf10() {
    long x = 1000000000000L;
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        assertEquals(12, LongMath.log10(x, mode));
    }
}

97. LongMathTest#testLog10ZeroAlwaysThrows()

Project: guava
File: LongMathTest.java
// TODO
@GwtIncompatible
public void testLog10ZeroAlwaysThrows() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        try {
            LongMath.log10(0L, mode);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException expected) {
        }
    }
}

98. LongMathTest#testLog2ZeroAlwaysThrows()

Project: guava
File: LongMathTest.java
public void testLog2ZeroAlwaysThrows() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        try {
            LongMath.log2(0L, mode);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException expected) {
        }
    }
}

99. IntMathTest#testSqrtZeroAlwaysZero()

Project: guava
File: IntMathTest.java
// Simple test to cover sqrt(0) for all types and all modes.
// sqrt
@GwtIncompatible
public void testSqrtZeroAlwaysZero() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        assertEquals(0, IntMath.sqrt(0, mode));
    }
}

100. IntMathTest#testLog10TrivialOnPowerOfTen()

Project: guava
File: IntMathTest.java
// log10
@GwtIncompatible
public void testLog10TrivialOnPowerOfTen() {
    int x = 1000000;
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
        assertEquals(6, IntMath.log10(x, mode));
    }
}