ffi-hydrogen 0.1.0

data/vendor/stringencoders/test/modp_b2_test.c

@@ -0,0 +1,250 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include "modp_b2.h"
+#include "minunit.h"
+#include "modp_b16.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static char* testEndian(void)
+{
+    /* this test that "0001" is "0...1" */
+    char buf[100];
+    char result[100];
+    char endian[] = { (char)0, (char)0, (char)0, (char)1 };
+    size_t d = modp_b2_encode(buf, endian, (size_t)4);
+    mu_assert_int_equals(32, d);
+    mu_assert_str_equals("00000000000000000000000000000001", buf);
+    mu_assert_int_equals('0', buf[0]);
+    mu_assert_int_equals('1', buf[31]);
+
+    memset(result, 255, sizeof(result));
+    d = modp_b2_decode(result, buf, (size_t)32);
+    mu_assert_int_equals(4, d);
+    mu_assert_int_equals(endian[0], result[0]);
+    mu_assert_int_equals(endian[1], result[1]);
+    mu_assert_int_equals(endian[2], result[2]);
+    mu_assert_int_equals(endian[3], result[3]);
+
+    return 0;
+}
+
+static char* testEncodeDecode(void)
+{
+    /* 2 bytes == 4 bytes out */
+    char ibuf[2];
+    char obuf[17];
+    char rbuf[17];
+    char msg[100]; /* for test messages output */
+    msg[0] = 0; /* make msg an empty string */
+    unsigned int i, j;
+    size_t d;
+
+    for (i = 0; i < 256; ++i) {
+        for (j = 0; j < 256; ++j) {
+            /* comment this out.. it really slows down the test */
+            sprintf(msg, "(i,j) = (%u,%u):", i, j);
+            ibuf[0] = (char)((unsigned char)i);
+            ibuf[1] = (char)((unsigned char)j);
+
+            memset(obuf, 0, sizeof(obuf));
+            d = modp_b16_encode(obuf, ibuf, (size_t)2);
+            mu_assert_int_equals_msg(msg, 4, d);
+            d = modp_b16_decode(rbuf, obuf, d);
+            mu_assert_int_equals_msg(msg, 2, d);
+            mu_assert_int_equals_msg(msg, ibuf[0], rbuf[0]);
+            mu_assert_int_equals_msg(msg, ibuf[1], rbuf[1]);
+        }
+    }
+    return 0;
+}
+
+static char* testOddDecode(void)
+{
+    char obuf[100];
+    char ibuf[100];
+
+    memset(obuf, 0, sizeof(obuf));
+    memset(ibuf, 0, sizeof(ibuf));
+
+    /* Test Odd Number of Input bytes
+     * Should be error
+     */
+    obuf[0] = 1;
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, (size_t)1));
+    mu_assert_int_equals(1, obuf[0]);
+
+    obuf[0] = 1;
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, (size_t)3));
+    mu_assert_int_equals(1, obuf[0]);
+
+    obuf[0] = 1;
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, (size_t)7));
+    mu_assert_int_equals(1, obuf[0]);
+
+    return 0;
+}
+
+/** \brief test input that is a multiple of 2 (special case in code)
+ */
+static char* testDecodeMutlipleOf2(void)
+{
+    char obuf[100];
+    memset(obuf, 0xff, sizeof(obuf));
+
+    mu_assert_int_equals(1, modp_b16_decode(obuf, "01", (size_t)2));
+    mu_assert_int_equals(1, obuf[0]);
+    return 0;
+}
+
+static char* testOddEncode(void)
+{
+    char obuf[100];
+    char ibuf[100];
+
+    /* oddball 1 char. */
+    ibuf[0] = 1;
+    mu_assert_int_equals(2, modp_b16_encode(obuf, ibuf, (size_t)1));
+    mu_assert_int_equals(obuf[0], '0');
+    mu_assert_int_equals(obuf[1], '1');
+
+    /* oddball 2 char.*/
+    ibuf[0] = 0;
+    ibuf[1] = 1;
+    mu_assert_int_equals(4, modp_b16_encode(obuf, ibuf, (size_t)2));
+    mu_assert_int_equals(obuf[0], '0');
+    mu_assert_int_equals(obuf[1], '0');
+    mu_assert_int_equals(obuf[2], '0');
+    mu_assert_int_equals(obuf[3], '1');
+
+    /* oddball 1 char. */
+    ibuf[0] = 0;
+    ibuf[1] = 0;
+    ibuf[2] = 1;
+    mu_assert_int_equals(6, modp_b16_encode(obuf, ibuf, (size_t)3));
+    mu_assert_int_equals(obuf[0], '0');
+    mu_assert_int_equals(obuf[1], '0');
+    mu_assert_int_equals(obuf[2], '0');
+    mu_assert_int_equals(obuf[3], '0');
+    mu_assert_int_equals(obuf[4], '0');
+    mu_assert_int_equals(obuf[5], '1');
+    return 0;
+}
+
+static char* testBadDecode(void)
+{
+    char obuf[100];
+    char ibuf[100];
+
+    memset(obuf, 0, sizeof(obuf));
+    memset(ibuf, 0, sizeof(ibuf));
+
+    /* we are testing input of 2 bytes, 4 bytes
+     * to test all possible screwups
+     */
+    strcpy(ibuf, "X1");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "1X");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "XX");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+
+    /* 1 bad char */
+    strcpy(ibuf, "X111");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "1X11");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "11X1");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "111X");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+
+    /* 2 bad chars */
+    strcpy(ibuf, "XX11");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "1XX1");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "11XX");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "X1X1");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "1X1X");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "X11X");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+
+    /* 3 bad chars */
+    strcpy(ibuf, "1XXX");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "X1XX");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "XX1X");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+    strcpy(ibuf, "XXX1");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+
+    /* 4 bad chars */
+    strcpy(ibuf, "XXXX");
+    mu_assert_int_equals(-1, modp_b2_decode(obuf, ibuf, strlen(ibuf)));
+
+    return 0;
+}
+
+static char* testEmptyInput(void)
+{
+    char obuf[100];
+    char ibuf[100];
+
+    memset(obuf, 0, sizeof(obuf));
+    memset(ibuf, 0, sizeof(ibuf));
+
+    /* encode 0 bytes, get a null byte back */
+    obuf[0] = 1;
+    mu_assert_int_equals(0, modp_b16_encode(obuf, ibuf, (size_t)0));
+    mu_assert_int_equals(0, obuf[0]);
+
+    /* decode 0 bytes, buffer is untouched */
+    obuf[0] = 1;
+    mu_assert_int_equals(0, modp_b16_decode(obuf, ibuf, (size_t)0));
+    mu_assert_int_equals(1, obuf[0]);
+    return 0;
+}
+
+static char* testLengths(void)
+{
+    /* Decode Len
+     * 2 input -> 1 output.  No added NULL byte
+     */
+    mu_assert_int_equals(0, modp_b16_decode_len(0));
+    mu_assert_int_equals(1, modp_b16_decode_len(1));
+    mu_assert_int_equals(1, modp_b16_decode_len(2));
+    mu_assert_int_equals(2, modp_b16_decode_len(3));
+    mu_assert_int_equals(2, modp_b16_decode_len(4));
+
+    /* Encode Len
+     * 1 byte -> 2 output + 1 null byte
+     */
+    mu_assert_int_equals(1, modp_b16_encode_len(0));
+    mu_assert_int_equals(3, modp_b16_encode_len(1));
+    mu_assert_int_equals(5, modp_b16_encode_len(2));
+    mu_assert_int_equals(7, modp_b16_encode_len(3));
+    mu_assert_int_equals(9, modp_b16_encode_len(4));
+    return 0;
+}
+
+static char* all_tests(void)
+{
+    mu_run_test(testEndian);
+    mu_run_test(testEncodeDecode);
+    mu_run_test(testLengths);
+    mu_run_test(testEmptyInput);
+    mu_run_test(testBadDecode);
+    mu_run_test(testOddDecode);
+    mu_run_test(testOddEncode);
+    mu_run_test(testDecodeMutlipleOf2);
+    return 0;
+}
+
+UNITTESTS

