ffi-hydrogen 0.1.0

data/vendor/stringencoders/test/modp_html_test.c

@@ -0,0 +1,296 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_html.h"
+
+/**
+ * Test empty input to decode
+ */
+static char* testHtmlDecodeEmpty(void)
+{
+    const char* junk = "junk";
+    int d;
+    size_t consumed;
+    d = modp_html_decode_char_at(NULL, 10, &consumed);
+    mu_assert_int_equals(d, -1);
+
+    d = modp_html_decode_char_at(junk, 0, &consumed);
+    mu_assert_int_equals(d, -1);
+
+    return 0;
+}
+
+/**
+ * Test characters that should be unchanged
+ * Mostly a copy from URL encoding
+ */
+static char* testHtmlDecodeUntouched(void)
+{
+    const char* digits = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_~!$()*,;:@/?";
+
+    int i;
+    int ch;
+    size_t consumed;
+
+    for (i = 0; i < (int)strlen(digits); ++i) {
+        consumed = 0;
+        ch = modp_html_decode_char_at(digits + i, 1, &consumed);
+        mu_assert_int_equals(ch, digits[i]);
+        mu_assert_int_equals(consumed, 1);
+    }
+    return 0;
+}
+
+static char* testHtmlDecodeDigits(void)
+{
+    size_t consumed;
+    int ch;
+    const char* s1 = "&#98;";
+    const char* s2 = "&#00;";
+    const char* s3 = "&#001;";
+    const char* s4 = "&#1;";
+    const char* s5 = "&#01";
+    const char* s6 = "&#1";
+    const char* s7 = "&#";
+    const char* s8 = "&#01X";
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+    mu_assert_int_equals(ch, 98);
+    mu_assert_int_equals(consumed, 5);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s2, strlen(s2), &consumed);
+    mu_assert_int_equals(ch, 0);
+    mu_assert_int_equals(consumed, 5);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s3, strlen(s3), &consumed);
+    mu_assert_int_equals(ch, 1);
+    mu_assert_int_equals(consumed, 6);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s4, strlen(s4), &consumed);
+    mu_assert_int_equals(ch, 1);
+    mu_assert_int_equals(consumed, 4);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s5, strlen(s5), &consumed);
+    mu_assert_int_equals(ch, 1);
+    mu_assert_int_equals(consumed, 4);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s6, strlen(s6), &consumed);
+    mu_assert_int_equals(ch, 1);
+    mu_assert_int_equals(consumed, 3);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s7, strlen(s7), &consumed);
+    mu_assert_int_equals(ch, '&');
+    mu_assert_int_equals(consumed, 1);
+
+    consumed = 0;
+    ch = modp_html_decode_char_at(s8, strlen(s8), &consumed);
+    mu_assert_int_equals(ch, 1);
+    mu_assert_int_equals(consumed, 4);
+
+    return 0;
+}
+
+static char* testHtmlDecodeHexDigits(void)
+{
+    size_t consumed;
+    int ch;
+
+    {
+        const char* s1 = "&#x98;";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 0x98);
+        mu_assert_int_equals(consumed, 6);
+    }
+
+    {
+        const char* s1 = "&#x00;";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 0);
+        mu_assert_int_equals(consumed, 6);
+    }
+
+    {
+        const char* s1 = "&#x001;";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 1);
+        mu_assert_int_equals(consumed, 7);
+    }
+
+    {
+        const char* s1 = "&#x1;";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 1);
+        mu_assert_int_equals(consumed, 5);
+    }
+
+    {
+        const char* s1 = "&#x01";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 1);
+        mu_assert_int_equals(consumed, 5);
+    }
+
+    {
+        const char* s1 = "&#x1";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 1);
+        mu_assert_int_equals(consumed, 4);
+    }
+
+    {
+        const char* s1 = "&#x";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, '&');
+        mu_assert_int_equals(consumed, 1);
+    }
+
+    {
+        const char* s1 = "&#x01X";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 1);
+        mu_assert_int_equals(consumed, 5);
+    }
+
+    {
+        const char* s1 = "&#X";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, '&');
+        mu_assert_int_equals(consumed, 1);
+    }
+
+    {
+        const char* s1 = "&#X1";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, 1);
+        mu_assert_int_equals(consumed, 4);
+    }
+
+    {
+        /* overflow */
+        const char* s1 = "&#xFFFFFF";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, '&');
+        mu_assert_int_equals(consumed, 1);
+    }
+
+    {
+        /* overflow */
+        const char* s1 = "&#99999999999999999999999";
+        consumed = 0;
+        ch = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(ch, '&');
+        mu_assert_int_equals(consumed, 1);
+    }
+
+    return 0;
+}
+
+/**
+ * http://www.w3.org/html/wg/drafts/html/master/text-level-semantics.html#character-references
+ * http://www.w3.org/html/wg/drafts/html/master/text-level-semantics.html#named-character-references
+ * http://www.w3.org/html/wg/drafts/html/master/text-level-semantics.html#consume-a-character-reference
+ */
+
+static char* testHtmlDecodeNamedEntities(void)
+{
+    size_t consumed;
+    int cp;
+
+    {
+        consumed = 0;
+        const char* s1 = "&amp;";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 38);
+        mu_assert_int_equals(consumed, 5);
+    }
+
+    {
+        consumed = 0;
+        const char* s1 = "&AMP;";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 38);
+        mu_assert_int_equals(consumed, 5);
+    }
+
+    {
+        consumed = 0;
+        const char* s1 = "&amp";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 38);
+        mu_assert_int_equals(consumed, 4);
+    }
+
+    {
+        consumed = 0;
+        const char* s1 = "&AMP";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 38);
+        mu_assert_int_equals(consumed, 4);
+    }
+
+    {
+        /* &not is a special one where '&not' and '&not;' are defined */
+        consumed = 0;
+        const char* s1 = "&notit";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 172);
+        mu_assert_int_equals(consumed, 4);
+    }
+
+    {
+        /* &not is a special one where '&not' and '&not;' are defined */
+        consumed = 0;
+        const char* s1 = "&notin;";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 8713);
+        mu_assert_int_equals(consumed, 7);
+    }
+
+    {
+        /* off the edge */
+        consumed = 0;
+        const char* s1 = "&NotHumpEqua";
+        cp = modp_html_decode_char_at(s1, strlen(s1), &consumed);
+        mu_assert_int_equals(cp, 38);
+        mu_assert_int_equals(consumed, 1);
+    }
+
+    return 0;
+}
+
+static char* all_tests(void)
+{
+    mu_run_test(testHtmlDecodeEmpty);
+    mu_run_test(testHtmlDecodeUntouched);
+    mu_run_test(testHtmlDecodeDigits);
+    mu_run_test(testHtmlDecodeHexDigits);
+    mu_run_test(testHtmlDecodeNamedEntities);
+
+    return 0;
+}
+
+UNITTESTS

