summaryrefslogtreecommitdiffstats
path: root/test/testencode.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--test/testencode.c1124
1 files changed, 1124 insertions, 0 deletions
diff --git a/test/testencode.c b/test/testencode.c
new file mode 100644
index 0000000..6d78310
--- /dev/null
+++ b/test/testencode.c
@@ -0,0 +1,1124 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "apr_encode.h"
+#include "apr_strings.h"
+
+#include "abts.h"
+#include "testutil.h"
+
+static const unsigned char ufoobar[] = { 'f', 'o', 'o', 'b', 'a', 'r' };
+
+static void test_encode_base64(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src, *target;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ src = "";
+ target = "";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "f";
+ target = "Zg==";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "f";
+ target = "Zg";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fo";
+ target = "Zm8=";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fo";
+ target = "Zm8";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foo";
+ target = "Zm9v";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foo";
+ target = "Zm9v";
+ dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_encode_base64_binary(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *target;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ target = "";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 0, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "Zg==";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 1, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "Zg";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 1, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "Zm8=";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 2, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "Zm8";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 2, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "Zm9v";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 3, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "Zm9v";
+ dest = apr_pencode_base64_binary(pool, ufoobar, 3, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_decode_base64(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *target, *src;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ src = "";
+ target = "";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zg==";
+ target = "f";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zg=";
+ target = "f";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zg";
+ target = "f";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zm8=";
+ target = "fo";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zm8";
+ target = "fo";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zm9v";
+ target = "foo";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "Zm9v";
+ target = "foo";
+ dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_decode_base64_binary(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src;
+ const unsigned char *udest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ src = "";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 0) == 0);
+ ABTS_INT_EQUAL(tc, len, 0);
+
+ src = "Zg==";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, len, 1);
+
+ src = "Zg=";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, len, 1);
+
+ src = "Zg";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, len, 1);
+
+ src = "Zm8=";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
+ ABTS_INT_EQUAL(tc, len, 2);
+
+ src = "Zm8";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
+ ABTS_INT_EQUAL(tc, len, 2);
+
+ src = "Zm9v";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
+ ABTS_INT_EQUAL(tc, len, 3);
+
+ src = "Zm9v";
+ udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
+ ABTS_INT_EQUAL(tc, len, 3);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_encode_base32(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src, *target;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ src = "";
+ target = "";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "f";
+ target = "MY======";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "f";
+ target = "MY";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "f";
+ target = "CO======";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "f";
+ target = "CO";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fo";
+ target = "MZXQ====";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fo";
+ target = "MZXQ";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fo";
+ target = "CPNG====";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fo";
+ target = "CPNG";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foo";
+ target = "MZXW6===";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foo";
+ target = "MZXW6";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foo";
+ target = "CPNMU===";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foo";
+ target = "CPNMU";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foob";
+ target = "MZXW6YQ=";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foob";
+ target = "MZXW6YQ";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foob";
+ target = "CPNMUOG=";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foob";
+ target = "CPNMUOG";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fooba";
+ target = "MZXW6YTB";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fooba";
+ target = "MZXW6YTB";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fooba";
+ target = "CPNMUOJ1";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "fooba";
+ target = "CPNMUOJ1";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foobar";
+ target = "MZXW6YTBOI======";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foobar";
+ target = "MZXW6YTBOI";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foobar";
+ target = "CPNMUOJ1E8======";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "foobar";
+ target = "CPNMUOJ1E8";
+ dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_encode_base32_binary(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *target;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ target = "";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 0, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MY======";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MY";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CO======";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CO";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXQ====";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXQ";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNG====";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNG";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6===";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMU===";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMU";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6YQ=";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6YQ";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMUOG=";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMUOG";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6YTB";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6YTB";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMUOJ1";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMUOJ1";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6YTBOI======";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "MZXW6YTBOI";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMUOJ1E8======";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ target = "CPNMUOJ1E8";
+ dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_decode_base32(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *target, *src;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ src = "";
+ target = "";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MY======";
+ target = "f";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MY";
+ target = "f";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CO======";
+ target = "f";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CO";
+ target = "f";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXQ====";
+ target = "fo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXQ";
+ target = "fo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNG====";
+ target = "fo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNG";
+ target = "fo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6===";
+ target = "foo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6";
+ target = "foo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMU===";
+ target = "foo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMU";
+ target = "foo";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6YQ=";
+ target = "foob";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6YQ=";
+ target = "foob";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMUOG=";
+ target = "foob";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMUOG";
+ target = "foob";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6YTB";
+ target = "fooba";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6YTB";
+ target = "fooba";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMUOJ1";
+ target = "fooba";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMUOJ1";
+ target = "fooba";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6YTBOI======";
+ target = "foobar";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "MZXW6YTBOI";
+ target = "foobar";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMUOJ1E8======";
+ target = "foobar";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ src = "CPNMUOJ1E8";
+ target = "foobar";
+ dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_decode_base32_binary(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src;
+ const unsigned char *udest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ /*
+ * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
+ */
+ src = "";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 0) == 0);
+ ABTS_INT_EQUAL(tc, 0, len);
+
+ src = "MY======";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, 1, len);
+
+ src = "MY";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, 1, len);
+
+ src = "CO======";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, 1, len);
+
+ src = "CO";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
+ ABTS_INT_EQUAL(tc, 1, len);
+
+ src = "MZXQ====";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
+ ABTS_INT_EQUAL(tc, 2, len);
+
+ src = "MZXQ";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
+ ABTS_INT_EQUAL(tc, 2, len);
+
+ src = "CPNG====";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
+ ABTS_INT_EQUAL(tc, 2, len);
+
+ src = "CPNG";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
+ ABTS_INT_EQUAL(tc, 2, len);
+
+ src = "MZXW6===";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
+ ABTS_INT_EQUAL(tc, 3, len);
+
+ src = "MZXW6";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
+ ABTS_INT_EQUAL(tc, 3, len);
+
+ src = "CPNMU===";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
+ ABTS_INT_EQUAL(tc, 3, len);
+
+ src = "CPNMU";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
+ ABTS_INT_EQUAL(tc, 3, len);
+
+ src = "MZXW6YQ=";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
+ ABTS_INT_EQUAL(tc, 4, len);
+
+ src = "MZXW6YQ=";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
+ ABTS_INT_EQUAL(tc, 4, len);
+
+ src = "CPNMUOG=";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
+ ABTS_INT_EQUAL(tc, 4, len);
+
+ src = "CPNMUOG";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
+ ABTS_INT_EQUAL(tc, 4, len);
+
+ src = "MZXW6YTB";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
+ ABTS_INT_EQUAL(tc, 5, len);
+
+ src = "MZXW6YTB";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
+ ABTS_INT_EQUAL(tc, 5, len);
+
+ src = "CPNMUOJ1";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
+ ABTS_INT_EQUAL(tc, 5, len);
+
+ src = "CPNMUOJ1";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
+ ABTS_INT_EQUAL(tc, 5, len);
+
+ src = "MZXW6YTBOI======";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
+ ABTS_INT_EQUAL(tc, 6, len);
+
+ src = "MZXW6YTBOI";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
+ ABTS_INT_EQUAL(tc, 6, len);
+
+ src = "CPNMUOJ1E8======";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
+ ABTS_INT_EQUAL(tc, 6, len);
+
+ src = "CPNMUOJ1E8";
+ udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
+ ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
+ ABTS_INT_EQUAL(tc, 6, len);
+
+ apr_pool_destroy(pool);
+}
+
+static void test_encode_base16(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src, *target;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ src = "foobar";
+ target = "666f6f626172";
+ dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_LOWER, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ src = "foobar";
+ target = "666F6F626172";
+ dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ src = "foobar";
+ target = "66:6f:6f:62:61:72";
+ dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON | APR_ENCODE_LOWER, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ src = "foobar";
+ target = "66:6F:6F:62:61:72";
+ dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ apr_pool_destroy(pool);
+}
+
+static void test_encode_base16_binary(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *target;
+ const unsigned char usrc[] = {
+ 0xFF, 0x00, 0xFF, 0x00
+ };
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ target = "ff00ff00";
+ dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_LOWER, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ target = "FF00FF00";
+ dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_NONE, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_NONE, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ target = "ff:00:ff:00";
+ dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_COLON | APR_ENCODE_LOWER, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_COLON, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ target = "FF:00:FF:00";
+ dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_COLON, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_COLON, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
+ (len == strlen(dest) + 1));
+
+ apr_pool_destroy(pool);
+}
+
+static void test_decode_base16(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src, *target;
+ const char *dest;
+ apr_size_t len;
+
+ apr_pool_create(&pool, NULL);
+
+ src = "3A:3B:3C:3D";
+ target = ":;<=";
+ dest = apr_pdecode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
+ ABTS_STR_EQUAL(tc, target, dest);
+ ABTS_INT_EQUAL(tc, 4, (int)len);
+ apr_decode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, (apr_size_t) 5),
+ (len == 5));
+
+ apr_pool_destroy(pool);
+}
+
+static void test_decode_base16_binary(abts_case * tc, void *data)
+{
+ apr_pool_t *pool;
+ const char *src;
+ const unsigned char utarget[] = {
+ 0xFF, 0x00, 0xFF, 0x00
+ };
+ const unsigned char *udest;
+ apr_size_t len, vlen;
+
+ apr_pool_create(&pool, NULL);
+
+ src = "ff:00:ff:00";
+ udest = apr_pdecode_base16_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &vlen);
+ ABTS_ASSERT(tc, "apr_pdecode_base16_binary target!=dest", memcmp(utarget, udest, 4) == 0);
+ ABTS_INT_EQUAL(tc, (int)vlen, 4);
+ apr_decode_base16_binary(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
+ ABTS_ASSERT(tc,
+ apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, (apr_size_t) 4),
+ (len == 4));
+
+ apr_pool_destroy(pool);
+}
+
+static void test_encode_errors(abts_case * tc, void *data)
+{
+ char dest[64];
+ apr_size_t len;
+ apr_status_t rv;
+
+ /* Can't test APR_ENOSPC without a NUL terminated buffer of
+ * length APR_SIZE_MAX / 4 * 3 and passing APR_ENCODE_STRING,
+ * which we won't even think about :)
+ */
+
+ /* base64 */
+ rv = apr_encode_base64(dest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_encode_base64(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+
+ /* base64_binary */
+ rv = apr_encode_base64_binary(dest, (const unsigned char *)"", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_encode_base64_binary(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+
+ /* base32 */
+ rv = apr_encode_base32(dest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_encode_base32(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+
+ /* base32_binary */
+ rv = apr_encode_base32_binary(dest, (const unsigned char *)"", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_encode_base32_binary(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+
+ /* base16 */
+ rv = apr_encode_base16(dest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_encode_base16(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+
+ /* base16_binary */
+ rv = apr_encode_base16_binary(dest, (const unsigned char *)"", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_encode_base16_binary(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+}
+
+static void test_decode_errors(abts_case * tc, void *data)
+{
+ char dest[64];
+ apr_size_t len;
+ apr_status_t rv;
+ unsigned char *udest = (unsigned char *)dest;
+
+ /* base64 */
+ rv = apr_decode_base64(dest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_decode_base64(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+ rv = apr_decode_base64(NULL, NULL, 5, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base64(dest, "ABCDE", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base64(dest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base64(dest, "ABCD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 3, len);
+
+ /* base64_binary */
+ rv = apr_decode_base64_binary(udest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_decode_base64_binary(udest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+ rv = apr_decode_base64_binary(NULL, NULL, 5, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base64_binary(udest, "ABCDE", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base64_binary(udest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base64_binary(udest, "ABCD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 3, len);
+
+ /* base32 */
+ rv = apr_decode_base32(dest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_decode_base32(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+ rv = apr_decode_base32(NULL, NULL, 9, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32(NULL, NULL, 11, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32(NULL, NULL, 14, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32(dest, "ABCDEFGHI", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32(dest, "ABCDEFGHIJK", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32(dest, "ABCDEFGHIJKLMN", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32(dest, "ABCDEFGH*IJ", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base32(dest, "ABCEEFGH*IJ", APR_ENCODE_STRING,
+ APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 5, len);
+
+ /* base32_binary */
+ rv = apr_decode_base32_binary(udest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_decode_base32_binary(udest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+ rv = apr_decode_base32_binary(NULL, NULL, 9, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32_binary(NULL, NULL, 11, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32_binary(NULL, NULL, 14, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32_binary(udest, "ABCDEFGHI", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32_binary(udest, "ABCDEFGHIJK", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32_binary(udest, "ABCDEFGHIJKLMN", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base32_binary(udest, "ABCDEFGH*IJ", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base32_binary(udest, "ABCEEFGH*IJ", APR_ENCODE_STRING,
+ APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 5, len);
+
+ /* base16 */
+ rv = apr_decode_base16(dest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_decode_base16(dest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+ rv = apr_decode_base16(NULL, NULL, 3, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16(dest, "ABC", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16(dest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base16(dest, "ABCD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 2, len);
+ /* base16 with colon */
+ rv = apr_decode_base16(dest, "AB:", APR_ENCODE_STRING,
+ APR_ENCODE_COLON, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16(dest, "AB:C", APR_ENCODE_STRING,
+ APR_ENCODE_COLON, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16(dest, "AB:CD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_COLON, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base16(dest, "AB:CD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_COLON|APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 2, len);
+
+ /* base16_binary */
+ rv = apr_decode_base16_binary(udest, "", -2, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
+ rv = apr_decode_base16_binary(udest, NULL, APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
+ rv = apr_decode_base16_binary(NULL, NULL, 3, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16_binary(udest, "ABC", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16_binary(udest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base16_binary(udest, "ABCD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 2, len);
+ /* base16_binary with colon */
+ rv = apr_decode_base16_binary(udest, "AB:", APR_ENCODE_STRING,
+ APR_ENCODE_COLON, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16_binary(udest, "AB:C", APR_ENCODE_STRING,
+ APR_ENCODE_COLON, &len);
+ ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
+ rv = apr_decode_base16_binary(udest, "AB:CD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_COLON, &len);
+ ABTS_INT_EQUAL(tc, APR_BADCH, rv);
+ rv = apr_decode_base16_binary(udest, "AB:CD*EF", APR_ENCODE_STRING,
+ APR_ENCODE_COLON|APR_ENCODE_RELAXED, &len);
+ ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+ ABTS_SIZE_EQUAL(tc, 2, len);
+}
+
+abts_suite *testencode(abts_suite * suite)
+{
+ suite = ADD_SUITE(suite);
+
+ abts_run_test(suite, test_encode_base64, NULL);
+ abts_run_test(suite, test_encode_base64_binary, NULL);
+ abts_run_test(suite, test_decode_base64, NULL);
+ abts_run_test(suite, test_decode_base64_binary, NULL);
+ abts_run_test(suite, test_encode_base32, NULL);
+ abts_run_test(suite, test_encode_base32_binary, NULL);
+ abts_run_test(suite, test_decode_base32, NULL);
+ abts_run_test(suite, test_decode_base32_binary, NULL);
+ abts_run_test(suite, test_encode_base16, NULL);
+ abts_run_test(suite, test_encode_base16_binary, NULL);
+ abts_run_test(suite, test_decode_base16, NULL);
+ abts_run_test(suite, test_decode_base16_binary, NULL);
+ abts_run_test(suite, test_encode_errors, NULL);
+ abts_run_test(suite, test_decode_errors, NULL);
+
+ return suite;
+}