h3 3.5.0 → 3.7.1

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 Uber Technologies, Inc.
+ * Copyright 2018-2019 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.
@@ -22,96 +22,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"
 #include "test.h"
 #include "utility.h"
 
-static const int MAX_DISTANCES[] = {1, 2, 5, 12, 19, 26};
-
-/**
- * Property-based testing of h3Line output
- */
-static void h3Line_assertions(H3Index start, H3Index end) {
-    int sz = H3_EXPORT(h3LineSize)(start, end);
-    t_assert(sz > 0, "got valid size");
-    H3Index *line = calloc(sz, sizeof(H3Index));
-
-    int err = H3_EXPORT(h3Line)(start, end, line);
-
-    t_assert(err == 0, "no error on line");
-    t_assert(line[0] == start, "line starts with start index");
-    t_assert(line[sz - 1] == end, "line ends with end index");
-
-    for (int i = 1; i < sz; i++) {
-        t_assert(H3_EXPORT(h3IsValid)(line[i]), "index is valid");
-        t_assert(H3_EXPORT(h3IndexesAreNeighbors)(line[i], line[i - 1]),
-                 "index is a neighbor of the previous index");
-        if (i > 1) {
-            t_assert(
-                !H3_EXPORT(h3IndexesAreNeighbors)(line[i], line[i - 2]),
-                "index is not a neighbor of the index before the previous");
-        }
-    }
-
-    free(line);
-}
-
-/**
- * Tests for invalid h3Line input
- */
-static void h3Line_invalid_assertions(H3Index start, H3Index end) {
-    int sz = H3_EXPORT(h3LineSize)(start, end);
-    t_assert(sz < 0, "line size marked as invalid");
-
-    H3Index *line = {0};
-    int err = H3_EXPORT(h3Line)(start, end, line);
-    t_assert(err != 0, "line marked as invalid");
-}
-
-/**
- * Test for lines from an index to all neighbors within a kRing
- */
-static void h3Line_kRing_assertions(H3Index h3) {
-    int r = H3_GET_RESOLUTION(h3);
-    t_assert(r <= 5, "resolution supported by test function (kRing)");
-    int maxK = MAX_DISTANCES[r];
-
-    int sz = H3_EXPORT(maxKringSize)(maxK);
-
-    if (H3_EXPORT(h3IsPentagon)(h3)) {
-        return;
-    }
-
-    H3Index *neighbors = calloc(sz, sizeof(H3Index));
-    H3_EXPORT(kRing)(h3, maxK, neighbors);
-
-    for (int i = 0; i < sz; i++) {
-        if (neighbors[i] == 0) {
-            continue;
-        }
-        int distance = H3_EXPORT(h3Distance)(h3, neighbors[i]);
-        if (distance >= 0) {
-            h3Line_assertions(h3, neighbors[i]);
-        } else {
-            h3Line_invalid_assertions(h3, neighbors[i]);
-        }
-    }
-
-    free(neighbors);
-}
-
 SUITE(h3Line) {
-    TEST(h3Line_kRing) {
-        iterateAllIndexesAtRes(0, h3Line_kRing_assertions);
-        iterateAllIndexesAtRes(1, h3Line_kRing_assertions);
-        iterateAllIndexesAtRes(2, h3Line_kRing_assertions);
-        // Don't iterate all of res 3, to save time
-        iterateAllIndexesAtResPartial(3, h3Line_kRing_assertions, 6);
-        // Further resolutions aren't tested to save time.
-    }
-
     TEST(h3Line_acrossMultipleFaces) {
         H3Index start = 0x85285aa7fffffff;
         H3Index end = 0x851d9b1bfffffff;

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

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2019 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 H3 distance function using tests over a large number of indexes.
+ *
+ *  usage: `testH3Distance`
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "h3Index.h"
+#include "h3api.h"
+#include "localij.h"
+#include "test.h"
+#include "utility.h"
+
+static const int MAX_DISTANCES[] = {1, 2, 5, 12, 19, 26};
+
+/**
+ * Property-based testing of h3Line output
+ */
+static void h3Line_assertions(H3Index start, H3Index end) {
+    int sz = H3_EXPORT(h3LineSize)(start, end);
+    t_assert(sz > 0, "got valid size");
+    H3Index *line = calloc(sz, sizeof(H3Index));
+
+    int err = H3_EXPORT(h3Line)(start, end, line);
+
+    t_assert(err == 0, "no error on line");
+    t_assert(line[0] == start, "line starts with start index");
+    t_assert(line[sz - 1] == end, "line ends with end index");
+
+    for (int i = 1; i < sz; i++) {
+        t_assert(H3_EXPORT(h3IsValid)(line[i]), "index is valid");
+        t_assert(H3_EXPORT(h3IndexesAreNeighbors)(line[i], line[i - 1]),
+                 "index is a neighbor of the previous index");
+        if (i > 1) {
+            t_assert(
+                !H3_EXPORT(h3IndexesAreNeighbors)(line[i], line[i - 2]),
+                "index is not a neighbor of the index before the previous");
+        }
+    }
+
+    free(line);
+}
+
+/**
+ * Tests for invalid h3Line input
+ */
+static void h3Line_invalid_assertions(H3Index start, H3Index end) {
+    int sz = H3_EXPORT(h3LineSize)(start, end);
+    t_assert(sz < 0, "line size marked as invalid");
+
+    H3Index *line = {0};
+    int err = H3_EXPORT(h3Line)(start, end, line);
+    t_assert(err != 0, "line marked as invalid");
+}
+
+/**
+ * Test for lines from an index to all neighbors within a kRing
+ */
+static void h3Line_kRing_assertions(H3Index h3) {
+    int r = H3_GET_RESOLUTION(h3);
+    t_assert(r <= 5, "resolution supported by test function (kRing)");
+    int maxK = MAX_DISTANCES[r];
+
+    int sz = H3_EXPORT(maxKringSize)(maxK);
+
+    if (H3_EXPORT(h3IsPentagon)(h3)) {
+        return;
+    }
+
+    H3Index *neighbors = calloc(sz, sizeof(H3Index));
+    H3_EXPORT(kRing)(h3, maxK, neighbors);
+
+    for (int i = 0; i < sz; i++) {
+        if (neighbors[i] == 0) {
+            continue;
+        }
+        int distance = H3_EXPORT(h3Distance)(h3, neighbors[i]);
+        if (distance >= 0) {
+            h3Line_assertions(h3, neighbors[i]);
+        } else {
+            h3Line_invalid_assertions(h3, neighbors[i]);
+        }
+    }
+
+    free(neighbors);
+}
+
+SUITE(h3Line) {
+    TEST(h3Line_kRing) {
+        iterateAllIndexesAtRes(0, h3Line_kRing_assertions);
+        iterateAllIndexesAtRes(1, h3Line_kRing_assertions);
+        iterateAllIndexesAtRes(2, h3Line_kRing_assertions);
+        // Don't iterate all of res 3, to save time
+        iterateAllIndexesAtResPartial(3, h3Line_kRing_assertions, 6);
+        // Further resolutions aren't tested to save time.
+    }
+}

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);
+    }
+}