Example usage for java.math BigDecimal ROUND_DOWN

List of usage examples for java.math BigDecimal ROUND_DOWN

Introduction

In this page you can find the example usage for java.math BigDecimal ROUND_DOWN.

Prototype

int ROUND_DOWN

To view the source code for java.math BigDecimal ROUND_DOWN.

Click Source Link

Document

Rounding mode to round towards zero.

Usage

From source file:org.netxilia.functions.MathFunctions.java

public double TRUNC(double number, int count) {
    return MathUtils.round(number, count, BigDecimal.ROUND_DOWN);
}

From source file:org.pentaho.di.core.ConstTest.java

@Test
public void testRound_BigDecimal() {
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.0"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.2"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.2"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.5"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.5"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("1.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.7"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("1.7"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.0"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.2"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.2"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.5"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.5"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("2.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.7"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("3.0"), Const.round(new BigDecimal("2.7"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.0"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.2"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.2"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.5"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.5"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-1.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.7"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-1.7"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.0"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.2"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.2"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.5"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.5"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-2.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.7"), 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-3.0"), Const.round(new BigDecimal("-2.7"), 0, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.010"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.012"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.012"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.015"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.015"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.010"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.017"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.017"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.020"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.022"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.022"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.025"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.025"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("0.020"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.027"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("0.030"), Const.round(new BigDecimal("0.027"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.010"),
            Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.010"),
            Const.round(new BigDecimal("-0.010"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.010"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.010"),
            Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.010"),
            Const.round(new BigDecimal("-0.012"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.012"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.010"),
            Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.015"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.015"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.010"), Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.017"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.017"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.020"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.020"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.022"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.022"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.020"),
            Const.round(new BigDecimal("-0.025"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.025"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-0.020"), Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-0.030"),
            Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-0.030"),
            Const.round(new BigDecimal("-0.027"), 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-0.030"), Const.round(new BigDecimal("-0.027"), 2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("100.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("120.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("120.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("150.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("150.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("100.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("170.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("170.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("200.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("220.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("220.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("250.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("250.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("200.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("270.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("300.0"), Const.round(new BigDecimal("270.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-100.0"),
            Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-100.0"),
            Const.round(new BigDecimal("-100.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-100.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-100.0"),
            Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-100.0"),
            Const.round(new BigDecimal("-120.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-120.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-100.0"),
            Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-150.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-150.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-100.0"), Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-170.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-170.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-200.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-200.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-220.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-220.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-200.0"),
            Const.round(new BigDecimal("-250.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-250.0"), -2, Const.ROUND_HALF_CEILING));

    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_UP));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_DOWN));
    assertEquals(new BigDecimal("-200.0"), Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_CEILING));
    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_FLOOR));
    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(new BigDecimal("-300.0"),
            Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(new BigDecimal("-300.0"),
            Const.round(new BigDecimal("-270.0"), -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(new BigDecimal("-300.0"), Const.round(new BigDecimal("-270.0"), -2, Const.ROUND_HALF_CEILING));
}

From source file:org.pentaho.di.core.ConstTest.java

@Test
public void testRound() {
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_UP));
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_DOWN));
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_CEILING));
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(1.0, Const.round(1.0, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(1.0, Const.round(1.0, 0, Const.ROUND_HALF_CEILING));

    assertEquals(2.0, Const.round(1.2, 0, BigDecimal.ROUND_UP));
    assertEquals(1.0, Const.round(1.2, 0, BigDecimal.ROUND_DOWN));
    assertEquals(2.0, Const.round(1.2, 0, BigDecimal.ROUND_CEILING));
    assertEquals(1.0, Const.round(1.2, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(1.0, Const.round(1.2, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(1.0, Const.round(1.2, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(1.0, Const.round(1.2, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(1.0, Const.round(1.2, 0, Const.ROUND_HALF_CEILING));

    assertEquals(2.0, Const.round(1.5, 0, BigDecimal.ROUND_UP));
    assertEquals(1.0, Const.round(1.5, 0, BigDecimal.ROUND_DOWN));
    assertEquals(2.0, Const.round(1.5, 0, BigDecimal.ROUND_CEILING));
    assertEquals(1.0, Const.round(1.5, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(2.0, Const.round(1.5, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(1.0, Const.round(1.5, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(2.0, Const.round(1.5, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(2.0, Const.round(1.5, 0, Const.ROUND_HALF_CEILING));

    assertEquals(2.0, Const.round(1.7, 0, BigDecimal.ROUND_UP));
    assertEquals(1.0, Const.round(1.7, 0, BigDecimal.ROUND_DOWN));
    assertEquals(2.0, Const.round(1.7, 0, BigDecimal.ROUND_CEILING));
    assertEquals(1.0, Const.round(1.7, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(2.0, Const.round(1.7, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(2.0, Const.round(1.7, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(2.0, Const.round(1.7, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(2.0, Const.round(1.7, 0, Const.ROUND_HALF_CEILING));

    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_UP));
    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_DOWN));
    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_CEILING));
    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(2.0, Const.round(2.0, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(2.0, Const.round(2.0, 0, Const.ROUND_HALF_CEILING));

    assertEquals(3.0, Const.round(2.2, 0, BigDecimal.ROUND_UP));
    assertEquals(2.0, Const.round(2.2, 0, BigDecimal.ROUND_DOWN));
    assertEquals(3.0, Const.round(2.2, 0, BigDecimal.ROUND_CEILING));
    assertEquals(2.0, Const.round(2.2, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(2.0, Const.round(2.2, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(2.0, Const.round(2.2, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(2.0, Const.round(2.2, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(2.0, Const.round(2.2, 0, Const.ROUND_HALF_CEILING));

    assertEquals(3.0, Const.round(2.5, 0, BigDecimal.ROUND_UP));
    assertEquals(2.0, Const.round(2.5, 0, BigDecimal.ROUND_DOWN));
    assertEquals(3.0, Const.round(2.5, 0, BigDecimal.ROUND_CEILING));
    assertEquals(2.0, Const.round(2.5, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(3.0, Const.round(2.5, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(2.0, Const.round(2.5, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(2.0, Const.round(2.5, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(3.0, Const.round(2.5, 0, Const.ROUND_HALF_CEILING));

    assertEquals(3.0, Const.round(2.7, 0, BigDecimal.ROUND_UP));
    assertEquals(2.0, Const.round(2.7, 0, BigDecimal.ROUND_DOWN));
    assertEquals(3.0, Const.round(2.7, 0, BigDecimal.ROUND_CEILING));
    assertEquals(2.0, Const.round(2.7, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(3.0, Const.round(2.7, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(3.0, Const.round(2.7, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(3.0, Const.round(2.7, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(3.0, Const.round(2.7, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_UP));
    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-1.0, Const.round(-1.0, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-1.0, Const.round(-1.0, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-2.0, Const.round(-1.2, 0, BigDecimal.ROUND_UP));
    assertEquals(-1.0, Const.round(-1.2, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-1.0, Const.round(-1.2, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-2.0, Const.round(-1.2, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-1.0, Const.round(-1.2, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-1.0, Const.round(-1.2, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-1.0, Const.round(-1.2, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-1.0, Const.round(-1.2, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-2.0, Const.round(-1.5, 0, BigDecimal.ROUND_UP));
    assertEquals(-1.0, Const.round(-1.5, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-1.0, Const.round(-1.5, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-2.0, Const.round(-1.5, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-2.0, Const.round(-1.5, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-1.0, Const.round(-1.5, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-2.0, Const.round(-1.5, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-1.0, Const.round(-1.5, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-2.0, Const.round(-1.7, 0, BigDecimal.ROUND_UP));
    assertEquals(-1.0, Const.round(-1.7, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-1.0, Const.round(-1.7, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-2.0, Const.round(-1.7, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-2.0, Const.round(-1.7, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-2.0, Const.round(-1.7, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-2.0, Const.round(-1.7, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-2.0, Const.round(-1.7, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_UP));
    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-2.0, Const.round(-2.0, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-2.0, Const.round(-2.0, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-3.0, Const.round(-2.2, 0, BigDecimal.ROUND_UP));
    assertEquals(-2.0, Const.round(-2.2, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-2.0, Const.round(-2.2, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-3.0, Const.round(-2.2, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-2.0, Const.round(-2.2, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-2.0, Const.round(-2.2, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-2.0, Const.round(-2.2, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-2.0, Const.round(-2.2, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-3.0, Const.round(-2.5, 0, BigDecimal.ROUND_UP));
    assertEquals(-2.0, Const.round(-2.5, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-2.0, Const.round(-2.5, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-3.0, Const.round(-2.5, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-3.0, Const.round(-2.5, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-2.0, Const.round(-2.5, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-2.0, Const.round(-2.5, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-2.0, Const.round(-2.5, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-3.0, Const.round(-2.7, 0, BigDecimal.ROUND_UP));
    assertEquals(-2.0, Const.round(-2.7, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-2.0, Const.round(-2.7, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-3.0, Const.round(-2.7, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-3.0, Const.round(-2.7, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-3.0, Const.round(-2.7, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-3.0, Const.round(-2.7, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-3.0, Const.round(-2.7, 0, Const.ROUND_HALF_CEILING));

    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_UP));
    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.010, Const.round(0.010, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.010, Const.round(0.010, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.020, Const.round(0.012, 2, BigDecimal.ROUND_UP));
    assertEquals(0.010, Const.round(0.012, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.020, Const.round(0.012, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.010, Const.round(0.012, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.010, Const.round(0.012, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.010, Const.round(0.012, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.010, Const.round(0.012, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.010, Const.round(0.012, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.020, Const.round(0.015, 2, BigDecimal.ROUND_UP));
    assertEquals(0.010, Const.round(0.015, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.020, Const.round(0.015, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.010, Const.round(0.015, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.020, Const.round(0.015, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.010, Const.round(0.015, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.020, Const.round(0.015, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.020, Const.round(0.015, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.020, Const.round(0.017, 2, BigDecimal.ROUND_UP));
    assertEquals(0.010, Const.round(0.017, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.020, Const.round(0.017, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.010, Const.round(0.017, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.020, Const.round(0.017, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.020, Const.round(0.017, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.020, Const.round(0.017, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.020, Const.round(0.017, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_UP));
    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.020, Const.round(0.020, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.020, Const.round(0.020, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.030, Const.round(0.022, 2, BigDecimal.ROUND_UP));
    assertEquals(0.020, Const.round(0.022, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.030, Const.round(0.022, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.020, Const.round(0.022, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.020, Const.round(0.022, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.020, Const.round(0.022, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.020, Const.round(0.022, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.020, Const.round(0.022, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.030, Const.round(0.025, 2, BigDecimal.ROUND_UP));
    assertEquals(0.020, Const.round(0.025, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.030, Const.round(0.025, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.020, Const.round(0.025, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.030, Const.round(0.025, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.020, Const.round(0.025, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.020, Const.round(0.025, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.030, Const.round(0.025, 2, Const.ROUND_HALF_CEILING));

    assertEquals(0.030, Const.round(0.027, 2, BigDecimal.ROUND_UP));
    assertEquals(0.020, Const.round(0.027, 2, BigDecimal.ROUND_DOWN));
    assertEquals(0.030, Const.round(0.027, 2, BigDecimal.ROUND_CEILING));
    assertEquals(0.020, Const.round(0.027, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(0.030, Const.round(0.027, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(0.030, Const.round(0.027, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(0.030, Const.round(0.027, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(0.030, Const.round(0.027, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.010, Const.round(-0.010, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.010, Const.round(-0.010, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.020, Const.round(-0.012, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.010, Const.round(-0.012, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.010, Const.round(-0.012, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.020, Const.round(-0.012, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.010, Const.round(-0.012, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.010, Const.round(-0.012, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.010, Const.round(-0.012, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.010, Const.round(-0.012, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.020, Const.round(-0.015, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.010, Const.round(-0.015, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.010, Const.round(-0.015, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.020, Const.round(-0.015, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.020, Const.round(-0.015, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.010, Const.round(-0.015, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.020, Const.round(-0.015, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.010, Const.round(-0.015, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.020, Const.round(-0.017, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.010, Const.round(-0.017, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.010, Const.round(-0.017, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.020, Const.round(-0.017, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.020, Const.round(-0.017, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.020, Const.round(-0.017, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.020, Const.round(-0.017, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.020, Const.round(-0.017, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.020, Const.round(-0.020, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.020, Const.round(-0.020, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.030, Const.round(-0.022, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.020, Const.round(-0.022, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.020, Const.round(-0.022, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.030, Const.round(-0.022, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.020, Const.round(-0.022, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.020, Const.round(-0.022, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.020, Const.round(-0.022, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.020, Const.round(-0.022, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.030, Const.round(-0.025, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.020, Const.round(-0.025, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.020, Const.round(-0.025, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.030, Const.round(-0.025, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.030, Const.round(-0.025, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.020, Const.round(-0.025, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.020, Const.round(-0.025, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.020, Const.round(-0.025, 2, Const.ROUND_HALF_CEILING));

    assertEquals(-0.030, Const.round(-0.027, 2, BigDecimal.ROUND_UP));
    assertEquals(-0.020, Const.round(-0.027, 2, BigDecimal.ROUND_DOWN));
    assertEquals(-0.020, Const.round(-0.027, 2, BigDecimal.ROUND_CEILING));
    assertEquals(-0.030, Const.round(-0.027, 2, BigDecimal.ROUND_FLOOR));
    assertEquals(-0.030, Const.round(-0.027, 2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-0.030, Const.round(-0.027, 2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-0.030, Const.round(-0.027, 2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-0.030, Const.round(-0.027, 2, Const.ROUND_HALF_CEILING));

    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_UP));
    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(100.0, Const.round(100.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(100.0, Const.round(100.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200.0, Const.round(120.0, -2, BigDecimal.ROUND_UP));
    assertEquals(100.0, Const.round(120.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200.0, Const.round(120.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100.0, Const.round(120.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(100.0, Const.round(120.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(100.0, Const.round(120.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(100.0, Const.round(120.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(100.0, Const.round(120.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200.0, Const.round(150.0, -2, BigDecimal.ROUND_UP));
    assertEquals(100.0, Const.round(150.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200.0, Const.round(150.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100.0, Const.round(150.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200.0, Const.round(150.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(100.0, Const.round(150.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200.0, Const.round(150.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200.0, Const.round(150.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200.0, Const.round(170.0, -2, BigDecimal.ROUND_UP));
    assertEquals(100.0, Const.round(170.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200.0, Const.round(170.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100.0, Const.round(170.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200.0, Const.round(170.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200.0, Const.round(170.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200.0, Const.round(170.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200.0, Const.round(170.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_UP));
    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200.0, Const.round(200.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200.0, Const.round(200.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(300.0, Const.round(220.0, -2, BigDecimal.ROUND_UP));
    assertEquals(200.0, Const.round(220.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(300.0, Const.round(220.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200.0, Const.round(220.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200.0, Const.round(220.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200.0, Const.round(220.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200.0, Const.round(220.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200.0, Const.round(220.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(300.0, Const.round(250.0, -2, BigDecimal.ROUND_UP));
    assertEquals(200.0, Const.round(250.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(300.0, Const.round(250.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200.0, Const.round(250.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(300.0, Const.round(250.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200.0, Const.round(250.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200.0, Const.round(250.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(300.0, Const.round(250.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(300.0, Const.round(270.0, -2, BigDecimal.ROUND_UP));
    assertEquals(200.0, Const.round(270.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(300.0, Const.round(270.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200.0, Const.round(270.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(300.0, Const.round(270.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(300.0, Const.round(270.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(300.0, Const.round(270.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(300.0, Const.round(270.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-100.0, Const.round(-100.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-100.0, Const.round(-100.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200.0, Const.round(-120.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-100.0, Const.round(-120.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100.0, Const.round(-120.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200.0, Const.round(-120.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-100.0, Const.round(-120.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-100.0, Const.round(-120.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-100.0, Const.round(-120.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-100.0, Const.round(-120.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200.0, Const.round(-150.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-100.0, Const.round(-150.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100.0, Const.round(-150.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200.0, Const.round(-150.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200.0, Const.round(-150.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-100.0, Const.round(-150.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200.0, Const.round(-150.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-100.0, Const.round(-150.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200.0, Const.round(-170.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-100.0, Const.round(-170.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100.0, Const.round(-170.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200.0, Const.round(-170.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200.0, Const.round(-170.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200.0, Const.round(-170.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200.0, Const.round(-170.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200.0, Const.round(-170.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200.0, Const.round(-200.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200.0, Const.round(-200.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-300.0, Const.round(-220.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-200.0, Const.round(-220.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200.0, Const.round(-220.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-300.0, Const.round(-220.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200.0, Const.round(-220.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200.0, Const.round(-220.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200.0, Const.round(-220.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200.0, Const.round(-220.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-300.0, Const.round(-250.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-200.0, Const.round(-250.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200.0, Const.round(-250.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-300.0, Const.round(-250.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-300.0, Const.round(-250.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200.0, Const.round(-250.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200.0, Const.round(-250.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200.0, Const.round(-250.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-300.0, Const.round(-270.0, -2, BigDecimal.ROUND_UP));
    assertEquals(-200.0, Const.round(-270.0, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200.0, Const.round(-270.0, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-300.0, Const.round(-270.0, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-300.0, Const.round(-270.0, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-300.0, Const.round(-270.0, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-300.0, Const.round(-270.0, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-300.0, Const.round(-270.0, -2, Const.ROUND_HALF_CEILING));

    assertEquals(Double.NaN, Const.round(Double.NaN, 0, BigDecimal.ROUND_UP));
    assertEquals(Double.NEGATIVE_INFINITY, Const.round(Double.NEGATIVE_INFINITY, 0, BigDecimal.ROUND_UP));
    assertEquals(Double.POSITIVE_INFINITY, Const.round(Double.POSITIVE_INFINITY, 0, BigDecimal.ROUND_UP));
}

From source file:org.pentaho.di.core.ConstTest.java

@Test
public void testRound_Long() {
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_UP));
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_DOWN));
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_CEILING));
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(1L, Const.round(1L, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(1L, Const.round(1L, 0, Const.ROUND_HALF_CEILING));

    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_UP));
    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_DOWN));
    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_CEILING));
    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(2L, Const.round(2L, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(2L, Const.round(2L, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_UP));
    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-1L, Const.round(-1L, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-1L, Const.round(-1L, 0, Const.ROUND_HALF_CEILING));

    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_UP));
    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_DOWN));
    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_CEILING));
    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_FLOOR));
    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_HALF_UP));
    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-2L, Const.round(-2L, 0, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-2L, Const.round(-2L, 0, Const.ROUND_HALF_CEILING));

    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_UP));
    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(100L, Const.round(100L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(100L, Const.round(100L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200L, Const.round(120L, -2, BigDecimal.ROUND_UP));
    assertEquals(100L, Const.round(120L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200L, Const.round(120L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100L, Const.round(120L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(100L, Const.round(120L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(100L, Const.round(120L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(100L, Const.round(120L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(100L, Const.round(120L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200L, Const.round(150L, -2, BigDecimal.ROUND_UP));
    assertEquals(100L, Const.round(150L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200L, Const.round(150L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100L, Const.round(150L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200L, Const.round(150L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(100L, Const.round(150L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200L, Const.round(150L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200L, Const.round(150L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200L, Const.round(170L, -2, BigDecimal.ROUND_UP));
    assertEquals(100L, Const.round(170L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200L, Const.round(170L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(100L, Const.round(170L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200L, Const.round(170L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200L, Const.round(170L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200L, Const.round(170L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200L, Const.round(170L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_UP));
    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200L, Const.round(200L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200L, Const.round(200L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(300L, Const.round(220L, -2, BigDecimal.ROUND_UP));
    assertEquals(200L, Const.round(220L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(300L, Const.round(220L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200L, Const.round(220L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(200L, Const.round(220L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200L, Const.round(220L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200L, Const.round(220L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(200L, Const.round(220L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(300L, Const.round(250L, -2, BigDecimal.ROUND_UP));
    assertEquals(200L, Const.round(250L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(300L, Const.round(250L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200L, Const.round(250L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(300L, Const.round(250L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(200L, Const.round(250L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(200L, Const.round(250L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(300L, Const.round(250L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(300L, Const.round(270L, -2, BigDecimal.ROUND_UP));
    assertEquals(200L, Const.round(270L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(300L, Const.round(270L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(200L, Const.round(270L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(300L, Const.round(270L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(300L, Const.round(270L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(300L, Const.round(270L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(300L, Const.round(270L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_UP));
    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-100L, Const.round(-100L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-100L, Const.round(-100L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200L, Const.round(-120L, -2, BigDecimal.ROUND_UP));
    assertEquals(-100L, Const.round(-120L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100L, Const.round(-120L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200L, Const.round(-120L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-100L, Const.round(-120L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-100L, Const.round(-120L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-100L, Const.round(-120L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-100L, Const.round(-120L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200L, Const.round(-150L, -2, BigDecimal.ROUND_UP));
    assertEquals(-100L, Const.round(-150L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100L, Const.round(-150L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200L, Const.round(-150L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200L, Const.round(-150L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-100L, Const.round(-150L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200L, Const.round(-150L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-100L, Const.round(-150L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200L, Const.round(-170L, -2, BigDecimal.ROUND_UP));
    assertEquals(-100L, Const.round(-170L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-100L, Const.round(-170L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200L, Const.round(-170L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200L, Const.round(-170L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200L, Const.round(-170L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200L, Const.round(-170L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200L, Const.round(-170L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_UP));
    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200L, Const.round(-200L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200L, Const.round(-200L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-300L, Const.round(-220L, -2, BigDecimal.ROUND_UP));
    assertEquals(-200L, Const.round(-220L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200L, Const.round(-220L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-300L, Const.round(-220L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-200L, Const.round(-220L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200L, Const.round(-220L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200L, Const.round(-220L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200L, Const.round(-220L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-300L, Const.round(-250L, -2, BigDecimal.ROUND_UP));
    assertEquals(-200L, Const.round(-250L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200L, Const.round(-250L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-300L, Const.round(-250L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-300L, Const.round(-250L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-200L, Const.round(-250L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-200L, Const.round(-250L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-200L, Const.round(-250L, -2, Const.ROUND_HALF_CEILING));

    assertEquals(-300L, Const.round(-270L, -2, BigDecimal.ROUND_UP));
    assertEquals(-200L, Const.round(-270L, -2, BigDecimal.ROUND_DOWN));
    assertEquals(-200L, Const.round(-270L, -2, BigDecimal.ROUND_CEILING));
    assertEquals(-300L, Const.round(-270L, -2, BigDecimal.ROUND_FLOOR));
    assertEquals(-300L, Const.round(-270L, -2, BigDecimal.ROUND_HALF_UP));
    assertEquals(-300L, Const.round(-270L, -2, BigDecimal.ROUND_HALF_DOWN));
    assertEquals(-300L, Const.round(-270L, -2, BigDecimal.ROUND_HALF_EVEN));
    assertEquals(-300L, Const.round(-270L, -2, Const.ROUND_HALF_CEILING));
}

From source file:org.sakaiproject.tool.gradebook.jsf.FacesUtil.java

/**
 * All Faces number formatting options round instead of truncating.
 * For the Gradebook, virtually no displayed numbers are ever supposed to
 * round up.// ww w . j  ava  2  s .  c o  m
 *
 * This method moves the specified raw value into a higher-resolution
 * BigDecimal, rounding away noise at MAXIMUM_MEANINGFUL_DECIMAL_PLACES.
 * It then rounds down to reach the specified maximum number
 * of decimal places and returns the equivalent double for
 * further formatting.
 *
 * This is all necessary because we don't store scores as
 * BigDecimal and because Java / JSF lacks a DecimalFormat
 * class which uses "floor" instead of "round" when
 * trimming decimal places.
 */
public static double getRoundDown(double rawValue, int maxDecimalPlaces) {
    if (maxDecimalPlaces == 0) {
        return Math.floor(rawValue);
    } else if (rawValue != 0) {
        // We don't use the BigDecimal ROUND_DOWN functionality directly,
        // because moving from lower resolution storage to a higher
        // resolution form can introduce false truncations (e.g.,
        // a "17.99" double being treated as a "17.9899999999999"
        // BigDecimal).
        BigDecimal bd = (new BigDecimal(rawValue))
                .setScale(MAXIMUM_MEANINGFUL_DECIMAL_PLACES, BigDecimal.ROUND_HALF_DOWN)
                .setScale(maxDecimalPlaces, BigDecimal.ROUND_DOWN);

        if (logger.isDebugEnabled())
            logger.debug("getRoundDown: rawValue=" + rawValue + ", maxDecimalPlaces=" + maxDecimalPlaces
                    + ", bigDecimal=" + (new BigDecimal(rawValue)) + ", returning=" + bd.doubleValue());

        return bd.doubleValue();
    } else {
        return rawValue;
    }
}

From source file:org.silverpeas.core.util.time.Duration.java

public static BigDecimal convertTo(BigDecimal value, final TimeUnit from, final TimeUnit to) {
    int fromIndex = orderedUnits.indexOf(from);
    int toIndex = orderedUnits.indexOf(to);
    final int offsetIndex = fromIndex - toIndex;
    if (offsetIndex > 0) {
        return value.multiply(d(from).getMultiplier(d(to))).setScale(15, BigDecimal.ROUND_DOWN);
    } else if (offsetIndex < 0) {
        return value.divide(d(from).getMultiplier(d(to)), 15, BigDecimal.ROUND_DOWN);
    }/*from   w ww  .  ja  v  a2s. c  om*/
    return value;
}

From source file:org.silverpeas.core.util.time.Duration.java

/**
 * Gets the time converted to desired unit.
 * @param to a time unit//from   w w  w  . j av  a 2  s .co  m
 * @return the time converted to desired unit.
 */
public BigDecimal getRoundedTimeConverted(final TimeUnit to) {
    BigDecimal convertedSize = getTimeConverted(to);
    int nbMaximumFractionDigits = 2;
    if (TimeUnit.MILLISECOND == to || TimeUnit.SECOND == to) {
        nbMaximumFractionDigits = 3;
    }
    return convertedSize.setScale(nbMaximumFractionDigits, BigDecimal.ROUND_DOWN);
}

From source file:org.silverpeas.core.util.time.TimeData.java

/**
 * Converting a value/*from  ww w  .jav a 2s . co  m*/
 * @param value
 * @param from
 * @param to
 * @return
 */
public static BigDecimal convertTo(BigDecimal value, final TimeUnit from, final TimeUnit to) {
    int fromIndex = orderedUnits.indexOf(from);
    int toIndex = orderedUnits.indexOf(to);
    final int offsetIndex = fromIndex - toIndex;
    if (offsetIndex > 0) {
        return value.multiply(from.getMultiplier(to)).setScale(15, BigDecimal.ROUND_DOWN);
    } else if (offsetIndex < 0) {
        return value.divide(from.getMultiplier(to), 15, BigDecimal.ROUND_DOWN);
    }
    return value;
}

From source file:org.silverpeas.core.util.time.TimeData.java

/**
 * Gets the time converted to desired unit.
 * @param to/*w  ww.  j  a  va  2 s .  c  om*/
 * @return
 */
public BigDecimal getRoundedTimeConverted(final TimeUnit to) {
    BigDecimal convertedSize = getTimeConverted(to);
    int nbMaximumFractionDigits = 2;
    if (TimeUnit.MILLI == to || TimeUnit.SEC == to) {
        nbMaximumFractionDigits = 3;
    }
    return convertedSize.setScale(nbMaximumFractionDigits, BigDecimal.ROUND_DOWN);
}

From source file:org.silverpeas.web.silverstatistics.control.SilverStatisticsPeasSessionController.java

/**
 * @return/*from   ww  w.java  2 s  .c  om*/
 */
public PeriodChart getEvolutionDocsSizeChart() {
    PeriodChart axisChart = null;
    try {
        currentStats.clear();
        Collection<String[]> statsDocsSize = SilverStatisticsPeasDAOVolumeServer.getStatsVolumeServer();
        Iterator<String[]> itStats = statsDocsSize.iterator();
        String[] values;
        List<String> dates = new ArrayList<>(statsDocsSize.size());
        List<BigDecimal> size = new ArrayList<>(statsDocsSize.size());
        while (itStats.hasNext()) {
            values = itStats.next();
            dates.add(values[0]);
            size.add(UnitUtil.convertTo(new BigDecimal(values[2]), MemoryUnit.KB, MemoryUnit.MB).setScale(2,
                    BigDecimal.ROUND_DOWN)); // size en Mo

            currentStats.add(new String[] { values[0], values[1], values[2] });
        }

        axisChart = getMonthPeriodChartFrom(dates, size)
                .withTitle(getString("silverStatisticsPeas.EvolutionAttachmentsTotalSize"));
        axisChart.getAxisY().setTitle(getGeneralLocalizationBundle(getLanguage()).getString("GML.size") + "("
                + MemoryUnit.MB.getLabel() + ")");

    } catch (Exception se) {
        SilverLogger.getLogger(this).error(se);
    }

    return axisChart;
}