geoip2_c 0.3.3 → 0.3.4

data/ext/geoip2/libmaxminddb/t/libtap/Makefile.win

@@ -0,0 +1,37 @@
+CFLAGS = /Zi /Wall /wd4255 /wd4996 /wd4127 /wd4820 /wd4100 /wd4619 \
+		 /wd4514 /wd4668 /I.
+CC = cl /nologo
+TESTS = $(patsubst %.c, %.exe, $(wildcard t/*.c))
+
+%.exe:
+	$(CC) $(LDFLAGS) $(filter %.obj %.lib %.dll, $^) $(LDLIBS) /Fe $@
+
+%.o:
+	$(CC) $(CFLAGS) $(CPPFLAGS) /c $(filter %.c, $^) $(LDLIBS) /Fo $@
+
+%.lib:
+	lib /nologo /out:$@ $(filter %.obj, $^)
+
+%.dll:
+	lib /nologo /out:$@ $(filter %.obj, $^)
+
+all: tap.lib tests
+
+tap.lib: tap.obj
+
+tap.obj: tap.c tap.h
+
+tests: $(TESTS)
+
+$(TESTS): %.exe: %.obj tap.lib
+
+$(patsubst %.exe, %.obj, $(TESTS)): %.obj: %.c tap.h
+
+clean:
+	rm -rf *.obj t/*.obj tap.lib $(TESTS)
+
+check test: all
+	prove
+
+.PHONY: all clean check test tests
+

data/ext/geoip2/libmaxminddb/t/libtap/README.md

@@ -0,0 +1,268 @@
+NAME
+====
+
+libtap - Write tests in C
+
+SYNOPSIS
+========
+
+    #include <tap.h>
+
+    int main () {
+        plan(5);
+        int bronze = 1, silver = 2, gold = 3;
+        ok(bronze < silver, "bronze is less than silver");
+        ok(bronze > silver, "not quite");
+        is("gold", "gold", "gold is gold");
+        cmp_ok(silver, "<", gold, "%d <= %d", silver, gold);
+        like("platinum", ".*inum", "platinum matches .*inum");
+        done_testing();
+    }
+
+results in:
+
+    1..5
+    ok 1 - bronze is less than silver
+    not ok 2 - not quite
+    #   Failed test 'not quite'
+    #   at t/synopsis.c line 7.
+    ok 3 - gold is gold
+    ok 4 - 2 <= 3
+    ok 5 - platinum matches .*inum
+    # Looks like you failed 1 test of 5 run.
+
+DESCRIPTION
+===========
+
+tap is an easy to read and easy to write way of creating tests for
+your software. This library creates functions that can be used to
+generate it for your C programs. It is implemented using macros
+that include file and line info automatically, and makes it so that
+the format message of each test is optional. It is mostly based on
+the Test::More Perl module.
+
+INSTALL
+=======
+
+On **Unix** systems:
+
+    $ make
+    $ make install
+
+For more detailed installation instructions (eg, for **Windows**), see `INSTALL`.
+
+FUNCTIONS
+=========
+
+-   plan(tests)
+-   plan(NO_PLAN)
+-   plan(SKIP_ALL);
+-   plan(SKIP_ALL, fmt, ...)
+
+    Use this to start a series of tests. When you know how many tests there
+    will be, you can put a number as a number of tests you expect to run. If
+    you do not know how many tests there will be, you can use plan(NO_PLAN)
+    or not call this function. When you pass it a number of tests to run, a
+    message similar to the following will appear in the output:
+
+        1..5
+
+    If you pass it SKIP_ALL, the whole test will be skipped.
+
+-   ok(test)
+-   ok(test, fmt, ...)
+
+    Specify a test. the test can be any statement returning a true or false
+    value. You may optionally pass a format string describing the test.
+
+        ok(r = reader_new("Of Mice and Men"), "create a new reader");
+        ok(reader_go_to_page(r, 55), "can turn the page");
+        ok(r->page == 55, "page turned to the right one");
+
+    Should print out:
+
+        ok 1 - create a new reader
+        ok 2 - can turn the page
+        ok 3 - page turned to the right one
+
+    On failure, a diagnostic message will be printed out.
+
+        not ok 3 - page turned to the right one
+        #   Failed test 'page turned to the right one'
+        #   at reader.c line 13.
+
+-   is(got, expected)
+-   is(got, expected, fmt, ...)
+-   isnt(got, unexpected)
+-   isnt(got, unexpected, fmt, ...)
+
+    Tests that the string you got is what you expected. with isnt, it is the
+    reverse.
+
+        is("this", "that", "this is that");
+
+    prints:
+
+        not ok 1 - this is that
+        #   Failed test 'this is that'
+        #   at is.c line 6.
+        #          got: 'this'
+        #     expected: 'that'
+
+-   cmp_ok(a, op, b)
+-   cmp_ok(a, op, b, fmt, ...)
+
+    Compares two ints with any binary operator that doesn't require an lvalue.
+    This is nice to use since it provides a better error message than an
+    equivalent ok.
+
+        cmp_ok(420, ">", 666);
+
+    prints:
+
+        not ok 1
+        #   Failed test at cmpok.c line 5.
+        #     420
+        #         >
+        #     666
+
+-   cmp_mem(got, expected, n)
+-   cmp_mem(got, expected, n, fmt, ...)
+
+    Tests that the first n bytes of the memory you got is what you expected.
+    NULL pointers for got and expected are handled (if either is NULL,
+    the test fails), but you need to ensure n is not too large.
+
+        char *a = "foo";
+        char *b = "bar";
+        cmp_mem(a, b, 3)
+
+    prints
+
+        not ok 1
+        #   Failed test at t/cmp_mem.c line 9.
+        #     Difference starts at offset 0
+        #          got: 0x66
+        #     expected: 0x62
+
+-   like(got, expected)
+-   like(got, expected, fmt, ...)
+-   unlike(got, unexpected)
+-   unlike(got, unexpected, fmt, ...)
+
+    Tests that the string you got matches the expected extended POSIX regex.
+    unlike is the reverse. These macros are the equivalent of a skip on
+    Windows.
+
+        like("stranger", "^s.(r).*\\1$", "matches the regex");
+
+    prints:
+
+        ok 1 - matches the regex
+
+-   pass()
+-   pass(fmt, ...)
+-   fail()
+-   fail(fmt, ...)
+
+    Speciy that a test succeeded or failed. Use these when the statement is
+    longer than you can fit into the argument given to an ok() test.
+
+-   dies_ok(code)
+-   dies_ok(code, fmt, ...)
+-   lives_ok(code)
+-   lives_ok(code, fmt, ...)
+
+    Tests whether the given code causes your program to exit. The code gets
+    passed to a macro that will test it in a forked process. If the code
+    succeeds it will be executed in the parent process. You can test things
+    like passing a function a null pointer and make sure it doesnt
+    dereference it and crash.
+
+        dies_ok({abort();}, "abort does close your program");
+        dies_ok({int x = 0/0;}, "divide by zero crash");
+        lives_ok({pow(3.0, 5.0);}, "nothing wrong with taking 3**5");
+
+    On Windows, these macros are the equivalent of a skip.
+
+-   done_testing()
+
+    Summarizes the tests that occurred and exits the main function. If
+    there was no plan, it will print out the number of tests as.
+
+        1..5
+
+    It will also print a diagnostic message about how many
+    failures there were.
+
+        # Looks like you failed 2 tests of 3 run.
+
+    If all planned tests were successful, it will return 0. If any
+    test fails, it will return 1. If they all passed, but there
+    were missing tests, it will return 2.
+
+-   diag(fmt, ...)
+
+    print out a message to the tap output on stdout. Each line is
+    preceeded by a "# " so that you know its a diagnostic message.
+
+        diag("This is\na diag\nto describe\nsomething.");
+
+    prints:
+
+        # This is
+        # a diag
+        # to describe
+        # something
+
+    ok() and this function return an int so you can use it like:
+
+        ok(0) || diag("doh!");
+
+-   skip(test, n)
+-   skip(test, n, fmt, ...)
+-   end_skip
+
+    Skip a series of n tests if test is true. You may give a reason why you are
+    skipping them or not. The (possibly) skipped tests must occur between the
+    skip and end_skip macros.
+
+        skip(TRUE, 2);
+        ok(1);
+        ok(0);
+        end_skip;
+
+    prints:
+
+        ok 1 # skip
+        ok 2 # skip
+
+-   todo()
+-   todo(fmt, ...)
+-   end_todo
+
+    Specifies a series of tests that you expect to fail because they are not
+    yet implemented.
+
+        todo()
+        ok(0);
+        end_todo;
+
+    prints:
+
+        not ok 1 # TODO
+        #   Failed (TODO) test at todo.c line 7
+
+-   BAIL_OUT()
+-   BAIL_OUT(fmt, ...)
+
+    Immediately stops all testing.
+
+        BAIL_OUT("Can't go no further");
+
+    prints
+
+        Bail out!  Can't go no further
+
+    and exits with 255.
+

data/ext/geoip2/libmaxminddb/t/libtap/t/cmp_mem.c

@@ -0,0 +1,20 @@
+#include "tap.h"
+
+int main () {
+    unsigned char all_0[] = {0, 0, 0, 0};
+    unsigned char all_255[] = {255, 255, 255, 255};
+    unsigned char half[] = {0, 0, 255, 255};
+    unsigned char half_2[] = {0, 0, 255, 255};
+
+    plan(8);
+    cmp_mem(half, half_2, 4, "Same array different address");
+    cmp_mem(all_0, all_0, 4, "Array must be equal to itself");
+    cmp_mem(all_0, all_255, 4, "Arrays with different contents");
+    cmp_mem(all_0, half, 4, "Arrays differ, but start the same");
+    cmp_mem(all_0, all_255, 0, "Comparing 0 bytes of different arrays");
+    cmp_mem(NULL, all_0, 4, "got == NULL");
+    cmp_mem(all_0, NULL, 4, "expected == NULL");
+    cmp_mem(NULL, NULL, 4, "got == expected == NULL");
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/cmp_mem.expected

@@ -0,0 +1,28 @@
+1..8
+ok 1 - Same array different address
+ok 2 - Array must be equal to itself
+not ok 3 - Arrays with different contents
+#   Failed test 'Arrays with different contents'
+#   at t/cmp_mem.c line 12.
+#     Difference starts at offset 0
+#          got: 0x00
+#     expected: 0xff
+not ok 4 - Arrays differ, but start the same
+#   Failed test 'Arrays differ, but start the same'
+#   at t/cmp_mem.c line 13.
+#     Difference starts at offset 2
+#          got: 0x00
+#     expected: 0xff
+ok 5 - Comparing 0 bytes of different arrays
+not ok 6 - got == NULL
+#   Failed test 'got == NULL'
+#   at t/cmp_mem.c line 15.
+#          got: NULL
+#     expected: not NULL
+not ok 7 - expected == NULL
+#   Failed test 'expected == NULL'
+#   at t/cmp_mem.c line 16.
+#          got: not NULL
+#     expected: NULL
+ok 8 - got == expected == NULL
+# Looks like you failed 4 tests of 8 run.

data/ext/geoip2/libmaxminddb/t/libtap/t/cmpok.c

@@ -0,0 +1,16 @@
+#include "tap.h"
+
+int main () {
+    plan(9);
+    cmp_ok(420, ">", 666);
+    cmp_ok(23, "==", 55, "the number 23 is definitely 55");
+    cmp_ok(23, "==", 55);
+    cmp_ok(23, "!=", 55);
+    cmp_ok(23, "frob", 55);
+    cmp_ok(23, "<=", 55);
+    cmp_ok(55, "+", -55);
+    cmp_ok(23, "%", 5);
+    cmp_ok(55, "%", 5);
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/cmpok.expected

@@ -0,0 +1,37 @@
+1..9
+not ok 1
+#   Failed test at t/cmpok.c line 5.
+#     420
+#         >
+#     666
+not ok 2 - the number 23 is definitely 55
+#   Failed test 'the number 23 is definitely 55'
+#   at t/cmpok.c line 6.
+#     23
+#         ==
+#     55
+not ok 3
+#   Failed test at t/cmpok.c line 7.
+#     23
+#         ==
+#     55
+ok 4
+# unrecognized operator 'frob'
+not ok 5
+#   Failed test at t/cmpok.c line 9.
+#     23
+#         frob
+#     55
+ok 6
+not ok 7
+#   Failed test at t/cmpok.c line 11.
+#     55
+#         +
+#     -55
+ok 8
+not ok 9
+#   Failed test at t/cmpok.c line 13.
+#     55
+#         %
+#     5
+# Looks like you failed 6 tests of 9 run.

data/ext/geoip2/libmaxminddb/t/libtap/t/diag.c

@@ -0,0 +1,10 @@
+#include "tap.h"
+
+int main () {
+    diag("diag no new line");
+    diag("diag new line\n");
+    diag("");
+    diag(NULL);
+    return 1;
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/diag.expected

@@ -0,0 +1,2 @@
+# diag no new line
+# diag new line

data/ext/geoip2/libmaxminddb/t/libtap/t/diesok.c

@@ -0,0 +1,14 @@
+#include "tap.h"
+
+int main () {
+    plan(5);
+    ok(1, "sanity");
+    dies_ok({int x = 0; x = x/x;}, "can't divide by zero");
+    lives_ok({int x = 3; x = x/7;}, "this is a perfectly fine statement");
+    dies_ok({abort();}, "abort kills the program");
+    dies_ok(
+        {printf("stdout\n"); fprintf(stderr, "stderr\n"); abort();},
+        "supress output");
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/diesok.expected

@@ -0,0 +1,6 @@
+1..5
+ok 1 - sanity
+ok 2 - can't divide by zero
+ok 3 - this is a perfectly fine statement
+ok 4 - abort kills the program
+ok 5 - supress output

data/ext/geoip2/libmaxminddb/t/libtap/t/is.c

@@ -0,0 +1,24 @@
+#include "tap.h"
+
+int main () {
+    plan(18);
+    is("this", "that", "this is that"); /* bang */
+    is("this", "this", "this is this");
+    is("this", "that"); /* bang */
+    is("this", "this");
+    is(NULL, NULL, "null is null");
+    is(NULL, "this", "null is this"); /* bang */
+    is("this", NULL, "this is null"); /* bang */
+    is("foo\nfoo\nfoo", "bar\nbar\nbar"); /* bang */
+    is("foo\nfoo\nfoo", "foo\nfoo\nfoo");
+    isnt("this", "that", "this isnt that");
+    isnt("this", "this", "this isnt this"); /* bang */
+    isnt("this", "that");
+    isnt("this", "this"); /* bang */
+    isnt(NULL, NULL, "null isnt null"); /* bang */
+    isnt(NULL, "this", "null isnt this");
+    isnt("this", NULL, "this isnt null");
+    isnt("foo\nfoo\nfoo", "bar\nbar\nbar");
+    isnt("foo\nfoo\nfoo", "foo\nfoo\nfoo"); /* bang */
+    done_testing();
+}

data/ext/geoip2/libmaxminddb/t/libtap/t/is.expected

@@ -0,0 +1,58 @@
+1..18
+not ok 1 - this is that
+#   Failed test 'this is that'
+#   at t/is.c line 5.
+#          got: 'this'
+#     expected: 'that'
+ok 2 - this is this
+not ok 3
+#   Failed test at t/is.c line 7.
+#          got: 'this'
+#     expected: 'that'
+ok 4
+ok 5 - null is null
+not ok 6 - null is this
+#   Failed test 'null is this'
+#   at t/is.c line 10.
+#          got: '(null)'
+#     expected: 'this'
+not ok 7 - this is null
+#   Failed test 'this is null'
+#   at t/is.c line 11.
+#          got: 'this'
+#     expected: '(null)'
+not ok 8
+#   Failed test at t/is.c line 12.
+#          got: 'foo
+# foo
+# foo'
+#     expected: 'bar
+# bar
+# bar'
+ok 9
+ok 10 - this isnt that
+not ok 11 - this isnt this
+#   Failed test 'this isnt this'
+#   at t/is.c line 15.
+#          got: 'this'
+#     expected: anything else
+ok 12
+not ok 13
+#   Failed test at t/is.c line 17.
+#          got: 'this'
+#     expected: anything else
+not ok 14 - null isnt null
+#   Failed test 'null isnt null'
+#   at t/is.c line 18.
+#          got: '(null)'
+#     expected: anything else
+ok 15 - null isnt this
+ok 16 - this isnt null
+ok 17
+not ok 18
+#   Failed test at t/is.c line 22.
+#          got: 'foo
+# foo
+# foo'
+#     expected: anything else
+# Looks like you failed 9 tests of 18 run.

data/ext/geoip2/libmaxminddb/t/libtap/t/like.c

@@ -0,0 +1,10 @@
+#include "tap.h"
+
+int main () {
+    plan(3);
+    like("strange", "range", "strange ~~ /range/");
+    unlike("strange", "anger", "strange !~~ /anger/");
+    like("stranger", "^s.(r).*$", "matches the regex");
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/like.expected

@@ -0,0 +1,4 @@
+1..3
+ok 1 - strange ~~ /range/
+ok 2 - strange !~~ /anger/
+ok 3 - matches the regex

data/ext/geoip2/libmaxminddb/t/libtap/t/simple.c

@@ -0,0 +1,31 @@
+#include "tap.h"
+
+int main () {
+    plan(24);
+    ok(1);
+    ok(1);
+    ok(1);
+    ok(0);
+    ok(1, "foo");
+    ok(1, "bar");
+    ok(1, "baz");
+    ok(1, "quux");
+    ok(1, "thud");
+    ok(1, "wombat");
+    ok(1, "blurgle");
+    ok(1, "frob");
+    ok(0, "frobnicate");
+    ok(1, "eek");
+    ok(1, "ook");
+    ok(1, "frodo");
+    ok(1, "bilbo");
+    ok(1, "wubble");
+    ok(1, "flarp");
+    ok(1, "fnord");
+    pass();
+    fail();
+    pass("good");
+    fail("bad");
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/simple.expected

@@ -0,0 +1,32 @@
+1..24
+ok 1
+ok 2
+ok 3
+not ok 4
+#   Failed test at t/simple.c line 8.
+ok 5 - foo
+ok 6 - bar
+ok 7 - baz
+ok 8 - quux
+ok 9 - thud
+ok 10 - wombat
+ok 11 - blurgle
+ok 12 - frob
+not ok 13 - frobnicate
+#   Failed test 'frobnicate'
+#   at t/simple.c line 17.
+ok 14 - eek
+ok 15 - ook
+ok 16 - frodo
+ok 17 - bilbo
+ok 18 - wubble
+ok 19 - flarp
+ok 20 - fnord
+ok 21
+not ok 22
+#   Failed test at t/simple.c line 26.
+ok 23 - good
+not ok 24 - bad
+#   Failed test 'bad'
+#   at t/simple.c line 28.
+# Looks like you failed 4 tests of 24 run.

data/ext/geoip2/libmaxminddb/t/libtap/t/skip.c

@@ -0,0 +1,23 @@
+#include "tap.h"
+
+int main () {
+    plan(8);
+    skip(0, 3, "%s cannot fork", "windows");
+    ok(1, "quux");
+    ok(1, "thud");
+    ok(1, "wombat");
+    end_skip;
+    skip(1, 1, "need to be on windows");
+    ok(0, "blurgle");
+    end_skip;
+    skip(0, 3);
+    ok(1, "quux");
+    ok(1, "thud");
+    ok(1, "wombat");
+    end_skip;
+    skip(1, 1);
+    ok(0, "blurgle");
+    end_skip;
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/skip.expected

@@ -0,0 +1,9 @@
+1..8
+ok 1 - quux
+ok 2 - thud
+ok 3 - wombat
+ok 4 # skip need to be on windows
+ok 5 - quux
+ok 6 - thud
+ok 7 - wombat
+ok 8 # skip 

data/ext/geoip2/libmaxminddb/t/libtap/t/synopsis.c

@@ -0,0 +1,13 @@
+#include "tap.h"
+
+int main () {
+    plan(5);
+    int bronze = 1, silver = 2, gold = 3;
+    ok(bronze < silver, "bronze is less than silver");
+    ok(bronze > silver, "not quite");
+    is("gold", "gold", "gold is gold");
+    cmp_ok(silver, "<", gold, "%d <= %d", silver, gold);
+    like("platinum", ".*inum", "platinum matches .*inum");
+    done_testing();
+}
+

data/ext/geoip2/libmaxminddb/t/libtap/t/synopsis.expected

@@ -0,0 +1,9 @@
+1..5
+ok 1 - bronze is less than silver
+not ok 2 - not quite
+#   Failed test 'not quite'
+#   at t/synopsis.c line 7.
+ok 3 - gold is gold
+ok 4 - 2 <= 3
+ok 5 - platinum matches .*inum
+# Looks like you failed 1 test of 5 run.