Initialisation depot

java/test/jmri/jmrix/rps/AbstractAlgorithmTestBase.java

@@ -0,0 +1,215 @@
+package jmri.jmrix.rps;
+
+import javax.vecmath.Point3d;
+
+import jmri.util.JUnitUtil;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.*;
+
+/**
+ * Common test scaffolding for Algorithm implementations.
+ *
+ * <p>
+ * The default transmitter location for the 7, 13, 13, 13 readings is (0,0,12)
+ *
+ * <p>
+ * Implementing subclasses should provide static "main" and "suite" methods.
+ *
+ * @author Bob Jacobsen Copyright 2008
+ */
+abstract public class AbstractAlgorithmTestBase {
+
+    abstract Calculator getAlgorithm(Point3d[] pts, double vs);
+
+    double vs = 0.0344;  // SI default for testing
+
+    Point3d[] receivers1 = new Point3d[]{
+        null,
+        new Point3d(0.0f, 0.0f, 10.0f),
+        new Point3d(-3.0f, 4.0f, 5.0f),
+        new Point3d(-3.0f, -4.0f, 5.0f),
+        new Point3d(5.0f, 0.0f, 5.0f),
+        new Point3d(0.0f, 0.0f, 9.0f)
+    };
+    Point3d result1 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances1 = distances(receivers1, vs, result1);
+
+    @Test
+    public void testCalc1() {
+        testCalc(receivers1, distances1, result1, "Test 1", distances1.length, 3);
+    }
+
+    Point3d[] receivers2 = new Point3d[]{
+        null,
+        new Point3d(0.0f, 0.0f, 15.0f),
+        new Point3d(-30.0f, 40.0f, 10.0f),
+        new Point3d(-30.0f, -40.0f, 10.0f),
+        new Point3d(50.0f, 0.0f, 10.0f),
+        new Point3d(0.0f, 0.0f, 19.0f)
+    };
+    Point3d result2 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances2 = distances(receivers2, vs, result2);
+
+    @Test
+    public void testCalc2() {
+        testCalc(receivers2, distances2, result2, "Test 2", distances2.length, 3);
+    }
+
+    Point3d[] receivers3 = new Point3d[]{
+        null,
+        new Point3d(0.0f, 0.0f, 15.0f),
+        new Point3d(-30.0f, 40.0f, 10.0f),
+        new Point3d(-30.0f, -40.0f, 10.0f),
+        new Point3d(50.0f, 0.0f, 10.0f),
+        new Point3d(23.0f, 0.0f, 19.0f),
+        new Point3d(0.0f, 30.0f, 9.0f),
+        new Point3d(-14.0f, 0.0f, 19.0f),
+        new Point3d(33.0f, 23.0f, 18.0f),
+        new Point3d(0.0f, 12.0f, 19.0f),
+        new Point3d(100.0f, 0.0f, 19.0f),
+        new Point3d(0.0f, 200.0f, 19.0f),
+        new Point3d(50.0f, 50.0f, 19.0f)
+    };
+    Point3d result3 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances3 = distances(receivers3, vs, result3);
+
+    @Test
+    public void testCalc3() {
+        testCalc(receivers3, distances3, result3, "Test 3", distances3.length, 3);
+    }
+
+    // bad point
+    Point3d[] receivers4 = new Point3d[]{
+        null,
+        new Point3d(0.0f, 0.0f, 15.0f),
+        new Point3d(-30.0f, 40.0f, 10.0f),
+        new Point3d(-30.0f, -40.0f, 10.0f),
+        new Point3d(50.0f, 0.0f, 10.0f),
+        new Point3d(30.0f, 12.0f, 19.0f)
+    };
+    Point3d result4 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances4 = distances(receivers4, vs, result4);
+
+    @Test
+    public void testCalc4() {
+        distances4[distances4.length - 1] = 9999.;
+        testCalc(receivers4, distances4, result4, "Test 4", distances4.length - 1, 3);
+    }
+
+    Point3d[] receivers5 = new Point3d[]{
+        null,
+        new Point3d(-3.0f, 4.0f, 9.0f),
+        new Point3d(-3.0f, -4.0f, 10.0f),
+        new Point3d(5.0f, 0.0f, 11.0f),
+        new Point3d(0.0f, 13.0f, 9.0f)
+    };
+    Point3d result5 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances5 = distances(receivers5, vs, result5);
+
+    @Test
+    public void testCalc5() {
+        testCalc(receivers5, distances5, result5, "Test 5", distances5.length, 3);
+    }
+
+    Point3d[] receivers6 = new Point3d[]{
+        null,
+        new Point3d(10.0f, 0.0f, 12.0f),
+        new Point3d(-3.0f, -4.0f, 10.0f),
+        new Point3d(5.0f, 0.0f, 11.0f),
+        new Point3d(0.0f, 13.0f, 9.0f)
+    };
+    Point3d result6 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances6 = distances(receivers6, vs, result6);
+
+    @Test
+    public void testCalc6() {
+        testCalc(receivers6, distances6, result6, "Test 6", distances6.length, 3);
+    }
+
+    Point3d[] receivers7 = new Point3d[]{
+        null,
+        new Point3d(10.0f, 0.0f, 12.0f),
+        new Point3d(-3.0f, 4.0f, 9.0f),
+        new Point3d(5.0f, 0.0f, 11.0f),
+        new Point3d(0.0f, 13.0f, 9.0f)
+    };
+    Point3d result7 = new Point3d(3.0, 2.0, 1.0);
+    double[] distances7 = distances(receivers7, vs, result7);
+
+    @Test
+    public void testCalc7() {
+        testCalc(receivers7, distances7, result7, "Test 7", distances7.length, 3);
+    }
+
+    // infrastructure
+    double tolerance = 0.05;
+
+    double distance(Point3d p, Point3d q) {
+        return Math.sqrt(
+                (p.x - q.x) * (p.x - q.x)
+                + (p.y - q.y) * (p.y - q.y)
+                + (p.z - q.z) * (p.z - q.z)
+        );
+    }
+
+    double time(Point3d p) {
+        Point3d q = new Point3d(3.0, 2.0, 1.0);
+        return distance(p, q) / vs;
+    }
+
+    double[] distances(Point3d[] ps, double vs, Point3d location) {
+        double[] retval = new double[ps.length];
+        for (int i = 0; i < ps.length; i++) {
+            if (ps[i] != null) {
+                retval[i] = distance(ps[i], location) / vs;
+            } else {
+                retval[i] = 0.;
+            }
+        }
+        return retval;
+    }
+
+    public void testCalc(Point3d[] receivers, double[] distances, Point3d result, String label,
+            int codemax, int codemin) {
+        Reading r = new Reading("21", distances);
+
+        Calculator c = getAlgorithm(receivers, vs);
+
+        Measurement m = c.convert(r, result);
+
+        Assert.assertEquals(label + " ID ok", "21", m.getId());
+
+        if (!(Math.abs(m.x - result.x) < tolerance)) {
+            System.err.println(label + " x not close " + m.x + " " + result.x);
+        }
+        Assert.assertEquals(label + " x close", true, Math.abs(m.x - result.x) < tolerance);
+
+        if (!(Math.abs(m.y - result.y) < tolerance)) {
+            System.err.println(label + " y not close " + m.y + " " + result.y);
+        }
+        Assert.assertEquals(label + " y close", true, Math.abs(m.y - result.y) < tolerance);
+
+        if (!(Math.abs(m.z - result.z) < tolerance)) {
+            System.err.println(label + " z not close " + m.z + " " + result.z);
+        }
+        Assert.assertEquals(label + " z close", true, Math.abs(m.z - result.z) < tolerance);
+
+        if (m.getCode() > codemax || m.getCode() < codemin) {
+            System.err.println(label + " bad code " + m.getCode());
+        }
+        Assert.assertTrue(label + " code > min", m.getCode() >= codemin);
+        Assert.assertTrue(label + " code <= max", m.getCode() <= codemax);
+    }
+
+    @BeforeEach
+    public void setUp() {
+        JUnitUtil.setUp();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        JUnitUtil.tearDown();
+    }
+
+}