FINERACT-2539: Add unit tests for MathUtil utility class

Add comprehensive unit tests for MathUtil covering core behaviors
including null handling, arithmetic operations, comparison helpers,
BigDecimal operations, percentage calculations, and formatting helpers.

The tests verify correct handling of:
- null and default value behavior
- negative and zero values
- arithmetic operations (add, subtract, abs)
- BigDecimal utilities
- percentage calculations
- trailing zero normalization

These tests improve reliability and increase test coverage for
shared mathematical utilities used across the platform.

Author: Devi Pathak

fineract-core/src/test/java/org/apache/fineract/infrastructure/core/service/MathUtilTest.java

@@ -0,0 +1,143 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fineract.infrastructure.core.service;
+
+import java.math.BigDecimal;
+import java.math.MathContext;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class MathUtilTest {
+
+    @Test
+    void nullToDefaultReturnsDefaultWhenValueNull() {
+        Long result = MathUtil.nullToDefault(null, 5L);
+        Assertions.assertEquals(5L, result);
+    }
+
+    @Test
+    void nullToDefaultReturnsValueWhenNotNull() {
+        Long result = MathUtil.nullToDefault(10L, 5L);
+        Assertions.assertEquals(10L, result);
+    }
+
+    @Test
+    void nullToZeroLongReturnsZeroWhenNull() {
+        Long result = MathUtil.nullToZero((Long) null);
+        Assertions.assertEquals(0L, result);
+    }
+
+    @Test
+    void zeroToNullReturnsNullWhenZero() {
+        Long result = MathUtil.zeroToNull(0L);
+        Assertions.assertNull(result);
+    }
+
+    @Test
+    void negativeToZeroReturnsZeroForNegativeValue() {
+        Long result = MathUtil.negativeToZero(-10L);
+        Assertions.assertEquals(0L, result);
+    }
+
+    @Test
+    void negativeToZeroReturnsSameValueForPositive() {
+        Long result = MathUtil.negativeToZero(20L);
+        Assertions.assertEquals(20L, result);
+    }
+
+    @Test
+    void isGreaterThanZeroReturnsTrueForPositive() {
+        Assertions.assertTrue(MathUtil.isGreaterThanZero(5L));
+    }
+
+    @Test
+    void isLessThanZeroReturnsTrueForNegative() {
+        Assertions.assertTrue(MathUtil.isLessThanZero(-5L));
+    }
+
+    @Test
+    void addHandlesNullValues() {
+        Long result = MathUtil.add(null, 10L);
+        Assertions.assertEquals(10L, result);
+    }
+
+    @Test
+    void addReturnsSumOfValues() {
+        Long result = MathUtil.add(10L, 20L);
+        Assertions.assertEquals(30L, result);
+    }
+
+    @Test
+    void subtractReturnsCorrectDifference() {
+        Long result = MathUtil.subtract(20L, 5L);
+        Assertions.assertEquals(15L, result);
+    }
+
+    @Test
+    void absReturnsPositiveValue() {
+        Long result = MathUtil.abs(-25L);
+        Assertions.assertEquals(25L, result);
+    }
+
+    @Test
+    void bigDecimalAddReturnsCorrectSum() {
+        BigDecimal result = MathUtil.add(new BigDecimal("10.5"), new BigDecimal("5.5"), new MathContext(10));
+
+        Assertions.assertEquals(new BigDecimal("16.0"), result);
+    }
+
+    @Test
+    void bigDecimalSubtractReturnsCorrectDifference() {
+        BigDecimal result = MathUtil.subtract(new BigDecimal("20"), new BigDecimal("5"), new MathContext(10));
+
+        Assertions.assertEquals(new BigDecimal("15"), result);
+    }
+
+    @Test
+    void percentageOfCalculatesCorrectValue() {
+        BigDecimal value = new BigDecimal("200");
+        BigDecimal percentage = new BigDecimal("10");
+
+        BigDecimal result = MathUtil.percentageOf(value, percentage, new MathContext(10));
+
+        Assertions.assertEquals(0, result.compareTo(new BigDecimal("20")));
+    }
+
+    @Test
+    void percentageOfReturnsZeroWhenValueZero() {
+        BigDecimal result = MathUtil.percentageOf(BigDecimal.ZERO, new BigDecimal("10"), new MathContext(10));
+        Assertions.assertEquals(BigDecimal.ZERO, result);
+    }
+
+    @Test
+    void stripTrailingZerosRemovesExtraZeros() {
+        BigDecimal value = new BigDecimal("10.5000");
+
+        BigDecimal result = MathUtil.stripTrailingZeros(value);
+
+        Assertions.assertEquals(new BigDecimal("10.5"), result);
+    }
+
+    @Test
+    void stripTrailingZerosReturnsNullWhenInputNull() {
+        Assertions.assertNull(MathUtil.stripTrailingZeros(null));
+    }
+
+}