ffi-hydrogen 0.1.0

data/vendor/stringencoders/test/modp_qsiter_test.c

@@ -0,0 +1,280 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_qsiter.h"
+
+/**
+ * Test empty input to encode and decode
+ */
+static char* test_qs_init()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "foobar";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    mu_assert_int_equals(qsi.pos, 0);
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+
+    return 0;
+}
+
+static char* test_qs_parse1()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "foo=bar1";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 3);
+    mu_assert_int_equals(qsi.vallen, 4);
+    mu_assert(!memcmp("foo", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("bar1", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse2()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "foobar";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 6);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("foobar", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse3()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "foo=bar&ding=bat";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, 8);
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 3);
+    mu_assert_int_equals(qsi.vallen, 3);
+    mu_assert(!memcmp("foo", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("bar", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 4);
+    mu_assert_int_equals(qsi.vallen, 3);
+    mu_assert(!memcmp("ding", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("bat", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse4()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse5()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "=";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse6()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "&";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse7()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "=&";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse8()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "&&";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, 1);
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, 2);
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* test_qs_parse9()
+{
+    struct qsiter_t qsi;
+
+    const char* s = "&&foo=bar";
+
+    qsiter_reset(&qsi, s, strlen(s));
+
+    int ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, 1);
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, 2);
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 0);
+    mu_assert_int_equals(qsi.vallen, 0);
+    mu_assert(!memcmp("", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(ok);
+    mu_assert_int_equals(qsi.pos, strlen(s));
+    mu_assert_int_equals(qsi.len, strlen(s));
+    mu_assert_int_equals(qsi.keylen, 3);
+    mu_assert_int_equals(qsi.vallen, 3);
+    mu_assert(!memcmp("foo", qsi.key, qsi.keylen));
+    mu_assert(!memcmp("bar", qsi.val, qsi.vallen));
+
+    ok = qsiter_next(&qsi);
+    mu_assert(!ok);
+
+    return 0;
+}
+
+static char* all_tests()
+{
+    mu_run_test(test_qs_init);
+    mu_run_test(test_qs_parse1);
+    mu_run_test(test_qs_parse2);
+    mu_run_test(test_qs_parse3);
+    mu_run_test(test_qs_parse4);
+    mu_run_test(test_qs_parse5);
+    mu_run_test(test_qs_parse6);
+    mu_run_test(test_qs_parse7);
+    mu_run_test(test_qs_parse8);
+    mu_run_test(test_qs_parse9);
+    return 0;
+}
+
+UNITTESTS

data/vendor/stringencoders/test/modp_utf8_test.c

@@ -0,0 +1,188 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_utf8.h"
+/**
+ * Test empty input to decode
+ */
+static char* testUtf8ValidateEmpty(void)
+{
+    int d = modp_utf8_validate("", (size_t)0);
+    mu_assert_int_equals(d, 0);
+    return 0;
+}
+
+static char* testUtf8ValidateAscii(void)
+{
+    int d = modp_utf8_validate("abc", (size_t)3);
+    mu_assert_int_equals(d, 0);
+
+    /* with null and highest ASCII character 127 */
+    d = modp_utf8_validate("a\x00\x7Fz", (size_t)4);
+    mu_assert_int_equals(d, 0);
+    return 0;
+}
+
+static char* testUtf8Validate2(void)
+{
+    /*
+     * examples taken from Wikipedia
+     *  http://en.wikipedia.org/wiki/UTF-8
+     */
+    int d;
+    const char* s2 = "\xC2\xA2";
+    mu_assert_int_equals(strlen(s2), 2);
+    d = modp_utf8_validate(s2, strlen(s2));
+    mu_assert_int_equals(d, 0);
+
+    d = modp_utf8_validate(s2, strlen(s2) - 1);
+    mu_assert_int_equals(d, MODP_UTF8_SHORT);
+
+    /* overlong, decodes to 0 */
+    s2 = "\xC0\x80";
+    d = modp_utf8_validate(s2, strlen(s2));
+    mu_assert_int_equals(d, MODP_UTF8_OVERLONG);
+
+    /* overlong, decodes to 127 */
+    s2 = "\xC1\xBF";
+    d = modp_utf8_validate(s2, strlen(s2));
+    mu_assert_int_equals(d, MODP_UTF8_OVERLONG);
+
+    s2 = "\xC2\xC0";
+    d = modp_utf8_validate(s2, strlen(s2));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    s2 = "\xC2\xFF";
+    d = modp_utf8_validate(s2, strlen(s2));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    s2 = "\xC2\x01";
+    d = modp_utf8_validate(s2, strlen(s2));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    return 0;
+}
+
+static char* testUtf8Validate3(void)
+{
+    int d;
+    const char* s3 = "\xE2\x82\xAC";
+    mu_assert_int_equals(strlen(s3), 3);
+    d = modp_utf8_validate(s3, strlen(s3));
+    mu_assert_int_equals(d, 0);
+
+    d = modp_utf8_validate(s3, strlen(s3) - 1);
+    mu_assert_int_equals(d, MODP_UTF8_SHORT);
+
+    s3 = "\xEF\xBF\xBF";
+    d = modp_utf8_validate(s3, strlen(s3));
+    mu_assert_int_equals(d, MODP_UTF8_OK);
+
+    s3 = "\xE0\x80\x80";
+    d = modp_utf8_validate(s3, strlen(s3));
+    mu_assert_int_equals(d, MODP_UTF8_OVERLONG);
+
+    s3 = "\xE2\x01\xAC";
+    d = modp_utf8_validate(s3, strlen(s3));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    s3 = "\xE2\x82\x01";
+    d = modp_utf8_validate(s3, strlen(s3));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+    return 0;
+}
+
+static char* testUtf8Validate4(void)
+{
+    int d;
+    const char* s4 = "\xF0\xA4\xAD\xA2";
+    mu_assert_int_equals(strlen(s4), 4);
+    d = modp_utf8_validate(s4, strlen(s4));
+    mu_assert_int_equals(d, 0);
+
+    d = modp_utf8_validate(s4, strlen(s4) - 1);
+    mu_assert_int_equals(d, MODP_UTF8_SHORT);
+
+    /* maximum value */
+    s4 = "\xF7\xBF\xBF\xBF";
+    d = modp_utf8_validate(s4, strlen(s4));
+    mu_assert_int_equals(d, MODP_UTF8_OK);
+
+    s4 = "\xF0\x01\xAD\xA2";
+    d = modp_utf8_validate(s4, strlen(s4));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    s4 = "\xF0\xA4\x01\xA2";
+    d = modp_utf8_validate(s4, strlen(s4));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    s4 = "\xF0\xA4\xAD\x01";
+    d = modp_utf8_validate(s4, strlen(s4));
+    mu_assert_int_equals(d, MODP_UTF8_INVALID);
+
+    return 0;
+}
+static char* testUtf8Validate5(void)
+{
+    int d;
+    const char* s = "\xF8";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xF9";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xFA";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xFB";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xFC";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xFD";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xFE";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    s = "\xFF";
+    mu_assert_int_equals(strlen(s), 1);
+    d = modp_utf8_validate(s, strlen(s));
+    mu_assert_int_equals(d, MODP_UTF8_CODEPOINT);
+
+    return 0;
+}
+
+static char* all_tests(void)
+{
+    mu_run_test(testUtf8ValidateEmpty);
+    mu_run_test(testUtf8ValidateAscii);
+    mu_run_test(testUtf8Validate2);
+    mu_run_test(testUtf8Validate3);
+    mu_run_test(testUtf8Validate4);
+    mu_run_test(testUtf8Validate5);
+    return 0;
+}
+
+UNITTESTS