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

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);
@@ -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);

js/closure/openlocationcode_test.js

@@ -67,21 +67,90 @@ 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 latDegrees = parseFloat(fields[0]);
+        const lngDegrees = parseFloat(fields[1]);
         const length = parseInt(fields[2], 10);
         const code = fields[3];
 
-        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.log(
+            'ENCODING DIFFERENCE: Expected code ' + code +', got ' + got
+          );
+          errors++;
+        }
+        asyncTestCase.continueTesting();
+      }
+      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]);
+        const lngIntegers = parseInt(fields[3]);
 
+        const got = OpenLocationCode._locationToIntegers(
+          latDegrees,
+          lngDegrees
+        );
+        // Due to floating point precision limitations, we may get values 1 less
+        // than expected.
+        assertTrue(
+          'testEncodeIntegers: expected latitude ' + latIntegers + ', got ' + got[0],
+          got[0] == latIntegers || got[0] == latIntegers - 1
+        );
+        assertTrue(
+          'testEncodeIntegers: 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]);
+        const lngIntegers = parseInt(fields[3]);
+        const length = parseInt(fields[2], 10);
+        const code = fields[3];
+
+        const got = OpenLocationCode._encodeIntegers(
+          latIntegers,
+          lngIntegers,
+          length
+        );
+        // Did we get the same code?
+        assertEquals(
+          'testEncodeIntegers: expected code ' + code + ', got ' + got
+        );
         asyncTestCase.continueTesting();
       }
     });