Added unit tests for Quatd.equals/isSimilar and Vec3d.equals/isSimilar

Fixed a bug related to NaN in isSimilar.

Author: pspeed42

build.gradle

@@ -1,6 +1,11 @@
 buildscript {
     repositories {
-        jcenter()
+        if( JavaVersion.current() == JavaVersion.VERSION_1_7 ) {
+            // Fallback for JDK 7 that can no longer connect to jcenter with https
+            maven { url "http://jcenter.bintray.com" }
+        } else {
+            jcenter()
+        }
     }
     dependencies {
         // This sucks down a lot of stuff that 'normal' users wouldn't 
@@ -12,6 +17,7 @@ buildscript {
 }
 
 apply plugin: 'java'
+apply plugin: 'groovy'
 apply plugin: 'maven'
 
 version='1.3.0-SNAPSHOT'
@@ -61,9 +67,18 @@ dependencies {
     // classes.
     compile "org.jmonkeyengine:jme3-core:$jmeVersion"
 
-    compile 'org.slf4j:slf4j-api:1.7.13'        
+    compile 'org.slf4j:slf4j-api:1.7.13'
+    
+    testCompile 'junit:junit:4.12'
+    testCompile 'org.codehaus.groovy:groovy-all:2.4.11'
 }
 
+test {
+    testLogging {
+        // I want to see the tests that are run and pass, etc.
+        events "passed", "skipped", "failed", "standardOut", "standardError"
+    }
+}        
 
 // Configuration to produce maven-repo style -sources and -javadoc jars
 task sourcesJar(type: Jar) {

src/main/java/com/simsilica/mathd/Quatd.java

@@ -116,16 +116,16 @@ public boolean isSimilar( Quatd other, double epsilon ) {
         if( other == null ) {
             return false;
         }
-        if( Math.abs(other.x - x) > epsilon ) {
+        if( Double.compare(Math.abs(other.x - x), epsilon) > 0 ) {
             return false;
         }
-        if( Math.abs(other.y - y) > epsilon ) {
+        if( Double.compare(Math.abs(other.y - y), epsilon) > 0 ) {
             return false;
         }
-        if( Math.abs(other.z - z) > epsilon ) {
+        if( Double.compare(Math.abs(other.z - z), epsilon) > 0 ) {
             return false;
         }
-        if( Math.abs(other.w - w) > epsilon ) {
+        if( Double.compare(Math.abs(other.w - w), epsilon) > 0 ) {
             return false;
         }
         return true;

src/main/java/com/simsilica/mathd/Vec3d.java

@@ -113,13 +113,13 @@ public boolean isSimilar( Vec3d other, double epsilon ) {
         if( other == null ) {
             return false;
         }
-        if( Math.abs(other.x - x) > epsilon ) {
+        if( Double.compare(Math.abs(other.x - x), epsilon) > 0 ) {
             return false;
         }
-        if( Math.abs(other.y - y) > epsilon ) {
+        if( Double.compare(Math.abs(other.y - y), epsilon) > 0 ) {
             return false;
         }
-        if( Math.abs(other.z - z) > epsilon ) {
+        if( Double.compare(Math.abs(other.z - z), epsilon) > 0 ) {
             return false;
         }
         return true;

src/test/groovy/com/simsilica/mathd/QuatdTest.groovy

@@ -0,0 +1,135 @@
+package com.simsilica.mathd;
+
+class QuatdTest {
+
+    static class IsSimilarTest extends GroovyTestCase {
+        
+        void testSimilarX() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1.01, 2, 3, 4);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+        
+        void testSimilarY() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2.01, 3, 4);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+        
+        void testSimilarZ() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3.01, 4);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+
+        void testSimilarW() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3, 4.01);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+        
+        void testNotSimilarX() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1.5, 2, 3, 4);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+
+        void testNotSimilarY() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2.5, 3, 4);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+
+        void testNotSimilarZ() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3.5, 4);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+
+        void testNotSimilarW() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3, 4.5);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+        
+        void testNanRight() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(Double.NaN, 2, 3, 4);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+        
+        void testNanLeft() {
+            Quatd a = new Quatd(Double.NaN, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3, 4);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+    }
+    
+    static class EqualsTest extends GroovyTestCase {
+        void testEquals() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3, 4);
+            
+            assert a.equals(b);
+        }
+                
+        void testNotEqualsX() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1.1, 2, 3, 4);
+            
+            assert !a.equals(b);
+        }
+                
+        void testNotEqualsY() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2.1, 3, 4);
+            
+            assert !a.equals(b);
+        }
+                
+        void testNotEqualsZ() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3.1, 4);
+            
+            assert !a.equals(b);
+        }
+
+        void testNotEqualsW() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3, 4.1);
+            
+            assert !a.equals(b);
+        }
+        
+        void testEqualsNanLeft() {
+            Quatd a = new Quatd(Double.NaN, 2, 3, 4);
+            Quatd b = new Quatd(1, 2, 3, 4);
+            
+            assert !a.equals(b);
+        }
+                
+        void testEqualsNanRight() {
+            Quatd a = new Quatd(1, 2, 3, 4);
+            Quatd b = new Quatd(Double.NaN, 2, 3, 4);
+            
+            assert !a.equals(b);
+        }
+        
+        void testEqualsNanBoth() {
+            Quatd a = new Quatd(Double.NaN, 2, 3, 4);
+            Quatd b = new Quatd(Double.NaN, 2, 3, 4);
+            
+            assert !a.equals(b);
+        }        
+    }
+}

