geoip2_c 0.3.2 → 0.3.4

data/ext/geoip2/libmaxminddb/t/data-pool-t.c

@@ -0,0 +1,374 @@
+#include <assert.h>
+#include <data-pool.h>
+#include <inttypes.h>
+#include "libtap/tap.h"
+#include <math.h>
+#include "maxminddb_test_helper.h"
+
+static void test_data_pool_new(void);
+static void test_data_pool_destroy(void);
+static void test_data_pool_alloc(void);
+static void test_data_pool_to_list(void);
+static bool create_and_check_list(size_t const,
+                                  size_t const);
+static void check_block_count(MMDB_entry_data_list_s const *const,
+                              size_t const);
+
+int main(void)
+{
+    plan(NO_PLAN);
+    test_data_pool_new();
+    test_data_pool_destroy();
+    test_data_pool_alloc();
+    test_data_pool_to_list();
+    done_testing();
+}
+
+static void test_data_pool_new(void)
+{
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(0);
+        ok(!pool, "size 0 is not valid");
+    }
+
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(SIZE_MAX - 10);
+        ok(!pool, "very large size is not valid");
+    }
+
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(512);
+        ok(pool != NULL, "size 512 is valid");
+        cmp_ok(pool->size, "==", 512, "size is 512");
+        cmp_ok(pool->used, "==", 0, "used size is 0");
+        data_pool_destroy(pool);
+    }
+}
+
+static void test_data_pool_destroy(void)
+{
+    {
+        data_pool_destroy(NULL);
+    }
+
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(512);
+        ok(pool != NULL, "created pool");
+        data_pool_destroy(pool);
+    }
+}
+
+static void test_data_pool_alloc(void)
+{
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(1);
+        ok(pool != NULL, "created pool");
+        cmp_ok(pool->used, "==", 0, "used size starts at 0");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "allocated first entry");
+        // Arbitrary so that we can recognize it.
+        entry1->entry_data.offset = (uint32_t)123;
+
+        cmp_ok(pool->size, "==", 1, "size is still 1");
+        cmp_ok(pool->used, "==", 1, "used size is 1 after taking one");
+
+        MMDB_entry_data_list_s *const entry2 = data_pool_alloc(pool);
+        ok(entry2 != NULL, "got another entry");
+        ok(entry1 != entry2, "second entry is different from first entry");
+
+        cmp_ok(pool->size, "==", 2, "size is 2 (new block)");
+        cmp_ok(pool->used, "==", 1, "used size is 1 in current block");
+
+        ok(entry1->entry_data.offset == 123,
+           "accessing the original entry's memory is ok");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        size_t const initial_size = 10;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *entry1 = NULL;
+        for (size_t i = 0; i < initial_size; i++) {
+            MMDB_entry_data_list_s *const entry = data_pool_alloc(pool);
+            ok(entry != NULL, "got an entry");
+            // Give each a unique number so we can check it.
+            entry->entry_data.offset = (uint32_t)i;
+            if (i == 0) {
+                entry1 = entry;
+            }
+        }
+
+        cmp_ok(pool->size, "==", initial_size, "size is the initial size");
+        cmp_ok(pool->used, "==", initial_size, "used size is as expected");
+
+        MMDB_entry_data_list_s *const entry = data_pool_alloc(pool);
+        ok(entry != NULL, "got an entry");
+        entry->entry_data.offset = (uint32_t)initial_size;
+
+        cmp_ok(pool->size, "==", initial_size * 2,
+               "size is the initial size*2");
+        cmp_ok(pool->used, "==", 1, "used size is as expected");
+
+        MMDB_entry_data_list_s *const list = data_pool_to_list(pool);
+
+        MMDB_entry_data_list_s *element = list;
+        for (size_t i = 0; i < initial_size + 1; i++) {
+            ok(
+                element->entry_data.offset == (uint32_t)i,
+                "found offset %" PRIu32 ", should have %zu",
+                element->entry_data.offset,
+                i
+                );
+            element = element->next;
+        }
+
+        ok(entry1->entry_data.offset == (uint32_t)0,
+           "accessing entry1's original memory is ok after growing the pool");
+
+        data_pool_destroy(pool);
+    }
+}
+
+static void test_data_pool_to_list(void)
+{
+    {
+        size_t const initial_size = 16;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "got an entry");
+
+        MMDB_entry_data_list_s *const list_one_element
+            = data_pool_to_list(pool);
+        ok(list_one_element != NULL, "got a list");
+        ok(list_one_element == entry1,
+           "list's first element is the first we retrieved");
+        ok(list_one_element->next == NULL, "list is one element in size");
+
+        MMDB_entry_data_list_s *const entry2 = data_pool_alloc(pool);
+        ok(entry2 != NULL, "got another entry");
+
+        MMDB_entry_data_list_s *const list_two_elements
+            = data_pool_to_list(pool);
+        ok(list_two_elements != NULL, "got a list");
+        ok(list_two_elements == entry1,
+           "list's first element is the first we retrieved");
+        ok(list_two_elements->next != NULL, "list has a second element");
+
+        MMDB_entry_data_list_s *const second_element = list_two_elements->next;
+        ok(second_element == entry2,
+           "second item in list is second we retrieved");
+        ok(second_element->next == NULL, "list ends with the second element");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        size_t const initial_size = 1;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "got an entry");
+
+        MMDB_entry_data_list_s *const list_one_element
+            = data_pool_to_list(pool);
+        ok(list_one_element != NULL, "got a list");
+        ok(list_one_element == entry1,
+           "list's first element is the first we retrieved");
+        ok(list_one_element->next == NULL, "list ends with this element");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        size_t const initial_size = 2;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "got an entry");
+
+        MMDB_entry_data_list_s *const entry2 = data_pool_alloc(pool);
+        ok(entry2 != NULL, "got an entry");
+        ok(entry1 != entry2, "second entry is different from the first");
+
+        MMDB_entry_data_list_s *const list_element1 = data_pool_to_list(pool);
+        ok(list_element1 != NULL, "got a list");
+        ok(list_element1 == entry1,
+           "list's first element is the first we retrieved");
+
+        MMDB_entry_data_list_s *const list_element2 = list_element1->next;
+        ok(list_element2 == entry2,
+           "second element is the second we retrieved");
+        ok(list_element2->next == NULL, "list ends with this element");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        diag("starting test: fill one block save for one spot");
+        ok(
+            create_and_check_list(3, 2),
+            "fill one block save for one spot"
+            );
+    }
+
+    {
+        diag("starting test: fill one block");
+        ok(
+            create_and_check_list(3, 3),
+            "fill one block"
+            );
+    }
+
+    {
+        diag("starting test: fill one block and use one spot in the next block");
+        ok(
+            create_and_check_list(3, 3 + 1),
+            "fill one block and use one spot in the next block"
+            );
+    }
+
+    {
+        diag("starting test: fill two blocks save for one spot");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 - 1),
+            "fill two blocks save for one spot"
+            );
+    }
+
+    {
+        diag("starting test: fill two blocks");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2),
+            "fill two blocks"
+            );
+    }
+
+    {
+        diag("starting test: fill two blocks and use one spot in the next");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 + 1),
+            "fill two blocks and use one spot in the next"
+            );
+    }
+
+    {
+        diag("starting test: fill three blocks save for one spot");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 + 3 * 2 * 2 - 1),
+            "fill three blocks save for one spot"
+            );
+    }
+
+    {
+        diag("starting test: fill three blocks");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 + 3 * 2 * 2),
+            "fill three blocks"
+            );
+    }
+
+    // It would be nice to have a larger number of these, but it's expensive to
+    // run many. We currently hardcode what this will be anyway, so varying
+    // this is not very interesting.
+    size_t const initial_sizes[] = { 1, 2, 32, 64, 128, 256 };
+
+    size_t const max_element_count = 4096;
+
+    for (size_t i = 0; i < sizeof(initial_sizes) / sizeof(initial_sizes[0]);
+         i++) {
+        size_t const initial_size = initial_sizes[i];
+
+        for (size_t element_count = 0; element_count < max_element_count;
+             element_count++) {
+            assert(create_and_check_list(initial_size, element_count));
+        }
+    }
+}
+
+// Use assert() rather than libtap as libtap is significantly slower and we run
+// this frequently.
+static bool create_and_check_list(size_t const initial_size,
+                                  size_t const element_count)
+{
+    MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+    assert(pool != NULL);
+
+    assert(pool->used == 0);
+
+    // Hold on to the pointers as we initially see them so that we can check
+    // they are still valid after building the list.
+    MMDB_entry_data_list_s **const entry_array
+        = calloc(element_count, sizeof(MMDB_entry_data_list_s *));
+    assert(entry_array != NULL);
+
+    for (size_t i = 0; i < element_count; i++) {
+        MMDB_entry_data_list_s *const entry = data_pool_alloc(pool);
+        assert(entry != NULL);
+
+        entry->entry_data.offset = (uint32_t)i;
+
+        entry_array[i] = entry;
+    }
+
+    MMDB_entry_data_list_s *const list = data_pool_to_list(pool);
+
+    if (element_count == 0) {
+        assert(list == NULL);
+        data_pool_destroy(pool);
+        free(entry_array);
+        return true;
+    }
+
+    assert(list != NULL);
+
+    MMDB_entry_data_list_s *element = list;
+    for (size_t i = 0; i < element_count; i++) {
+        assert(element->entry_data.offset == (uint32_t)i);
+
+        assert(element == entry_array[i]);
+
+        element = element->next;
+    }
+    assert(element == NULL);
+
+    check_block_count(list, initial_size);
+
+    data_pool_destroy(pool);
+    free(entry_array);
+    return true;
+}
+
+// Use assert() rather than libtap as libtap is significantly slower and we run
+// this frequently.
+static void check_block_count(MMDB_entry_data_list_s const *const list,
+                              size_t const initial_size)
+{
+    size_t got_block_count = 0;
+    size_t got_element_count = 0;
+
+    MMDB_entry_data_list_s const *element = list;
+    while (element) {
+        got_element_count++;
+
+        if (element->pool) {
+            got_block_count++;
+        }
+
+        element = element->next;
+    }
+
+    // Because <number of elements> = <initial size> * 2^(number of blocks)
+    double const a = ceil((double)got_element_count / (double)initial_size);
+    double const b = log2(a);
+    size_t const expected_block_count = ((size_t)b) + 1;
+
+    assert(got_block_count == expected_block_count);
+}