data/vendor/stringencoders/test/modp_json_test.c

@@ -0,0 +1,336 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_json.h"
+
+/**
+ * Smoke test
+ */
+static char* test_json_init()
+{
+    char buf[100];
+    modp_json_ctx ctx;
+
+    modp_json_init(&ctx, NULL);
+    mu_assert(ctx.dest == NULL);
+
+    modp_json_init(&ctx, buf);
+    mu_assert(ctx.dest != NULL);
+
+    modp_json_init(&ctx, NULL);
+    mu_assert(ctx.dest == NULL);
+
+    return 0;
+}
+
+static char* test_json_map_empty()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 2;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals("{}", buf);
+    return 0;
+}
+
+static char* test_json_map_1()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 13;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_add_string(&ctx, "bar", 3);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_add_string(&ctx, "bar", 3);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals("{\"foo\":\"bar\"}", buf);
+    mu_assert_int_equals(len, expected);
+    return 0;
+}
+
+static char* test_json_map_2()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 21;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_add_string(&ctx, "bar", 3);
+    modp_json_add_string(&ctx, "x", 1);
+    modp_json_add_string(&ctx, "y", 1);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_add_string(&ctx, "bar", 3);
+    modp_json_add_string(&ctx, "x", 1);
+    modp_json_add_string(&ctx, "y", 1);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals("{\"foo\":\"bar\",\"x\":\"y\"}", buf);
+    mu_assert_int_equals(len, expected);
+    return 0;
+}
+
+static char* test_json_nest_1()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 17;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_ary_open(&ctx);
+    modp_json_add_string(&ctx, "x", 1);
+    modp_json_add_string(&ctx, "y", 1);
+    modp_json_ary_close(&ctx);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_map_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_ary_open(&ctx);
+    modp_json_add_string(&ctx, "x", 1);
+    modp_json_add_string(&ctx, "y", 1);
+    modp_json_ary_close(&ctx);
+    modp_json_map_close(&ctx);
+    len = modp_json_end(&ctx);
+
+    mu_assert_int_equals(len, expected);
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals(buf, "{\"foo\":[\"x\",\"y\"]}");
+
+    return 0;
+}
+
+static char* test_json_ary_empty()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 2;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_ary_open(&ctx);
+    modp_json_ary_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_ary_open(&ctx);
+    modp_json_ary_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals("[]", buf);
+    return 0;
+}
+
+static char* test_json_ary_1()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 7;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_ary_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_ary_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_ary_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_ary_close(&ctx);
+    len = modp_json_end(&ctx);
+
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals("[\"foo\"]", buf);
+    mu_assert_int_equals(len, expected);
+    return 0;
+}
+
+static char* test_json_ary_2()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+    const int expected = 13;
+
+    /* do count */
+    modp_json_init(&ctx, buf);
+    modp_json_ary_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_add_string(&ctx, "bar", 3);
+    modp_json_ary_close(&ctx);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, expected);
+
+    /* do real thing */
+    modp_json_init(&ctx, buf);
+    modp_json_ary_open(&ctx);
+    modp_json_add_string(&ctx, "foo", 3);
+    modp_json_add_string(&ctx, "bar", 3);
+    modp_json_ary_close(&ctx);
+    len = modp_json_end(&ctx);
+
+    mu_assert_int_equals(strlen(buf), expected);
+    mu_assert_str_equals("[\"foo\",\"bar\"]", buf);
+    mu_assert_int_equals(len, expected);
+    return 0;
+}
+
+static char* test_json_int32()
+{
+    size_t len;
+    char buf[100];
+    modp_json_ctx ctx;
+
+    /* do count */
+    modp_json_init(&ctx, NULL);
+    modp_json_add_int32(&ctx, 123);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 3);
+
+    modp_json_init(&ctx, buf);
+    modp_json_add_int32(&ctx, -123);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 4);
+    mu_assert_str_equals("-123", buf);
+
+    modp_json_init(&ctx, NULL);
+    modp_json_add_int32(&ctx, -123);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 4);
+
+    modp_json_init(&ctx, buf);
+    modp_json_add_int32(&ctx, -123);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 4);
+    mu_assert_str_equals("-123", buf);
+
+    return 0;
+}
+
+static char* test_json_uint64()
+{
+    size_t len;
+    char buf[100];
+    unsigned long long val = (1ULL << 53);
+    modp_json_ctx ctx;
+
+    /* do count */
+    modp_json_init(&ctx, NULL);
+    modp_json_add_uint64(&ctx, val, 0);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 16);
+
+    modp_json_init(&ctx, buf);
+    modp_json_add_uint64(&ctx, val, 0);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 16);
+    mu_assert_str_equals("9007199254740992", buf);
+
+    /* force string-only */
+    modp_json_init(&ctx, NULL);
+    modp_json_add_uint64(&ctx, val, 1);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 18);
+
+    modp_json_init(&ctx, buf);
+    modp_json_add_uint64(&ctx, val, 1);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 18);
+    mu_assert_str_equals("\"9007199254740992\"", buf);
+
+    /* automatic stringonly mode */
+    val = (1ULL << 54);
+
+    modp_json_init(&ctx, NULL);
+    modp_json_add_uint64(&ctx, val, 0);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 19);
+
+    modp_json_init(&ctx, buf);
+    modp_json_add_uint64(&ctx, val, 0);
+    len = modp_json_end(&ctx);
+    mu_assert_int_equals(len, 19);
+    mu_assert_str_equals("\"18014398509481984\"", buf);
+
+    return 0;
+}
+
+static char* all_tests()
+{
+    mu_run_test(test_json_init);
+    mu_run_test(test_json_map_empty);
+    mu_run_test(test_json_map_1);
+    mu_run_test(test_json_map_2);
+    mu_run_test(test_json_ary_empty);
+    mu_run_test(test_json_ary_1);
+    mu_run_test(test_json_ary_2);
+    mu_run_test(test_json_nest_1);
+    mu_run_test(test_json_int32);
+    mu_run_test(test_json_uint64);
+    return 0;
+}
+
+UNITTESTS