[Minor] Added tests for MathHelper

utils/src/main/java/li/strolch/utils/helper/MathHelper.java

@@ -29,18 +29,20 @@ public class MathHelper {
 	public static final double PRECISION = 1.0E08;
 	public static final int PRECISION_DIGITS = 3;
 
+	public static boolean isEqualPrecision(double d1, double d2, double precision) {
+		return Double.compare(d1, d2) == 0 || Math.abs(d1 - d2) <= (1.0d / precision);
+	}
+
 	/**
 	 * Check if the two values are equal with respect to the precision
 	 *
-	 * @param firstValue
-	 * 		the first value to compare
-	 * @param secondValue
-	 * 		the second value to compare to
+	 * @param firstValue  the first value to compare
+	 * @param secondValue the second value to compare to
 	 *
 	 * @return boolean True, if the two values are equal under the set precision. Fales, otherwise.
 	 */
 	public static boolean isEqualPrecision(double firstValue, double secondValue) {
-		return (java.lang.Math.abs(firstValue - secondValue) < (1.0d / PRECISION));
+		return (java.lang.Math.abs(firstValue - secondValue) <= (1.0d / PRECISION));
 	}
 
 	/**
@@ -49,10 +51,8 @@ public class MathHelper {
 	 * the values are equal under the precision. Thus, it's efficient whenever the value is expected to be smaller than
 	 * the bound.
 	 *
-	 * @param value
-	 * 		The value to check
-	 * @param bound
-	 * 		The bound given
+	 * @param value The value to check
+	 * @param bound The bound given
 	 *
 	 * @return true, if value < bound under the given precision. False, otherwise.
 	 */
@@ -65,10 +65,8 @@ public class MathHelper {
 	 * the given bound. <p> Note: This implementation tests if value > bound and, if it is so, if equality does NOT
 	 * hold. Thus, it is efficient whenever the value is not expected to be greater than the bound.
 	 *
-	 * @param value
-	 * 		The value to check
-	 * @param bound
-	 * 		The bound given.
+	 * @param value The value to check
+	 * @param bound The bound given.
 	 *
 	 * @return true, if value > bound and the values do not test equal under precision. False, otherwise.
 	 */
@@ -80,14 +78,13 @@ public class MathHelper {
 	 * <p> Rounds the given double value to the number of decimals </p>
 	 *
 	 * <p> <b>Warning:</b> Do not use the returned value for further calculations. Always finish calculates and use one
-	 * of the following methods: </p> <ul> <li>{@link #isEqualPrecision(double, double)},</li> <li>{@link
-	 * #isGreaterPrecision(double, double)} or</li> <li>{@link #isSmallerEqualPrecision(double, double)}</li> </ul> to
-	 * test on equality or greater than/ smaller than
+	 * of the following methods: </p> <ul> <li>{@link #isEqualPrecision(double, double)},</li>
+	 * <li>{@link #isGreaterPrecision(double, double)} or</li>
+	 * <li>{@link #isSmallerEqualPrecision(double, double)}</li>
+	 * </ul> to test on equality or greater than/ smaller than
 	 *
-	 * @param value
-	 * 		the double value to round
-	 * @param decimals
-	 * 		number of decimals
+	 * @param value    the double value to round
+	 * @param decimals number of decimals
 	 *
 	 * @return the rounded number
 	 */
@@ -139,8 +136,7 @@ public class MathHelper {
 	/**
 	 * Formatting a double to a string, without scientific notation
 	 *
-	 * @param d
-	 * 		the double to format
+	 * @param d the double to format
 	 *
 	 * @return the formatted string
 	 */

utils/src/test/java/li/strolch/utils/MathHelperTest.java

@@ -0,0 +1,95 @@
+package li.strolch.utils;
+
+import org.junit.Test;
+
+import static li.strolch.utils.helper.MathHelper.*;
+import static org.junit.Assert.*;
+
+public class MathHelperTest {
+	@Test
+	public void shouldRound1() {
+		assertEquals(1.0, toPrecision(1.00001), 0.0);
+	}
+
+	@Test
+	public void shouldRound2() {
+		assertEquals(1.001, toPrecision(1.001), 0.0);
+	}
+
+	@Test
+	public void shouldRound3() {
+		assertEquals(1.333, toPrecision(1.3333333), 0.0);
+	}
+
+	@Test
+	public void shouldTestToPrecision1() {
+		assertEquals(1.0, toPrecision(1.00001, 3), 0.0);
+	}
+
+	@Test
+	public void shouldTestToPrecision2() {
+		assertEquals(1.001, toPrecision(1.001, 3), 0.0);
+	}
+
+	@Test
+	public void shouldTestToPrecision3() {
+		assertEquals(1.333, toPrecision(1.3333333, 3), 0.0);
+	}
+
+	@Test
+	public void shouldTestEqualsPrecision1() {
+		assertTrue(isEqualPrecision(1.333333333, 1.33333333));
+	}
+
+	@Test
+	public void shouldTestEqualsPrecision2() {
+		assertTrue(isEqualPrecision(1.3333333, 1.333, 3));
+	}
+
+	@Test
+	public void shouldTestEqualsPrecision3() {
+		assertTrue(isEqualPrecision(1.033, 1.033435345345, 3));
+	}
+
+	@Test
+	public void shouldTestSmallerEqualPrecision1() {
+		assertTrue(isSmallerEqualPrecision(1.03333, 1.033435345345));
+	}
+
+	@Test
+	public void shouldTestSmallerEqualPrecision2() {
+		assertTrue(isSmallerEqualPrecision(1.033333338, 1.033333335));
+	}
+
+	@Test
+	public void shouldTestGreaterEqualPrecision1() {
+		assertTrue(isGreaterPrecision(1.03343537, 1.03343535));
+	}
+
+	@Test
+	public void shouldTestGreaterEqualPrecision2() {
+		assertTrue(isGreaterPrecision(1.03333335, 1.03333333));
+	}
+
+	@Test
+	public void shouldTestToPrecisionString1() {
+		assertEquals("1.033", toPrecisionString(1.03333335));
+	}
+
+	@Test
+	public void shouldTestToPrecisionString2() {
+		assertEquals("1.034", toPrecisionString(1.0344444));
+	}
+	@Test
+	public void shouldTestGetNumberOfDecimalPlaces1() {
+		assertEquals(7, getNumberOfDecimalPlaces(1.0344444));
+	}
+	@Test
+	public void shouldTestGetNumberOfDecimalPlaces2() {
+		assertEquals(3, getNumberOfDecimalPlaces(1.034));
+	}
+	@Test
+	public void shouldTestDoubleToString() {
+		assertEquals("0.0000000453453335", doubleToString(0.0000000453453335));
+	}
+}