ffi-hydrogen 0.1.0

data/vendor/stringencoders/test/modp_xml_test.c

@@ -0,0 +1,339 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_xml.h"
+
+/**
+ * Test empty input to decode
+ */
+static char* testXmlDecodeEmpty(void)
+{
+    size_t d;
+    char buf[1000];
+
+    buf[0] = 1;
+    d = modp_xml_decode(buf, "", (size_t)0);
+    mu_assert_int_equals(d, 0);
+    mu_assert(buf[0] == 0);
+
+    return 0;
+}
+
+/**
+ * Test characters that should be unchanged
+ * Mostly a copy from URL encoding
+ */
+static char* testXmlDecodeUntouched(void)
+{
+    const char* lower = "abcdefghijklmnopqrstuvwxyz";
+    const char* upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const char* digits = "0123456789";
+    const char* special = ".-_~!$()*,;:@/?";
+    char buf[1000];
+
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, lower, strlen(lower));
+    mu_assert_int_equals(d, strlen(lower));
+    mu_assert_str_equals(buf, lower);
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, upper, strlen(upper));
+    mu_assert_int_equals(d, strlen(upper));
+    mu_assert_str_equals(buf, upper);
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, digits, strlen(digits));
+    mu_assert_int_equals(d, strlen(digits));
+    mu_assert_str_equals(buf, digits);
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, special, strlen(special));
+    mu_assert_int_equals(d, strlen(special));
+    mu_assert_str_equals(buf, special);
+
+    return 0;
+}
+
+/**
+ * Test characters that should be unchanged
+ * Mostly a copy from URL encoding
+ */
+static char* testXmlDecodeNames(void)
+{
+    const char* strin = "X&quot;X&apos;X&amp;X&gt;X&lt;X";
+    const char* strout = "X\"X'X&X>X<X";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+/**
+ * Bad entity name.. not existent
+ */
+static char* testXmlDecodeBadNames1(void)
+{
+    const char* strin = "X&quo;X";
+    const char* strout = "X&quo;X";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+/**
+ * Bad entity name -- no semi-colon
+ */
+static char* testXmlDecodeBadNames2(void)
+{
+    const char* strin = "X&quotX";
+    const char* strout = "X&quotX";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+/**
+ * Bad entity name -- no name!
+ */
+static char* testXmlDecodeBadNames3(void)
+{
+    const char* strin = "X&;X";
+    const char* strout = "X&;X";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+/**
+ * Bad entity name -- boundary!
+ */
+static char* testXmlDecodeBadNames4(void)
+{
+    const char* strin = "X&;";
+    const char* strout = "X&;";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+/**
+ * Bad entity name -- boundary!
+ */
+static char* testXmlDecodeBadNames5(void)
+{
+    const char* strin = "X&";
+    const char* strout = "X&";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+/**
+ * Bad entity name.. case sensitive
+ */
+static char* testXmlDecodeBadNames6(void)
+{
+    const char* strin = "X&QUOT;X";
+    const char* strout = "X&QUOT;X";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+static char* testXmlUnicodeCodePoints(void)
+{
+    static const int ranges[] = {
+        0x0000, 0x0008, /* control characters */
+        0x000B, 0x000B, /* Vertical Tab is forbidden, ?? */
+        0x000E, 0x001F, /* control characters */
+        0x0080, 0x009F, /* control characters */
+        0x0750, 0x077D, /* the rest are undefined */
+        0x07C0, 0x08FF,
+        0x1380, 0x139F,
+        0x18B0, 0x18FF,
+        0x1980, 0x19DF,
+        0x1A00, 0x1CFF,
+        0x1D80, 0x1DFF,
+        0x2C00, 0x2E7F,
+        0x2FE0, 0x2FEF,
+        0x31C0, 0x31EF,
+        0x9FB0, 0x9FFF,
+        0xA4D0, 0xABFF,
+        0xD7B0, 0xD7FF,
+        0xFE10, 0xFE1F,
+        0x10140, 0x102FF,
+        0x104B0, 0x107FF,
+        0x1D200, 0x1D2FF,
+        0x1D360, 0x1D3FF,
+        0x1D800, 0x1FFFF,
+        0x2A6E0, 0x2F7FF,
+        0x2FAB0, 0xDFFFF,
+        0xE0080, 0xE00FF,
+        0xE01F0, 0xEFFFF,
+        0xFFFFE, 0xFFFFF
+    };
+    static const int imax = sizeof(ranges) / sizeof(uint32_t);
+    int i;
+    for (i = 0; i < imax; ++i) {
+        mu_assert_int_equals(-1, modp_xml_validate_unicode(ranges[i]));
+    }
+
+    /* too big */
+    mu_assert_int_equals(-1, modp_xml_validate_unicode(0xFFFFFF));
+
+    /* ok */
+    mu_assert_int_equals(0x41, modp_xml_validate_unicode(0x41));
+    return 0;
+}
+
+static char* testXmlUnicodeCharToUTF8(void)
+{
+    char buf[1000];
+    size_t d = 0;
+    int val = 0;
+
+    d = modp_xml_unicode_char_to_utf8(buf, 0x41);
+    mu_assert_int_equals(1, d);
+    buf[d] = '\0';
+    mu_assert_str_equals(buf, "A");
+
+    /* Cent symbol */
+    d = modp_xml_unicode_char_to_utf8(buf, 0x00A2);
+    mu_assert_int_equals(2, d);
+    val = (unsigned char)buf[0];
+    mu_assert_int_equals(val, 0xC2);
+    val = (unsigned char)buf[1];
+    mu_assert_int_equals(val, 0xA2);
+
+    /* Euro symbol */
+    d = modp_xml_unicode_char_to_utf8(buf, 0x20AC);
+    mu_assert_int_equals(3, d);
+    val = (unsigned char)buf[0];
+    mu_assert_int_equals(val, 0xE2);
+    val = (unsigned char)buf[1];
+    mu_assert_int_equals(val, 0x82);
+    val = (unsigned char)buf[2];
+    mu_assert_int_equals(val, 0xAC);
+
+    /* Chinese Character */
+    d = modp_xml_unicode_char_to_utf8(buf, 0x24B62);
+    mu_assert_int_equals(4, d);
+    val = (unsigned char)buf[0];
+    mu_assert_int_equals(val, 0xF0);
+    val = (unsigned char)buf[1];
+    mu_assert_int_equals(val, 0xA4);
+    val = (unsigned char)buf[2];
+    mu_assert_int_equals(val, 0xAD);
+    val = (unsigned char)buf[3];
+    mu_assert_int_equals(val, 0xA2);
+
+    return 0;
+}
+
+static char* testXmlDecodeDecimalEntities(void)
+{
+    const char* strin = "X&#65;X";
+    const char* strout = "XAX";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+static char* testXmlDecodeHexEntities(void)
+{
+    const char* strin = "X&#x41;X";
+    const char* strout = "XAX";
+
+    char buf[1000];
+    size_t d = 0;
+
+    memset(buf, 0, sizeof(buf));
+    d = modp_xml_decode(buf, strin, strlen(strin));
+    mu_assert_int_equals(d, strlen(strout));
+    mu_assert_str_equals(strout, buf);
+
+    return 0;
+}
+
+static char* all_tests(void)
+{
+    mu_run_test(testXmlDecodeEmpty);
+    mu_run_test(testXmlDecodeUntouched);
+    mu_run_test(testXmlDecodeNames);
+    mu_run_test(testXmlDecodeBadNames1);
+    mu_run_test(testXmlDecodeBadNames2);
+    mu_run_test(testXmlDecodeBadNames3);
+    mu_run_test(testXmlDecodeBadNames4);
+    mu_run_test(testXmlDecodeBadNames5);
+    mu_run_test(testXmlDecodeBadNames6);
+    mu_run_test(testXmlUnicodeCodePoints);
+    mu_run_test(testXmlUnicodeCharToUTF8);
+    mu_run_test(testXmlDecodeDecimalEntities);
+    mu_run_test(testXmlDecodeHexEntities);
+    return 0;
+}
+
+UNITTESTS

data/vendor/stringencoders/test/speedtest.c

@@ -0,0 +1,241 @@
+/** \file speedtest.c
+ *
+ * Copyright 2005-2016 Nick Galbreath -- nickg [at] client9 [dot] com
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders/
+ *
+ * Released under MIT license.  See LICENSE for details.
+ *
+ * Quickie performance tester.  This does NOT test correctness.
+ *
+ */
+
+#include "apr_base64.h"
+#include "modp_b16.h"
+#include "modp_b2.h"
+#include "modp_b64.h"
+#include "modp_b85.h"
+#include "modp_bjavascript.h"
+#include "modp_burl.h"
+
+#include <time.h>
+#ifndef CLOCKS_PER_SEC
+#ifdef CLK_TCK
+#define CLOCKS_PER_SEC (CLK_TCK)
+#endif
+#endif
+#include <stdio.h>
+#include <string.h>
+
+#define SZ 4096
+int main(void)
+{
+    double s1, s2;
+    int i, j;
+    clock_t c0, c1;
+    char teststr1[SZ];
+
+    /*
+      this contains the message sizes we'll test on
+      add, subtract, change as desired.
+    */
+    size_t sizes[] = { 20, 200, 2000 };
+
+    for (i = 0; i < (int)sizeof(teststr1); ++i) {
+        teststr1[i] = (char)('A' + i % 26);
+    }
+
+    /* over allocate result buffers */
+    char result[SZ * 8];
+    char result2[SZ * 8];
+
+    const int MAX = 1000000;
+
+    for (j = 0; j < (int)(sizeof(sizes) / sizeof(size_t)); ++j) {
+        printf("\nMessage size = %d\n", (int)sizes[j]);
+
+        printf("\tmodpb64\tapache\timprovement\tmodpb85\tmodpurl\tmodpb16\tmodpb2\tmodpjs\n");
+        printf("Encode\t");
+        fflush(stdout);
+
+        /* MODP_B64 ENCODE */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b64_encode(result, teststr1, sizes[j]);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /* APACHE ENCODE */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            apr_base64_encode_binary(result,
+                (const unsigned char*)teststr1,
+                (int)sizes[j]);
+        }
+        c1 = clock();
+        s2 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s2);
+        printf("%6.2fx\t\t", s2 / s1);
+        fflush(stdout);
+
+        /*
+         * base85 encode, let's see what is faster
+         */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b85_encode(result, teststr1, sizes[j]);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /*
+         * url encode
+         */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_burl_encode(result, teststr1, sizes[j]);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /**
+         * B16
+         */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b16_encode(result, teststr1, sizes[j]);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /**
+         * B2 BINARY
+         */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b2_encode(result, teststr1, sizes[j]);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /**
+         * javascript
+         */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_bjavascript_encode(result, teststr1, sizes[j]);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        printf("\n");
+        fflush(stdout);
+
+        /***
+         * DECODE
+         */
+        /* reset result to have b64 chars */
+        modp_b64_encode(result, teststr1, sizes[j]);
+        size_t len = strlen(result);
+
+        printf("Decode\t");
+        fflush(stdout);
+
+        /* MODP_B64 */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b64_decode(result2, result, len);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /* APACHE */
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            apr_base64_decode_binary((unsigned char*)result2, result);
+        }
+        c1 = clock();
+        s2 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s2);
+        printf("%6.2fx\t\t", s2 / s1);
+        fflush(stdout);
+
+        /*
+         * modp_b85 decode
+         */
+        /* re-encode to get b85 chars, not b64 */
+        len = modp_b85_encode(result, teststr1, sizes[j]);
+
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b85_decode(result2, result, len);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /* re-encode to get urlencoded chars, not b64 */
+        len = modp_burl_encode(result, teststr1, sizes[j]);
+
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_burl_decode(result2, result, len);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /**
+         ** B16 DECODE
+         **/
+        /* re-encode to get urlencoded chars, not b64 */
+        len = modp_b16_encode(result, teststr1, sizes[j]);
+
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b16_decode(result2, result, len);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        /**
+         ** B16 DECODE
+         **/
+        /* re-encode to get urlencoded chars, not b64 */
+        len = modp_b2_encode(result, teststr1, sizes[j]);
+
+        c0 = clock();
+        for (i = 0; i < MAX; ++i) {
+            modp_b2_decode(result2, result, len);
+        }
+        c1 = clock();
+        s1 = (double)(c1 - c0) * (1.0 / (double)CLOCKS_PER_SEC);
+        printf("%6.2f\t", s1);
+        fflush(stdout);
+
+        printf("\n");
+        fflush(stdout);
+    }
+
+    return 0;
+}