data/ext/geoip2/libmaxminddb/t/external_symbols_t.pl

@@ -0,0 +1,106 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+
+use FindBin qw( $Bin );
+
+_skip_tests_if_required_modules_are_not_present();
+_skip_tests_if_nm_is_not_present();
+_test_libs_external_symbols();
+
+done_testing();
+
+sub _skip_tests_if_required_modules_are_not_present {
+    eval <<'EOF';
+    use Test::More 0.88;
+    use IPC::Run3 qw( run3 );
+EOF
+
+    if ($@) {
+        print
+            "1..0 # skip all tests skipped - these tests need the Test::More 0.88, IPC::Run3 modules:\n";
+        print "$@";
+        exit 0;
+    }
+}
+
+sub _skip_tests_if_nm_is_not_present {
+    run3(
+        [ 'nm', '-V' ],
+        \undef,
+        \undef,
+        \undef,
+    );
+
+    my $exit_status = $? >> 8;
+    if ($exit_status) {
+        print
+            "1..0 # skipp all tests skipped - this test requires the command line utility `nm`.\n";
+        exit 0;
+    }
+}
+
+sub _test_libs_external_symbols {
+    my @libs = _libs_to_test();
+
+    if (@libs) {
+        for my $lib (@libs) {
+            _test_lib_external_symbols($lib);
+        }
+    }
+    else {
+        fail('No libs were found to test');
+    }
+}
+
+sub _libs_to_test {
+    my $lib_dir = "$Bin/../src/.libs";
+    opendir my $dh, $lib_dir
+        or die "Failed to open the lib dir at $lib_dir for reading: $!\n";
+    my @libs = map { $lib_dir . q{/} . $_ }
+        grep { $_ =~ m/\.so$/ } readdir $dh;
+    closedir $dh;
+
+    return @libs;
+}
+
+sub _test_lib_external_symbols {
+    my $lib = shift;
+
+    my $stdout;
+    my $stderr;
+    run3(
+        [ 'nm', '-g', '--defined-only', $lib ],
+        \undef,
+        \$stdout,
+        \$stderr,
+    );
+
+    my $exit_status = $? >> 8;
+    ok( !$exit_status, 'nm returned a non-error status' )
+        or diag($stderr);
+
+    my @external_symbols = _extract_external_symbols($stdout);
+    is_deeply(
+        [ grep { $_ !~ m/^MMDB_/ } @external_symbols ],
+        [],
+        "$lib exports only MMDB_ symbols"
+    );
+}
+
+sub _extract_external_symbols {
+    my $nm_output = shift;
+
+    my @lines = split /\r\n|\r|\n/, $nm_output;
+
+    my @external_symbols;
+    for my $line (@lines) {
+        my @fields = split /\s+/, $line;
+        die "Unexpected nm output for line $line\n"
+            if @fields != 3;
+        push @external_symbols, $fields[2];
+    }
+
+    return @external_symbols;
+}

data/ext/geoip2/libmaxminddb/t/libtap/.gitignore

@@ -0,0 +1,13 @@
+/t/*
+!/t/*.*
+/t/*.exe
+/t/*.got
+*.a
+*.lo
+*.o
+*.so
+*.pc
+usr/
+*.sw?
+/.deps
+/.dirstamp

data/ext/geoip2/libmaxminddb/t/libtap/.travis.yml

@@ -0,0 +1,13 @@
+language: c
+
+compiler:
+  - gcc
+  - clang
+
+before_install: sudo apt-get install -y libtest-differences-perl
+
+install: make CC=$CC install
+
+script: make CC=$CC test
+
+after_script: make uninstall

data/ext/geoip2/libmaxminddb/t/libtap/COPYING

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.