geoip2_c 0.3.0 → 0.3.1

data/ext/geoip2/libmaxminddb/t/get_value_t.c

@@ -0,0 +1,249 @@
+#include "maxminddb_test_helper.h"
+
+void test_array_0_result(int status, MMDB_entry_data_s entry_data,
+                         char *function)
+{
+    cmp_ok(status, "==", MMDB_SUCCESS,
+           "status for %s() is MMDB_SUCCESS - array[0]", function);
+    ok(entry_data.has_data, "found a value for array[0]");
+    cmp_ok(entry_data.type, "==", MMDB_DATA_TYPE_UINT32,
+           "returned entry type is uint32 - array[0]");
+    cmp_ok(entry_data.uint32, "==", 1, "entry value is 1 - array[0]");
+}
+
+void test_array_2_result(int status, MMDB_entry_data_s entry_data,
+                         char *function)
+{
+    cmp_ok(status, "==", MMDB_SUCCESS,
+           "status for %s() is MMDB_SUCCESS - array[2]", function);
+    ok(entry_data.has_data, "found a value for array[2]");
+    cmp_ok(entry_data.type, "==", MMDB_DATA_TYPE_UINT32,
+           "returned entry type is uint32 - array[2]");
+    cmp_ok(entry_data.uint32, "==", 3, "entry value is 3 - array[2]");
+}
+
+int call_vget_value(MMDB_entry_s *entry, MMDB_entry_data_s *entry_data, ...)
+{
+    va_list keys;
+    va_start(keys, entry_data);
+
+    int status = MMDB_vget_value(entry, entry_data, keys);
+
+    va_end(keys);
+
+    return status;
+}
+
+void test_simple_structure(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-decoder.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const char *ip = "1.1.1.1";
+    MMDB_lookup_result_s result =
+        lookup_string_ok(mmdb, ip, filename, mode_desc);
+
+    {
+        MMDB_entry_data_s entry_data;
+        const char *lookup_path[] = { "array", "0", NULL };
+        int status = MMDB_aget_value(&result.entry, &entry_data, lookup_path);
+        test_array_0_result(status, entry_data, "MMDB_aget_value");
+
+        status = MMDB_get_value(&result.entry, &entry_data, "array", "0", NULL);
+        test_array_0_result(status, entry_data, "MMDB_get_value");
+
+        status =
+            call_vget_value(&result.entry, &entry_data, "array", "0", NULL);
+        test_array_0_result(status, entry_data, "MMDB_vget_value");
+    }
+
+    {
+        MMDB_entry_data_s entry_data;
+        const char *lookup_path[] = { "array", "2", NULL };
+        int status = MMDB_aget_value(&result.entry, &entry_data, lookup_path);
+        test_array_2_result(status, entry_data, "MMDB_aget_value");
+
+        status = MMDB_get_value(&result.entry, &entry_data, "array", "2", NULL);
+        test_array_2_result(status, entry_data, "MMDB_get_value");
+
+        status =
+            call_vget_value(&result.entry, &entry_data, "array", "2", NULL);
+        test_array_2_result(status, entry_data, "MMDB_vget_value");
+    }
+
+
+    {
+        MMDB_entry_data_s entry_data;
+        int status = MMDB_get_value(&result.entry, &entry_data, "array", "zero",
+                                    NULL);
+        cmp_ok(status, "==", MMDB_LOOKUP_PATH_DOES_NOT_MATCH_DATA_ERROR,
+               "MMDB_get_value() returns error on non-integer array index");
+    }
+
+    {
+        MMDB_entry_data_s entry_data;
+        int status = MMDB_get_value(&result.entry, &entry_data, "array", "-1",
+                                    NULL);
+        cmp_ok(status, "==", MMDB_INVALID_LOOKUP_PATH_ERROR,
+               "MMDB_get_value() returns error on negative integer");
+    }
+
+    {
+        MMDB_entry_data_s entry_data;
+        int status =
+            MMDB_get_value(&result.entry, &entry_data, "array",
+                           "18446744073709551616",
+                           NULL);
+        cmp_ok(status, "==", MMDB_INVALID_LOOKUP_PATH_ERROR,
+               "MMDB_get_value() returns error on integer larger than LONG_MAX");
+    }
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+void test_complex_map_a_result(int status, MMDB_entry_data_s entry_data,
+                               char *function)
+{
+    cmp_ok(status, "==", MMDB_SUCCESS,
+           "status for %s() is MMDB_SUCCESS - map1{map2}{array}[0]{map3}{a}",
+           function);
+    ok(entry_data.has_data,
+       "found a value for map1{map2}{array}[0]{map3}{a}");
+    cmp_ok(entry_data.type, "==", MMDB_DATA_TYPE_UINT32,
+           "returned entry type is uint32 - map1{map2}{array}[0]{map3}{a}");
+    cmp_ok(entry_data.uint32, "==", 1,
+           "entry value is 1 - map1{map2}{array}[0]{map3}{a}");
+}
+
+void test_complex_map_c_result(int status, MMDB_entry_data_s entry_data,
+                               char *function)
+{
+    cmp_ok(
+        status, "==", MMDB_SUCCESS,
+        "status for %s() is MMDB_SUCCESS - map1{map2}{array}[0]{map3}{c}",
+        function);
+    ok(entry_data.has_data,
+       "found a value for map1{map2}{array}[0]{map3}{c}");
+    cmp_ok(entry_data.type, "==", MMDB_DATA_TYPE_UINT32,
+           "returned entry type is uint32 - map1{map2}{array}[0]{map3}{c}");
+    cmp_ok(entry_data.uint32, "==", 3,
+           "entry value is 3 - map1{map2}{array}[0]{map3}{c}");
+}
+
+void test_no_result(int status, MMDB_entry_data_s entry_data, char *function,
+                    char *path_description)
+{
+    cmp_ok(status, "==", MMDB_LOOKUP_PATH_DOES_NOT_MATCH_DATA_ERROR,
+           "status for %s() is MMDB_LOOKUP_PATH_DOES_NOT_MATCH_DATA_ERROR - %s",
+           function, path_description);
+    ok(!entry_data.has_data, "did not find a value for %s", path_description);
+}
+
+void test_nested_structure(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-nested.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const char *ip = "1.1.1.1";
+    MMDB_lookup_result_s result =
+        lookup_string_ok(mmdb, ip, filename, mode_desc);
+
+    {
+        MMDB_entry_data_s entry_data;
+        const char *lookup_path[] =
+        { "map1", "map2", "array", "0", "map3", "a", NULL };
+        int status = MMDB_aget_value(&result.entry, &entry_data, lookup_path);
+        test_complex_map_a_result(status, entry_data, "MMDB_aget_value");
+
+        status = MMDB_get_value(&result.entry, &entry_data,
+                                "map1", "map2", "array", "0", "map3", "a",
+                                NULL);
+        test_complex_map_a_result(status, entry_data, "MMDB_get_value");
+
+        status = call_vget_value(&result.entry, &entry_data,
+                                 "map1", "map2", "array", "0", "map3", "a",
+                                 NULL);
+        test_complex_map_a_result(status, entry_data, "MMDB_vget_value");
+    }
+
+    {
+        MMDB_entry_data_s entry_data;
+        const char *lookup_path[] =
+        { "map1", "map2", "array", "0", "map3", "c", NULL };
+        int status = MMDB_aget_value(&result.entry, &entry_data, lookup_path);
+        test_complex_map_c_result(status, entry_data, "MMDB_aget_value");
+
+        status = MMDB_get_value(&result.entry, &entry_data,
+                                "map1", "map2", "array", "0", "map3", "c",
+                                NULL);
+        test_complex_map_c_result(status, entry_data, "MMDB_get_value");
+
+        status = call_vget_value(&result.entry, &entry_data,
+                                 "map1", "map2", "array", "0", "map3", "c",
+                                 NULL);
+        test_complex_map_c_result(status, entry_data, "MMDB_vget_value");
+    }
+
+    {
+        MMDB_entry_data_s entry_data;
+        const char *lookup_path[] =
+        { "map1", "map42", "array", "0", "map3", "c", NULL };
+        int status = MMDB_aget_value(&result.entry, &entry_data, lookup_path);
+        test_no_result(status, entry_data, "MMDB_aget_value",
+                       "map1{map42}{array}[0]{map3}{c}");
+
+        status = MMDB_get_value(&result.entry, &entry_data,
+                                "map1", "map42", "array", "0", "map3", "c",
+                                NULL);
+        test_no_result(status, entry_data, "MMDB_get_value",
+                       "map1{map42}{array}[0]{map3}{c}");
+
+        status = call_vget_value(&result.entry, &entry_data,
+                                 "map1", "map42", "array", "0", "map3", "c",
+                                 NULL);
+        test_no_result(status, entry_data, "MMDB_vget_value",
+                       "map1{map42}{array}[0]{map3}{c}");
+    }
+
+    {
+        MMDB_entry_data_s entry_data;
+        const char *lookup_path[] =
+        { "map1", "map2", "array", "9", "map3", "c", NULL };
+        int status = MMDB_aget_value(&result.entry, &entry_data, lookup_path);
+        test_no_result(status, entry_data, "MMDB_aget_value",
+                       "map1{map42}{array}[9]{map3}{c}");
+
+        status = MMDB_get_value(&result.entry, &entry_data,
+                                "map1", "map2", "array", "9", "map3", "c",
+                                NULL);
+        test_no_result(status, entry_data, "MMDB_get_value",
+                       "map1{map42}{array}[9]{map3}{c}");
+
+        status = call_vget_value(&result.entry, &entry_data,
+                                 "map1", "map2", "array", "9", "map3", "c",
+                                 NULL);
+        test_no_result(status, entry_data, "MMDB_vget_value",
+                       "map1{map42}{array}[9]{map3}{c}");
+    }
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+void run_tests(int mode, const char *mode_desc)
+{
+    test_simple_structure(mode, mode_desc);
+    test_nested_structure(mode, mode_desc);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}

data/ext/geoip2/libmaxminddb/t/ipv4_start_cache_t.c

@@ -0,0 +1,36 @@
+#include "maxminddb_test_helper.h"
+
+void test_one_ip(MMDB_s *mmdb, const char *ip, const char *filename,
+                 const char *mode_desc)
+{
+    MMDB_lookup_result_s result =
+        lookup_string_ok(mmdb, ip, filename, mode_desc);
+
+    ok(
+        result.found_entry,
+        "got a result for an IPv4 address included in a larger-than-IPv4 subnet - %s - %s",
+        ip, mode_desc);
+
+    data_ok(&result, MMDB_DATA_TYPE_UTF8_STRING, "string value for IP", NULL);
+}
+
+void run_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-no-ipv4-search-tree.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    test_one_ip(mmdb, "1.1.1.1", filename, mode_desc);
+    test_one_ip(mmdb, "255.255.255.255", filename, mode_desc);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}

data/ext/geoip2/libmaxminddb/t/ipv6_lookup_in_ipv4_t.c

@@ -0,0 +1,48 @@
+#include "maxminddb_test_helper.h"
+
+void run_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-ipv4-28.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const char *ip = "::abcd";
+    int gai_error, mmdb_error;
+    MMDB_lookup_result_s UNUSED(result) =
+        MMDB_lookup_string(mmdb, ip, &gai_error, &mmdb_error);
+
+    cmp_ok(
+        mmdb_error, "==", MMDB_IPV6_LOOKUP_IN_IPV4_DATABASE_ERROR,
+        "MMDB_lookup_string sets mmdb_error to MMDB_IPV6_LOOKUP_IN_IPV4_DATABASE_ERROR when we try to look up an IPv6 address in an IPv4-only database");
+
+    struct addrinfo hints = {
+        .ai_family = AF_INET6,
+        .ai_flags  = AI_NUMERICHOST
+    };
+
+    struct addrinfo *addresses;
+    gai_error = getaddrinfo("2001:db8:85a3:0:0:8a2e:370:7334", NULL,
+                            &hints, &addresses);
+    if (gai_error) {
+        BAIL_OUT("getaddrinfo failed: %s", gai_strerror(gai_error));
+    }
+
+    mmdb_error = 0;
+    MMDB_lookup_sockaddr(mmdb, addresses->ai_addr, &mmdb_error);
+
+    cmp_ok(
+        mmdb_error, "==", MMDB_IPV6_LOOKUP_IN_IPV4_DATABASE_ERROR,
+        "MMDB_lookup_sockaddr sets mmdb_error to MMDB_IPV6_LOOKUP_IN_IPV4_DATABASE_ERROR when we try to look up an IPv6 address in an IPv4-only database");
+
+    freeaddrinfo(addresses);
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}

