Add some tests for FormatUtils.toStr()

4 files changed, 111 insertions, 1 deletions

diff --git a/pom.xml b/pom.xml
index d97fb24..98e3167 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,10 +15,22 @@
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <maven.compiler.source>8</maven.compiler.source>
     <maven.compiler.target>8</maven.compiler.target>
+    <dep.version.junit>4.13.2</dep.version.junit>
   </properties>
 
   <modules>
     <module>xtra4j-misc</module>
   </modules>
 
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>junit</groupId>
+        <artifactId>junit</artifactId>
+        <version>${dep.version.junit}</version>
+        <scope>test</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
 </project>
diff --git a/xtra4j-misc/pom.xml b/xtra4j-misc/pom.xml
index 8172f36..e93de16 100644
--- a/xtra4j-misc/pom.xml
+++ b/xtra4j-misc/pom.xml
@@ -15,4 +15,12 @@
 
   <packaging>jar</packaging>
 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
 </project>
diff --git a/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/format/FormatUtils.java b/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/format/FormatUtils.java
index fc10ab2..2311628 100644
--- a/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/format/FormatUtils.java
+++ b/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/format/FormatUtils.java
@@ -19,6 +19,7 @@ public class FormatUtils {
      *      How many significant digits to be printed. MUST be in range 1..7.
      */
     public static String toStr( float val, int ndig ){
+        assert ndig >= 1 && ndig <= 7 : ndig;
         int exp;
         float limit;
         String fmt;
@@ -37,7 +38,7 @@ public class FormatUtils {
         }
         if( val >= exp && val <= limit ){
             // Print simple numbers as int.
-            return String.valueOf((int)val);
+            return String.valueOf((int)(val + .5));
         }else{
             // Format too large or too small numbers with not wasting too much
             // space. In addition, fix annoying locale chars as this function is
diff --git a/xtra4j-misc/src/test/java/ch/hiddenalpha/xtra4j/format/FormatUtilsTest.java b/xtra4j-misc/src/test/java/ch/hiddenalpha/xtra4j/format/FormatUtilsTest.java
new file mode 100644
index 0000000..237f171
--- /dev/null
+++ b/xtra4j-misc/src/test/java/ch/hiddenalpha/xtra4j/format/FormatUtilsTest.java
@@ -0,0 +1,89 @@
+package ch.hiddenalpha.xtra4j.format;
+
+import org.junit.Test;
+
+import static ch.hiddenalpha.xtra4j.format.FormatUtils.toStr;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+public class FormatUtilsTest {
+
+    @Test
+    public void zeroIsJustZero() {
+        for( int i = 1; i < 8; ++i ){
+            assertEquals("i=" + i, "0", toStr(0F, i));
+        }
+    }
+
+    @Test
+    public void smallIntsAreJustInts() {
+        assertEquals("1", toStr(1F, 1));
+        assertEquals("7", toStr(7F, 1));
+        assertEquals("19", toStr(19F, 1));
+        assertEquals("123", toStr(123F, 1));
+    }
+
+    @Test
+    public void nonsensePrecisionGetsThrownAway() {
+        assertEquals("2", toStr(1.99999999999999999F, 1));
+        assertEquals("2", toStr(1.50000000000000001F, 1));
+        assertEquals("1", toStr(1.4999999F, 1));
+        assertEquals("2.0", toStr(1.99999999999999999F, 2));
+        assertEquals("1.5", toStr(1.50000000000000001F, 2));
+        assertEquals("1.5", toStr(1.4999999F, 2));
+    }
+
+    @Test
+    public void veryLargeNumsUseScientificNotation() {
+        assertEquals("1e+08", toStr(123456700F, 1));
+        assertEquals("1.2e+08", toStr(123456700F, 2));
+        assertEquals("1.23e+08", toStr(123456700F, 3));
+        assertEquals("1.235e+08", toStr(123456700F, 4));
+        assertTrue(toStr(123456700F, 5).matches("^1234567\\d\\d$"));
+        assertTrue(toStr(123456700F, 6).matches("^1234567\\d\\d$"));
+        assertTrue(toStr(123456700F, 7).matches("^1234567\\d\\d$"));
+    }
+
+    @Test
+    public void smallNumsAreJustFloats() {
+        assertEquals("0.0001", toStr(0.000123456789F, 1));
+        assertEquals("0.00012", toStr(0.000123456789F, 2));
+        assertEquals("0.000123", toStr(0.000123456789F, 3));
+        assertEquals("0.0001235", toStr(0.000123456789F, 4));
+        assertEquals("0.00012346", toStr(0.000123456789F, 5));
+        assertEquals("0.000123457", toStr(0.000123456789F, 6));
+        assertEquals("0.0001234568", toStr(0.000123456789F, 7));
+    }
+
+    @Test
+    public void verySmallNumsUseScientificNotation() {
+        assertEquals("1e-05", toStr(0.0000123456789F, 1));
+        assertEquals("1.2e-05", toStr(0.0000123456789F, 2));
+        assertEquals("1.23e-05", toStr(0.0000123456789F, 3));
+        assertEquals("1.235e-05", toStr(0.0000123456789F, 4));
+        assertEquals("1.2346e-05", toStr(0.0000123456789F, 5));
+        assertEquals("1.23457e-05", toStr(0.0000123456789F, 6));
+        assertEquals("1.234568e-05", toStr(0.0000123456789F, 7));
+    }
+
+    @Test
+    public void positiveInfinityIsSameAsToString() {
+        assertEquals(String.valueOf(Float.POSITIVE_INFINITY),
+                toStr(Float.POSITIVE_INFINITY, 7));
+    }
+
+    @Test
+    public void negativeInfinityIsSameAsToString() {
+        assertEquals(String.valueOf(Float.NEGATIVE_INFINITY),
+                toStr(Float.NEGATIVE_INFINITY, 7));
+    }
+
+    @Test
+    public void NaNisNaN() {
+        for( int i = 1 ; i <= 7 ; ++i ){
+            assertEquals("NaN", toStr(Float.NaN, i));
+        }
+    }
+
+}