h3 3.6.0 → 3.7.2

data/ext/h3/src/src/apps/testapps/testH3Distance.c

@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"

data/ext/h3/src/src/apps/testapps/testH3DistanceExhaustive.c

@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"

data/ext/h3/src/src/apps/testapps/testH3GetFaces.c

@@ -19,6 +19,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "baseCells.h"
 #include "h3Index.h"
 #include "h3api.h"

data/ext/h3/src/src/apps/testapps/testH3Index.c

@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "constants.h"
 #include "h3Index.h"
 #include "test.h"
@@ -109,12 +110,41 @@ SUITE(h3Index) {
         for (int i = 0; i <= 0xf; i++) {
             H3Index h = H3_INIT;
             H3_SET_MODE(h, i);
-            char failureMessage[BUFF_SIZE];
-            sprintf(failureMessage, "h3IsValid failed on mode %d", i);
-            t_assert(!H3_EXPORT(h3IsValid)(h) || i == 1, failureMessage);
+            if (i == H3_HEXAGON_MODE) {
+                t_assert(H3_EXPORT(h3IsValid)(h),
+                         "h3IsValid succeeds on valid mode");
+            } else {
+                char failureMessage[BUFF_SIZE];
+                sprintf(failureMessage, "h3IsValid failed on mode %d", i);
+                t_assert(!H3_EXPORT(h3IsValid)(h), failureMessage);
+            }
         }
     }
 