data/ext/geoip2/libmaxminddb/t/maxminddb_test_helper.c

@@ -0,0 +1,255 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _POSIX_C_SOURCE 200112L
+#include <assert.h>
+#include <stdarg.h>
+#include <sys/types.h>
+
+#include "maxminddb.h"
+#include "maxminddb_test_helper.h"
+
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <libgen.h>
+#include <unistd.h>
+#endif
+
+#define NO_PROTO
+
+#ifndef strndup
+/* *INDENT-OFF* */
+/* Copied from the libiberty strndup.c, which is LPGPL 2+ */
+NO_PROTO char *strndup (const char *s, size_t n)
+{
+  char *result;
+  size_t len = strlen (s);
+
+  if (n < len)
+    len = n;
+
+  result = (char *) malloc (len + 1);
+  if (!result)
+    return 0;
+
+  result[len] = '\0';
+  return (char *) memcpy (result, s, len);
+}
+/* *INDENT-ON* */
+#endif
+
+void for_all_record_sizes(const char *filename_fmt,
+                          void (*tests)(int record_size, const char *filename,
+                                        const char *description))
+{
+    int sizes[] = { 24, 28, 32 };
+    for (int i = 0; i < 3; i++) {
+        int size = sizes[i];
+
+        char filename[500];
+        snprintf(filename, 500, filename_fmt, size);
+
+        char description[14];
+        snprintf(description, 14, "%i bit record", size);
+
+        tests(size, filename, description);
+    }
+}
+
+void for_all_modes(void (*tests)(int mode, const char *description))
+{
+    tests(MMDB_MODE_MMAP, "mmap mode");
+}
+
+const char *test_database_path(const char *filename)
+{
+    char cwd[500];
+    char *UNUSED(tmp) = getcwd(cwd, 500);
+
+    char *test_db_dir;
+#ifdef _WIN32
+    test_db_dir = "./t/maxmind-db/test-data";
+#else
+    if (strcmp(basename(cwd), "t") == 0) {
+        test_db_dir = "./maxmind-db/test-data";
+    } else {
+        test_db_dir = "./t/maxmind-db/test-data";
+    }
+#endif
+
+    char *path = malloc(500);
+    assert(NULL != path);
+
+    snprintf(path, 500, "%s/%s", test_db_dir, filename);
+
+    return (const char *)path;
+}
+
+const char *dup_entry_string_or_bail(MMDB_entry_data_s entry_data)
+{
+    const char *string = strndup(entry_data.utf8_string, entry_data.data_size);
+    if (NULL == string) {
+        BAIL_OUT("strndup failed");
+    }
+
+    return string;
+}
+
+MMDB_s *open_ok(const char *db_file, int mode, const char *mode_desc)
+{
+    if (0 != access(db_file, R_OK)) {
+        BAIL_OUT(
+            "could not read the specified file - %s\nIf you are in a git checkout try running 'git submodule update --init'",
+            db_file);
+    }
+
+    MMDB_s *mmdb = (MMDB_s *)calloc(1, sizeof(MMDB_s));
+
+    if (NULL == mmdb) {
+        BAIL_OUT("could not allocate memory for our MMDB_s struct");
+    }
+
+    int status = MMDB_open(db_file, mode, mmdb);
+
+    int is_ok = ok(MMDB_SUCCESS == status, "open %s status is success - %s",
+                   db_file, mode_desc);
+
+    if (!is_ok) {
+        diag("open status code = %d (%s)", status, MMDB_strerror(status));
+        free(mmdb);
+        return NULL;
+    }
+
+    is_ok = ok(mmdb->file_size > 0,
+               "mmdb struct has been set for %s - %s",
+               db_file, mode_desc);
+
+    if (!is_ok) {
+        free(mmdb);
+        return NULL;
+    }
+
+    return mmdb;
+}
+
+MMDB_lookup_result_s lookup_string_ok(MMDB_s *mmdb, const char *ip,
+                                      const char *file, const char *mode_desc)
+{
+    int gai_error, mmdb_error;
+    MMDB_lookup_result_s result =
+        MMDB_lookup_string(mmdb, ip, &gai_error, &mmdb_error);
+
+    test_lookup_errors(gai_error, mmdb_error, "MMDB_lookup_string", ip, file,
+                       mode_desc);
+
+    return result;
+}
+
+MMDB_lookup_result_s lookup_sockaddr_ok(MMDB_s *mmdb, const char *ip,
+                                        const char *file, const char *mode_desc)
+{
+    int ai_flags = AI_NUMERICHOST;
+    struct addrinfo hints = {
+        .ai_socktype = SOCK_STREAM
+    };
+    struct addrinfo *addresses = NULL;
+
+    if (ip[0] == ':') {
+        hints.ai_flags = ai_flags;
+#if defined AI_V4MAPPED && !defined __FreeBSD__
+        hints.ai_flags |= AI_V4MAPPED;
+#endif
+        hints.ai_family = AF_INET6;
+    } else {
+        hints.ai_flags = ai_flags;
+        hints.ai_family = AF_INET;
+    }
+
+    int gai_error = getaddrinfo(ip, NULL, &hints, &addresses);
+
+    int mmdb_error = 0;
+    MMDB_lookup_result_s result = { .found_entry = false };
+    if (gai_error == 0) {
+        result = MMDB_lookup_sockaddr(mmdb, addresses->ai_addr, &mmdb_error);
+    }
+    if (NULL != addresses) {
+        freeaddrinfo(addresses);
+    }
+
+    test_lookup_errors(gai_error, mmdb_error, "MMDB_lookup_sockaddr", ip, file,
+                       mode_desc);
+
+    return result;
+}
+
+void test_lookup_errors(int gai_error, int mmdb_error,
+                        const char *function, const char *ip,
+                        const char *file, const char *mode_desc)
+{
+
+    int is_ok = ok(0 == gai_error,
+                   "no getaddrinfo error in call to %s for %s - %s - %s",
+                   function, ip, file, mode_desc);
+
+    if (!is_ok) {
+        diag("error from call to getaddrinfo for %s - %s",
+             ip, gai_strerror(gai_error));
+    }
+
+    is_ok = ok(0 == mmdb_error,
+               "no MMDB error in call to %s for %s - %s - %s",
+               function, ip, file, mode_desc);
+
+    if (!is_ok) {
+        diag("MMDB error - %s", MMDB_strerror(mmdb_error));
+    }
+}
+
+MMDB_entry_data_s data_ok(MMDB_lookup_result_s *result, uint32_t expect_type,
+                          const char *description, ...)
+{
+    va_list keys;
+    va_start(keys, description);
+
+    MMDB_entry_data_s data;
+    int status = MMDB_vget_value(&result->entry, &data, keys);
+
+    va_end(keys);
+
+    if (cmp_ok(status, "==", MMDB_SUCCESS,
+               "no error from call to MMDB_vget_value - %s", description)) {
+
+        if (!cmp_ok(data.type, "==", expect_type,
+                    "got the expected data type - %s", description)) {
+
+            diag("  data type value is %i but expected %i", data.type,
+                 expect_type);
+        }
+    } else {
+        diag("  error from MMDB_vget_value - %s", MMDB_strerror(status));
+    }
+
+    return data;
+}
+
+void compare_double(double got, double expect)
+{
+    double diff = fabs(got - expect);
+    int is_ok = ok(diff < 0.01, "double value was approximately %2.6f", expect);
+    if (!is_ok) {
+        diag("  got %2.6f but expected %2.6f (diff = %2.6f)",
+             got, expect, diff);
+    }
+}
+
+void compare_float(float got, float expect)
+{
+    float diff = fabsf(got - expect);
+    int is_ok = ok(diff < 0.01, "float value was approximately %2.1f", expect);
+    if (!is_ok) {
+        diag("  got %2.4f but expected %2.1f (diff = %2.1f)",
+             got, expect, diff);
+    }
+}

