Add validity tests to cover edge cases

I added these tests to improve Go coverage for optimizations I want to be sure
are safe. In adding these, I found two cases where the libraries of various
language handle validation logic inconsistently. In cases of inconsistency, I
defaulted to the behavior used by most language in the repository.

1. Automatically expanding requested short code length if odd. Most of the
language implementations automatically add 1 to the length of requested codes
if the length indicates it is in the pair part of the code.

2. Validate latitude and longitude bounds within validation logic for full
codes. Most of the language implementations only check the first two characters
for latitude/longitude bounds when within the validation logic for full codes,
not when generally checking if codes are valid. This does introduce a strange
case where a code is "valid", but is neither a valid short nor a valid long
code. As this was the preexisting behavior, I have defaulted to this.

Author: willbeason

cpp/openlocationcode.cc

@@ -78,6 +78,10 @@ std::string encodeIntegers(int64_t lat_val, int64_t lng_val,
   // Add the separator character.
   code[internal::kSeparatorPosition] = internal::kSeparator;
 
+  // Limit the maximum number of digits in the code.
+  code_length = std::min(code_length, internal::kMaximumDigitCount);
+  // Ensure the length is valid.
+  code_length = std::max(code_length, internal::kMinimumDigitCount);
   // Compute the grid part of the code if necessary.
   if (code_length > internal::kPairCodeLength) {
     for (size_t i = internal::kGridCodeLength; i >= 1; i--) {
@@ -89,6 +93,9 @@ std::string encodeIntegers(int64_t lat_val, int64_t lng_val,
       lng_val /= internal::kGridColumns;
     }
   } else {
+    if (code_length % 2 == 1) {
+      code_length++;
+    }
     lat_val /= pow(internal::kGridRows, internal::kGridCodeLength);
     lng_val /= pow(internal::kGridColumns, internal::kGridCodeLength);
   }
@@ -193,13 +200,6 @@ std::string clean_code_chars(const std::string &code) {
 }  // anonymous namespace
 
 std::string Encode(const LatLng &location, size_t code_length) {
-  // Limit the maximum number of digits in the code.
-  code_length = std::min(code_length, internal::kMaximumDigitCount);
-  // Ensure the length is valid.
-  code_length = std::max(code_length, internal::kMinimumDigitCount);
-  if (code_length < internal::kPairCodeLength && code_length % 2 == 1) {
-    code_length = code_length + 1;
-  }
   // Convert latitude and longitude into integer values.
   int64_t lat_val = internal::latitudeToInteger(location.latitude);
   int64_t lng_val = internal::longitudeToInteger(location.longitude);

java/src/main/java/com/google/openlocationcode/OpenLocationCode.java

@@ -205,8 +205,12 @@ public OpenLocationCode(double latitude, double longitude, int codeLength) {
   static String encodeIntegers(long lat, long lng, int codeLength) {
     // Limit the maximum number of digits in the code.
     codeLength = Math.min(codeLength, MAX_DIGIT_COUNT);
+    // Automatically increase code length if odd and below pair code length.
+    if ((codeLength < PAIR_CODE_LENGTH) && codeLength % 2 == 1) {
+      codeLength += 1;
+    }
     // Check that the code length requested is valid.
-    if (codeLength < PAIR_CODE_LENGTH && codeLength % 2 == 1 || codeLength < MIN_DIGIT_COUNT) {
+    if (codeLength < MIN_DIGIT_COUNT) {
       throw new IllegalArgumentException("Illegal code length " + codeLength);
     }
 
@@ -359,6 +363,15 @@ public static CodeArea decode(String code) throws IllegalArgumentException {
    * @return True if it is a full code.
    */
   public boolean isFull() {
+    // First latitude character can only have first 9 values.
+    if (CODE_ALPHABET.indexOf(code.charAt(0)) > 8) {
+      return false;
+    }
+
+    // First longitude character can only have first 18 values.
+    if (CODE_ALPHABET.indexOf(code.charAt(1)) > 17) {
+      return false;
+    }
     return code.indexOf(SEPARATOR) == SEPARATOR_POSITION;
   }
 
@@ -569,19 +582,6 @@ public static boolean isValidCode(String code) {
       return false;
     }
 
-    // Check first two characters: only some values from the alphabet are permitted.
-    if (separatorPosition == SEPARATOR_POSITION) {
-      // First latitude character can only have first 9 values.
-      if (CODE_ALPHABET.indexOf(code.charAt(0)) > 8) {
-        return false;
-      }
-
-      // First longitude character can only have first 18 values.
-      if (CODE_ALPHABET.indexOf(code.charAt(1)) > 17) {
-        return false;
-      }
-    }
-
     // Check the characters before the separator.
     boolean paddingStarted = false;
     for (int i = 0; i < separatorPosition; i++) {

js/closure/openlocationcode.js

@@ -420,10 +420,11 @@ 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)
-  ) {
+  // Increment length if short and not even.
+  if (codeLength < PAIR_CODE_LENGTH && codeLength % 2 === 1) {
+    codeLength++;
+  }
+  if (codeLength < MIN_CODE_LEN) {
     throw new Error('IllegalArgumentException: Invalid Plus Code length');
   }
   codeLength = Math.min(codeLength, MAX_CODE_LEN);

python/openlocationcode/openlocationcode.py

@@ -287,8 +287,10 @@ def encodeIntegers(latVal, lngVal, codeLength):
     This function is exposed for testing purposes and should not be called
     directly.
     """
-    if codeLength < MIN_DIGIT_COUNT_ or (codeLength < PAIR_CODE_LENGTH_ and
-                                         codeLength % 2 == 1):
+    if codeLength < PAIR_CODE_LENGTH_ and codeLength % 2 == 1:
+        # Automatically increment short lengths to be even.
+        codeLength+=1
+    if codeLength < MIN_DIGIT_COUNT_:
         raise ValueError('Invalid Open Location Code length - ' +
                          str(codeLength))
     codeLength = min(codeLength, MAX_DIGIT_COUNT_)