src/test/groovy/com/simsilica/mathd/Vec3dTest.groovy

@@ -0,0 +1,114 @@
+package com.simsilica.mathd;
+
+class Vec3dTest {
+
+    static class IsSimilarTest extends GroovyTestCase {
+        
+        void testSimilarX() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1.01, 2, 3);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+        
+        void testSimilarY() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2.01, 3);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+        
+        void testSimilarZ() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2, 3.01);
+            
+            assert a.isSimilar(b, 0.1)
+        }
+        
+        void testNotSimilarX() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1.5, 2, 3);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+
+        void testNotSimilarY() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2.5, 3);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+
+        void testNotSimilarZ() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2, 3.5);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+        
+        void testNanRight() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(Double.NaN, 2, 3);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+        
+        void testNanLeft() {
+            Vec3d a = new Vec3d(Double.NaN, 2, 3);
+            Vec3d b = new Vec3d(1, 2, 3);
+            
+            assert !a.isSimilar(b, 0.1)
+        }
+    }
+    
+    static class EqualsTest extends GroovyTestCase {
+        void testEquals() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2, 3);
+            
+            assert a.equals(b);
+        }
+                
+        void testNotEqualsX() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1.1, 2, 3);
+            
+            assert !a.equals(b);
+        }
+                
+        void testNotEqualsY() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2.1, 3);
+            
+            assert !a.equals(b);
+        }
+                
+        void testNotEqualsZ() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(1, 2, 3.1);
+            
+            assert !a.equals(b);
+        }
+        
+        void testEqualsNanLeft() {
+            Vec3d a = new Vec3d(Double.NaN, 2, 3);
+            Vec3d b = new Vec3d(1, 2, 3);
+            
+            assert !a.equals(b);
+        }
+                
+        void testEqualsNanRight() {
+            Vec3d a = new Vec3d(1, 2, 3);
+            Vec3d b = new Vec3d(Double.NaN, 2, 3);
+            
+            assert !a.equals(b);
+        }
+        
+        void testEqualsNanBoth() {
+            Vec3d a = new Vec3d(Double.NaN, 2, 3);
+            Vec3d b = new Vec3d(Double.NaN, 2, 3);
+            
+            assert !a.equals(b);
+        }        
+    }
+}