data/ext/geoip2/libmaxminddb/t/maxminddb_test_helper.h

@@ -0,0 +1,69 @@
+/* Some test files may require something newer */
+#if !defined(_GNU_SOURCE) && !defined(_POSIX_C_SOURCE)
+#define _POSIX_C_SOURCE 200112L
+#endif
+
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include "maxminddb.h"
+#include "libtap/tap.h"
+
+#ifdef _WIN32
+#include <Winsock2.h>
+#include <ws2tcpip.h>
+
+#define R_OK 4
+
+#else
+#include <netdb.h>
+#endif
+
+#if (_MSC_VER && _MSC_VER < 1900)
+/* _snprintf has security issues, but I don't think it is worth
+   worrying about for the unit tests. */
+#define snprintf _snprintf
+#endif
+
+#ifndef MMDB_TEST_HELPER_C
+#define MMDB_TEST_HELPER_C (1)
+
+#ifdef __GNUC__
+#  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
+#else
+#  define UNUSED
+#endif
+
+#define MAX_DESCRIPTION_LENGTH 500
+
+#ifndef strndup
+extern char *strndup(const char *s, size_t n);
+#endif
+
+    /* *INDENT-OFF* */
+    /* --prototypes automatically generated by dev-bin/regen-prototypes.pl - don't remove this comment */
+    extern void for_all_record_sizes(const char *filename_fmt,
+                                     void (*tests)(int record_size, const char *filename,
+                                                   const char *description));
+    extern void for_all_modes(void (*tests)(int mode, const char *description));
+    extern const char *test_database_path(const char *filename);
+    extern const char *dup_entry_string_or_bail(MMDB_entry_data_s entry_data);
+    extern MMDB_s *open_ok(const char *db_file, int mode, const char *mode_desc);
+    extern MMDB_lookup_result_s lookup_string_ok(MMDB_s *mmdb, const char *ip,
+                                                 const char *file, const char *mode_desc);
+    extern MMDB_lookup_result_s lookup_sockaddr_ok(MMDB_s *mmdb, const char *ip,
+                                                   const char *file, const char *mode_desc);
+    extern void test_lookup_errors(int gai_error, int mmdb_error,
+                                   const char *function, const char *ip,
+                                   const char *file, const char *mode_desc);
+    extern MMDB_entry_data_s data_ok(MMDB_lookup_result_s *result, uint32_t expect_type,
+                                     const char *description, ...);
+    extern void compare_double(double got, double expect);
+    extern void compare_float(float got, float expect);
+    /* --prototypes end - don't remove this comment-- */
+    /* *INDENT-ON* */
+
+#endif

data/ext/geoip2/libmaxminddb/t/metadata_pointers_t.c

@@ -0,0 +1,32 @@
+#include "maxminddb_test_helper.h"
+
+void run_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-metadata-pointers.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    char *repeated_string = "Lots of pointers in metadata";
+
+    is(mmdb->metadata.database_type, repeated_string,
+       "decoded pointer database_type");
+
+    for (uint16_t i = 0; i < mmdb->metadata.description.count; i++) {
+        const char *language =
+            mmdb->metadata.description.descriptions[i]->language;
+        const char *description =
+            mmdb->metadata.description.descriptions[i]->description;
+        is(description, repeated_string, "%s description", language);
+    }
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}