js/closure: use floor for conversion, add integer tests (#731)

* js/closure: use floor for conversion, add integer tests

* missing args

* test logging, use correct fields

* switch to floor

* correct csv fields

* lint fixes

Author: drinckes

js/closure/openlocationcode.js

@@ -362,17 +362,6 @@ exports.isFull = isFull;
       specified.
  */
 function encode(latitude, longitude, codeLength) {
-  if (typeof codeLength == 'undefined') {
-    codeLength = PAIR_CODE_LENGTH;
-  }
-  if (
-    codeLength < MIN_CODE_LEN ||
-    (codeLength < PAIR_CODE_LENGTH && codeLength % 2 == 1)
-  ) {
-    throw new Error('IllegalArgumentException: Invalid Plus Code length');
-  }
-  codeLength = Math.min(codeLength, MAX_CODE_LEN);
-
   const locationIntegers = _locationToIntegers(latitude, longitude);
 
   return _encodeIntegers(locationIntegers[0], locationIntegers[1], codeLength);
@@ -395,14 +384,14 @@ exports.encode = encode;
  * @return {Array<number>} A tuple of the latitude integer and longitude integer.
  */
 function _locationToIntegers(latitude, longitude) {
-  var latVal = roundAwayFromZero(latitude * FINAL_LAT_PRECISION);
+  var latVal = Math.floor(latitude * FINAL_LAT_PRECISION);
   latVal += LATITUDE_MAX * FINAL_LAT_PRECISION;
   if (latVal < 0) {
     latVal = 0;
   } else if (latVal >= 2 * LATITUDE_MAX * FINAL_LAT_PRECISION) {
     latVal = 2 * LATITUDE_MAX * FINAL_LAT_PRECISION - 1;
   }
-  var lngVal = roundAwayFromZero(longitude * FINAL_LNG_PRECISION);
+  var lngVal = Math.floor(longitude * FINAL_LNG_PRECISION);
   lngVal += LONGITUDE_MAX * FINAL_LNG_PRECISION;
   if (lngVal < 0) {
     lngVal =
@@ -428,6 +417,17 @@ exports._locationToIntegers = _locationToIntegers;
       specified.
  */
 function _encodeIntegers(latInt, lngInt, codeLength) {
+  if (typeof codeLength == 'undefined') {
+    codeLength = PAIR_CODE_LENGTH;
+  }
+  if (
+    codeLength < MIN_CODE_LEN ||
+    (codeLength < PAIR_CODE_LENGTH && codeLength % 2 == 1)
+  ) {
+    throw new Error('IllegalArgumentException: Invalid Plus Code length');
+  }
+  codeLength = Math.min(codeLength, MAX_CODE_LEN);
+
   // Javascript strings are immutable and it doesn't have a native
   // StringBuilder, so we'll use an array.
   const code = new Array(MAX_CODE_LEN + 1);
@@ -694,20 +694,6 @@ function shorten(code, latitude, longitude) {
 }
 exports.shorten = shorten;
 
-/**
- * Round numbers like C does. This implements rounding away from zero (see
- * https://en.wikipedia.org/wiki/Rounding).
- *
- * @param {number} num A number to round.
- * @return {number} The rounded value usn
- */
-function roundAwayFromZero(num) {
-  if (num >= 0) {
-    return Math.round(num);
-  }
-  return -1 * Math.round(Math.abs(num));
-}
-
 /**
   Clip a latitude into the range -90 to 90.
   @param {number} latitude A latitude in signed decimal degrees.

js/closure/openlocationcode_test.js

@@ -67,21 +67,92 @@ testSuite({
     asyncTestCase.waitForAsync('Waiting for xhr to respond');
     xhrIo_.send(DECODING_TEST_FILE, 'GET');
   },
-  testEncode: function() {
+  testEncodeDegrees: function() {
     const xhrIo_ = new XhrIo();
     xhrIo_.listenOnce(EventType.COMPLETE, () => {
+      // Allow a 5% error rate encoding from degree coordinates (because of floating
+      // point precision).
+      const allowedErrorRate = 0.05;
+      var errors = 0;
       const lines = xhrIo_.getResponseText().match(/^[^#].+/gm);
       for (var i = 0; i < lines.length; i++) {
         const fields = lines[i].split(',');
-        const lat = parseFloat(fields[0]);
-        const lng = parseFloat(fields[1]);
-        const length = parseInt(fields[2], 10);
-        const code = fields[3];
+        const latDegrees = parseFloat(fields[0]);
+        const lngDegrees = parseFloat(fields[1]);
+        const length = parseInt(fields[4], 10);
+        const code = fields[5];
 
-        const gotCode = OpenLocationCode.encode(lat, lng, length);
+        const got = OpenLocationCode.encode(latDegrees, lngDegrees, length);
         // Did we get the same code?
-        assertEquals('testEncode ' + 1, code, gotCode);
+        if (code != got) {
+          console.warn(
+              'ENCODING DIFFERENCE: Expected code ' + code +', got ' + got
+          );
+          errors++;
+        }
+        asyncTestCase.continueTesting();
+      }
+      console.info('testEncodeDegrees error rate is ' + (errors / lines.length));
+      assertTrue(
+          'testEncodeDegrees: too many errors ' + errors / lines.length,
+          (errors / lines.length) < allowedErrorRate
+      );
+    });
+    asyncTestCase.waitForAsync('Waiting for xhr to respond');
+    xhrIo_.send(ENCODING_TEST_FILE, 'GET');
+  },
+  testLocationToIntegers: function() {
+    const xhrIo_ = new XhrIo();
+    xhrIo_.listenOnce(EventType.COMPLETE, () => {
+      const lines = xhrIo_.getResponseText().match(/^[^#].+/gm);
+      for (var i = 0; i < lines.length; i++) {
+        const fields = lines[i].split(',');
+        const latDegrees = parseFloat(fields[0]);
+        const lngDegrees = parseFloat(fields[1]);
+        const latIntegers = parseInt(fields[2], 10);
+        const lngIntegers = parseInt(fields[3], 10);
 
+        const got = OpenLocationCode._locationToIntegers(
+            latDegrees,
+            lngDegrees
+        );
+        // Due to floating point precision limitations, we may get values 1 less
+        // than expected.
+        assertTrue(
+            'testLocationToIntegers: expected latitude ' + latIntegers + ', got ' + got[0],
+            got[0] == latIntegers || got[0] == latIntegers - 1
+        );
+        assertTrue(
+            'testLocationToIntegers: expected longitude ' + lngIntegers + ', got ' + got[1],
+            got[1] == lngIntegers || got[1] == lngIntegers - 1
+        );
+        asyncTestCase.continueTesting();
+      }
+    });
+    asyncTestCase.waitForAsync('Waiting for xhr to respond');
+    xhrIo_.send(ENCODING_TEST_FILE, 'GET');
+  },
+  testEncodeIntegers: function() {
+    const xhrIo_ = new XhrIo();
+    xhrIo_.listenOnce(EventType.COMPLETE, () => {
+      const lines = xhrIo_.getResponseText().match(/^[^#].+/gm);
+      for (var i = 0; i < lines.length; i++) {
+        const fields = lines[i].split(',');
+        const latIntegers = parseInt(fields[2], 10);
+        const lngIntegers = parseInt(fields[3], 10);
+        const length = parseInt(fields[4], 10);
+        const code = fields[5];
+
+        const got = OpenLocationCode._encodeIntegers(
+            latIntegers,
+            lngIntegers,
+            length
+        );
+        // Did we get the same code?
+        assertEquals(
+            'testEncodeIntegers: expected code ' + code + ', got ' + got,
+            code, got
+        );
         asyncTestCase.continueTesting();
       }
     });