budaidev commented on code in PR #5730:
URL: https://github.com/apache/fineract/pull/5730#discussion_r3026193823
##########
fineract-core/src/test/java/org/apache/fineract/organisation/monetary/domain/MoneyTest.java:
##########
@@ -109,4 +121,379 @@ void testAddMoney() {
Money result = tenDollars.add(oneDollar, MATH_CONTEXT);
assertEquals(0, result.getAmount().compareTo(new BigDecimal("11.00")),
"Should correctly add two Money amounts");
}
+
+ @ParameterizedTest(name = "plus(double {0}) = {1}")
+ @CsvSource({ "0.0, 10.00", "1.0, 11.00", "0.01, 10.01", "5.5,
15.50", "10.0, 20.00", "0.99, 10.99", "100.0, 110.00",
+ "999999.99, 1000009.99", "-1.0, 9.00", "-0.01,9.99", "-10.0,0.00",
"-10.01,-0.01", "-100.0,-90.00", "-999999.99,-999989.99",
+ "0.1, 10.10", "0.2, 10.20", "0.10000000000000001, 10.10", })
+ void testPlusDouble(double amountToAdd, BigDecimal expected) {
+ Money result = tenDollars.plus(amountToAdd);
+ assertEquals(0, result.getAmount().compareTo(expected),
+ () -> String.format("tenDollars.plus(%s): expected %s but got
%s", amountToAdd, expected, result.getAmount()));
+ }
+
+ @Test
+ void testTotalVarargs() {
+ Money result = Money.total(oneDollar, oneDollar, oneDollar);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("3.00")));
+ }
+
+ @Test
+ void testTotalVarargsThrowsOnEmpty() {
+ IllegalArgumentException exception =
assertThrows(IllegalArgumentException.class, Money::total);
+ assertEquals("Money array must not be empty", exception.getMessage());
+ }
+
+ @Test
+ void testTotalIterable() {
+ List<Money> monies = Arrays.asList(tenDollars, oneDollar);
+ Money result = Money.total(monies);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("11.00")));
+ }
+
+ @Test
+ void testTotalIterableThrowsOnEmpty() {
+ IllegalArgumentException exception =
assertThrows(IllegalArgumentException.class, () ->
Money.total(Collections.emptyList()));
+ assertEquals("Money iterator must not be empty",
exception.getMessage());
+ }
+
+ @Test
+ void testTotalIterableSingleElement() {
+ Money result = Money.total(Collections.singletonList(tenDollars));
+ assertEquals(0, result.getAmount().compareTo(BigDecimal.TEN));
+ }
+
+ @ParameterizedTest
+ @CsvSource({ "76.0, 50, 100.0", "75.0, 100, 100.0", "0.0, 50, 0.0", "74.0,
50, 50.0", })
+ void testRoundToMultiplesOfDouble(double value, int multiple, double
expected) {
+ double result = Money.roundToMultiplesOf(value, multiple);
+ assertEquals(expected, result);
+ }
+
+ @Test
+ void testRoundToMultiplesOfDoubleNegativeValuePositiveMultipleReturnsNaN()
{
+ double result = Money.roundToMultiplesOf(-75.0, 50);
+ assertTrue(Double.isNaN(result));
+ }
+
+ @ParameterizedTest(name = "roundToMultiplesOf({0}, {1}) = {2}")
+ @CsvSource({ "100, 50, 100", "50, 50, 50", "0, 50, 0", "75, 1,
75", "99, 1, 99", "300, 100, 300", "40, 20, 40",
+ "75, 0, 75", "100, 0, 100", "75, -50, 75", })
+ void testRoundToMultiplesOfBigDecimal(BigDecimal existingVal, Integer
inMultiplesOf, BigDecimal expected) {
+ BigDecimal result = Money.roundToMultiplesOf(existingVal,
inMultiplesOf);
+ assertEquals(0, result.compareTo(expected),
+ () -> String.format("roundToMultiplesOf(%s, %s): expected %s
but got %s", existingVal, inMultiplesOf, expected, result));
+ }
+
+ @Test
+ void testRoundToMultiplesOfMoney() {
+ MonetaryCurrency currencyNoDecimal = new MonetaryCurrency("USD", 0,
50);
+ Money money = Money.of(currencyNoDecimal, new BigDecimal("75"));
+ Money result = Money.roundToMultiplesOf(money, 50);
+ assertEquals("USD", result.getCurrencyCode());
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("100")));
+ }
+
+ @Test
+ void testRoundToMultiplesOfMoneyWithMathContext() {
+ MonetaryCurrency currencyNoDecimal = new MonetaryCurrency("USD", 0,
50);
+ Money money = Money.of(currencyNoDecimal, new BigDecimal("75"));
+ Money result = Money.roundToMultiplesOf(money, 50, MATH_CONTEXT);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("100")));
+ }
+
+ @Test
+ void testRoundToMultiplesOfMoneyZeroMultiple() {
+ Money money = Money.of(CURRENCY, new BigDecimal("75"));
+ Money result = Money.roundToMultiplesOf(money, 0);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("75.00")));
+ }
+
+ @ParameterizedTest(name = "ceiling({0}, {1}) = NaN")
+ @CsvSource({ "-75.0, 50.0", "-1.0, 1.0", "-0.01, 0.01", "-1000.0,
0.001", "75.0, -50.0", "1.0, -1.0", "0.01, -0.01",
+ "1000.0, -0.001", })
+ void testCeilingReturnsNaN(double n, double s) {
+ assertTrue(Double.isNaN(Money.ceiling(n, s)), () ->
String.format("ceiling(%s, %s) should be NaN", n, s));
+ }
+
+ @ParameterizedTest(name = "ceiling({0}, {1}) = {2}")
+ @CsvSource({ "0.0, 50.0, 0.0", "0.0, -50.0, 0.0", "0.0, 0.0,
0.0", "0.0, 1.0, 0.0", "50.0, 0.0, 0.0",
+ "0.01, 0.0, 0.0", "50.0, 50.0, 50.0", "100.0, 50.0,
100.0", "75.0, 25.0, 75.0", "51.0, 50.0, 100.0",
+ "75.0, 50.0, 100.0", "99.0, 50.0, 100.0", "1.0, 50.0,
50.0", "26.0, 25.0, 50.0", "-50.0, -50.0, -50.0",
+ "1.0, 0.3, 1.2", "0.1, 0.3, 0.3", "1000.0, 50.0,
1000.0", "1001.0, 50.0, 1050.0", })
+ void testCeilingReturnsDouble(double n, double s, double expected) {
+ assertEquals(expected, Money.ceiling(n, s), 0.0001, () ->
String.format("ceiling(%s, %s): expected %s", n, s, expected));
+ }
+
+ @ParameterizedTest(name = "floor({0}, {1}) = NaN")
+ @CsvSource({ "-75.0, 50.0", "-1.0, 1.0", "-0.01, 0.01", "-1000.0,
0.001", "-50.0, 50.0", "75.0, -50.0", "1.0, -1.0",
+ "0.01, -0.01", "1000.0, -0.001", "50.0, -50.0", "1.0,
0.0", "75.0, 0.0", "-1.0, 0.0", "-75.0, 0.0",
+ "0.001, 0.0", "-0.001, 0.0", })
+ void testFloorReturnsNaN(double n, double s) {
+ assertTrue(Double.isNaN(Money.floor(n, s)), () ->
String.format("floor(%s, %s) should be NaN", n, s));
+ }
+
+ @ParameterizedTest(name = "floor({0}, {1}) = {2}")
+ @CsvSource({ "0.0, 50.0, 0.0", "0.0, -50.0, 0.0", "0.0, 1.0,
0.0", "0.0, 0.0, 0.0", "50.0, 50.0, 50.0",
+ "100.0, 50.0, 100.0", "75.0, 25.0, 75.0", "200.0, 100.0,
200.0", "51.0, 50.0, 50.0", "75.0, 50.0, 50.0",
+ "99.0, 50.0, 50.0", "1.0, 50.0, 0.0", "24.0, 25.0,
0.0", "26.0, 25.0, 25.0", "149.0, 50.0, 100.0",
+ "-50.0, -50.0, -50.0", "-75.0, -50.0, -50.0", "-100.0,
-50.0, -100.0", "-1.0, -50.0, 0.0", "1.0, 0.3, 0.9",
+ "0.5, 0.3, 0.3", "0.1, 0.3, 0.0", "1000.0, 50.0,
1000.0", "1001.0, 50.0, 1000.0", "1049.0, 50.0, 1000.0",
+ "1050.0, 50.0, 1050.0", })
+ void testFloorReturnsDouble(double n, double s, double expected) {
+ assertEquals(expected, Money.floor(n, s), 0.0001, () ->
String.format("floor(%s, %s): expected %s", n, s, expected));
+ }
+
+ @Test
+ void testGetAmountDefaultedToNullIfZeroReturnsNullForZero() {
+ assertNull(zeroDollar.getAmountDefaultedToNullIfZero());
+ }
+
+ @Test
+ void testGetAmountDefaultedToNullIfZeroReturnsAmountForNonZero() {
+ assertNotNull(tenDollars.getAmountDefaultedToNullIfZero());
+ assertEquals(0,
tenDollars.getAmountDefaultedToNullIfZero().compareTo(BigDecimal.TEN));
+ }
+
+ @Test
+ void testDividedByBigDecimalOne() {
+ Money result = tenDollars.dividedBy(BigDecimal.ONE, MATH_CONTEXT);
+ assertSame(tenDollars, result, "Dividing by 1 should return the same
instance");
+ }
+
+ @Test
+ void testDividedByBigDecimal() {
+ Money result = tenDollars.dividedBy(new BigDecimal("2"), MATH_CONTEXT);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("5.00")));
+ }
+
+ @Test
+ void testDividedByDoubleOne() {
+ Money result = tenDollars.dividedBy(1.0, MATH_CONTEXT);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testDividedByDouble() {
+ Money result = tenDollars.dividedBy(2.0, MATH_CONTEXT);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("5.00")));
+ }
+
+ @Test
+ void testDividedByLongOneWithMathContext() {
+ Money result = tenDollars.dividedBy(1L, MATH_CONTEXT);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testDividedByLongWithMathContext() {
+ Money result = tenDollars.dividedBy(2L, MATH_CONTEXT);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("5.00")));
+ }
+
+ @Test
+ void testDividedByLongOneNoMathContext() {
+ Money result = tenDollars.dividedBy(1L);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testDividedByLongNoMathContext() {
+ Money result = tenDollars.dividedBy(2L);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("5.00")));
+ }
+
+ @Test
+ void testMultipliedByBigDecimalOne() {
+ Money result = tenDollars.multipliedBy(BigDecimal.ONE);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testMultipliedByBigDecimal() {
+ Money result = tenDollars.multipliedBy(new BigDecimal("3"));
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("30.00")));
+ }
+
+ @Test
+ void testMultipliedByBigDecimalWithMathContext() {
+ Money result = tenDollars.multipliedBy(new BigDecimal("3"),
MATH_CONTEXT);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("30.00")));
+ }
+
+ @Test
+ void testMultipliedByBigDecimalOneWithMathContext() {
+ Money result = tenDollars.multipliedBy(BigDecimal.ONE, MATH_CONTEXT);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testMultipliedByDoubleOne() {
+ Money result = tenDollars.multipliedBy(1.0);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testMultipliedByDouble() {
+ Money result = tenDollars.multipliedBy(2.5);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("25.00")));
+ }
+
+ @Test
+ void testMultipliedByLongOne() {
+ Money result = tenDollars.multipliedBy(1L);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testMultipliedByLong() {
+ Money result = tenDollars.multipliedBy(3L);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("30.00")));
+ }
+
+ @Test
+ void testMultipliedByLongWithMathContext() {
+ Money result = tenDollars.multipliedBy(3L, MATH_CONTEXT);
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("30.00")));
+ }
+
+ @Test
+ void testMultipliedByLongOneWithMathContext() {
+ Money result = tenDollars.multipliedBy(1L, MATH_CONTEXT);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testMultiplyRetainScaleBigDecimalOne() {
+ Money result = tenDollars.multiplyRetainScale(BigDecimal.ONE,
MATH_CONTEXT);
+ assertSame(tenDollars, result);
+ }
+
+ @Test
+ void testMultiplyRetainScaleBigDecimal() {
+ Money result = tenDollars.multiplyRetainScale(new BigDecimal("1.5"),
MATH_CONTEXT);
+ assertEquals(2, result.getAmount().scale(), "Scale should be retained
at currency decimal places");
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("15.00")));
+ }
+
+ @Test
+ void testMultiplyRetainScaleDouble() {
+ Money result = tenDollars.multiplyRetainScale(1.5, MATH_CONTEXT);
+ assertEquals(2, result.getAmount().scale());
+ assertEquals(0, result.getAmount().compareTo(new BigDecimal("15.00")));
+ }
+
+ @Test
+ void testMultiplyRetainScaleDoubleOne() {
+ // BigDecimal.valueOf(1.0) == BigDecimal.ONE, so returns same instance
Review Comment:
this comment is not exactly true, since these 2 values are a little bit
different. For this scenario it works, because in the calculation uses
compareTo. I would suggest to remove the comment.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