data/vendor/stringencoders/test/modp_b64_test.c

@@ -0,0 +1,266 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_b64.h"
+/**
+ * checks to make sure results are the same reguardless of
+ * CPU endian type (i.e. Intel vs. Sparc, etc)
+ *
+ */
+static char* testEndian(void)
+{
+    /* this test that "1" is "AAAB" */
+    char buf[100];
+    char result[10];
+    char endian[] = { (char)0, (char)0, (char)1 };
+    size_t d = modp_b64_encode(buf, endian, (size_t)3);
+    mu_assert_int_equals(4, d);
+    mu_assert_int_equals('A', buf[0]);
+    mu_assert_int_equals('A', buf[1]);
+    mu_assert_int_equals('A', buf[2]);
+    mu_assert_int_equals('B', buf[3]);
+
+    memset(result, 255, sizeof(result));
+    d = modp_b64_decode(result, "AAAB", (size_t)4);
+    mu_assert_int_equals(3, d);
+    mu_assert_int_equals(0, result[0]);
+    mu_assert_int_equals(0, result[1]);
+    mu_assert_int_equals(1, result[2]);
+    mu_assert_int_equals(-1, result[3]);
+
+    return 0;
+}
+
+/**
+ * sending 0 as length to encode and decode
+ * should basically do nothing
+ */
+static char* testEmpty(void)
+{
+    char buf[10];
+    const char* input = 0; /* null */
+    size_t d;
+
+    memset(buf, 1, sizeof(buf));
+    d = modp_b64_encode(buf, input, (size_t)0);
+    mu_assert_int_equals(0, d);
+    mu_assert_int_equals(0, buf[0]);
+    mu_assert_int_equals(1, buf[1]);
+
+    memset(buf, 1, sizeof(buf));
+    d = modp_b64_decode(buf, input, (size_t)0);
+    mu_assert_int_equals(0, d);
+    mu_assert_int_equals(1, buf[0]);
+    mu_assert_int_equals(1, buf[1]);
+
+    return 0;
+}
+
+/**
+ * Test 1-6 bytes input and decode
+ *
+ */
+static char* testPadding(void)
+{
+    char msg[100];
+    const char ibuf[6] = { 1, 1, 1, 1, 1, 1 };
+    char obuf[10];
+    char rbuf[10];
+    size_t d = 0;
+
+    /* 1 in, 4 out */
+    memset(obuf, 255, sizeof(obuf));
+    d = modp_b64_encode(obuf, ibuf, (size_t)1);
+    sprintf(msg, "b64='%s', d=%d", obuf, (int)d);
+    mu_assert_int_equals_msg(msg, 4, d);
+    mu_assert_int_equals_msg(msg, 0, obuf[4]);
+    memset(rbuf, 255, sizeof(rbuf));
+    d = modp_b64_decode(rbuf, obuf, d);
+    mu_assert_int_equals_msg(msg, 1, d);
+    mu_assert_int_equals(1, rbuf[0]);
+    mu_assert_int_equals(-1, rbuf[1]);
+
+    /* 2 in, 4 out */
+    memset(obuf, 255, sizeof(obuf));
+    d = modp_b64_encode(obuf, ibuf, (size_t)2);
+    sprintf(msg, "b64='%s', d=%d", obuf, (int)d);
+    mu_assert_int_equals_msg(msg, 4, d);
+    mu_assert_int_equals_msg(msg, 0, obuf[4]);
+    memset(rbuf, 255, sizeof(rbuf));
+    d = modp_b64_decode(rbuf, obuf, d);
+    mu_assert_int_equals_msg(msg, 2, d);
+    mu_assert_int_equals_msg(msg, 1, rbuf[0]);
+    mu_assert_int_equals_msg(msg, 1, rbuf[1]);
+    mu_assert_int_equals_msg(msg, -1, rbuf[2]);
+
+    /* 3 in, 4 out */
+    memset(obuf, 255, sizeof(obuf));
+    d = modp_b64_encode(obuf, ibuf, (size_t)3);
+    sprintf(msg, "b64='%s', d=%d", obuf, (int)d);
+    mu_assert_int_equals_msg(msg, 4, d);
+    mu_assert_int_equals_msg(msg, 0, obuf[4]);
+    memset(rbuf, 255, sizeof(rbuf));
+    d = modp_b64_decode(rbuf, obuf, d);
+    mu_assert_int_equals_msg(msg, 3, d);
+    mu_assert_int_equals_msg(msg, 1, rbuf[0]);
+    mu_assert_int_equals_msg(msg, 1, rbuf[1]);
+    mu_assert_int_equals_msg(msg, 1, rbuf[2]);
+    mu_assert_int_equals_msg(msg, -1, rbuf[3]);
+
+    /* 4 in, 8 out */
+    memset(obuf, 255, sizeof(obuf));
+    d = modp_b64_encode(obuf, ibuf, (size_t)4);
+    sprintf(msg, "b64='%s', d=%d", obuf, (int)d);
+    mu_assert_int_equals_msg(msg, 8, d);
+    mu_assert_int_equals_msg(msg, 0, obuf[8]);
+    memset(rbuf, 255, sizeof(rbuf));
+    d = modp_b64_decode(rbuf, obuf, d);
+    mu_assert_int_equals(4, d);
+    mu_assert_int_equals(1, rbuf[0]);
+    mu_assert_int_equals(1, rbuf[1]);
+    mu_assert_int_equals(1, rbuf[2]);
+    mu_assert_int_equals(1, rbuf[3]);
+    mu_assert_int_equals(-1, rbuf[4]);
+
+    /* 5 in, 8 out */
+    memset(obuf, 255, sizeof(obuf));
+    d = modp_b64_encode(obuf, ibuf, (size_t)5);
+    sprintf(msg, "b64='%s', d=%d", obuf, (int)d);
+    mu_assert_int_equals_msg(msg, 8, d);
+    mu_assert_int_equals_msg(msg, 0, obuf[8]);
+    memset(rbuf, 255, sizeof(rbuf));
+    d = modp_b64_decode(rbuf, obuf, d);
+    mu_assert_int_equals(5, d);
+    mu_assert_int_equals(1, rbuf[0]);
+    mu_assert_int_equals(1, rbuf[1]);
+    mu_assert_int_equals(1, rbuf[2]);
+    mu_assert_int_equals(1, rbuf[3]);
+    mu_assert_int_equals(1, rbuf[4]);
+    mu_assert_int_equals(-1, rbuf[5]);
+
+    /* 6 in, 8 out */
+    memset(obuf, 255, sizeof(obuf));
+    d = modp_b64_encode(obuf, ibuf, (size_t)6);
+    sprintf(msg, "b64='%s', d=%d", obuf, (int)d);
+    mu_assert_int_equals_msg(msg, 8, d);
+    mu_assert_int_equals_msg(msg, 0, obuf[8]);
+    memset(rbuf, 255, sizeof(rbuf));
+    d = modp_b64_decode(rbuf, obuf, d);
+    mu_assert_int_equals(6, d);
+    mu_assert_int_equals(1, rbuf[0]);
+    mu_assert_int_equals(1, rbuf[1]);
+    mu_assert_int_equals(1, rbuf[2]);
+    mu_assert_int_equals(1, rbuf[3]);
+    mu_assert_int_equals(1, rbuf[4]);
+    mu_assert_int_equals(1, rbuf[5]);
+    mu_assert_int_equals(-1, rbuf[6]);
+
+    return 0;
+}
+
+/**
+ * Test all 17M 3 bytes inputs to encoder, decode
+ * and make sure it's equal.
+ */
+static char* testEncodeDecode(void)
+{
+    char ibuf[4];
+    char obuf[5];
+    char rbuf[4];
+    char msg[100];
+    msg[0] = 0; /* make msg an empty string */
+    unsigned int i, j, k;
+    size_t d = 0;
+    for (i = 0; i < 256; ++i) {
+        for (j = 0; j < 256; ++j) {
+            for (k = 0; k < 256; ++k) {
+                /* comment this out.. it really slows down the test */
+                /* sprintf(msg, "(i,j,k) = (%d,%d,%d):", i,j,k); */
+                ibuf[0] = (char)((unsigned char)i);
+                ibuf[1] = (char)((unsigned char)j);
+                ibuf[2] = (char)((unsigned char)k);
+                ibuf[3] = 0;
+
+                memset(obuf, 1, sizeof(obuf));
+                d = modp_b64_encode(obuf, ibuf, (size_t)3);
+                mu_assert_int_equals_msg(msg, 4, d);
+                mu_assert_int_equals_msg(msg, 0, obuf[4]);
+
+                memset(rbuf, 1, sizeof(rbuf));
+                d = modp_b64_decode(rbuf, obuf, (size_t)4);
+                mu_assert_int_equals_msg(msg, 3, d);
+                mu_assert_int_equals_msg(msg, ibuf[0], rbuf[0]);
+                mu_assert_int_equals_msg(msg, ibuf[1], rbuf[1]);
+                mu_assert_int_equals_msg(msg, ibuf[2], rbuf[2]);
+                mu_assert_int_equals_msg(msg, 1, rbuf[3]);
+            }
+        }
+    }
+    return 0;
+}
+
+static char* testDecodeErrors(void)
+{
+    int i;
+    size_t y;
+    char out[1000];
+    char decode[5];
+    char msg[100];
+
+    /* negative length */
+    memset(decode, 1, sizeof(decode));
+    y = modp_b64_decode(out, decode, (size_t)-1);
+    mu_assert_int_equals(-1, y);
+
+    /* test bad input -  all combinations */
+    char goodchar = 'A';
+    char badchar = '~';
+    for (i = 1; i < 16; ++i) {
+        decode[0] = (char)(((i & 0x01) == 0) ? goodchar : badchar);
+        decode[1] = (char)(((i & 0x02) == 0) ? goodchar : badchar);
+        decode[2] = (char)(((i & 0x04) == 0) ? goodchar : badchar);
+        decode[3] = (char)(((i & 0x08) == 0) ? goodchar : badchar);
+        decode[4] = '\0';
+
+        sprintf(msg, "i = %d, %s", i, decode);
+        y = modp_b64_decode(out, decode, (size_t)4);
+        mu_assert_int_equals_msg(msg, (size_t)-1, y);
+    }
+
+    /*  test just 1-4 padchars */
+    for (i = 0; i < 4; ++i) {
+        decode[i] = '=';
+        decode[i + 1] = '\0';
+        y = modp_b64_decode(out, decode, (size_t)(i + 1));
+        sprintf(msg, "i=%d, b64=%s", i, decode);
+        mu_assert_int_equals_msg(msg, (size_t)-1, y);
+    }
+
+    /* Test good+3 pad chars (should be impossible) */
+    decode[0] = 'A';
+    decode[1] = '=';
+    decode[2] = '=';
+    decode[3] = '=';
+    y = modp_b64_decode(out, decode, (size_t)4);
+    mu_assert_int_equals(-1, y);
+
+    return 0;
+}
+
+static char* all_tests(void)
+{
+    mu_run_test(testEndian);
+    mu_run_test(testEmpty);
+    mu_run_test(testPadding);
+    mu_run_test(testEncodeDecode);
+    mu_run_test(testDecodeErrors);
+    return 0;
+}
+
+UNITTESTS

