use floor for integer conversion (#727)

Author: drinckes

c/openlocationcode_test.cc

@@ -122,7 +122,7 @@ std::vector<EncodingTestData> GetEncodingDataFromCsv() {
   return data_results;
 }
 
-// TolerantTestParams runs a test with the
+// TolerantTestParams runs a test with a permitted failure rate.
 struct TolerantTestParams {
   double allowed_failure_rate;
   std::vector<EncodingTestData> test_data;

cpp/openlocationcode.cc

@@ -49,7 +49,7 @@ const int kPositionLUT['X' - 'C' + 1] = {8,  -1, -1, 9,  10, 11, -1, 12,
                                          -1, -1, -1, 17, 18, 19};
 
 int64_t latitudeToInteger(double latitude) {
-  int64_t lat = round(latitude * kGridLatPrecisionInverse);
+  int64_t lat = floor(latitude * kGridLatPrecisionInverse);
   lat += kLatitudeMaxDegrees * kGridLatPrecisionInverse;
   if (lat < 0) {
     lat = 0;
@@ -60,7 +60,7 @@ int64_t latitudeToInteger(double latitude) {
 }
 
 int64_t longitudeToInteger(double longitude) {
-  int64_t lng = round(longitude * kGridLngPrecisionInverse);
+  int64_t lng = floor(longitude * kGridLngPrecisionInverse);
   lng += kLongitudeMaxDegrees * kGridLngPrecisionInverse;
   if (lng <= 0) {
     lng = lng % (2 * kLongitudeMaxDegrees * kGridLngPrecisionInverse) +

cpp/openlocationcode_test.cc

@@ -136,12 +136,12 @@ INSTANTIATE_TEST_CASE_P(OLC_Tests, DecodingChecks,
 struct EncodingTestData {
   double lat_deg;
   double lng_deg;
+  long long int lat_int;
+  long long int lng_int;
   size_t length;
   std::string code;
 };
 
-class EncodingChecks : public ::testing::TestWithParam<EncodingTestData> {};
-
 const std::string kEncodingTestsFile = "test_data/encoding.csv";
 
 std::vector<EncodingTestData> GetEncodingDataFromCsv() {
@@ -152,19 +152,71 @@ std::vector<EncodingTestData> GetEncodingDataFromCsv() {
     EncodingTestData test_data = {};
     test_data.lat_deg = strtod(csv_records[i][0].c_str(), nullptr);
     test_data.lng_deg = strtod(csv_records[i][1].c_str(), nullptr);
-    test_data.length = atoi(csv_records[i][2].c_str());
-    test_data.code = csv_records[i][3];
+    test_data.lat_int = strtoll(csv_records[i][2].c_str(), nullptr, 10);
+    test_data.lng_int = strtoll(csv_records[i][3].c_str(), nullptr, 10);
+    test_data.length = atoi(csv_records[i][4].c_str());
+    test_data.code = csv_records[i][5];
     data_results.push_back(test_data);
   }
   return data_results;
 }
 
-TEST_P(EncodingChecks, Encode) {
+// TolerantTestParams runs a test with a permitted failure rate.
+struct TolerantTestParams {
+  double allowed_failure_rate;
+  std::vector<EncodingTestData> test_data;
+};
+
+class TolerantEncodingChecks
+    : public ::testing::TestWithParam<TolerantTestParams> {};
+
+TEST_P(TolerantEncodingChecks, EncodeDegrees) {
+  const TolerantTestParams& test_params = GetParam();
+  int failure_count = 0;
+
+  for (EncodingTestData tc : test_params.test_data) {
+    LatLng lat_lng = LatLng{tc.lat_deg, tc.lng_deg};
+    // Encode the test location and make sure we get the expected code.
+    std::string got_code = Encode(lat_lng, tc.length);
+    if (tc.code.compare(got_code) != 0) {
+      failure_count++;
+      printf("  ENCODING FAILURE: Got: '%s', expected: '%s'\n",
+             got_code.c_str(), tc.code.c_str());
+    }
+  }
+  double actual_failure_rate =
+      double(failure_count) / test_params.test_data.size();
+  EXPECT_LE(actual_failure_rate, test_params.allowed_failure_rate)
+      << "Failure rate " << actual_failure_rate << " exceeds allowed rate "
+      << test_params.allowed_failure_rate;
+}
+
+// Allow a 5% error rate encoding from degree coordinates (because of floating
+// point precision).
+INSTANTIATE_TEST_SUITE_P(OLC_Tests, TolerantEncodingChecks,
+                         ::testing::Values(TolerantTestParams{
+                             0.05, GetEncodingDataFromCsv()}));
+
+class EncodingChecks : public ::testing::TestWithParam<EncodingTestData> {};
+
+TEST_P(EncodingChecks, OLC_EncodeIntegers) {
   EncodingTestData test_data = GetParam();
-  LatLng lat_lng = LatLng{test_data.lat_deg, test_data.lng_deg};
   // Encode the test location and make sure we get the expected code.
-  std::string actual_code = Encode(lat_lng, test_data.length);
-  EXPECT_EQ(test_data.code, actual_code);
+  std::string got_code = internal::encodeIntegers(
+      test_data.lat_int, test_data.lng_int, test_data.length);
+  EXPECT_EQ(test_data.code, got_code);
+}
+
+TEST_P(EncodingChecks, OLC_LocationToIntegers) {
+  EncodingTestData test_data = GetParam();
+  int64_t got_lat = internal::latitudeToInteger(test_data.lat_deg);
+  // Due to floating point precision limitations, we may get values 1 less than
+  // expected.
+  EXPECT_LE(got_lat, test_data.lat_int);
+  EXPECT_GE(got_lat + 1, test_data.lat_int);
+  int64_t got_lng = internal::longitudeToInteger(test_data.lng_deg);
+  EXPECT_LE(got_lng, test_data.lng_int);
+  EXPECT_GE(got_lng + 1, test_data.lng_int);
 }
 
 INSTANTIATE_TEST_CASE_P(OLC_Tests, EncodingChecks,