+    TEST(h3IsValidReservedBits) {
+        for (int i = 0; i < 8; i++) {
+            H3Index h = H3_INIT;
+            H3_SET_MODE(h, H3_HEXAGON_MODE);
+            H3_SET_RESERVED_BITS(h, i);
+            if (i == 0) {
+                t_assert(H3_EXPORT(h3IsValid)(h),
+                         "h3IsValid succeeds on valid reserved bits");
+            } else {
+                char failureMessage[BUFF_SIZE];
+                sprintf(failureMessage, "h3IsValid failed on reserved bits %d",
+                        i);
+                t_assert(!H3_EXPORT(h3IsValid)(h), failureMessage);
+            }
+        }
+    }
+
+    TEST(h3IsValidHighBit) {
+        H3Index h = H3_INIT;
+        H3_SET_MODE(h, H3_HEXAGON_MODE);
+        H3_SET_HIGH_BIT(h, 1);
+        t_assert(!H3_EXPORT(h3IsValid)(h), "h3IsValid failed on high bit");
+    }
+
     TEST(h3BadDigitInvalid) {
         H3Index h = H3_INIT;
         // By default the first index digit is out of range.

data/ext/h3/src/src/apps/testapps/testH3Line.c

@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"

data/ext/h3/src/src/apps/testapps/testH3LineExhaustive.c

@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"

data/ext/h3/src/src/apps/testapps/testH3Memory.c

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2020 Uber Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** @file
+ * @brief tests main H3 core library memory management.
+ *
+ *  usage: `testH3Memory`
+ */
+
+#include <math.h>
+#include <string.h>
+
+#include "geoCoord.h"
+#include "h3Index.h"
+#include "h3api.h"
+#include "test.h"
+#include "utility.h"
+
+// Whether to fail all allocations
+static bool failAlloc = false;
+// Actual number of malloc/calloc/realloc calls observed
+static int actualAllocCalls = 0;
+// Actual number of free calls observed
+static int actualFreeCalls = 0;
+// Set to non-zero to begin failing allocations after a certain number of calls
+static int permittedAllocCalls = 0;
+
+void resetMemoryCounters(int permitted) {
+    failAlloc = false;
+    actualAllocCalls = 0;
+    actualFreeCalls = 0;
+    permittedAllocCalls = permitted;
+}
+
+void* test_prefix_malloc(size_t size) {
+    actualAllocCalls++;
+    if (permittedAllocCalls && actualAllocCalls > permittedAllocCalls) {
+        failAlloc = true;
+    }
+    if (failAlloc) {
+        return NULL;
+    }
+    return malloc(size);
+}
+
+void* test_prefix_calloc(size_t num, size_t size) {
+    actualAllocCalls++;
+    if (permittedAllocCalls && actualAllocCalls > permittedAllocCalls) {
+        failAlloc = true;
+    }
+    if (failAlloc) {
+        return NULL;
+    }
+    return calloc(num, size);
+}
+
+void* test_prefix_realloc(void* ptr, size_t size) {
+    actualAllocCalls++;
+    if (permittedAllocCalls && actualAllocCalls > permittedAllocCalls) {
+        failAlloc = true;
+    }
+    if (failAlloc) {
+        return NULL;
+    }
+    return realloc(ptr, size);
+}
+
+void test_prefix_free(void* ptr) {
+    actualFreeCalls++;
+    return free(ptr);
+}
+
+H3Index sunnyvale = 0x89283470c27ffff;
+H3Index pentagon = 0x89080000003ffff;
+
+SUITE(h3Memory) {
+    TEST(kRing) {
+        int k = 2;
+        int hexCount = H3_EXPORT(maxKringSize)(k);
+        H3Index* kRingOutput = calloc(hexCount, sizeof(H3Index));
+
+        resetMemoryCounters(0);
+        H3_EXPORT(kRing)(sunnyvale, k, kRingOutput);
+        t_assert(actualAllocCalls == 0, "kRing did not call alloc");
+        t_assert(actualFreeCalls == 0, "kRing did not call free");
+
+        resetMemoryCounters(0);
+        H3_EXPORT(kRing)(pentagon, k, kRingOutput);
+        t_assert(actualAllocCalls == 1, "kRing called alloc");
+        t_assert(actualFreeCalls == 1, "kRing called free");
+
+        resetMemoryCounters(0);
+        failAlloc = true;
+        memset(kRingOutput, 0, hexCount * sizeof(H3Index));
+        H3_EXPORT(kRing)(pentagon, k, kRingOutput);
+        t_assert(actualAllocCalls == 1, "kRing called alloc");
+        t_assert(actualFreeCalls == 0, "kRing did not call free");
+
+        for (int i = 0; i < hexCount; i++) {
+            t_assert(!kRingOutput[i],
+                     "kRing did not produce output without alloc");
+        }
+
+        free(kRingOutput);
+    }
+
+    TEST(compact) {
+        int k = 9;
+        int hexCount = H3_EXPORT(maxKringSize)(k);
+        int expectedCompactCount = 73;
+
+        // Generate a set of hexagons to compact
+        H3Index* sunnyvaleExpanded = calloc(hexCount, sizeof(H3Index));
+        resetMemoryCounters(0);
+        H3_EXPORT(kRing)(sunnyvale, k, sunnyvaleExpanded);
+        t_assert(actualAllocCalls == 0, "kRing did not call alloc");
+        t_assert(actualFreeCalls == 0, "kRing did not call free");
+
+        H3Index* compressed = calloc(hexCount, sizeof(H3Index));
+
+        resetMemoryCounters(0);
+        failAlloc = true;
+        int err = H3_EXPORT(compact)(sunnyvaleExpanded, compressed, hexCount);
+        t_assert(err == COMPACT_ALLOC_FAILED, "malloc failed (1)");
+        t_assert(actualAllocCalls == 1, "alloc called once");
+        t_assert(actualFreeCalls == 0, "free not called");
+
+        resetMemoryCounters(1);
+        err = H3_EXPORT(compact)(sunnyvaleExpanded, compressed, hexCount);
+        t_assert(err == COMPACT_ALLOC_FAILED, "malloc failed (2)");
+        t_assert(actualAllocCalls == 2, "alloc called twice");
+        t_assert(actualFreeCalls == 1, "free called once");
+
+        resetMemoryCounters(2);
+        err = H3_EXPORT(compact)(sunnyvaleExpanded, compressed, hexCount);
+        t_assert(err == COMPACT_ALLOC_FAILED, "malloc failed (3)");
+        t_assert(actualAllocCalls == 3, "alloc called three times");
+        t_assert(actualFreeCalls == 2, "free called twice");
+
+        resetMemoryCounters(3);
+        err = H3_EXPORT(compact)(sunnyvaleExpanded, compressed, hexCount);
+        t_assert(err == COMPACT_ALLOC_FAILED, "compact failed (4)");
+        t_assert(actualAllocCalls == 4, "alloc called four times");
+        t_assert(actualFreeCalls == 3, "free called three times");
+
+        resetMemoryCounters(4);
+        err = H3_EXPORT(compact)(sunnyvaleExpanded, compressed, hexCount);
+        t_assert(err == COMPACT_SUCCESS, "compact using successful malloc");
+        t_assert(actualAllocCalls == 4, "alloc called four times");
+        t_assert(actualFreeCalls == 4, "free called four times");
+
+        int count = 0;
+        for (int i = 0; i < hexCount; i++) {
+            if (compressed[i] != 0) {
+                count++;
+            }
+        }
+        t_assert(count == expectedCompactCount, "got expected compacted count");
+
+        free(compressed);
+        free(sunnyvaleExpanded);
+    }
+}

data/ext/h3/src/src/apps/testapps/testH3NeighborRotations.c

@@ -29,6 +29,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "h3Index.h"

data/ext/h3/src/src/apps/testapps/testH3SetToLinkedGeo.c

@@ -15,6 +15,7 @@
  */
 
 #include <stdio.h>
+
 #include "algos.h"
 #include "test.h"
 #include "utility.h"

data/ext/h3/src/src/apps/testapps/testH3SetToVertexGraph.c

@@ -15,6 +15,7 @@
  */
 
 #include <stdio.h>
+
 #include "algos.h"
 #include "test.h"
 #include "utility.h"

data/ext/h3/src/src/apps/testapps/testH3ToCenterChild.c

@@ -16,6 +16,7 @@
 
 #include <inttypes.h>
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

data/ext/h3/src/src/apps/testapps/testH3ToChildren.c

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

data/ext/h3/src/src/apps/testapps/testH3ToGeo.c

@@ -26,6 +26,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3Index.h"

data/ext/h3/src/src/apps/testapps/testH3ToGeoBoundary.c

@@ -27,6 +27,7 @@
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "baseCells.h"
 #include "geoCoord.h"
 #include "h3Index.h"

data/ext/h3/src/src/apps/testapps/testH3ToLocalIj.c

@@ -23,6 +23,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"
@@ -86,17 +87,22 @@ SUITE(h3ToLocalIj) {
     }
 
     TEST(ijOutOfRange) {
-        const int numCoords = 5;
-        const CoordIJ coords[] = {{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}};
-        const H3Index expected[] = {0x81283ffffffffff, 0x81293ffffffffff,
-                                    0x8150bffffffffff, 0x8151bffffffffff,
-                                    H3_INVALID_INDEX};
+        const int numCoords = 7;
+        const CoordIJ coords[] = {{0, 0}, {1, 0},  {2, 0}, {3, 0},
+                                  {4, 0}, {-4, 0}, {0, 4}};
+        const H3Index expected[] = {0x81283ffffffffff,
+                                    0x81293ffffffffff,
+                                    0x8150bffffffffff,
+                                    0x8151bffffffffff,
+                                    H3_NULL,
+                                    H3_NULL,
+                                    H3_NULL};
 
         for (int i = 0; i < numCoords; i++) {
             H3Index result;
             const int err = H3_EXPORT(experimentalLocalIjToH3)(
                 expected[0], &coords[i], &result);
-            if (expected[i] == H3_INVALID_INDEX) {
+            if (expected[i] == H3_NULL) {
                 t_assert(err != 0, "coordinates out of range");
             } else {
                 t_assert(err == 0, "coordinates in range");

data/ext/h3/src/src/apps/testapps/testH3ToLocalIjExhaustive.c

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"

data/ext/h3/src/src/apps/testapps/testH3ToParent.c

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

data/ext/h3/src/src/apps/testapps/testH3UniEdge.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 Uber Technologies, Inc.
+ * Copyright 2017-2020 Uber Technologies, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,10 +20,12 @@
  */
 
 #include <stdlib.h>
+
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3Index.h"
 #include "test.h"
+#include "utility.h"
 
 // Fixtures
 static GeoCoord sfGeo = {0.659966917655, -2.1364398519396};
@@ -123,13 +125,31 @@ SUITE(h3UniEdge) {
     }
 
     TEST(getH3UnidirectionalEdgeFromPentagon) {
+        H3Index pentagons[NUM_PENTAGONS] = {0};
+        H3Index ring[7] = {0};
         H3Index pentagon;
-        setH3Index(&pentagon, 0, 4, 0);
-        H3Index adjacent;
-        setH3Index(&adjacent, 0, 8, 0);
-
-        H3Index edge = H3_EXPORT(getH3UnidirectionalEdge)(pentagon, adjacent);
-        t_assert(edge != 0, "Produces a valid edge");
+        H3Index edge;
+
+        for (int res = 0; res < MAX_H3_RES; res++) {
+            H3_EXPORT(getPentagonIndexes)(res, pentagons);
+            for (int p = 0; p < NUM_PENTAGONS; p++) {
+                pentagon = pentagons[p];
+                H3_EXPORT(kRing)(pentagon, 1, ring);
+
+                for (int i = 0; i < 7; i++) {
+                    H3Index neighbor = ring[i];
+                    if (neighbor == pentagon || neighbor == H3_NULL) continue;
+                    edge =
+                        H3_EXPORT(getH3UnidirectionalEdge)(pentagon, neighbor);
+                    t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(edge),
+                             "pentagon-to-neighbor is a valid edge");
+                    edge =
+                        H3_EXPORT(getH3UnidirectionalEdge)(neighbor, pentagon);
+                    t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(edge),
+                             "neighbor-to-pentagon is a valid edge");
+                }
+            }
+        }
     }
 
     TEST(h3UnidirectionalEdgeIsValid) {
@@ -166,6 +186,11 @@ SUITE(h3UniEdge) {
         H3_SET_RESERVED_BITS(badPentagonalEdge, 1);
         t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(badPentagonalEdge) == 0,
                  "missing pentagonal edge does not validate");
+
+        H3Index highBitEdge = edge;
+        H3_SET_HIGH_BIT(highBitEdge, 1);
+        t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(highBitEdge) == 0,
+                 "high bit set edge does not validate");
     }
 
     TEST(getH3UnidirectionalEdgesFromHexagon) {
@@ -222,9 +247,7 @@ SUITE(h3UniEdge) {
         const int expectedVertices[][2] = {{3, 4}, {1, 2}, {2, 3},
                                            {5, 0}, {4, 5}, {0, 1}};
 
-        // TODO: The current implementation relies on lat/lon comparison and
-        // fails on resolutions finer than 12
-        for (int res = 0; res < 13; res++) {
+        for (int res = 0; res < MAX_H3_RES; res++) {
             sf = H3_EXPORT(geoToH3)(&sfGeo, res);
             H3_EXPORT(h3ToGeoBoundary)(sf, &boundary);
             H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(sf, edges);
@@ -253,9 +276,7 @@ SUITE(h3UniEdge) {
         const int expectedVertices[][3] = {{-1, -1, -1}, {2, 3, 4}, {4, 5, 6},
                                            {8, 9, 0},    {6, 7, 8}, {0, 1, 2}};
 
-        // TODO: The current implementation relies on lat/lon comparison and
-        // fails on resolutions finer than 12
-        for (int res = 1; res < 13; res += 2) {
+        for (int res = 1; res < MAX_H3_RES; res += 2) {
             setH3Index(&pentagon, res, 24, 0);
             H3_EXPORT(h3ToGeoBoundary)(pentagon, &boundary);
             H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(pentagon, edges);
@@ -293,9 +314,7 @@ SUITE(h3UniEdge) {
         const int expectedVertices[][3] = {{-1, -1}, {1, 2}, {2, 3},
                                            {4, 0},   {3, 4}, {0, 1}};
 
-        // TODO: The current implementation relies on lat/lon comparison and
-        // fails on resolutions finer than 12
-        for (int res = 0; res < 12; res += 2) {
+        for (int res = 0; res < MAX_H3_RES; res += 2) {
             setH3Index(&pentagon, res, 24, 0);
             H3_EXPORT(h3ToGeoBoundary)(pentagon, &boundary);
             H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(pentagon, edges);
@@ -323,4 +342,14 @@ SUITE(h3UniEdge) {
                      "Only one edge was deleted for the pentagon");
         }
     }
+
+    TEST(exactEdgeLength_invalid) {
+        // Test that invalid inputs do not cause crashes.
+        t_assert(H3_EXPORT(exactEdgeLengthRads)(0) == 0,
+                 "Invalid edge has zero length");
+        GeoCoord zero = {0, 0};
+        H3Index h3 = H3_EXPORT(geoToH3)(&zero, 0);
+        t_assert(H3_EXPORT(exactEdgeLengthRads)(h3) == 0,
+                 "Non-edge (cell) has zero edge length");
+    }
 }