@ohos-ports/bare-buffer 3.7.1-beta.0

package/deps/libbase64/include/base64.h

@@ -0,0 +1,323 @@
+#ifndef BASE64_H
+#define BASE64_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <utf.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static const char base64__alphabet[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static const char base64url__alphabet[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+static const char base64__inverse_alphabet[256] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+
+static inline int
+base64__encode_utf8(const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t *string_len, bool url_safe) {
+  const char *alphabet = url_safe ? base64url__alphabet : base64__alphabet;
+
+  bool pad = !url_safe;
+
+  size_t len = pad ? 4 * ((buffer_len + 2) / 3) : ((buffer_len * 4 + 2) / 3);
+
+  if (string == NULL) {
+    *string_len = len;
+    return 0;
+  }
+
+  if (*string_len < len) return -1;
+
+  bool terminate = *string_len > len;
+
+  *string_len = len;
+
+  size_t k = 0, i = 0, n = buffer_len;
+
+  uint8_t a, b, c;
+
+  for (; i + 2 < n; i += 3) {
+    a = buffer[i];
+    b = buffer[i + 1];
+    c = buffer[i + 2];
+
+    string[k++] = alphabet[a >> 2];
+    string[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+    string[k++] = alphabet[((b & 0x0f) << 2) | (c >> 6)];
+    string[k++] = alphabet[c & 0x3f];
+  }
+
+  if (i < n) {
+    a = buffer[i];
+
+    string[k++] = alphabet[a >> 2];
+
+    if (i + 1 < n) {
+      b = buffer[i + 1];
+
+      string[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+      string[k++] = alphabet[(b & 0x0f) << 2];
+
+      if (pad) string[k++] = '=';
+    } else {
+      string[k++] = alphabet[(a & 0x03) << 4];
+
+      if (pad) {
+        string[k++] = '=';
+        string[k++] = '=';
+      }
+    }
+  }
+
+  if (terminate) string[k] = '\0';
+
+  return 0;
+}
+
+static inline int
+base64__encode_utf16le(const uint8_t *buffer, size_t buffer_len, utf16_t *string, size_t *string_len, bool url_safe) {
+  const char *alphabet = url_safe ? base64url__alphabet : base64__alphabet;
+
+  bool pad = !url_safe;
+
+  size_t len = pad ? 4 * ((buffer_len + 2) / 3) : ((buffer_len * 4 + 2) / 3);
+
+  if (string == NULL) {
+    *string_len = len;
+    return 0;
+  }
+
+  if (*string_len < len) return -1;
+
+  bool terminate = *string_len > len;
+
+  *string_len = len;
+
+  size_t k = 0, i = 0, n = buffer_len;
+
+  uint8_t a, b, c;
+
+  for (; i + 2 < n; i += 3) {
+    a = buffer[i];
+    b = buffer[i + 1];
+    c = buffer[i + 2];
+
+    string[k++] = alphabet[a >> 2];
+    string[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+    string[k++] = alphabet[((b & 0x0f) << 2) | (c >> 6)];
+    string[k++] = alphabet[c & 0x3f];
+  }
+
+  if (i < n) {
+    a = buffer[i];
+
+    string[k++] = alphabet[a >> 2];
+
+    if (i + 1 < n) {
+      b = buffer[i + 1];
+
+      string[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+      string[k++] = alphabet[(b & 0x0f) << 2];
+
+      if (pad) string[k++] = '=';
+    } else {
+      string[k++] = alphabet[(a & 0x03) << 4];
+
+      if (pad) {
+        string[k++] = '=';
+        string[k++] = '=';
+      }
+    }
+  }
+
+  if (terminate) string[k] = '\0';
+
+  return 0;
+}
+
+static inline int
+base64__decode_utf8(const utf8_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len) {
+  if (string_len % 4 == 1) return -1;
+
+  if (string_len == 0) {
+    *buffer_len = 0;
+    return 0;
+  }
+
+  size_t pad = 0;
+  if (string_len >= 2 && string[string_len - 1] == '=') pad++;
+  if (string_len >= 2 && string[string_len - 2] == '=') pad++;
+
+  size_t trailing = string_len % 4;
+
+  size_t len = string_len / 4 * 3;
+
+  if (trailing == 2) len += 1;
+  else if (trailing == 3) len += 2;
+
+  len -= pad;
+
+  if (buffer == NULL) {
+    *buffer_len = len;
+    return 0;
+  }
+
+  if (*buffer_len < len) return -1;
+
+  *buffer_len = len;
+
+  size_t k = 0;
+  size_t i = 0;
+
+  for (; i + 3 < string_len; i += 4) {
+    char chunk[4];
+
+    for (size_t j = 0; j < 4; j++) {
+      chunk[j] = string[i + j] == '=' ? 0 : base64__inverse_alphabet[string[i + j]];
+
+      if (chunk[j] == (char) -1) return -1;
+    }
+
+    uint32_t triple = (chunk[0] << 18) + (chunk[1] << 12) + (chunk[2] << 6) + chunk[3];
+
+    if (k < len) buffer[k++] = (triple >> 2 * 8) & 0xff;
+    if (k < len) buffer[k++] = (triple >> 1 * 8) & 0xff;
+    if (k < len) buffer[k++] = (triple >> 0 * 8) & 0xff;
+  }
+
+  if (trailing) {
+    char chunk[4] = {0, 0, 0, 0};
+
+    for (size_t j = 0; j < trailing; j++) {
+      chunk[j] = base64__inverse_alphabet[string[i + j]];
+
+      if (chunk[j] == (char) -1) return -1;
+    }
+
+    uint32_t triple = (chunk[0] << 18) | (chunk[1] << 12) | (chunk[2] << 6) | chunk[3];
+
+    if (trailing == 2) {
+      buffer[k++] = (triple >> 16) & 0xff;
+    } else if (trailing == 3) {
+      buffer[k++] = (triple >> 16) & 0xff;
+      buffer[k++] = (triple >> 8) & 0xff;
+    }
+  }
+
+  return 0;
+}
+
+static inline int
+base64__decode_utf16le(const utf16_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len) {
+  if (string_len % 4 == 1) return -1;
+
+  if (string_len == 0) {
+    *buffer_len = 0;
+    return 0;
+  }
+
+  size_t pad = 0;
+  if (string_len >= 2 && string[string_len - 1] == '=') pad++;
+  if (string_len >= 2 && string[string_len - 2] == '=') pad++;
+
+  size_t trailing = string_len % 4;
+
+  size_t len = string_len / 4 * 3;
+
+  if (trailing == 2) len += 1;
+  else if (trailing == 3) len += 2;
+
+  len -= pad;
+
+  if (buffer == NULL) {
+    *buffer_len = len;
+    return 0;
+  }
+
+  if (*buffer_len < len) return -1;
+
+  *buffer_len = len;
+
+  size_t k = 0;
+  size_t i = 0;
+
+  for (; i + 3 < string_len; i += 4) {
+    char chunk[4];
+
+    for (size_t j = 0; j < 4; j++) {
+      utf16_t c = string[i + j];
+      if (c >= 256) return -1;
+      chunk[j] = c == '=' ? 0 : base64__inverse_alphabet[c];
+
+      if (chunk[j] == (char) -1) return -1;
+    }
+
+    uint32_t triple = (chunk[0] << 18) + (chunk[1] << 12) + (chunk[2] << 6) + chunk[3];
+
+    if (k < len) buffer[k++] = (triple >> 2 * 8) & 0xff;
+    if (k < len) buffer[k++] = (triple >> 1 * 8) & 0xff;
+    if (k < len) buffer[k++] = (triple >> 0 * 8) & 0xff;
+  }
+
+  if (trailing) {
+    char chunk[4] = {0, 0, 0, 0};
+
+    for (size_t j = 0; j < trailing; j++) {
+      utf16_t c = string[i + j];
+      if (c >= 256) return -1;
+      chunk[j] = base64__inverse_alphabet[c];
+
+      if (chunk[j] == (char) -1) return -1;
+    }
+
+    uint32_t triple = (chunk[0] << 18) | (chunk[1] << 12) | (chunk[2] << 6) | chunk[3];
+
+    if (trailing == 2) {
+      buffer[k++] = (triple >> 16) & 0xff;
+    } else if (trailing == 3) {
+      buffer[k++] = (triple >> 16) & 0xff;
+      buffer[k++] = (triple >> 8) & 0xff;
+    }
+  }
+
+  return 0;
+}
+
+static inline int
+base64_encode_utf8(const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t *string_len) {
+  return base64__encode_utf8(buffer, buffer_len, string, string_len, false /* url_safe */);
+}
+
+static inline int
+base64url_encode_utf8(const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t *string_len) {
+  return base64__encode_utf8(buffer, buffer_len, string, string_len, true /* url_safe */);
+}
+
+static inline int
+base64_decode_utf8(const utf8_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len) {
+  return base64__decode_utf8(string, string_len, buffer, buffer_len);
+}
+
+static inline int
+base64_encode_utf16le(const uint8_t *buffer, size_t buffer_len, utf16_t *string, size_t *string_len) {
+  return base64__encode_utf16le(buffer, buffer_len, string, string_len, false /* url_safe */);
+}
+
+static inline int
+base64url_encode_utf16le(const uint8_t *buffer, size_t buffer_len, utf16_t *string, size_t *string_len) {
+  return base64__encode_utf16le(buffer, buffer_len, string, string_len, true /* url_safe */);
+}
+
+static inline int
+base64_decode_utf16le(const utf16_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len) {
+  return base64__decode_utf16le(string, string_len, buffer, buffer_len);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // BASE64_H

package/deps/libbase64/package.json

@@ -0,0 +1,25 @@
+{
+  "private": true,
+  "name": "libbase64",
+  "scripts": {
+    "format": "prettier --write .",
+    "lint": "prettier --check ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/holepunchto/libbase64.git"
+  },
+  "author": "Holepunch",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/holepunchto/libbase64/issues"
+  },
+  "homepage": "https://github.com/holepunchto/libbase64#readme",
+  "devDependencies": {
+    "cmake-fetch": "^1.0.0",
+    "cmake-fuzz": "^0.1.0",
+    "lunte": "^1.8.0",
+    "prettier": "^3.8.3",
+    "prettier-config-holepunch": "^2.0.0"
+  }
+}

package/deps/libbase64/src/base64.c

@@ -0,0 +1,22 @@
+#include <stdint.h>
+#include <utf.h>
+
+#include "../include/base64.h"
+
+extern int
+base64_encode_utf8(const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t *string_len);
+
+extern int
+base64url_encode_utf8(const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t *string_len);
+
+extern int
+base64_decode_utf8(const utf8_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len);
+
+extern int
+base64_encode_utf16le(const uint8_t *buffer, size_t buffer_len, utf16_t *string, size_t *string_len);
+
+extern int
+base64url_encode_utf16le(const uint8_t *buffer, size_t buffer_len, utf16_t *string, size_t *string_len);
+
+extern int
+base64_decode_utf16le(const utf16_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len);

package/deps/libbase64/test/CMakeLists.txt

@@ -0,0 +1,31 @@
+list(APPEND tests
+  decode
+  decode-invalid
+  decode-length
+  encode
+  encode-length
+)
+
+foreach(test IN LISTS tests)
+  add_executable(${test} ${test}.c)
+
+  target_link_libraries(
+    ${test}
+    PRIVATE
+      base64_static
+  )
+
+  add_test(
+    NAME ${test}
+    COMMAND ${test}
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+  )
+
+  set_tests_properties(
+    ${test}
+    PROPERTIES
+    TIMEOUT 30
+  )
+endforeach()
+
+add_subdirectory(fuzz)

package/deps/libbase64/test/decode-invalid.c

@@ -0,0 +1,35 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/base64.h"
+
+#define test_decode_invalid(string) \
+  { \
+    size_t string_len = strlen(string); \
+    size_t buffer_len = string_len; \
+    uint8_t buffer[buffer_len]; \
+    int err = base64_decode_utf8((utf8_t *) string, string_len, buffer, &buffer_len); \
+    assert(err != 0); \
+  };
+
+#define test_decode_invalid_utf16le(...) \
+  { \
+    utf16_t string[] = __VA_ARGS__; \
+    size_t string_len = sizeof(string) / sizeof(utf16_t); \
+    size_t buffer_len = string_len; \
+    uint8_t buffer[buffer_len]; \
+    int err = base64_decode_utf16le(string, string_len, buffer, &buffer_len); \
+    assert(err != 0); \
+  };
+
+int
+main() {
+  test_decode_invalid("a");
+  test_decode_invalid("abc*");
+
+  test_decode_invalid_utf16le({0x0041, 0x0042, 0x0043, 0x0100});
+  test_decode_invalid_utf16le({0x0041, 0x0042, 0x0100});
+  test_decode_invalid_utf16le({0xffff, 0xffff, 0xffff, 0xffff});
+  test_decode_invalid_utf16le({0x0041, 0xd800, 0x0042, 0x0043});
+}

package/deps/libbase64/test/decode-length.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/base64.h"
+
+#define test_decode_length(string, expected) \
+  { \
+    size_t string_len = strlen(string); \
+    size_t buffer_len = 0; \
+    int err = base64_decode_utf8((utf8_t *) string, string_len, NULL, &buffer_len); \
+    assert(err == 0); \
+    assert(buffer_len == expected); \
+  };
+
+int
+main() {
+  test_decode_length("YQ==", 1);
+  test_decode_length("YWI=", 2);
+  test_decode_length("YWJj", 3);
+  test_decode_length("YWJjZA==", 4);
+  test_decode_length("YWJjZGU=", 5);
+}

package/deps/libbase64/test/decode.c

@@ -0,0 +1,36 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/base64.h"
+
+#define test_decode(string, expected) \
+  { \
+    size_t string_len = strlen(string); \
+    size_t buffer_len = string_len; \
+    uint8_t buffer[buffer_len]; \
+    int err = base64_decode_utf8((utf8_t *) string, string_len, buffer, &buffer_len); \
+    assert(err == 0); \
+    assert(buffer_len == strlen(expected)); \
+    assert(strncmp((char *) buffer, expected, buffer_len) == 0); \
+  };
+
+int
+main() {
+  test_decode("YQ", "a");
+  test_decode("YQ==", "a");
+  test_decode("YWI", "ab");
+  test_decode("YWI=", "ab");
+  test_decode("YWJj", "abc");
+  test_decode("YWJjZA", "abcd");
+  test_decode("YWJjZA==", "abcd");
+  test_decode("YWJjZGU=", "abcde");
+
+  // URL unsafe
+  test_decode("+w", "\xfb");
+  test_decode("+w==", "\xfb");
+
+  // URL safe
+  test_decode("-w", "\xfb");
+  test_decode("-w==", "\xfb");
+}

package/deps/libbase64/test/encode-length.c

@@ -0,0 +1,22 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../include/base64.h"
+
+#define test_encode_length(buffer, expected) \
+  { \
+    size_t buffer_len = strlen(buffer); \
+    size_t string_len = 0; \
+    int err = base64_encode_utf8((uint8_t *) buffer, buffer_len, NULL, &string_len); \
+    assert(err == 0); \
+    assert(string_len == expected); \
+  };
+
+int
+main() {
+  test_encode_length("a", 4);
+  test_encode_length("ab", 4);
+  test_encode_length("abc", 4);
+  test_encode_length("abcd", 8);
+  test_encode_length("abcde", 8);
+}

package/deps/libbase64/test/encode.c

@@ -0,0 +1,42 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/base64.h"
+
+#define test_encode(buffer, expected) \
+  { \
+    size_t buffer_len = strlen(buffer); \
+    size_t string_len = 4 * ((buffer_len + 2) / 3) + 1; \
+    char string[string_len]; \
+    int err = base64_encode_utf8((uint8_t *) buffer, buffer_len, (utf8_t *) string, &string_len); \
+    assert(err == 0); \
+    assert(string_len == strlen(expected)); \
+    assert(strncmp(string, expected, string_len) == 0); \
+  };
+
+#define test_encode_url(buffer, expected) \
+  { \
+    size_t buffer_len = strlen(buffer); \
+    size_t string_len = ((buffer_len * 4 + 2) / 3) + 1; \
+    char string[string_len]; \
+    int err = base64url_encode_utf8((uint8_t *) buffer, buffer_len, (utf8_t *) string, &string_len); \
+    assert(err == 0); \
+    assert(string_len == strlen(expected)); \
+    assert(strncmp(string, expected, string_len) == 0); \
+  };
+
+int
+main() {
+  test_encode("a", "YQ==");
+  test_encode("ab", "YWI=");
+  test_encode("abc", "YWJj");
+  test_encode("abcd", "YWJjZA==");
+  test_encode("abcde", "YWJjZGU=");
+
+  // URL unsafe
+  test_encode("\xfb", "+w==");
+
+  // URL safe
+  test_encode_url("\xfb", "-w");
+}

package/deps/libbase64/test/fuzz/CMakeLists.txt

@@ -0,0 +1,18 @@
+list(APPEND fuzzers
+  encode/utf8
+  encode/utf16le
+  decode/utf8
+  decode/utf16le
+)
+
+foreach(fuzzer IN LISTS fuzzers)
+  string(REPLACE "/" "_" name ${fuzzer})
+
+  add_fuzzer(fuzz_${name} ${fuzzer}.c)
+
+  target_link_libraries(
+    fuzz_${name}
+    PRIVATE
+      base64_static
+  )
+endforeach()

package/deps/libbase64/test/fuzz/decode/utf16le.c

@@ -0,0 +1,53 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/base64.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Reinterpret the raw bytes as a sequence of UTF-16 code units.
+  size_t units = size / sizeof(utf16_t);
+  utf16_t *string = units > 0 ? malloc(units * sizeof(utf16_t)) : NULL;
+
+  if (string != NULL) memcpy(string, data, units * sizeof(utf16_t));
+
+  size_t buffer_len = units;
+  uint8_t *buffer = buffer_len > 0 ? malloc(buffer_len) : NULL;
+
+  int err = base64_decode_utf16le(string, units, buffer, &buffer_len);
+
+  if (err == 0) {
+    // Re-encode the decoded bytes; the result must decode back identically.
+    size_t reencoded_len = 4 * ((buffer_len + 2) / 3);
+    utf16_t *reencoded = reencoded_len > 0 ? malloc(reencoded_len * sizeof(utf16_t)) : NULL;
+
+    size_t len = reencoded_len;
+    err = base64_encode_utf16le(buffer, buffer_len, reencoded, &len);
+
+    assert(err == 0);
+    assert(len == reencoded_len);
+
+    size_t roundtrip_len = buffer_len;
+    uint8_t *roundtrip = roundtrip_len > 0 ? malloc(roundtrip_len) : NULL;
+
+    err = base64_decode_utf16le(reencoded, reencoded_len, roundtrip, &roundtrip_len);
+
+    assert(err == 0);
+    assert(roundtrip_len == buffer_len);
+
+    if (buffer_len > 0) {
+      assert(memcmp(roundtrip, buffer, buffer_len) == 0);
+    }
+
+    free(roundtrip);
+    free(reencoded);
+  }
+
+  free(buffer);
+  free(string);
+
+  return 0;
+}

package/deps/libbase64/test/fuzz/decode/utf8.c

@@ -0,0 +1,47 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/base64.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Decoded output is never larger than the input.
+  size_t buffer_len = size;
+  uint8_t *buffer = buffer_len > 0 ? malloc(buffer_len) : NULL;
+
+  int err = base64_decode_utf8((const utf8_t *) data, size, buffer, &buffer_len);
+
+  if (err == 0) {
+    // Re-encode the decoded bytes; the result must decode back identically.
+    size_t string_len = 4 * ((buffer_len + 2) / 3);
+    utf8_t *string = string_len > 0 ? malloc(string_len) : NULL;
+
+    size_t len = string_len;
+    err = base64_encode_utf8(buffer, buffer_len, string, &len);
+
+    assert(err == 0);
+    assert(len == string_len);
+
+    size_t roundtrip_len = buffer_len;
+    uint8_t *roundtrip = roundtrip_len > 0 ? malloc(roundtrip_len) : NULL;
+
+    err = base64_decode_utf8(string, string_len, roundtrip, &roundtrip_len);
+
+    assert(err == 0);
+    assert(roundtrip_len == buffer_len);
+
+    if (buffer_len > 0) {
+      assert(memcmp(roundtrip, buffer, buffer_len) == 0);
+    }
+
+    free(roundtrip);
+    free(string);
+  }
+
+  free(buffer);
+
+  return 0;
+}