[chk-double-is-int] check if doulbe is integer (#15312)

core-java-modules/core-java-numbers-7/pom.xml

@@ -0,0 +1,37 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-numbers-7</artifactId>
+    <name>core-java-numbers-7</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+    </dependencies>
+    <build>
+        <finalName>core-java-numbers-7</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+</project>

core-java-modules/core-java-numbers-7/src/test/java/com/baeldung/doubleisint/CheckDoubleIsAnIntegerUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.doubleisint;
+
+import com.google.common.math.DoubleMath;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class CheckDoubleIsAnIntegerUnitTest {
+
+    boolean notNaNOrInfinity(double d) {
+        return !(Double.isNaN(d) || Double.isInfinite(d));
+    }
+
+    @Test
+    void whenConvertingToInt_thenGetExpectedResult() {
+        double d1 = 42.0D;
+        boolean d1IsInteger = notNaNOrInfinity(d1) && (int) d1 == d1;
+        assertTrue(d1IsInteger);
+
+        double d2 = 42.42D;
+        boolean d2IsInteger = notNaNOrInfinity(d2) && (int) d2 == d2;
+        assertFalse(d2IsInteger);
+
+        double d3 = 2.0D * Integer.MAX_VALUE;
+        boolean d3IsInteger = notNaNOrInfinity(d3) && (int) d3 == d3;
+        assertTrue(!d3IsInteger); // <-- fails if exceeding Integer's range
+    }
+
+    @Test
+    void whenUsingModuloOperator_thenGetExpectedResult() {
+        double d1 = 42.0D;
+        boolean d1IsInteger = notNaNOrInfinity(d1) && (d1 % 1) == 0;
+        assertTrue(d1IsInteger);
+
+        double d2 = 42.42D;
+        boolean d2IsInteger = notNaNOrInfinity(d2) && (d2 % 1) == 0;
+        assertFalse(d2IsInteger);
+
+        double d3 = 2.0D * Integer.MAX_VALUE;
+        boolean d3IsInteger = notNaNOrInfinity(d3) && (d3 % 1) == 0;
+        assertTrue(d3IsInteger);
+
+    }
+
+
+    @Test
+    void whenCheckingFloorOrCeilingValue_thenGetExpectedResult() {
+        double d1 = 42.0D;
+        boolean d1IsInteger = notNaNOrInfinity(d1) && Math.floor(d1) == d1;
+        assertTrue(d1IsInteger);
+
+        double d2 = 42.42D;
+        boolean d2IsInteger = notNaNOrInfinity(d2) && Math.floor(d2) == d2;
+        assertFalse(d2IsInteger);
+
+        double d3 = 2.0D * Integer.MAX_VALUE;
+        boolean d3IsInteger = notNaNOrInfinity(d3) && Math.floor(d3) == d3;
+        assertTrue(d3IsInteger);
+
+    }
+
+    @Test
+    void whenUsingGuava_thenGetExpectedResult() {
+        double d1 = 42.0D;
+        boolean d1IsInteger = DoubleMath.isMathematicalInteger(d1);
+        assertTrue(d1IsInteger);
+
+        double d2 = 42.42D;
+        boolean d2IsInteger = DoubleMath.isMathematicalInteger(d2);
+        assertFalse(d2IsInteger);
+
+        double d3 = 2.0D * Integer.MAX_VALUE;
+        boolean d3IsInteger = DoubleMath.isMathematicalInteger(d3);
+        assertTrue(d3IsInteger);
+
+        boolean isInfinityInt = DoubleMath.isMathematicalInteger(Double.POSITIVE_INFINITY);
+        assertFalse(isInfinityInt);
+
+        boolean isNanInt = DoubleMath.isMathematicalInteger(Double.NaN);
+        assertFalse(isNanInt);
+    }
+}

core-java-modules/pom.xml

@@ -166,6 +166,7 @@
         <module>core-java-numbers-4</module>
         <module>core-java-numbers-5</module>
         <module>core-java-numbers-6</module>
+        <module>core-java-numbers-7</module>
         <module>core-java-optional</module>
         <module>core-java-perf</module>
         <module>core-java-properties</module>
@@ -225,5 +226,4 @@
             </dependency>
         </dependencies>
     </dependencyManagement>
-
 </project>