data/vendor/stringencoders/test/modp_b85_test.c

@@ -0,0 +1,130 @@
+/* we compile as C90 but use snprintf */
+#define _ISOC99_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "minunit.h"
+
+#include "modp_b85.h"
+
+/**
+ * checks to make sure results are the same reguardless of
+ * CPU endian type (i.e. Intel vs. Sparc, etc)
+ *
+ */
+static char* testEndian(void)
+{
+    /* this test that "1" is "!!!!#" */
+    char buf[100];
+    char result[10];
+    char endian[] = { (char)0, (char)0, (char)0, (char)1 };
+    size_t d = modp_b85_encode(buf, endian, (size_t)4);
+    mu_assert_int_equals(5, d);
+    mu_assert_int_equals('!', buf[0]);
+    mu_assert_int_equals('!', buf[1]);
+    mu_assert_int_equals('!', buf[2]);
+    mu_assert_int_equals('!', buf[3]);
+    mu_assert_int_equals('#', buf[4]);
+
+    memset(result, 255, sizeof(result));
+    d = modp_b85_decode(result, "!!!!#", (size_t)5);
+    mu_assert_int_equals(4, d);
+    mu_assert_int_equals(0, result[0]);
+    mu_assert_int_equals(0, result[1]);
+    mu_assert_int_equals(0, result[2]);
+    mu_assert_int_equals(1, result[3]);
+    mu_assert_int_equals(-1, result[4]);
+
+    return 0;
+}
+
+static char* testLength(void)
+{
+    /**
+     * Decode Len
+     * 5 bytes -> 4 in, no null
+     */
+    mu_assert_int_equals(0, modp_b85_decode_len(0));
+    mu_assert_int_equals(4, modp_b85_decode_len(5));
+    mu_assert_int_equals(8, modp_b85_decode_len(10));
+
+    /* Encode Len
+     * 4 byte -> 5 output + 1 null byte
+     */
+    mu_assert_int_equals(1, modp_b85_encode_len(0));
+    mu_assert_int_equals(6, modp_b85_encode_len(4));
+    mu_assert_int_equals(11, modp_b85_encode_len(8));
+    return 0;
+}
+
+/** \brief test bad input lengths
+ * The b85 encode only accepts multiples of 4.
+ *
+ * The b85 decoder only accepts a multiple of 5.
+ *
+ */
+static char* testBadInputLength(void)
+{
+    char buf[100];
+    mu_assert_int_equals(-1, modp_b85_encode(buf, buf, (size_t)5));
+    mu_assert_int_equals(-1, modp_b85_decode(buf, buf, (size_t)11));
+    return 0;
+}
+
+/** \brief test decoding invalid b85 chars
+ *
+ */
+static char* testBadCharDecode(void)
+{
+    char buf[] = { 'A', 'B', 'C', 'D', '\n', '\0' };
+    mu_assert_int_equals(-1, modp_b85_decode(buf, buf, (size_t)5));
+    return 0;
+}
+
+static char* testEncodeDecode(void)
+{
+    char ibuf[10]; /* input */
+    char obuf[10]; /* output */
+    char rbuf[10]; /* final result */
+    size_t d;
+    int i, j, k, l;
+    for (i = 0; i < 256; ++i) {
+        for (j = 0; j < 256; j += 16) { /* save some time +=16 */
+            for (k = 0; k < 256; k += 8) { /* save some time += 8 */
+                for (l = 0; l < 256; ++l) {
+                    ibuf[0] = (char)i;
+                    ibuf[1] = (char)j;
+                    ibuf[2] = (char)k;
+                    ibuf[3] = (char)l;
+                    memset(obuf, 255, sizeof(obuf));
+                    d = modp_b85_encode(obuf, ibuf, (size_t)4);
+                    mu_assert_int_equals(5, d);
+                    mu_assert_int_equals(0, obuf[5]);
+                    memset(rbuf, 255, sizeof(rbuf));
+                    d = modp_b85_decode(rbuf, obuf, (size_t)5);
+                    mu_assert_int_equals(4, d);
+                    mu_assert_int_equals(ibuf[0], rbuf[0]);
+                    mu_assert_int_equals(ibuf[1], rbuf[1]);
+                    mu_assert_int_equals(ibuf[2], rbuf[2]);
+                    mu_assert_int_equals(ibuf[3], rbuf[3]);
+                    mu_assert_int_equals(-1, rbuf[4]);
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static char* all_tests(void)
+{
+    mu_run_test(testEndian);
+    mu_run_test(testLength);
+    mu_run_test(testBadInputLength);
+    mu_run_test(testBadCharDecode);
+    mu_run_test(testEncodeDecode);
+    return 0;
+}
+
+UNITTESTS