Improved unit test, added max delta in meters to Mapcode class

Author: rijnb

src/main/java/com/mapcode/Mapcode.java

@@ -43,6 +43,13 @@ public final class Mapcode {
     @Nonnull
     private final Territory territory;
 
+    /**
+     * These constants define a safe maximum for the distance between a decoded mapcode and its original
+     * location used for encoding the mapcode.
+     *
+     * The actual accuracy (resolution) of mapcodes are actually slightly better than this, but these are
+     * safe values to use under normal circumstances.
+     */
     public static final double PRECISION_0_MAX_DELTA_METERS = 10.0;
     public static final double PRECISION_1_MAX_DELTA_METERS = 2.0;
     public static final double PRECISION_2_MAX_DELTA_METERS = 0.4;

src/test/java/com/mapcode/ReferenceFileTest.java

@@ -129,10 +129,6 @@ private static void checkFile(@Nonnull final String baseFileName) throws Excepti
                     LOG.info("checkFile: expected = {}", GSON.toJson(reference.mapcodes));
                 }
 
-                /**
-                 * Check encode.
-                 */
-
                 // Encode lat/lon to series of mapcodes and check the resulting mapcodes.
                 final List<Mapcode> results = MapcodeCodec.encode(
                         reference.point.getLatDeg(), reference.point.getLonDeg());
@@ -146,33 +142,37 @@ private static void checkFile(@Nonnull final String baseFileName) throws Excepti
                     ++error;
                 }
 
-                /**
-                 * Check encodeToInternational.
-                 */
-                final Mapcode resultInternational = MapcodeCodec.encodeToInternational(reference.point.getLatDeg(), reference.point.getLonDeg());
+                // Check encodeToInternational.
+                final Mapcode resultInternational = MapcodeCodec.encodeToInternational(
+                        reference.point.getLatDeg(), reference.point.getLonDeg());
                 final Mapcode expectedInternational = results.get(results.size() - 1);
                 if (!resultInternational.equals(expectedInternational)) {
                     LOG.error("checkFile: encodeToInternational fails, expected={}, got={} for reference",
                             expectedInternational, resultInternational, reference);
                     ++error;
                 }
 
-                // Check the size and order of the results with a single assertion.
-                //
-                assertEquals("Encode #" + i + " incorrect number of results:" +
-                                "\n  lat/lon  = " + reference.point +
-                                "\n  expected = " + reference.mapcodes.size() + " results, " +
-                                GSON.toJson(reference.mapcodes) +
-                                "\n  actual   = " + results.size() + " results, " + GSON.toJson(results),
-                        reference.mapcodes.size(), results.size());
+                // Check the size of the results.
+                if (reference.mapcodes.size() != results.size()) {
+                    LOG.error("checkFile: Encode #{} incorrect number of results:" +
+                                    "\n  lat/lon  = {}" +
+                                    "\n  expected = {} results," +
+                                    "\n  actual   = {} results",
+                            i,
+                            reference.point,
+                            reference.mapcodes.size(),
+                            GSON.toJson(reference.mapcodes),
+                            GSON.toJson(results));
+                    ++error;
+                }
 
                 // For every mapcode in the result set, check if it is contained in the reference set.
                 for (final Mapcode result : results) {
                     boolean found = false;
                     for (final MapcodeRec referenceMapcodeRec : reference.mapcodes) {
                         if (referenceMapcodeRec.territory.equals(result.getTerritory())) {
                             if (referenceMapcodeRec.mapcode.lastIndexOf('-') > 4) {
-                                if (referenceMapcodeRec.mapcode.equals(result.getMapcodePrecision2())) {
+                                if (referenceMapcodeRec.mapcode.equals(result.getMapcodePrecision(2))) {
                                     found = true;
                                     break;
                                 }
@@ -200,7 +200,7 @@ private static void checkFile(@Nonnull final String baseFileName) throws Excepti
                     for (final Mapcode result : results) {
                         if (referenceMapcodeRec.territory.equals(result.getTerritory())) {
                             if (referenceMapcodeRec.mapcode.lastIndexOf('-') > 4) {
-                                if (referenceMapcodeRec.mapcode.equals(result.getMapcodePrecision2())) {
+                                if (referenceMapcodeRec.mapcode.equals(result.getMapcodePrecision(2))) {
                                     found = true;
                                     break;
                                 }
@@ -219,19 +219,20 @@ private static void checkFile(@Nonnull final String baseFileName) throws Excepti
                     }
                 }
 
-                /**
-                 * Check distance of decoded point to reference point.
-                 */
+                // Check distance of decoded point to reference point.
                 for (final MapcodeRec mapcodeRec : reference.mapcodes) {
                     //noinspection NestedTryStatement
                     try {
                         final Point result = MapcodeCodec.decode(mapcodeRec.mapcode, mapcodeRec.territory);
                         final double distanceMeters = Point.distanceInMeters(reference.point, result);
                         maxdelta = Math.max(maxdelta, distanceMeters);
-                        if (distanceMeters > Mapcode.PRECISION_0_MAX_DELTA_METERS) {
-                            LOG.error(
-                                    "Mapcode {} {} was generated for point {}, but decodes to point {} which is {} meters from the original point.",
-                                    mapcodeRec.territory, mapcodeRec.mapcode, reference.point, result, distanceMeters);
+
+                        final double maxDeltaMeters = (mapcodeRec.mapcode.lastIndexOf('-') > 4) ?
+                                Mapcode.PRECISION_2_MAX_DELTA_METERS : Mapcode.PRECISION_0_MAX_DELTA_METERS;
+                        if (distanceMeters > maxDeltaMeters) {
+                            LOG.error("Mapcode {} {} was generated for point {}, but decodes to point {} " +
+                                            "which is {} meters from the original point (max is {} meters).",
+                                    mapcodeRec.territory, mapcodeRec.mapcode, reference.point, result, distanceMeters, maxDeltaMeters);
                             ++error;
                         }
                     } catch (final UnknownMapcodeException unknownMapcodeException) {