#include "simdutf.h"

#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstring>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>

#include <tests/helpers/random_int.h>
#include <tests/helpers/test.h>

// to limit the runtime of this test
#ifndef SIMDUTF_BASE64_TEST_MAXLEN
  #error "SIMDUTF_BASE64_TEST_MAXLEN not set."
#endif
constexpr std::size_t max_len = SIMDUTF_BASE64_TEST_MAXLEN;

// Return the length of the prefix that contains count base64 characters.
// Thus, if count is 3, the function returns the length of the prefix
// that contains 3 base64 characters. Padding characters are counted.
size_t prefix_length_base64_index(size_t count, simdutf::base64_options options,
                                  const char *input, size_t length) {
  size_t i = 0;
  while (i < length && simdutf::base64_ignorable(input[i], options)) {
    i++;
  }
  if (count == 0) {
    return i; // duh!
  }
  for (; i < length; i++) {
    if (simdutf::base64_ignorable(input[i], options)) {
      continue;
    }
    // We have a base64 character or a padding character.
    count--;
    if (count == 0) {
      return i + 1;
    }
  }
  return -1; // should never happen
}

template <typename char_type>
size_t length_without_empty_tail(
    const std::vector<char_type> &input,
    simdutf::base64_options options = simdutf::base64_options::base64_default) {
  if (input.size() == 0) {
    return 0;
  }
  size_t i = input.size();
  while (i > 0 && simdutf::base64_ignorable(input[i - 1], options)) {
    i--;
  }
  return i;
}

// We may disable base64url tests by commenting out this next line.
#define SIMDUTF_BASE64URL_TESTS 1

using random_generator = std::mt19937;
static random_generator::result_type seed = 42;

constexpr uint8_t to_base64_value[] = {
    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
    255, 255, 255, 255, 255, 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,  255, 255, 255, 255, 255, 255, 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,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255};

constexpr uint8_t to_base64url_value[] = {
    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    62,  255, 255, 52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
    255, 255, 255, 255, 255, 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,  255, 255, 255, 255, 63,  255, 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,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255};

template <typename char_type> bool is_space(char_type c) {
  const static std::array<char_type, 5> space = {' ', '\t', '\n', '\r', '\f'};
  return std::find(space.begin(), space.end(), c) != space.end();
}

template <typename char_type> bool is_non_base64_space(char_type c) {
  return uint8_t(c) >= 128 || to_base64_value[uint8_t(c)] == 255;
}

template <typename char_type> bool is_non_base64_url_space(char_type c) {
  return uint8_t(c) >= 128 || to_base64url_value[uint8_t(c)] == 255;
}

template <typename char_type>
size_t add_space(std::vector<char_type> &v, std::mt19937 &gen) {
  const static std::array<char_type, 5> space = {' ', '\t', '\n', '\r', '\f'};
  std::uniform_int_distribution<int> index_dist(0, v.size());
  size_t i = index_dist(gen);
  std::uniform_int_distribution<int> char_dist(0, space.size() - 1);
  v.insert(v.begin() + i, space[char_dist(gen)]);
  return i;
}

// consider using add_simple_spaces for better performance.
template <typename char_type>
size_t add_simple_space(std::vector<char_type> &v, std::mt19937 &gen) {
  std::uniform_int_distribution<int> index_dist(0, v.size());
  size_t i = index_dist(gen);
  v.insert(v.begin() + i, ' ');
  return i;
}

template <typename char_type>
std::vector<char_type> add_simple_spaces(std::vector<char_type> &v,
                                         std::mt19937 &gen,
                                         size_t number_of_spaces) {
  // If there are no spaces to add or the vector is empty, return
  if (number_of_spaces == 0) {
    return v;
  }

  // Generate unique random positions
  std::vector<bool> positions(v.size() + number_of_spaces, false);
  std::uniform_int_distribution<size_t> dist(0, positions.size() - 1);
  for (size_t i = 0; i < number_of_spaces; ++i) {
    size_t pos = dist(gen);
    while (positions[pos]) {
      pos = dist(gen);
    }
    positions[pos] = true;
  }
  std::vector<char_type> result;
  result.resize(v.size() + number_of_spaces);
  int pos = 0;
  for (size_t i = 0; i < v.size() + number_of_spaces; ++i) {
    if (positions[i]) {
      result[i] = ' ';
    } else {
      result[i] = v[pos++];
    }
  }
  return result;
}

std::string add_simple_spaces(const std::string &v, std::mt19937 &gen,
                              size_t number_of_spaces) {
  // If there are no spaces to add or the vector is empty, return
  if (number_of_spaces == 0) {
    return v;
  }

  // Generate unique random positions
  std::vector<bool> positions(v.size() + number_of_spaces, false);
  std::uniform_int_distribution<size_t> dist(0, positions.size() - 1);
  for (size_t i = 0; i < number_of_spaces; ++i) {
    size_t pos = dist(gen);
    while (positions[pos]) {
      pos = dist(gen);
    }
    positions[pos] = true;
  }
  std::string result;
  result.resize(v.size() + number_of_spaces);
  int pos = 0;
  for (size_t i = 0; i < v.size() + number_of_spaces; ++i) {
    if (positions[i]) {
      result[i] = ' ';
    } else {
      result[i] = v[pos++];
    }
  }
  return result;
}

template <typename char_type>
size_t add_garbage(std::vector<char_type> &v, std::mt19937 &gen,
                   const uint8_t *table) {
  auto equal_sign = std::find(v.begin(), v.end(), '=');
  size_t len = v.size();
  if (equal_sign != v.end()) {
    len = std::distance(v.begin(), equal_sign);
  }
  std::uniform_int_distribution<int> index_dist(0, len);
  size_t i = index_dist(gen);
  std::uniform_int_distribution<int> char_dist(
      0, (1 << (sizeof(char_type) * 8)) - 1);
  char_type c = char_dist(gen);
  while ((uint8_t(c) == c && table[uint8_t(c)] != 255) || c == '=') {
    c = char_dist(gen);
  }
  v.insert(v.begin() + i, c);
  return i;
}

// https://github.com/tc39/test262/blob/f0dc15c6c7ec095ba3caf3acc0f8665394665841/test/built-ins/Uint8Array/fromBase64/last-chunk-invalid.js
TEST(tc39_illegal_padded_chunks) {
  std::string test_cases[] = {
      "=",         "==",        "===",       "====",     "=====",   "A=",
      "A==",       "A===",      "A====",     "A=====",   "AA====",  "AA=====",
      "AAA==",     "AAA===",    "AAA====",   "AAA=====", "AAAA=",   "AAAA==",
      "AAAA===",   "AAAA====",  "AAAA=====", "AAAAA=",   "AAAAA==", "AAAAA===",
      "AAAAA====", "AAAAA====="};
  std::mt19937 gen((std::mt19937::result_type)(seed));
  for (const std::string &input : test_cases) {
    std::vector<uint8_t> back(255);
    size_t len = back.size();
    for (auto option :
         {simdutf::last_chunk_handling_options::strict,
          simdutf::last_chunk_handling_options::loose,
          simdutf::last_chunk_handling_options::stop_before_partial}) {
      auto r = simdutf::base64_to_binary_safe(
          input.data(), input.size(), reinterpret_cast<char *>(back.data()),
          len, simdutf::base64_default, option, true);
      ASSERT_FALSE(r.error == simdutf::error_code::SUCCESS);
      ASSERT_FALSE(r.error == simdutf::error_code::OUTPUT_BUFFER_TOO_SMALL);
    }
  }
}

// From Node.js tests:
TEST(issue_node_anything_goes) {

  auto test =
      [](const std::string &input, const std::string &expected,
         simdutf::base64_options options =
             simdutf::base64_options::base64_default_or_url_accept_garbage) {
        size_t buflen = simdutf::maximal_binary_length_from_base64(
            input.data(), input.size());
        std::vector<char> back(buflen);
        size_t written_len = buflen;
        auto result = simdutf::base64_to_binary_safe(
            input.data(), input.length(), back.data(), written_len,
            simdutf::base64_default_or_url_accept_garbage);
        ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(written_len, expected.size());
        ASSERT_TRUE(std::equal(back.begin(), back.begin() + written_len,
                               expected.begin()));
      };
  test("YQ", "a");
  test("Y Q", "a");
  test("Y Q ", "a");
  test(" Y Q", "a");
  test("Y Q==", "a");
  test("YQ ==", "a");
  test("YQ == junk", "a");
  test("YWI", "ab");
  test("YWI=", "ab");
  test("YWJj", "abc");
  test("YWJjZA", "abcd");
  test("YWJjZA==", "abcd");
  test("YW Jj ZA ==", "abcd");
  test("YWJjZGU=", "abcde");
  test("YWJjZGVm", "abcdef");
  test("Y WJjZGVm", "abcdef");
  test("YW JjZGVm", "abcdef");
  test("YWJ jZGVm", "abcdef");
  test("YWJj ZGVm", "abcdef");
  test("Y W J j Z G V m", "abcdef");
  test("Y   W\n JjZ \nG Vm", "abcdef");
  test("rMeTqoNvw-M_dQ", "\xac\xc7\x93\xaa\x83\x6f\xc3\xe3\x3f\x75");

  const char *text =
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
      "eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut "
      "enim ad minim veniam, quis nostrud exercitation ullamco laboris "
      "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in "
      "reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla "
      "pariatur. Excepteur sint occaecat cupidatat non proident, sunt in "
      "culpa qui officia deserunt mollit anim id est laborum.";

  test("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2Npbmcg"
       "ZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0"
       "IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlz"
       "IG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1"
       "aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBp"
       "biByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xv"
       "cmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNh"
       "dCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lh"
       "IGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg==",
       text);

  test("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2Npbmcg"
       "ZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0"
       "IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlz"
       "IG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1"
       "aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBp"
       "biByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xv"
       "cmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNh"
       "dCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lh"
       "IGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg",
       text);

  test("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2Npbmcg\n"
       "ZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0\n"
       "IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlz\n"
       "IG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1\n"
       "aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBp\n"
       "biByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xv\n"
       "cmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNh\n"
       "dCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lh\n"
       "IGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg==",
       text);

  test("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2Npbmcg\n"
       "ZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0\n"
       "IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlz\n"
       "IG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1\n"
       "aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBp\n"
       "biByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xv\n"
       "cmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNh\n"
       "dCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lh\n"
       "IGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg",
       text);
}

TEST(issue_dash) {
  const std::string input = "Iw==";
  std::vector<char> back(1);
  size_t len = back.size();
  auto r = simdutf::base64_to_binary_safe(input.data(), input.size(),
                                          back.data(), len);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.count, 4);
  ASSERT_EQUAL(len, 1);
  ASSERT_EQUAL(back[0], '#');
}

TEST(issue_dash_partial) {
  const std::string input = "Iw==";
  std::vector<char> back(1);
  size_t len = back.size();
  auto r = simdutf::base64_to_binary_safe(
      input.data(), input.size(), back.data(), len, simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.count, 4);
  ASSERT_EQUAL(len, 1);
  ASSERT_EQUAL(back[0], '#');
}

// https://github.com/tc39/test262
TEST(tc39_4a) {
  std::pair<std::string, std::vector<uint8_t>> test_cases[] = {
      {"ZXhhZg==", {101, 120, 97, 102}},
      {"ZXhhZg", {101, 120, 97}},
      {"ZXhhZh==", {101, 120, 97, 102}},
      {"ZXhhZh", {101, 120, 97}},
      {"ZXhhZg=", {101, 120, 97}}};
  for (const auto tc : test_cases) {
    const std::string &input = tc.first;
    const std::vector<uint8_t> &expected = tc.second;
    std::vector<uint8_t> back(expected.size(), 255);
    size_t len = back.size();
    auto r = simdutf::base64_to_binary_safe(
        input.data(), input.size(), reinterpret_cast<char *>(back.data()), len,
        simdutf::base64_default,
        simdutf::last_chunk_handling_options::stop_before_partial, true);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(len, expected.size());
    ASSERT_EQUAL(back, expected);
  }
}

// https://github.com/tc39/test262
TEST(tc39_4b) {
  std::pair<std::string, std::vector<uint8_t>> test_cases[] = {
      {"ZXhhZg==", {101, 120, 97, 102}},
      {"ZXhhZg", {101, 120, 97}},
      {"ZXhhZh==", {101, 120, 97, 102}},
      {"ZXhhZh", {101, 120, 97}},
      {"ZXhhZg=", {101, 120, 97}}};
  for (const auto tc : test_cases) {
    const std::string &input = tc.first;
    const std::vector<uint8_t> &expected = tc.second;
    std::vector<uint8_t> back(expected.size(), 255);
    size_t len = back.size();
    auto r = simdutf::base64_to_binary_safe(
        input.data(), input.size(), reinterpret_cast<char *>(back.data()), len,
        simdutf::base64_default,
        simdutf::last_chunk_handling_options::stop_before_partial, true);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(len, expected.size());
    ASSERT_EQUAL(back, expected);
  }
}

// https://github.com/tc39/test262
TEST(tc39_3a) {
  const std::string input = "ZXhhZg===";
  std::vector<uint8_t> back = {255, 255, 255, 255, 255};

  size_t len = back.size();
  auto r = simdutf::base64_to_binary_safe(
      input.data(), input.size(), reinterpret_cast<char *>(back.data()), len,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial, true);
  ASSERT_TRUE(r.error != simdutf::error_code::SUCCESS);
}

// https://github.com/tc39/test262
TEST(tc39_3b) {
  const std::string input = "ZXhhZg===";
  std::vector<uint8_t> back = {255, 255, 255, 255, 255};

  size_t len = back.size();
  auto r = implementation.base64_to_binary(
      input.data(), input.size(), reinterpret_cast<char *>(back.data()),
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_TRUE(r.error != simdutf::error_code::SUCCESS);
}

// https://github.com/tc39/test262
TEST(tc39_1a) {
  const std::string input = "Zm9vYmE=";
  std::vector<uint8_t> back = {255, 255, 255, 255, 255};
  std::vector<uint8_t> expected = {102, 111, 111, 98, 97};

  size_t len = back.size();
  auto r = simdutf::base64_to_binary_safe(
      input.data(), input.size(), reinterpret_cast<char *>(back.data()), len,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial, true);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.count, 8);
  ASSERT_EQUAL(len, 5);
  ASSERT_EQUAL(back, expected);
}

// https://github.com/tc39/test262
TEST(tc39_1b) {
  const std::string input = "Zm9vYmE=";
  std::vector<uint8_t> back = {255, 255, 255, 255, 255};
  std::vector<uint8_t> expected = {102, 111, 111, 98, 97};

  size_t len = back.size();
  auto r = simdutf::base64_to_binary_safe(
      input.data(), input.size(), reinterpret_cast<char *>(back.data()), len,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial, true);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.count, 8);
  ASSERT_EQUAL(len, 5);
  ASSERT_EQUAL(back, expected);
}

// https://github.com/tc39/test262
TEST(tc39_2) {
  const std::string input = "Zm9vYmE";
  std::vector<uint8_t> back = {255, 255, 255, 255, 255};
  std::vector<uint8_t> expected = {102, 111, 111, 255, 255};

  size_t len = back.size();
  auto r = simdutf::base64_to_binary_safe(
      input.data(), input.size(), reinterpret_cast<char *>(back.data()), len,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial, true);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.count, 4);
  ASSERT_EQUAL(len, 3);
  ASSERT_EQUAL(back, expected);
}

// https://github.com/tc39/test262/blob/f0dc15c6c7ec095ba3caf3acc0f8665394665841/test/built-ins/Uint8Array/fromBase64/last-chunk-invalid.js
TEST(tc39_illegal_padded_chunks_unsafe) {
  std::string test_cases[] = {
      "=",         "==",        "===",       "====",     "=====",   "A=",
      "A==",       "A===",      "A====",     "A=====",   "AA====",  "AA=====",
      "AAA==",     "AAA===",    "AAA====",   "AAA=====", "AAAA=",   "AAAA==",
      "AAAA===",   "AAAA====",  "AAAA=====", "AAAAA=",   "AAAAA==", "AAAAA===",
      "AAAAA====", "AAAAA====="};
  std::mt19937 gen((std::mt19937::result_type)(seed));
  for (const std::string &input : test_cases) {
    std::vector<uint8_t> back(255);
    size_t len = back.size();
    for (auto option :
         {simdutf::last_chunk_handling_options::strict,
          simdutf::last_chunk_handling_options::loose,
          simdutf::last_chunk_handling_options::stop_before_partial}) {
      auto r = simdutf::base64_to_binary(input.data(), input.size(),
                                         reinterpret_cast<char *>(back.data()),
                                         simdutf::base64_default, option);
      ASSERT_FALSE(r.error == simdutf::error_code::SUCCESS);
    }
  }
  std::string base(128, 'A');
  for (const std::string &input_orig : test_cases) {
    std::string input = base + input_orig;

    std::vector<uint8_t> back(255);
    size_t len = back.size();
    for (auto option :
         {simdutf::last_chunk_handling_options::strict,
          simdutf::last_chunk_handling_options::loose,
          simdutf::last_chunk_handling_options::stop_before_partial}) {
      auto r = simdutf::base64_to_binary(input.data(), input.size(),
                                         reinterpret_cast<char *>(back.data()),
                                         simdutf::base64_default, option);
      ASSERT_FALSE(r.error == simdutf::error_code::SUCCESS);
    }
  }
  for (const std::string &input_orig : test_cases) {
    std::string input = base + input_orig;
    input = add_simple_spaces(input, gen, 5 + 2 * input.size());
    std::vector<uint8_t> back(255);
    size_t len = back.size();
    for (auto option :
         {simdutf::last_chunk_handling_options::strict,
          simdutf::last_chunk_handling_options::loose,
          simdutf::last_chunk_handling_options::stop_before_partial}) {
      auto r = simdutf::base64_to_binary(input.data(), input.size(),
                                         reinterpret_cast<char *>(back.data()),
                                         simdutf::base64_default, option);
      ASSERT_FALSE(r.error == simdutf::error_code::SUCCESS);
    }
  }
}

auto verify_lines = [](const char *c, int N, int line_length) {
  int current_line_length = 0; // Track the length of the current line
  // Iterate through the string
  for (int i = 0; i < N; ++i) {
    if (c[i] == '\n') {
      // Check if a non-final line has incorrect length
      if (current_line_length != line_length) {
        std::cerr << "A non-final line has incorrect length "
                  << current_line_length << " != " << line_length << "\n";
        std::cerr << std::string(c, N) << "\n";
        return false;
      }
      current_line_length = 0; // Reset for the next line
      continue;
    }

    current_line_length++;
    // Check if the current line exceeds the allowed length
    if (current_line_length > line_length) {
      std::cerr << "A line exceeds the allowed length " << current_line_length
                << " > " << line_length << "\n";
      std::cerr << std::string(c, N) << "\n";
      return false;
    }
  }
  return true;
};

TEST(with_lines_pauldreik) {
  size_t line_length = 5;
  size_t max_length = 2048;
  std::vector<char> source(max_length, 'f');
  std::vector<char> back(max_length);
  std::vector<char> buffer;
  for (auto selected_option : {simdutf::base64_options::base64_url,
                               simdutf::base64_options::base64_default}) {
    for (size_t line_length = 5; line_length < 128; line_length += 7) {
      for (size_t length = 1; length < 2048; length += 17) {
        buffer.resize(simdutf::base64_length_from_binary_with_lines(
            length, selected_option, line_length));
        size_t size = implementation.binary_to_base64_with_lines(
            source.data(), length, buffer.data(), line_length, selected_option);
        auto r = implementation.base64_to_binary(buffer.data(), buffer.size(),
                                                 back.data(), selected_option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_TRUE(
            std::equal(back.begin(), back.begin() + length, source.begin()));
        ASSERT_EQUAL(size, buffer.size());
        ASSERT_TRUE(verify_lines(buffer.data(), buffer.size(), line_length));
      }
    }
  }
}

TEST(with_lines) {

  for (size_t line_length : {4, 64, 76, 80, 128}) {
    for (size_t len = 0; len < max_len; len += 17) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      buffer.resize(simdutf::base64_length_from_binary_with_lines(
          len, simdutf::base64_default, line_length));
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t trial = 0; trial < 2; trial++) {
        for (size_t i = 0; i < len; i++) {
          source[i] = byte_generator(gen);
        }
        size_t size = implementation.binary_to_base64_with_lines(
            source.data(), source.size(), buffer.data(), line_length);
        ASSERT_EQUAL(size, buffer.size());
        buffer.resize(size); // unnecessary
        ASSERT_TRUE(verify_lines(buffer.data(), buffer.size(), line_length));
        std::vector<char> back(simdutf::maximal_binary_length_from_base64(
            buffer.data(), buffer.size()));
        auto option = simdutf::last_chunk_handling_options::stop_before_partial;

        simdutf::full_result r = implementation.base64_to_binary_details(
            buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
            option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        const size_t expected_output_length = len;
        const size_t expected_input_length = prefix_length_base64_index(
            (expected_output_length + 2) / 3 * 4, simdutf::base64_default,
            buffer.data(), buffer.size());
        ASSERT_EQUAL(r.output_count, expected_output_length);
        ASSERT_TRUE(std::equal(back.begin(),
                               back.begin() + expected_output_length,
                               source.begin()));
        ASSERT_EQUAL(r.input_count, expected_input_length);
      }
    }
  }
}

// stop-before-partial should behave like so:
// 1. if the last chunk is not a multiple of 4, we should stop before the last
//    chunk
// 2. if the last chunk is a multiple of 4 (counting padding), we should
// decode it
// 3. If there is a padding character appearing in the last chunk where we have
//    fewer than 2 base64 characters, we should return an error.
//
// https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
//
TEST(partial_should_decode_up_to_last_chunk) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      buffer.resize(simdutf::base64_length_from_binary(len));
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      ASSERT_EQUAL(size, buffer.size());
      buffer.resize(size); // unnecessary
      add_simple_spaces(buffer, gen, 5 + 2 * len);
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      auto option = simdutf::last_chunk_handling_options::stop_before_partial;

      simdutf::full_result r = implementation.base64_to_binary_details(
          buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
          option);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      const size_t expected_output_length = len;
      const size_t expected_input_length = prefix_length_base64_index(
          (expected_output_length + 2) / 3 * 4, simdutf::base64_default,
          buffer.data(), buffer.size());
      ASSERT_EQUAL(r.output_count, expected_output_length);
      ASSERT_TRUE(std::equal(
          back.begin(), back.begin() + expected_output_length, source.begin()));
      // If there is just zero one character in the last chunk, and there is a
      // padding character, we should return an error.
      if (buffer.size() > 0 && len > 0 && len % 3 != 0) {
        // We have a last chunk that is not a multiple of 4.
        // So there are padding characters.
        size_t to_remove = 0;
        // We want to leave just one character in the last chunk
        // This should cause an error.
        if (len % 3 == 1) {
          // last chunk is 2
          to_remove = 1;
        } else if (len % 3 == 2) {
          // last chunk is 3
          to_remove = 2;
        }
        for (size_t i = buffer.size() - 1;; i--) {
          if (simdutf::base64_valid(buffer[i], simdutf::base64_default)) {
            buffer[i] = ' ';
            to_remove--;
            if (to_remove == 0) {
              break;
            }
          }
        }
        r = implementation.base64_to_binary_details(
            buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
            option);
        ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
        // Next, we empty the last chunk
        for (size_t i = buffer.size() - 1;; i--) {
          if (simdutf::base64_valid(buffer[i], simdutf::base64_default)) {
            buffer[i] = ' ';
            break;
          }
        }
        r = implementation.base64_to_binary_details(
            buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
            option);
        ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
      }
    }
  }
}

TEST(partial_should_decode_four_wise_chunks) {
  // 37 bytes = 4 * 3 + 1
  const std::string input = "X8vzLrvHmZgncicZDnXdVZkktaYFDvi41fA2A";
  std::vector<char> buffer;
  buffer.resize(input.size() / 4 * 3);
  auto option = simdutf::last_chunk_handling_options::stop_before_partial;
  auto r = implementation.base64_to_binary_details(
      input.data(), input.size(), buffer.data(), simdutf::base64_default,
      option);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_TRUE(r.input_count == 36);
  ASSERT_TRUE(r.output_count == 27);
}

TEST(stop_before_partial_one_char) {
  std::vector<char> base64(5463, 0x20);
  base64.back() = 0x38; // this is the number 8 (a valid base64 character)
  std::vector<char> back(0);
  // with stop_before_partial, we should stop before the last character
  // and not decode it. There should be no error.
  // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
  simdutf::result r = implementation.base64_to_binary(
      base64.data(), base64.size(), back.data(), simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.count, 0);
  size_t buflen = back.size();
  ASSERT_EQUAL(buflen, 0);
  r = simdutf::base64_to_binary_safe(
      base64.data(), base64.size(), back.data(), buflen,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(buflen, 0);
  back.resize(base64.size());
  buflen = back.size();
  r = simdutf::base64_to_binary_safe(
      base64.data(), base64.size(), back.data(), buflen,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(buflen, 0);
}

TEST(hybrid_decoding) {
  std::vector<std::pair<std::string, std::vector<uint8_t>>> test_data = {
      {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA__--_"
       "--"
       "_--__"
       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA__-+_"
       "--"
       "_--/"
       "_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA__-+_"
       "--"
       " / "
       "--/_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//-+/"
       "--/--/"
       "_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},

  };
  for (const auto &test : test_data) {
    const std::string &base64 = test.first;
    const std::vector<uint8_t> &expected = test.second;
    std::vector<uint8_t> decoded(simdutf::maximal_binary_length_from_base64(
        base64.data(), base64.size()));
    auto r = implementation.base64_to_binary(
        base64.data(), base64.size(), reinterpret_cast<char *>(decoded.data()),
        simdutf::base64_default_or_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, expected.size());
    decoded.resize(r.count);
    ASSERT_EQUAL(decoded, expected);
  }
}

TEST(roundtrip_base64_with_spaces) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = 'a' + i % ('z' - 'a'); // byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      for (size_t i = 0; i < 5; i++) {
        add_space(buffer, gen);
      }
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        simdutf::result r = implementation.base64_to_binary(
            buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
            option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(r.count, len);
        ASSERT_BYTES_EQUAL(source, back, len);
      }
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        size_t back_length = back.size();
        auto r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), back_length,
            simdutf::base64_default, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(back_length, len);

        for (size_t i = r.count; i < buffer.size(); i++) {
          ASSERT_TRUE(is_space(buffer[i]));
        }
        ASSERT_TRUE(std::equal(back.begin(), back.begin() + back_length,
                               source.begin()));
      }
    }
  }
}

TEST(roundtrip_base64_with_garbage) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      for (size_t i = 0; i < 5; i++) {
        add_garbage(buffer, gen, to_base64_value);
      }
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      for (auto option : {simdutf::last_chunk_handling_options::strict,
                          simdutf::last_chunk_handling_options::loose}) {
        simdutf::result r = implementation.base64_to_binary(
            buffer.data(), buffer.size(), back.data(),
            simdutf::base64_default_accept_garbage, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(r.count, len);
        ASSERT_TRUE(
            std::equal(back.begin(), back.begin() + len, source.begin()));
      }
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        size_t back_length = back.size();
        auto r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), back_length,
            simdutf::base64_default_accept_garbage, option);

        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(back_length, len);
        for (size_t i = r.count; i < buffer.size(); i++) {
          ASSERT_TRUE(!simdutf::base64_valid(
              buffer[i], simdutf::base64_default_accept_garbage));
        }
        ASSERT_TRUE(std::equal(back.begin(), back.begin() + back_length,
                               source.begin()));
      }
    }
  }
}

TEST(roundtrip_base64_url_with_garbage) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data(), simdutf::base64_url);
      buffer.resize(size);
      for (size_t i = 0; i < 5; i++) {
        add_garbage(buffer, gen, to_base64url_value);
      }
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        simdutf::result r = implementation.base64_to_binary(
            buffer.data(), buffer.size(), back.data(),
            simdutf::base64_url_accept_garbage, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(r.count, len);
        ASSERT_TRUE(
            std::equal(back.begin(), back.begin() + len, source.begin()));
      }
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        size_t back_length = back.size();
        auto r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), back_length,
            simdutf::base64_url_accept_garbage, option);

        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(back_length, len);

        if (option ==
            simdutf::last_chunk_handling_options::stop_before_partial) {
          for (size_t i = r.count; i < buffer.size(); i++) {
            ASSERT_TRUE(is_non_base64_url_space(buffer[i]));
          }
        } else {
          ASSERT_EQUAL(r.count, buffer.size());
        }
        ASSERT_TRUE(std::equal(back.begin(), back.begin() + back_length,
                               source.begin()));
      }
    }
  }
}

TEST(roundtrip_base64_with_lots_of_spaces) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      add_simple_spaces(buffer, gen, 5 + 2 * len);
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        simdutf::result r = implementation.base64_to_binary(
            buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
            option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(r.count, len);
        ASSERT_TRUE(
            std::equal(back.begin(), back.begin() + len, source.begin()));
      }
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        size_t back_length = back.size();
        auto r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), back_length,
            simdutf::base64_default, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(back_length, len);

        if (option ==
            simdutf::last_chunk_handling_options::stop_before_partial) {
          for (size_t i = r.count; i < buffer.size(); i++) {
            ASSERT_TRUE(is_space(buffer[i]));
          }
          if (r.count > 0) {
            ASSERT_TRUE(!is_space(buffer[r.count - 1]));
          }
        } else {
          ASSERT_EQUAL(r.count, buffer.size());
        }
        ASSERT_TRUE(std::equal(back.begin(), back.begin() + back_length,
                               source.begin()));
      }
    }
  }
}

TEST(roundtrip_base64_with_lots_of_spaces_at_the_end) {
  std::vector<char> buffer;
  for (size_t len = 0; len < max_len; len += 10) {
    std::vector<char> source(len, 0);
    buffer.clear();
    buffer.resize(simdutf::base64_length_from_binary(len), '\0');
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      add_simple_spaces(buffer, gen, 5 + 2 * len);
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      buffer.resize(buffer.size() + 65536, ' ');
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        size_t back_length = back.size();
        auto r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), back_length,
            simdutf::base64_default, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(back_length, len);
        for (size_t i = r.count; i < buffer.size(); i++) {
          ASSERT_TRUE(is_space(buffer[i]));
        }
        ASSERT_TRUE(std::equal(back.begin(), back.begin() + back_length,
                               source.begin()));
      }
    }
  }
}

TEST(roundtrip_base64_with_lots_of_spaces_at_the_beginning) {
  std::vector<char> buffer;
  for (size_t len = 0; len < max_len; len += 10) {
    std::vector<char> source(len, 0);
    buffer.clear();
    buffer.resize(simdutf::base64_length_from_binary(len), '\0');
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      add_simple_spaces(buffer, gen, 5 + 2 * len);
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      buffer.insert(buffer.begin(), 65536, ' ');
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        if (option ==
                simdutf::last_chunk_handling_options::stop_before_partial &&
            len % 3 != 0) {
          continue;
        }
        size_t back_length = back.size();
        auto r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), back_length,
            simdutf::base64_default, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(back_length, len);
        for (size_t i = r.count; i < buffer.size(); i++) {
          ASSERT_TRUE(is_space(buffer[i]));
        }

        ASSERT_TRUE(std::equal(back.begin(), back.begin() + back_length,
                               source.begin()));
      }
    }
  }
}

TEST(base64_decode_just_one_padding_partial_safe) {
  std::vector<std::tuple<std::string, simdutf::result, size_t>> test_cases = {
      {"uuuu             uu=", {simdutf::error_code::SUCCESS, 4}, 3},
      // 5. If char is "=", then If chunkLength < 2, then Let error be a new
      // SyntaxError exception.
      {"uuuu             u==",
       {simdutf::error_code::BASE64_INPUT_REMAINDER, 18},
       3}, // error
      {"uuuu             u=",
       {simdutf::error_code::BASE64_INPUT_REMAINDER, 18},
       3}, // error
      {"uuuu             ==",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17},
       3}, // error
      {"uuuu             =",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17},
       3}, // error
  };
  std::vector<char> buffer(128);
  printf("\n");
  for (auto &p : test_cases) {
    auto input = std::get<0>(p);
    auto expected_result = std::get<1>(p);
    size_t expected_output = std::get<2>(p);
    printf("input: %s\n", input.c_str());
    for (auto option : {simdutf::base64_options::base64_default,
                        simdutf::base64_options::base64_url}) {
      for (auto chunk_option :
           {simdutf::last_chunk_handling_options::stop_before_partial}) {
        for (size_t output = 3; output < buffer.size(); output++) {
          size_t written = output;
          auto result = simdutf::base64_to_binary_safe(
              input.data(), input.size(), buffer.data(), written, option,
              chunk_option);
          ASSERT_EQUAL(result.error, expected_result.error);
          ASSERT_EQUAL(written, expected_output);
          ASSERT_EQUAL(result.count, expected_result.count);
        }
      }
    }
  }
}

// partial decoding will succeed and just decode the first 3 bytes, even if we
// have ample output memory.
TEST(base64_decode_just_one_padding_partial_generous) {
  std::vector<std::pair<std::string, simdutf::result>> test_cases = {
      {"uuuu             uu=", {simdutf::error_code::SUCCESS, 3}},
      // 5. If char is "=", then If chunkLength < 2, then Let error be a new
      // SyntaxError exception.
      {"uuuu             u==",
       {simdutf::error_code::BASE64_INPUT_REMAINDER, 18}}, // error
      {"uuuu             u=",
       {simdutf::error_code::BASE64_INPUT_REMAINDER, 18}}, // error
      {"uuuu             ==",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17}}, // error
      {"uuuu             =",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17}}, // error
  };
  std::vector<char> buffer(6);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_result = p.second;
    for (auto option : {simdutf::base64_options::base64_default,
                        simdutf::base64_options::base64_url}) {
      for (auto chunk_option :
           {simdutf::last_chunk_handling_options::stop_before_partial}) {
        auto result = implementation.base64_to_binary(
            input.data(), input.size(), buffer.data(), option, chunk_option);
        ASSERT_EQUAL(result.error, expected_result.error);
        ASSERT_EQUAL(result.count, expected_result.count);
      }
    }
  }
}

// loose decoding will fail when there is a single leftover padding character.
TEST(base64_decode_just_one_padding_loose) {
  std::vector<std::pair<std::string, simdutf::result>> test_cases = {
      {"uuuu             =",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17}}};
  std::vector<char> buffer(3);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_result = p.second;
    for (auto option : {simdutf::base64_options::base64_default,
                        simdutf::base64_options::base64_url}) {
      for (auto chunk_option : {simdutf::last_chunk_handling_options::loose}) {
        auto result = implementation.base64_to_binary(
            input.data(), input.size(), buffer.data(), option, chunk_option);
        ASSERT_EQUAL(result.error, expected_result.error);
        ASSERT_EQUAL(result.count, expected_result.count);
      }
    }
  }
}

// strict decoding will fail with a pointer to the last valid character.
TEST(base64_decode_just_one_padding_strict) {
  std::vector<std::pair<std::string, simdutf::result>> test_cases = {
      {"uuuu             =",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17}}};
  std::vector<char> buffer(3);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_result = p.second;
    for (auto option : {simdutf::base64_options::base64_default,
                        simdutf::base64_options::base64_url}) {
      for (auto chunk_option : {simdutf::last_chunk_handling_options::strict}) {
        auto result = implementation.base64_to_binary(
            input.data(), input.size(), buffer.data(), option, chunk_option);
        ASSERT_EQUAL(result.error, expected_result.error);
        ASSERT_EQUAL(result.count, expected_result.count);
      }
    }
  }
}

// partial decoding will succeed and just decode the first 3 bytes.
// https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
TEST(base64_decode_just_one_padding_partial) {
  std::vector<std::pair<std::string, simdutf::result>> test_cases = {
      {"uuuu             uu=", {simdutf::error_code::SUCCESS, 3}},
      // 5. If char is "=", then If chunkLength < 2, then Let error be a new
      // SyntaxError exception.
      {"uuuu             u==",
       {simdutf::error_code::BASE64_INPUT_REMAINDER, 18}}, // error
      {"uuuu             u=",
       {simdutf::error_code::BASE64_INPUT_REMAINDER, 18}}, // error
      {"uuuu             ==",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17}}, // error
      {"uuuu             =",
       {simdutf::error_code::INVALID_BASE64_CHARACTER, 17}}, // error
  };
  std::vector<char> buffer(3);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_result = p.second;
    for (auto option : {simdutf::base64_options::base64_default,
                        simdutf::base64_options::base64_url}) {
      for (auto chunk_option :
           {simdutf::last_chunk_handling_options::stop_before_partial}) {
        auto result = implementation.base64_to_binary(
            input.data(), input.size(), buffer.data(), option, chunk_option);

        ASSERT_EQUAL(result.error, expected_result.error);
        ASSERT_EQUAL(result.count, expected_result.count);
      }
    }
  }
}

TEST(base64_decode_partial_cases) {
  std::vector<std::pair<std::string, simdutf::result>> test_cases = {
      {"ZXhhZg", {simdutf::error_code::SUCCESS, 4}},
      {"ZXhhZg                                                               "
       " ",
       {simdutf::error_code::SUCCESS, 4}},
      {"                                                                "
       "ZXhhZg",
       {simdutf::error_code::SUCCESS, 68}},
  };
  std::vector<char> buffer(3);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_result = p.second;
    size_t written = buffer.size();
    auto result = simdutf::base64_to_binary_safe(
        input.data(), input.size(), buffer.data(), written,
        simdutf::base64_default,
        simdutf::last_chunk_handling_options::stop_before_partial);
    ASSERT_EQUAL(result.error, expected_result.error);
    ASSERT_EQUAL(result.count, expected_result.count);
  }
}

TEST(base64_decode_strict_cases) {
  std::vector<std::pair<std::string, uint64_t>> test_cases = {
      {"ZXhhZg==", simdutf::error_code::SUCCESS},
      {"YWE=", simdutf::error_code::SUCCESS},
      {"YWF=", simdutf::error_code::BASE64_EXTRA_BITS},
      {"ZXhhZh==", simdutf::error_code::BASE64_EXTRA_BITS},
      // {"ZXhhZg", simdutf::error_code::BASE64_INPUT_REMAINDER},
      // {"ZXhhZh", simdutf::error_code::BASE64_INPUT_REMAINDER},
      {"Z   X  h  h   Z h =   =", simdutf::error_code::BASE64_EXTRA_BITS},
      //{"ZX  h  hZg", simdutf::error_code::BASE64_INPUT_REMAINDER},
      //{"ZXh  hZ  h", simdutf::error_code::BASE64_INPUT_REMAINDER},
  };
  std::vector<char> buffer(1024);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_error = p.second;
    simdutf::result result = implementation.base64_to_binary(
        input.data(), input.size(), buffer.data(), simdutf::base64_default,
        simdutf::last_chunk_handling_options::strict);
    ASSERT_EQUAL(result.error, expected_error);
    size_t written = buffer.size();
    result = simdutf::base64_to_binary_safe(
        input.data(), input.size(), buffer.data(), written,
        simdutf::base64_default, simdutf::last_chunk_handling_options::strict);
    ASSERT_EQUAL(result.error, expected_error);
  }
}

TEST(base64_decode_strict_cases_length) {
  std::vector<std::pair<std::string, simdutf::result>> test_cases = {
      {"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
       "dd"
       "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddzzz=",
       {simdutf::error_code::BASE64_EXTRA_BITS, 131}},
  };
  std::vector<char> buffer(1024);
  for (auto &p : test_cases) {
    auto input = p.first;
    auto expected_result = p.second;
    simdutf::result result = implementation.base64_to_binary(
        input.data(), input.size(), buffer.data(), simdutf::base64_default,
        simdutf::last_chunk_handling_options::strict);
    ASSERT_EQUAL(result.error, expected_result.error);
    ASSERT_EQUAL(result.count, expected_result.count);
    size_t written = buffer.size();
    result = simdutf::base64_to_binary_safe(
        input.data(), input.size(), buffer.data(), written,
        simdutf::base64_default, simdutf::last_chunk_handling_options::strict);
    ASSERT_EQUAL(result.error, expected_result.error);
    ASSERT_EQUAL(result.count, expected_result.count);
  }
}

// https://bugs.webkit.org/show_bug.cgi?id=290829
TEST(issue_webkit_290829) {
  std::string data = "MjYyZg===";
  std::vector<char> output(5); // 5 is part of the issue
  std::vector<uint8_t> expected = {0x32, 0x36, 0x32};

  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    std::fill(output.begin(), output.end(), 0);
    const auto r1 =
        implementation.base64_to_binary(data.data(), data.size(), output.data(),
                                        simdutf::base64_default, option);
    ASSERT_EQUAL(r1.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
    ASSERT_EQUAL(r1.count, 6);
  }

  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    std::fill(output.begin(), output.end(), 0);
    size_t back_length = output.size();
    constexpr bool decode_up_to_bad_char = true;
    auto r = simdutf::base64_to_binary_safe(
        data.data(), data.size(), output.data(), back_length,
        simdutf::base64_default, option, decode_up_to_bad_char);

    ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
    ASSERT_EQUAL(r.count, 6);
    ASSERT_EQUAL(back_length, 3);
    ASSERT_BYTES_EQUAL(output, expected, 3);
  }
}

// https://bugs.webkit.org/show_bug.cgi?id=290829
TEST(issue_webkit_utf16_290829) {
  std::string data = "MjYyZg===";
  std::vector<char> output(5); // 5 is part of the issue
  std::vector<uint16_t> expected = {0x32, 0x36, 0x32};

  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    std::fill(output.begin(), output.end(), 0);
    const auto r1 =
        implementation.base64_to_binary(data.data(), data.size(), output.data(),
                                        simdutf::base64_default, option);
    ASSERT_EQUAL(r1.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
    ASSERT_EQUAL(r1.count, 6);
  }

  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    std::fill(output.begin(), output.end(), 0);
    size_t back_length = output.size();
    constexpr bool decode_up_to_bad_char = true;
    auto r = simdutf::base64_to_binary_safe(
        data.data(), data.size(), output.data(), back_length,
        simdutf::base64_default, option, decode_up_to_bad_char);

    ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
    ASSERT_EQUAL(r.count, 6);
    ASSERT_EQUAL(back_length, 3);
    ASSERT_BYTES_EQUAL(output, expected, 3);
  }
}

// https://bugs.webkit.org/show_bug.cgi?id=290829
TEST(issue_webkit_utf16_290829_bad_char) {
  std::string data(1024, 'A');
  std::vector<char> expected(1024 / 4 * 3, 0);
  std::vector<char> output(1024 / 4 * 3);
  for (size_t invalid = 0; invalid < data.size(); invalid++) {
    data[invalid] = '?'; // invalid
    for (auto option :
         {simdutf::last_chunk_handling_options::strict,
          simdutf::last_chunk_handling_options::loose,
          simdutf::last_chunk_handling_options::stop_before_partial}) {
      std::fill(output.begin(), output.end(), 255);
      size_t back_length = output.size();
      constexpr bool decode_up_to_bad_char = true;
      auto r = simdutf::base64_to_binary_safe(
          data.data(), data.size(), output.data(), back_length,
          simdutf::base64_default, option, decode_up_to_bad_char);

      ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
      ASSERT_EQUAL(r.count, invalid);
      size_t expected_length = invalid / 4 * 3;
      ASSERT_EQUAL(back_length, expected_length);
      ASSERT_BYTES_EQUAL(output, expected, expected_length);
    }
    data[invalid] = 'A'; // valid
  }
}

TEST(issue_webkit_utf16_290829_example) {
  std::string data(1024, 'A');
  std::vector<char> expected(1024 / 4 * 3, 0);
  std::vector<char> output(1024 / 4 * 3);
  for (size_t invalid = 0; invalid < data.size(); invalid++) {
    data[invalid] = '?'; // invalid
    for (auto option :
         {simdutf::last_chunk_handling_options::strict,
          simdutf::last_chunk_handling_options::loose,
          simdutf::last_chunk_handling_options::stop_before_partial}) {
      std::fill(output.begin(), output.end(), 255);
      size_t back_length = output.size();
      constexpr bool decode_up_to_bad_char = true;
      auto r = simdutf::base64_to_binary_safe(
          data.data(), data.size(), output.data(), back_length,
          simdutf::base64_default, option, decode_up_to_bad_char);

      ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
      ASSERT_EQUAL(r.count, invalid);
      size_t expected_length = invalid / 4 * 3;
      ASSERT_EQUAL(back_length, expected_length);
      ASSERT_BYTES_EQUAL(output, expected, expected_length);
    }
    data[invalid] = 'A'; // valid
  }
}

TEST(issue_single_bad16) {
  std::vector<char16_t> data = {0x3f};
  ASSERT_EQUAL(data.size(), 1);
  size_t outlen = implementation.maximal_binary_length_from_base64(data.data(),
                                                                   data.size());
  std::vector<char> out(outlen);
  const auto r = implementation.base64_to_binary(
      (const char *)data.data(), data.size(), out.data(),
      simdutf::base64_url_with_padding,
      simdutf::last_chunk_handling_options::strict);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 0);
}

TEST(issue_615) {
  const std::vector<char> data{' ', '=', '='};
  std::vector<char> output(100);
  const auto r1 =
      implementation.base64_to_binary(data.data(), data.size(), output.data(),
                                      simdutf::base64_default, simdutf::strict);
  ASSERT_EQUAL(r1.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r1.count, 1);
  const auto r2 = implementation.base64_to_binary(
      data.data() + 1, data.size() - 1, output.data(), simdutf::base64_default,
      simdutf::strict);
  ASSERT_EQUAL(r2.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r2.count, 0);
  const auto r3 = implementation.base64_to_binary(
      data.data(), data.size(), output.data(), simdutf::base64_default,
      simdutf::stop_before_partial);
  ASSERT_EQUAL(r3.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r3.count, 1);
  const auto r4 = implementation.base64_to_binary(
      data.data() + 1, data.size() - 1, output.data(), simdutf::base64_default,
      simdutf::stop_before_partial);
  ASSERT_EQUAL(r4.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r4.count, 0);
}

TEST(issue_kkk) {
  std::vector<char> data = {
      0x20, 0x20, 0x20, 0x20, 0x20, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x20, 0x20, 0x20, 0x20, 0x20,
      0x20, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
      0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x20, 0x20, 0x20,
      0x63};
  ASSERT_EQUAL(data.size(), 193);
  size_t outlen = implementation.maximal_binary_length_from_base64(data.data(),
                                                                   data.size());
  std::vector<char> out(outlen);
  const auto r = implementation.base64_to_binary(
      (const char *)data.data(), data.size(), out.data(),
      simdutf::base64_url_with_padding,
      simdutf::last_chunk_handling_options::strict);
  ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
  ASSERT_EQUAL(r.count, 193);
}

TEST(issue_520) {
  std::vector<unsigned char> data{
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 12, 32,
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 82,
  };
  std::vector<char> out(48);

  const auto r =
      implementation.base64_to_binary((const char *)data.data(), data.size(),
                                      out.data(), simdutf::base64_default);
  ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
  ASSERT_EQUAL(r.count, 64);
}

TEST(base64_decode_complete_input) {
  std::vector<unsigned char> input_data = {0x54, 0x57, 0x46,
                                           0x75}; // "TWFu" Base64 for "Man"
  std::vector<char> expected_output = {'M', 'a', 'n'};
  std::vector<char> output_buffer(expected_output.size());

  // Test with all last_chunk_handling_options
  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    auto result = implementation.base64_to_binary(
        reinterpret_cast<const char *>(input_data.data()), input_data.size(),
        output_buffer.data(), simdutf::base64_default, option);

    ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(result.count, expected_output.size());
    ASSERT_TRUE(
        (std::equal(output_buffer.begin(), output_buffer.begin() + result.count,
                    expected_output.begin())));
  }
}

// https://github.com/simdutf/simdutf/issues/824
/*
The TC39 base64 proposal step 10.a and 10.b together means that, when using
stop-before-partial:

If in the middle of decoding a chunk, return the ending position of the previous
chunk before skipping whitespace. If not in the middle of decoding a chunk,
return the entire input length, including trailing whitespace.
*/
TEST(issue_824) {
  struct read_write {
    size_t read;
    size_t written;
  };
  std::vector<std::tuple<std::string, read_write, std::vector<uint8_t>>>
      test_cases = {
          {"  ", {2, 0}, {}}, // return the entire input length, including
                              // trailing whitespace.
          {" A A G A / v 8 ",
           {8, 3},
           {0, 1, 128}} // return the ending position of the previous chunk
                        // before skipping whitespace.
      };

  std::vector<unsigned char> case1(5463, 0x20);
  case1.back() = 0x38;
  test_cases.emplace_back(std::string(case1.begin(), case1.end()),
                          read_write{0, 0}, std::vector<uint8_t>{});

  std::string long_input(1000, ' ');
  test_cases.emplace_back(long_input, read_write{1000, 0},
                          std::vector<uint8_t>{});
  test_cases.emplace_back(long_input + " A A G A / v 8 ",
                          read_write{1000 + 8, 3},
                          std::vector<uint8_t>{0, 1, 128});
  // In https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
  // the 'read' variable is only ever incremented when a full chunk is
  // successfully decoded. And we always return the 'read' variable,
  // except when we reach the end of the input with a chunkLength of zero.
  test_cases.emplace_back(long_input + "A", read_write{0, 0},
                          std::vector<uint8_t>{});
  test_cases.emplace_back("AAAA" + long_input + "A", read_write{4, 3},
                          std::vector<uint8_t>{0, 0, 0});

  for (const std::tuple<std::string, read_write, std::vector<uint8_t>> &t :
       test_cases) {
    auto input_data = std::get<0>(t);
    auto read_write_info = std::get<1>(t);
    auto expected_output = std::get<2>(t);
    std::vector<uint8_t> output_buffer(
        implementation.maximal_binary_length_from_base64(input_data.data(),
                                                         input_data.size()));
    size_t written = output_buffer.size();
    auto result = simdutf::base64_to_binary_safe(
        input_data.data(), input_data.size(),
        reinterpret_cast<char *>(output_buffer.data()), written,
        simdutf::base64_default,
        simdutf::last_chunk_handling_options::stop_before_partial, true);
    ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(result.count, read_write_info.read);
    ASSERT_EQUAL(written, expected_output.size());
    output_buffer.resize(written);
    ASSERT_TRUE(output_buffer == expected_output);
  }
  for (const std::tuple<std::string, read_write, std::vector<uint8_t>> &t :
       test_cases) {
    auto input_data = std::get<0>(t);
    auto read_write_info = std::get<1>(t);
    auto expected_output = std::get<2>(t);
    std::vector<uint8_t> output_buffer(expected_output.size());
    size_t written = output_buffer.size();
    auto result = simdutf::base64_to_binary_safe(
        input_data.data(), input_data.size(),
        reinterpret_cast<char *>(output_buffer.data()), written,
        simdutf::base64_default,
        simdutf::last_chunk_handling_options::stop_before_partial, true);
    ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(result.count, read_write_info.read);
    ASSERT_EQUAL(written, expected_output.size());
    output_buffer.resize(written);
    ASSERT_TRUE(output_buffer == expected_output);
  }
}

TEST(issue_824_a) {
  std::vector<unsigned char> base64(5463, 0x20);
  base64.back() = 0x38;
  std::vector<char> outbuf(8224);
  std::size_t outlen = outbuf.size();
  const auto result = simdutf::base64_to_binary_safe(
      (const char *)base64.data(), base64.size(), outbuf.data(), outlen,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial, false);
  ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(result.count, 0);
  ASSERT_EQUAL(outlen, 0);
}

TEST(issue_06_05_2025_001) {
  const std::vector<unsigned char> base64{
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x0a, 0x0a,
      0x0a, 0x6f, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
      0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71,
      0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x0a,
      0x0a, 0x0a, 0x0a, 0x0a, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x0a,
      0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x4b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
      0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
  };
  std::vector<char> outbuf(28426);
  std::size_t outlen = outbuf.size();
  const auto result = simdutf::base64_to_binary_safe(
      (const char *)base64.data(), base64.size(), outbuf.data(), outlen,
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial, true);
  ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(result.count, base64.size());
  ASSERT_EQUAL(outlen, 111);
};

// https://github.com/WebKit/WebKit/blob/18fad22e2078542316a576989676d31cfd08d777/JSTests/stress/uint8array-fromBase64.js#L135
TEST(base64_decode_webkit_cases) {

  struct read_write {
    size_t read;
    size_t written;
  };
  std::vector<std::tuple<std::string, read_write, std::vector<uint8_t>>>
      test_cases = {
          {"", {0, 0}, {}},
          {"AA==", {4, 1}, {0}},
          {"AQ==", {4, 1}, {1}},
          {"gA==", {4, 1}, {128}},
          {"/g==", {4, 1}, {254}},
          {"/w==", {4, 1}, {255}},
          {"AAE=", {4, 2}, {0, 1}},
          {"/v8=", {4, 2}, {254, 255}},
          {"AAGA/v8=", {8, 5}, {0, 1, 128, 254, 255}},
          {"  ", {2, 0}, {}},
          {"  A  A  =  =  ", {14, 1}, {0}},
          {"  A  Q  =  =  ", {14, 1}, {1}},
          {"  g  A  =  =  ", {14, 1}, {128}},
          {"  /  g  =  =  ", {14, 1}, {254}},
          {"  /  w  =  =  ", {14, 1}, {255}},
          {"  A  A  E  =  ", {14, 2}, {0, 1}},
          {"  /  v  8  =  ", {14, 2}, {254, 255}},
          {"  A  A  G  A  /  v  8  =  ", {26, 5}, {0, 1, 128, 254, 255}}};

  // Test with all last_chunk_handling_options
  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    for (const std::tuple<std::string, read_write, std::vector<uint8_t>> &t :
         test_cases) {
      auto input_data = std::get<0>(t);
      auto expected_output = std::get<2>(t);
      std::vector<uint8_t> output_buffer(
          implementation.maximal_binary_length_from_base64(input_data.data(),
                                                           input_data.size()));
      auto result = implementation.base64_to_binary(
          input_data.data(), input_data.size(),
          reinterpret_cast<char *>(output_buffer.data()),
          simdutf::base64_default, option);
      ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(result.count, expected_output.size());
      output_buffer.resize(result.count);
      ASSERT_TRUE(output_buffer == expected_output);
    }
  }

  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::loose,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    for (const std::tuple<std::string, read_write, std::vector<uint8_t>> &t :
         test_cases) {
      auto input_data = std::get<0>(t);
      auto read_write_info = std::get<1>(t);
      auto expected_output = std::get<2>(t);
      std::vector<uint8_t> output_buffer(
          implementation.maximal_binary_length_from_base64(input_data.data(),
                                                           input_data.size()));
      auto result = implementation.base64_to_binary_details(
          input_data.data(), input_data.size(),
          reinterpret_cast<char *>(output_buffer.data()),
          simdutf::base64_default, option);
      ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(result.output_count, expected_output.size());
      ASSERT_EQUAL(result.output_count, read_write_info.written);
      ASSERT_EQUAL(result.input_count, read_write_info.read);
      output_buffer.resize(result.output_count);
      ASSERT_TRUE(output_buffer == expected_output);
    }
  }
  // Test with all last_chunk_handling_options
  for (auto option : {simdutf::last_chunk_handling_options::strict,
                      simdutf::last_chunk_handling_options::loose}) {
    for (const std::tuple<std::string, read_write, std::vector<uint8_t>> &t :
         test_cases) {
      auto input_data = std::get<0>(t);
      auto read_write_info = std::get<1>(t);
      auto expected_output = std::get<2>(t);
      std::vector<uint8_t> output_buffer(
          implementation.maximal_binary_length_from_base64(input_data.data(),
                                                           input_data.size()));
      size_t written = output_buffer.size();
      auto result = simdutf::base64_to_binary_safe(
          input_data.data(), input_data.size(),
          reinterpret_cast<char *>(output_buffer.data()), written,
          simdutf::base64_default, option);
      ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(result.count, read_write_info.read);
      ASSERT_EQUAL(written, expected_output.size());
      output_buffer.resize(written);
      ASSERT_TRUE(output_buffer == expected_output);
    }
  }
}

// https://github.com/WebKit/WebKit/blob/18fad22e2078542316a576989676d31cfd08d777/JSTests/stress/uint8array-fromBase64.js#L206
TEST(base64_decode_webkit_more_cases) {
  std::vector<std::string> test_cases = {
      "AA",       "  A  A  ",    "AQ",       "  A  Q  ",   "gA",
      "  g  A  ", "/g",          "  /  g  ", "/w",         "  /  w  ",
      "AAE",      "  A  A  E  ", "/v8",      "  /  v  8  "};
  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    for (const std::string &input_data : test_cases) {
      std::vector<uint8_t> output_buffer(
          implementation.maximal_binary_length_from_base64(input_data.data(),
                                                           input_data.size()));
      auto result = implementation.base64_to_binary(
          input_data.data(), input_data.size(),
          reinterpret_cast<char *>(output_buffer.data()),
          simdutf::base64_default, option);
      if (option == simdutf::last_chunk_handling_options::strict) {
        ASSERT_EQUAL(result.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
      } else {
        ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(result.count, 0);
      }
    }
  }
  for (auto option :
       {simdutf::last_chunk_handling_options::strict,
        simdutf::last_chunk_handling_options::stop_before_partial}) {
    for (const std::string &input_data : test_cases) {
      std::vector<uint8_t> output_buffer(
          implementation.maximal_binary_length_from_base64(input_data.data(),
                                                           input_data.size()));
      size_t written = output_buffer.size();
      auto result = simdutf::base64_to_binary_safe(
          input_data.data(), input_data.size(),
          reinterpret_cast<char *>(output_buffer.data()), written,
          simdutf::base64_default, option);
      if (option == simdutf::last_chunk_handling_options::strict) {
        ASSERT_EQUAL(result.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
      } else {
        ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(written, 0);
      }
    }
  }
}

TEST(base64_decode_webkit_like_but_random_more_cases) {
  for (size_t len = 1; len <= max_len; len++) {
    for (size_t trial = 0; trial < 10; trial++) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      buffer.resize(simdutf::base64_length_from_binary(len));
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      simdutf_maybe_unused const size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      for (size_t removed = 1; !buffer.empty() && removed <= 2; removed++) {
        buffer.pop_back();
        for (auto option :
             {simdutf::last_chunk_handling_options::strict,
              simdutf::last_chunk_handling_options::stop_before_partial}) {
          std::vector<uint8_t> output_buffer(
              implementation.maximal_binary_length_from_base64(buffer.data(),
                                                               buffer.size()));
          auto result = implementation.base64_to_binary(
              buffer.data(), buffer.size(),
              reinterpret_cast<char *>(output_buffer.data()),
              simdutf::base64_default, option);
          if (option == simdutf::last_chunk_handling_options::strict) {
            ASSERT_EQUAL(result.error,
                         simdutf::error_code::BASE64_INPUT_REMAINDER);
          } else {
            ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(result.count, (len - 1) / 3 * 3);
          }
        }
        for (auto option :
             {simdutf::last_chunk_handling_options::strict,
              simdutf::last_chunk_handling_options::stop_before_partial}) {
          std::vector<uint8_t> output_buffer(
              implementation.maximal_binary_length_from_base64(buffer.data(),
                                                               buffer.size()));
          size_t written = output_buffer.size();
          auto result = simdutf::base64_to_binary_safe(
              buffer.data(), buffer.size(),
              reinterpret_cast<char *>(output_buffer.data()), written,
              simdutf::base64_default, option);
          if (option == simdutf::last_chunk_handling_options::strict) {
            ASSERT_EQUAL(result.error,
                         simdutf::error_code::BASE64_INPUT_REMAINDER);
          } else {
            ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(written, (len - 1) / 3 * 3);
          }
        }
      }
    }
  }
}

TEST(base64_decode_webkit_like_but_random_with_spaces_more_cases) {
  for (size_t len = 1; len <= max_len; len++) {
    for (size_t trial = 0; trial < 20; trial++) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      buffer.resize(simdutf::base64_length_from_binary(len));
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      simdutf_maybe_unused const size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer = add_simple_spaces(buffer, gen, 5 + len / 4);
      auto is_space = [](char c) {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
      };
      for (size_t removed = 1; !buffer.empty() && removed <= 2; removed++) {
        while (is_space(buffer.back())) {
          buffer.pop_back();
        }
        buffer.pop_back();
        for (auto option :
             {simdutf::last_chunk_handling_options::strict,
              simdutf::last_chunk_handling_options::stop_before_partial}) {
          std::vector<uint8_t> output_buffer(
              implementation.maximal_binary_length_from_base64(buffer.data(),
                                                               buffer.size()));
          auto result = implementation.base64_to_binary(
              buffer.data(), buffer.size(),
              reinterpret_cast<char *>(output_buffer.data()),
              simdutf::base64_default, option);
          if (option == simdutf::last_chunk_handling_options::strict) {
            ASSERT_EQUAL(result.error,
                         simdutf::error_code::BASE64_INPUT_REMAINDER);
          } else {
            ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(result.count, (len - 1) / 3 * 3);
          }
        }
        for (auto option :
             {simdutf::last_chunk_handling_options::strict,
              simdutf::last_chunk_handling_options::stop_before_partial}) {
          std::vector<uint8_t> output_buffer(
              simdutf::maximal_binary_length_from_base64(buffer.data(),
                                                         buffer.size()));
          size_t written = output_buffer.size();
          auto result = simdutf::base64_to_binary_safe(
              buffer.data(), buffer.size(),
              reinterpret_cast<char *>(output_buffer.data()), written,
              simdutf::base64_default, option);
          if (option == simdutf::last_chunk_handling_options::strict) {
            ASSERT_EQUAL(result.error,
                         simdutf::error_code::BASE64_INPUT_REMAINDER);
          } else {
            ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(written, (len - 1) / 3 * 3);
          }
        }
      }
    }
  }
}

TEST(base64_decode_strict_mode) {
  std::vector<std::pair<std::string, std::string>> test_cases = {
      {"TQ", "M"},            // Length 2 (not multiple of 4)
      {"TWE", "Ma"},          // Length 3 (not multiple of 4)
      {"TWFu", "Man"},        // Length 4 (multiple of 4)
      {"TWF1", "Mau"},        // Length 4 (multiple of 4)
      {"TWFubWFu", "Manman"}, // Length 8 (multiple of 4)
  };
  for (const std::pair<std::string, std::string> &t : test_cases) {
    auto input_data = t.first;
    auto expected_output = t.second;
    std::vector<uint8_t> output_buffer(expected_output.size() +
                                       3); // Add extra space for safety

    auto result = implementation.base64_to_binary(
        input_data.data(), input_data.size(),
        reinterpret_cast<char *>(output_buffer.data()), simdutf::base64_default,
        simdutf::last_chunk_handling_options::strict);

    if (input_data.size() % 4 == 0) {
      // Input length is a multiple of 4, expect success
      ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(result.count, expected_output.size());
      ASSERT_TRUE((std::equal(output_buffer.begin(),
                              output_buffer.begin() + result.count,
                              expected_output.begin())));
    } else {
      // Input length is not a multiple of 4, expect failure in strict mode
      ASSERT_EQUAL(result.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
    }
  }
}

TEST(base64_decode_stop_before_partial) {
  std::vector<std::pair<std::string, std::string>> test_cases = {
      {"TQ", ""},             // Length 2 (no complete blocks)
      {"TWE", ""},            // Length 3 (no complete blocks)
      {"TWFu", "Man"},        // Length 4 (1 complete block)
      {"TWFuTQ", "Man"},      // Length 6 (1 complete block)
      {"TWFuTW", "Man"},      // Length 7 (1 complete block)
      {"TWFuTWFu", "ManMan"}, // Length 8 (2 complete blocks)
  };

  for (const std::pair<std::string, std::string> &t : test_cases) {
    auto input_data = t.first;
    auto expected_output = t.second;
    std::vector<char> output_buffer(expected_output.size() + 3); // Extra space

    auto result = implementation.base64_to_binary(
        input_data.data(), input_data.size(), output_buffer.data(),
        simdutf::base64_default,
        simdutf::last_chunk_handling_options::stop_before_partial);

    ASSERT_EQUAL(result.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(result.count, expected_output.size());
    ASSERT_TRUE(
        (std::equal(output_buffer.begin(), output_buffer.begin() + result.count,
                    expected_output.begin())));
  }
}

TEST(issue_520_url) {
  // output differs between implementations for decode
  // impl arm64 got maxbinarylength=48 convertresult=[count=64,
  // error=INVALID_BASE64_CHARACTER] impl fallback got maxbinarylength=48
  // convertresult=[count=0, error=BASE64_INPUT_REMAINDER]

  std::vector<unsigned char> data{
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 12, 32,
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 82,
  };
  std::vector<char> out(48);

  const auto r = implementation.base64_to_binary(
      (const char *)data.data(), data.size(), out.data(), simdutf::base64_url);
  ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
  ASSERT_EQUAL(r.count, 64);
}

TEST(issue_511) {
  // 0x7f is not a valid base64 character.
  std::vector<unsigned char> data{
      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
      0x20, 0x7f, 0x57, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x5a};
  std::vector<char> out(48);
  const auto r = implementation.base64_to_binary(
      (const char *)data.data(), data.size(), out.data(), simdutf::base64_url);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 12);
}

TEST(issue_509) {
  std::vector<char> data{' ', '='};
  std::vector<char> out(1);
  const auto r = implementation.base64_to_binary(
      data.data(), data.size(), out.data(), simdutf::base64_default);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 1);
}

TEST(issue_502_alt) {
  for (std::size_t nof_equals = 1; nof_equals < 100; ++nof_equals) {
    std::vector<char> data(nof_equals, '=');
    std::vector<char> out(1);
    const auto r = implementation.base64_to_binary(
        data.data(), data.size(), out.data(), simdutf::base64_default);
    ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
    ASSERT_EQUAL(r.count, 0);
  }
}

TEST(issue_504) {
  std::array<char16_t, 1> data{61}; // 61 is the ASCII code for '='
  std::vector<char> out(1);
  const auto r = implementation.base64_to_binary(
      data.data(), data.size(), out.data(), simdutf::base64_default);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 0);
}

TEST(issue_504_8bit) {
  std::array<char, 1> data{61}; // 61 is the ASCII code for '='
  std::vector<char> out(1);
  const auto r = implementation.base64_to_binary(
      data.data(), data.size(), out.data(), simdutf::base64_default);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 0);
}

TEST(issue_502) {
  std::array<char, 1> data{'='};
  std::vector<char> out(1);
  const auto r = implementation.base64_to_binary(
      data.data(), data.size(), out.data(), simdutf::base64_default);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 0);
}

TEST(issue_503) {
  std::array<char16_t, 1> data{15626}; // 0x3D0A
  std::vector<char> out(1);
  const auto r = implementation.base64_to_binary(
      data.data(), data.size(), out.data(), simdutf::base64_default);
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.count, 0);
}

TEST(decode_non_ascii_utf16) {
  std::vector<std::u16string> cases = {u"Zg\u2009=="};
  std::vector<simdutf::error_code> codes = {
      simdutf::error_code::INVALID_BASE64_CHARACTER};
  std::vector<size_t> counts = {2};

  for (size_t i = 0; i < cases.size(); i++) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        cases[i].data(), cases[i].size()));
    simdutf::result r = implementation.base64_to_binary(
        cases[i].data(), cases[i].size(), buffer.data());
    ASSERT_EQUAL(r.error, codes[i]);
    ASSERT_EQUAL(r.count, counts[i]);
    size_t len = buffer.size();
    r = simdutf::base64_to_binary_safe(cases[i].data(), cases[i].size(),
                                       buffer.data(), len);
    ASSERT_EQUAL(r.error, codes[i]);
    ASSERT_EQUAL(r.count, counts[i]);
  }
}

TEST(decode_non_ascii) {
  std::vector<std::string> cases = {"Zg\u2009=="};
  std::vector<simdutf::error_code> codes = {
      simdutf::error_code::INVALID_BASE64_CHARACTER};
  std::vector<size_t> counts = {2};

  for (size_t i = 0; i < cases.size(); i++) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        cases[i].data(), cases[i].size()));
    simdutf::result r = implementation.base64_to_binary(
        cases[i].data(), cases[i].size(), buffer.data());
    ASSERT_EQUAL(r.error, codes[i]);
    ASSERT_EQUAL(r.count, counts[i]);
    size_t len = buffer.size();
    r = simdutf::base64_to_binary_safe(cases[i].data(), cases[i].size(),
                                       buffer.data(), len);
    ASSERT_EQUAL(r.error, codes[i]);
    ASSERT_EQUAL(r.count, counts[i]);
  }
}

TEST(decode_base64_cases) {
  std::vector<std::vector<char>> cases = {{0x53, 0x53}};
  std::vector<simdutf::error_code> codes = {simdutf::error_code::SUCCESS};
  std::vector<size_t> counts = {1};

  for (size_t i = 0; i < cases.size(); i++) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        cases[i].data(), cases[i].size()));
    simdutf::result r = implementation.base64_to_binary(
        cases[i].data(), cases[i].size(), buffer.data());
    ASSERT_EQUAL(r.error, codes[i]);
    ASSERT_EQUAL(r.count, counts[i]);
  }
}

namespace cases {
const std::vector<std::pair<std::string, std::string>> whitespaces = {
    {"abcd", " Y\fW\tJ\njZ A=\r= "},
};

const std::vector<std::pair<std::string, std::string>> simple = {
    {"Hello, World!", "SGVsbG8sIFdvcmxkIQ=="},
    {"GeeksforGeeks", "R2Vla3Nmb3JHZWVrcw=="},
    {"123456", "MTIzNDU2"},
    {"Base64 Encoding", "QmFzZTY0IEVuY29kaW5n"},
    {"!R~J2jL&mI]O)3=c:G3Mo)oqmJdxoprTZDyxEvU0MI.'Ww5H{G>}y;;+B8E_Ah,Ed[ "
     "PdBqY'^N>O$4:7LK1<:|7)btV@|{YWR$$Er59-XjVrFl4L}~yzTEd4'E[@k",
     "IVJ+SjJqTCZtSV1PKTM9YzpHM01vKW9xbUpkeG9wclRaRHl4RXZVME1JLidXdzVIe0c+"
     "fXk7OytCOEVfQWgsRWRbIFBkQnFZJ15OPk8kNDo3TEsxPDp8NylidFZAfHtZV1IkJEVyNTk"
     "tWGpWckZsNEx9fnl6VEVkNCdFW0Br"}};

const std::vector<std::pair<std::string, std::string>> no_padding = {
    {"Hello, World!", "SGVsbG8sIFdvcmxkIQ"},
    {"GeeksforGeeks", "R2Vla3Nmb3JHZWVrcw"},
    {"123456", "MTIzNDU2"},
    {"Base64 Encoding", "QmFzZTY0IEVuY29kaW5n"},
    {"!R~J2jL&mI]O)3=c:G3Mo)oqmJdxoprTZDyxEvU0MI.'Ww5H{G>}y;;+B8E_Ah,Ed[ "
     "PdBqY'^N>O$4:7LK1<:|7)btV@|{YWR$$Er59-XjVrFl4L}~yzTEd4'E[@k",
     "IVJ+SjJqTCZtSV1PKTM9YzpHM01vKW9xbUpkeG9wclRaRHl4RXZVME1JLidXdzVIe0c+"
     "fXk7OytCOEVfQWgsRWRbIFBkQnFZJ15OPk8kNDo3TEsxPDp8NylidFZAfHtZV1IkJEVyNTk"
     "tWGpWckZsNEx9fnl6VEVkNCdFW0Br"}};

const std::vector<std::pair<std::string, std::string>> simple_url = {
    {"Hello, World!", "SGVsbG8sIFdvcmxkIQ"},
    {"GeeksforGeeks", "R2Vla3Nmb3JHZWVrcw"},
    {"123456", "MTIzNDU2"},
    {"Base64 Encoding", "QmFzZTY0IEVuY29kaW5n"},
    {"!R~J2jL&mI]O)3=c:G3Mo)oqmJdxoprTZDyxEvU0MI.'Ww5H{G>}y;;+B8E_Ah,Ed[ "
     "PdBqY'^N>O$4:7LK1<:|7)btV@|{YWR$$Er59-XjVrFl4L}~yzTEd4'E[@k",
     "IVJ-SjJqTCZtSV1PKTM9YzpHM01vKW9xbUpkeG9wclRaRHl4RXZVME1JLidXdzVIe0c-"
     "fXk7OytCOEVfQWgsRWRbIFBkQnFZJ15OPk8kNDo3TEsxPDp8NylidFZAfHtZV1IkJEVyNTk"
     "tWGpWckZsNEx9fnl6VEVkNCdFW0Br"}};

const std::vector<std::pair<std::string, std::string>> simple_url_with_padding =
    {{"Hello, World!", "SGVsbG8sIFdvcmxkIQ=="},
     {"GeeksforGeeks", "R2Vla3Nmb3JHZWVrcw=="},
     {"123456", "MTIzNDU2"},
     {"Base64 Encoding", "QmFzZTY0IEVuY29kaW5n"},
     {"!R~J2jL&mI]O)3=c:G3Mo)oqmJdxoprTZDyxEvU0MI.'Ww5H{G>}y;;+B8E_Ah,Ed[ "
      "PdBqY'^N>O$4:7LK1<:|7)btV@|{YWR$$Er59-XjVrFl4L}~yzTEd4'E[@k",
      "IVJ-"
      "SjJqTCZtSV1PKTM9YzpHM01vKW9xbUpkeG9wclRaRHl4RXZVME1JLidXdzVIe0c-"
      "fXk7OytCOEVfQWgsRWRbIFBkQnFZJ15OPk8kNDo3TEsxPDp8NylidFZAfHtZV1IkJEV"
      "yNTk"
      "tWGpWckZsNEx9fnl6VEVkNCdFW0Br"}};
} // namespace cases

namespace cases16 {
const std::vector<std::pair<std::string, std::u16string>> simple_with_padding =
    {{"Hello, World!", u"SGVsbG8sIFdvcmxkIQ=="},
     {"GeeksforGeeks", u"R2Vla3Nmb3JHZWVrcw=="},
     {"123456", u"MTIzNDU2"},
     {"Base64 Encoding", u"QmFzZTY0IEVuY29kaW5n"},
     {"!R~J2jL&mI]O)3=c:G3Mo)oqmJdxoprTZDyxEvU0MI.'Ww5H{G>}y;;+B8E_Ah,Ed[ "
      "PdBqY'^N>O$4:7LK1<:|7)btV@|{YWR$$Er59-XjVrFl4L}~yzTEd4'E[@k",
      u"IVJ+"
      u"SjJqTCZtSV1PKTM9YzpHM01vKW9xbUpkeG9wclRaRHl4RXZVME1JLidXdzVIe0c+"
      u"fXk7OytCOEVfQWgsRWRbIFBkQnFZJ15OPk8kNDo3TEsxPDp8NylidFZAfHtZV1IkJE"
      u"VyNT"
      u"ktWGpWckZsNEx9fnl6VEVkNCdFW0Br"}};

const std::vector<std::pair<std::string, std::u16string>>
    simple_url_without_padding = {
        {"Hello, World!", u"SGVsbG8sIFdvcmxkIQ"},
        {"GeeksforGeeks", u"R2Vla3Nmb3JHZWVrcw"},
        {"123456", u"MTIzNDU2"},
        {"Base64 Encoding", u"QmFzZTY0IEVuY29kaW5n"},
        {"!R~J2jL&mI]O)3=c:G3Mo)oqmJdxoprTZDyxEvU0MI.'Ww5H{G>}y;;+B8E_Ah,Ed[ "
         "PdBqY'^N>O$4:7LK1<:|7)btV@|{YWR$$Er59-XjVrFl4L}~yzTEd4'E[@k",
         u"IVJ-"
         u"SjJqTCZtSV1PKTM9YzpHM01vKW9xbUpkeG9wclRaRHl4RXZVME1JLidXdzVIe0c-"
         u"fXk7OytCOEVfQWgsRWRbIFBkQnFZJ15OPk8kNDo3TEsxPDp8NylidFZAfHtZV1IkJE"
         u"Vy"
         u"NT"
         u"ktWGpWckZsNEx9fnl6VEVkNCdFW0Br"}};
} // namespace cases16

TEST(complete_decode_base64_cases) {
  for (const auto &p : cases::whitespaces) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    simdutf::result r = implementation.base64_to_binary(
        p.second.data(), p.second.size(), buffer.data());
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.first.size());
    for (size_t i = 0; i < r.count; i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

TEST(complete_safe_decode_base64_cases) {
  for (const auto &p : cases::whitespaces) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    size_t bufsize = buffer.size();
    simdutf::result r = simdutf::base64_to_binary_safe(
        p.second.data(), p.second.size(), buffer.data(), bufsize);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(bufsize, p.first.size());
    for (size_t i = 0; i < bufsize; i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
#if SIMDUTF_ATOMIC_REF
    bufsize = buffer.size();
    r = simdutf::atomic_base64_to_binary_safe(p.second.data(), p.second.size(),
                                              buffer.data(), bufsize);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(bufsize, p.first.size());
    for (size_t i = 0; i < bufsize; i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
#endif
  }
}

TEST(complete_safe_decode_base64url_cases) {
  for (const auto &p : cases::whitespaces) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    size_t bufsize = buffer.size();
    simdutf::result r = simdutf::base64_to_binary_safe(
        p.second.data(), p.second.size(), buffer.data(), bufsize,
        simdutf::base64_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(bufsize, p.first.size());
    for (size_t i = 0; i < bufsize; i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
#if SIMDUTF_ATOMIC_REF
    bufsize = buffer.size();
    r = simdutf::base64_to_binary_safe(p.second.data(), p.second.size(),
                                       buffer.data(), bufsize,
                                       simdutf::base64_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(bufsize, p.first.size());
    for (size_t i = 0; i < bufsize; i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
#endif
  }
}

TEST(encode_base64_cases) {
  for (const auto &p : cases::simple) {
    std::vector<char> buffer(
        simdutf::base64_length_from_binary(p.first.size()));
    ASSERT_EQUAL(buffer.size(), p.second.size());
    size_t s = implementation.binary_to_base64(p.first.data(), p.first.size(),
                                               buffer.data());
    ASSERT_EQUAL(s, p.second.size());
    ASSERT_EQUAL(std::string(buffer.data(), buffer.size()), p.second);
  }
}

TEST(decode_base64_simple) {
  for (const auto &p : cases::simple) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    simdutf::result r = implementation.base64_to_binary(
        p.second.data(), p.second.size(), buffer.data());
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

TEST(safe_decode_base64_simple) {
  for (const auto &p : cases::simple) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    size_t length = buffer.size();
    simdutf::result r = simdutf::base64_to_binary_safe(
        p.second.data(), p.second.size(), buffer.data(), length);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.second.size());
    ASSERT_EQUAL(length, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

TEST(encode_base64_cases_no_padding) {
  for (const auto &p : cases::no_padding) {
    std::vector<char> buffer(simdutf::base64_length_from_binary(
        p.first.size(), simdutf::base64_default_no_padding));
    ASSERT_EQUAL(buffer.size(), p.second.size());
    size_t s = implementation.binary_to_base64(
        p.first.data(), p.first.size(), buffer.data(),
        simdutf::base64_default_no_padding);
    ASSERT_EQUAL(s, p.second.size());
    ASSERT_EQUAL(std::string(buffer.data(), buffer.size()), p.second);
  }
}

#if SIMDUTF_BASE64URL_TESTS

TEST(encode_base64url_simple) {
  for (const auto &p : cases::simple_url) {
    std::vector<char> buffer(simdutf::base64_length_from_binary(
        p.first.size(), simdutf::base64_url));
    ASSERT_EQUAL(buffer.size(), p.second.size());
    size_t s = implementation.binary_to_base64(
        p.first.data(), p.first.size(), buffer.data(), simdutf::base64_url);
    ASSERT_EQUAL(s, p.second.size());
    if (std::string(buffer.data(), buffer.size()) != p.second) {
      printf("difference:\n");
      printf(" %.*s\n", (int)s, buffer.data());
      printf(" %.*s\n", (int)s, p.second.data());
    }
    ASSERT_EQUAL(std::string(buffer.data(), buffer.size()), p.second);
  }
}

TEST(decode_base64url) {
  for (const auto &p : cases::simple_url) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    simdutf::result r = implementation.base64_to_binary(
        p.second.data(), p.second.size(), buffer.data(), simdutf::base64_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

TEST(safe_decode_base64url) {
  for (const auto &p : cases::simple_url) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    size_t length = buffer.size();
    simdutf::result r = simdutf::base64_to_binary_safe(
        p.second.data(), p.second.size(), buffer.data(), length,
        simdutf::base64_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.second.size());
    ASSERT_EQUAL(length, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

TEST(encode_base64url_with_padding_cases) {
  for (const auto &p : cases::simple_url_with_padding) {
    std::vector<char> buffer(simdutf::base64_length_from_binary(
        p.first.size(), simdutf::base64_url_with_padding));
    ASSERT_EQUAL(buffer.size(), p.second.size());
    size_t s = implementation.binary_to_base64(
        p.first.data(), p.first.size(), buffer.data(),
        simdutf::base64_url_with_padding);
    ASSERT_EQUAL(s, p.second.size());
    if (std::string(buffer.data(), buffer.size()) != p.second) {
      printf("difference:\n");
      printf(" %.*s\n", (int)s, buffer.data());
      printf(" %.*s\n", (int)s, p.second.data());
    }
    ASSERT_EQUAL(std::string(buffer.data(), buffer.size()), p.second);
  }
}

#endif

TEST(decode_base64_cases_16) {
  for (const auto &p : cases16::simple_with_padding) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    simdutf::result r = implementation.base64_to_binary(
        p.second.data(), p.second.size(), buffer.data());
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.first.size());
    ASSERT_BYTES_EQUAL(buffer, p.first, r.count);
  }
}

TEST(safe_decode_base64_cases_16) {
  for (const auto &p : cases16::simple_with_padding) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    size_t length = buffer.size();
    simdutf::result r = simdutf::base64_to_binary_safe(
        p.second.data(), p.second.size(), buffer.data(), length);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.second.size());
    ASSERT_EQUAL(length, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

#if SIMDUTF_BASE64URL_TESTS

TEST(decode_base64url_cases_16) {
  for (const auto &p : cases16::simple_url_without_padding) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    simdutf::result r = implementation.base64_to_binary(
        p.second.data(), p.second.size(), buffer.data(), simdutf::base64_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

TEST(safe_decode_base64url_cases_16) {
  for (const auto &p : cases16::simple_url_without_padding) {
    std::vector<char> buffer(implementation.maximal_binary_length_from_base64(
        p.second.data(), p.second.size()));
    ASSERT_EQUAL(buffer.size(), p.first.size());
    size_t length = buffer.size();
    simdutf::result r = simdutf::base64_to_binary_safe(
        p.second.data(), p.second.size(), buffer.data(), length,
        simdutf::base64_url);
    ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
    ASSERT_EQUAL(r.count, p.second.size());
    ASSERT_EQUAL(length, p.first.size());
    for (size_t i = 0; i < buffer.size(); i++) {
      ASSERT_EQUAL(buffer[i], p.first[i]);
    }
  }
}

#endif

TEST(roundtrip_base64) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      ASSERT_EQUAL(size, simdutf::base64_length_from_binary(len));
      simdutf::result r =
          implementation.base64_to_binary(buffer.data(), size, back.data());
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);

      // Test with all last_chunk_handling_options
      for (auto option : {simdutf::last_chunk_handling_options::strict,
                          simdutf::last_chunk_handling_options::loose}) {
        r = implementation.base64_to_binary(buffer.data(), size, back.data(),
                                            simdutf::base64_default, option);
        ASSERT_TRUE((size % 4) == 0);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(r.count, len);
        ASSERT_TRUE(back == source);
      }
    }
  }
}

TEST(roundtrip_base64_16) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::vector<char16_t> buffer16;

    buffer.resize(simdutf::base64_length_from_binary(len));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      buffer16.resize(buffer.size());
      for (size_t i = 0; i < buffer.size(); i++) {
        buffer16[i] = buffer[i];
      }
      ASSERT_EQUAL(size, simdutf::base64_length_from_binary(len));
      simdutf::result r =
          implementation.base64_to_binary(buffer16.data(), size, back.data());
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);

      // Test with all last_chunk_handling_options
      for (auto option : {simdutf::last_chunk_handling_options::strict,
                          simdutf::last_chunk_handling_options::loose}) {
        r = implementation.base64_to_binary(buffer.data(), size, back.data(),
                                            simdutf::base64_default, option);
        ASSERT_TRUE((size % 4) == 0);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        ASSERT_EQUAL(r.count, len);
        ASSERT_TRUE(back == source);
      }
    }
  }
}

#if SIMDUTF_BASE64URL_TESTS

TEST(roundtrip_base64url) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len, simdutf::base64_url));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data(), simdutf::base64_url);
      ASSERT_EQUAL(
          size, simdutf::base64_length_from_binary(len, simdutf::base64_url));
      simdutf::result r = implementation.base64_to_binary(
          buffer.data(), size, back.data(), simdutf::base64_url);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);

      // Test with all last_chunk_handling_options
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        r = implementation.base64_to_binary(buffer.data(), size, back.data(),
                                            simdutf::base64_url, option);
        if ((size % 4) == 0) {
          ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
          ASSERT_EQUAL(r.count, len);
          ASSERT_TRUE(back == source);
        } else {
          if (option == simdutf::last_chunk_handling_options::strict) {
            ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
          } else if (option == simdutf::last_chunk_handling_options::loose) {
            ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(r.count, len);
            ASSERT_TRUE(back == source);
          } else if (option == simdutf::last_chunk_handling_options::
                                   stop_before_partial) {
            ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(r.count, len / 3 * 3);
            ASSERT_TRUE(std::equal(back.begin(), back.begin() + len / 3 * 3,
                                   source.begin()));
          }
        }
      }
    }
  }
}

TEST(roundtrip_base64url_16) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::vector<char16_t> buffer16;

    buffer.resize(simdutf::base64_length_from_binary(len, simdutf::base64_url));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data(), simdutf::base64_url);
      buffer.resize(size);
      buffer16.resize(buffer.size());
      for (size_t i = 0; i < buffer.size(); i++) {
        buffer16[i] = buffer[i];
      }
      ASSERT_EQUAL(
          size, simdutf::base64_length_from_binary(len, simdutf::base64_url));
      simdutf::result r = implementation.base64_to_binary(
          buffer16.data(), size, back.data(), simdutf::base64_url);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        r = implementation.base64_to_binary(buffer.data(), size, back.data(),
                                            simdutf::base64_url, option);
        if ((size % 4) == 0) {
          ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
          ASSERT_EQUAL(r.count, len);
          ASSERT_TRUE(back == source);
        } else {
          if (option == simdutf::last_chunk_handling_options::strict) {
            ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
          } else if (option == simdutf::last_chunk_handling_options::loose) {
            ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(r.count, len);
            ASSERT_TRUE(back == source);
          } else if (option == simdutf::last_chunk_handling_options::
                                   stop_before_partial) {
            ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
            ASSERT_EQUAL(r.count, len / 3 * 3);
            ASSERT_TRUE(std::equal(back.begin(), back.begin() + len / 3 * 3,
                                   source.begin()));
          }
        }
      }
    }
  }
}
#endif

TEST(bad_padding_base64) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len) + 1);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      size_t padding = 0;
      if (size > 0 && buffer[size - 1] == '=') {
        padding++;
        if (size > 1 && buffer[size - 2] == '=') {
          padding++;
        }
      }
      buffer.resize(size);
      ; // in case we need
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      if (padding == 1) {
        // adding padding should break
        buffer.push_back('=');
        for (size_t i = 0; i < 5; i++) {
          add_space(buffer, gen);
        }
        simdutf::result r = simdutf::base64_to_binary(
            buffer.data(), buffer.size(), back.data());
        ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
      } else if (padding == 2) {
        // adding padding should break
        {
          auto copy = buffer;
          copy.push_back('=');
          for (size_t i = 0; i < 5; i++) {
            add_space(copy, gen);
          }
          simdutf::result r =
              simdutf::base64_to_binary(copy.data(), copy.size(), back.data());
          ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
        }
        // removing padding should break
        {
          auto copy = buffer;
          copy.resize(copy.size() - 1);
          for (size_t i = 0; i < 5; i++) {
            add_space(copy, gen);
          }
          simdutf::result r =
              simdutf::base64_to_binary(copy.data(), copy.size(), back.data());
          ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
        }

      } else {
        {
          auto copy = buffer;
          copy.push_back('=');
          for (size_t i = 0; i < 5; i++) {
            add_space(copy, gen);
          }
          simdutf::result r =
              simdutf::base64_to_binary(copy.data(), copy.size(), back.data());
          ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
        }
      }
    }
  }
}
TEST(doomed_base64_roundtrip) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    buffer.resize(simdutf::base64_length_from_binary(len));
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      size_t location = add_garbage(buffer, gen, to_base64_value);
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      simdutf::result r =
          simdutf::base64_to_binary(buffer.data(), buffer.size(), back.data());
      ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
      ASSERT_EQUAL(r.count, location);
      for (auto option :
           {simdutf::last_chunk_handling_options::strict,
            simdutf::last_chunk_handling_options::loose,
            simdutf::last_chunk_handling_options::stop_before_partial}) {
        size_t back_length = back.size();
        r = simdutf::base64_to_binary_safe(buffer.data(), buffer.size(),
                                           back.data(), back_length,
                                           simdutf::base64_default, option);
        ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
        ASSERT_EQUAL(r.count, location);
      }
    }
  }
}

TEST(doomed_truncated_base64_roundtrip) {
  for (size_t len = 1; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      buffer.resize(simdutf::base64_length_from_binary(len));
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size - 3);
      std::vector<char> back(simdutf::maximal_binary_length_from_base64(
          buffer.data(), buffer.size()));
      for (auto option : {simdutf::last_chunk_handling_options::loose,
                          simdutf::last_chunk_handling_options::strict}) {
        simdutf::result r = implementation.base64_to_binary(
            buffer.data(), buffer.size(), back.data(), simdutf::base64_default,
            option);
        ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
        size_t back_length = back.size();
        r = simdutf::base64_to_binary_safe(buffer.data(), buffer.size(),
                                           back.data(), back_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
      }
    }
  }
}

TEST(doomed_truncated_base64_roundtrip_16) {
  for (size_t len = 1; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::vector<char16_t> buffer16;
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      buffer.resize(simdutf::base64_length_from_binary(len));
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size - 3);
      buffer16.resize(buffer.size());
      for (size_t i = 0; i < buffer.size(); i++) {
        buffer16[i] = buffer[i];
      }
      std::vector<char> back(implementation.maximal_binary_length_from_base64(
          buffer16.data(), buffer16.size()));
      simdutf::result r = implementation.base64_to_binary(
          buffer16.data(), buffer16.size(), back.data());
      ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
      size_t back_length = back.size();
      r = simdutf::base64_to_binary_safe(buffer16.data(), buffer16.size(),
                                         back.data(), back_length);
      ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
    }
  }
}

TEST(roundtrip_base64_16_with_spaces) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::vector<char16_t> buffer16;

    buffer.resize(simdutf::base64_length_from_binary(len));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      for (size_t i = 0; i < 5; i++) {
        add_space(buffer, gen);
      }
      buffer16.resize(buffer.size());
      for (size_t i = 0; i < buffer.size(); i++) {
        buffer16[i] = buffer[i];
      }
      ASSERT_EQUAL(size, simdutf::base64_length_from_binary(len));
      simdutf::result r = implementation.base64_to_binary(
          buffer16.data(), buffer16.size(), back.data());
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);
    }
  }
}

TEST(roundtrip_base64_16_with_garbage) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::vector<char16_t> buffer16;

    buffer.resize(simdutf::base64_length_from_binary(len));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data());
      buffer.resize(size);
      for (size_t i = 0; i < 5; i++) {
        add_garbage(buffer, gen, to_base64_value);
      }
      buffer16.resize(buffer.size());
      for (size_t i = 0; i < buffer.size(); i++) {
        buffer16[i] = buffer[i];
      }
      ASSERT_EQUAL(size, simdutf::base64_length_from_binary(len));
      simdutf::result r = implementation.base64_to_binary(
          buffer16.data(), buffer16.size(), back.data(),
          simdutf::base64_default_accept_garbage);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);
    }
  }
}

TEST(roundtrip_base64_url_16_with_garbage) {
  for (size_t len = 0; len < max_len; len++) {
    std::vector<char> source(len, 0);
    std::vector<char> buffer;
    std::vector<char16_t> buffer16;

    buffer.resize(simdutf::base64_length_from_binary(len));
    std::vector<char> back(len);
    std::mt19937 gen((std::mt19937::result_type)(seed));
    std::uniform_int_distribution<int> byte_generator{0, 255};
    for (size_t trial = 0; trial < 10; trial++) {
      for (size_t i = 0; i < len; i++) {
        source[i] = byte_generator(gen);
      }
      size_t size = implementation.binary_to_base64(
          source.data(), source.size(), buffer.data(), simdutf::base64_url);
      buffer.resize(size);
      for (size_t i = 0; i < 5; i++) {
        add_garbage(buffer, gen, to_base64url_value);
      }
      buffer16.resize(buffer.size());
      for (size_t i = 0; i < buffer.size(); i++) {
        buffer16[i] = buffer[i];
      }
      ASSERT_EQUAL(
          size, simdutf::base64_length_from_binary(len, simdutf::base64_url));
      simdutf::result r = implementation.base64_to_binary(
          buffer16.data(), buffer16.size(), back.data(),
          simdutf::base64_url_accept_garbage);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_EQUAL(r.count, len);
      if (back != source) {
        printf("=====input size %zu\n", len);
        for (size_t i = 0; i < len; i++) {
          if (back[i] != source[i]) {
            printf("Mismatch at position %zu trial %zu\n", i, trial);
          }
          printf("%zu: %02x %02x\n", i, uint8_t(back[i]), uint8_t(source[i]));
        }
        printf("=====base64 size %zu\n", size);
        for (size_t i = 0; i < size; i++) {
          printf("%zu: %02x %c\n", i, uint8_t(buffer[i]), buffer[i]);
        }
      }
      ASSERT_TRUE(back == source);
    }
  }
}

TEST(aborted_safe_roundtrip_base64) {
  for (size_t offset = 1; offset <= 16; offset += 3) {
    for (size_t len = offset; len < (max_len / 2); len++) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      buffer.resize(simdutf::base64_length_from_binary(len));
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t trial = 0; trial < 10; trial++) {
        for (size_t i = 0; i < len; i++) {
          source[i] = byte_generator(gen);
        }
        size_t size = implementation.binary_to_base64(
            source.data(), source.size(), buffer.data());
        buffer.resize(size);
        std::vector<char> back(simdutf::maximal_binary_length_from_base64(
            buffer.data(), buffer.size()));
        size_t limited_length = len - offset; // intentionally too little
        back.resize(limited_length);
        back.shrink_to_fit();
        simdutf::result r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), limited_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::OUTPUT_BUFFER_TOO_SMALL);
        for (size_t i = 0; i < limited_length; i++) {
          ASSERT_EQUAL(source[i], back[i]);
        }
        // Now let us decode the rest !!!
        size_t input_index = r.count;
        back.resize(simdutf::maximal_binary_length_from_base64(
            buffer.data() + input_index, buffer.size() - input_index));
        size_t second_length = back.size();
        r = simdutf::base64_to_binary_safe(buffer.data() + input_index,
                                           buffer.size() - input_index,
                                           back.data(), second_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        back.resize(second_length);
        ASSERT_EQUAL(second_length + limited_length, len);

        for (size_t i = 0; i < second_length; i++) {
          ASSERT_EQUAL(source[i + limited_length], back[i]);
        }
      }
    }
  }
}

TEST(aborted_safe_roundtrip_base64_16) {
  for (size_t offset = 1; offset <= 16; offset += 3) {
    for (size_t len = offset; len < (max_len / 2); len++) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      std::vector<char16_t> buffer16;

      buffer.resize(simdutf::base64_length_from_binary(len));
      std::vector<char> back(len);
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t trial = 0; trial < 10; trial++) {
        for (size_t i = 0; i < len; i++) {
          source[i] = byte_generator(gen);
        }
        size_t size = implementation.binary_to_base64(
            source.data(), source.size(), buffer.data());
        buffer.resize(size);
        buffer16.resize(buffer.size());
        for (size_t i = 0; i < buffer.size(); i++) {
          buffer16[i] = buffer[i];
        }
        ASSERT_EQUAL(size, simdutf::base64_length_from_binary(len));
        size_t limited_length = len - offset; // intentionally too little
        back.resize(limited_length);
        back.shrink_to_fit();
        simdutf::result r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), limited_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::OUTPUT_BUFFER_TOO_SMALL);
        for (size_t i = 0; i < limited_length; i++) {
          ASSERT_EQUAL(source[i], back[i]);
        }
        // Now let us decode the rest !!!
        size_t input_index = r.count;
        back.resize(simdutf::maximal_binary_length_from_base64(
            buffer.data() + input_index, buffer.size() - input_index));
        size_t second_length = back.size();
        r = simdutf::base64_to_binary_safe(buffer.data() + input_index,
                                           buffer.size() - input_index,
                                           back.data(), second_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        back.resize(second_length);
        ASSERT_EQUAL(second_length + limited_length, len);
        for (size_t i = 0; i < second_length; i++) {
          ASSERT_EQUAL(source[i + limited_length], back[i]);
        }
      }
    }
  }
}

TEST(aborted_safe_roundtrip_base64_with_spaces) {
  for (size_t offset = 1; offset <= 16; offset += 3) {
    for (size_t len = offset; len < (max_len / 2); len++) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      buffer.resize(simdutf::base64_length_from_binary(len));
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t trial = 0; trial < 10; trial++) {
        for (size_t i = 0; i < len; i++) {
          source[i] = byte_generator(gen);
        }
        size_t size = implementation.binary_to_base64(
            source.data(), source.size(), buffer.data());
        buffer.resize(size);
        for (size_t i = 0; i < 5; i++) {
          add_space(buffer, gen);
        }
        std::vector<char> back(simdutf::maximal_binary_length_from_base64(
            buffer.data(), buffer.size()));
        size_t limited_length = len - offset; // intentionally too little
        back.resize(limited_length);
        back.shrink_to_fit();
        simdutf::result r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), limited_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::OUTPUT_BUFFER_TOO_SMALL);
        for (size_t i = 0; i < limited_length; i++) {
          ASSERT_EQUAL(source[i], back[i]);
        }
        // Now let us decode the rest !!!
        size_t input_index = r.count;
        back.resize(simdutf::maximal_binary_length_from_base64(
            buffer.data() + input_index, buffer.size() - input_index));
        size_t second_length = back.size();
        r = simdutf::base64_to_binary_safe(buffer.data() + input_index,
                                           buffer.size() - input_index,
                                           back.data(), second_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        back.resize(second_length);
        ASSERT_EQUAL(second_length + limited_length, len);
        for (size_t i = 0; i < second_length; i++) {
          ASSERT_EQUAL(source[i + limited_length], back[i]);
        }
      }
    }
  }
}

TEST(aborted_safe_roundtrip_base64_16_with_spaces) {
  for (size_t offset = 1; offset <= 16; offset += 3) {
    for (size_t len = offset; len < (max_len / 2); len++) {
      std::vector<char> source(len, 0);
      std::vector<char> buffer;
      std::vector<char16_t> buffer16;

      buffer.resize(simdutf::base64_length_from_binary(len));
      std::vector<char> back(len);
      std::mt19937 gen((std::mt19937::result_type)(seed));
      std::uniform_int_distribution<int> byte_generator{0, 255};
      for (size_t trial = 0; trial < 10; trial++) {
        for (size_t i = 0; i < len; i++) {
          source[i] = byte_generator(gen);
        }
        size_t size = implementation.binary_to_base64(
            source.data(), source.size(), buffer.data());
        buffer.resize(size);
        for (size_t i = 0; i < 5; i++) {
          add_space(buffer, gen);
        }
        buffer16.resize(buffer.size());
        for (size_t i = 0; i < buffer.size(); i++) {
          buffer16[i] = buffer[i];
        }
        ASSERT_EQUAL(size, simdutf::base64_length_from_binary(len));
        size_t limited_length = len - offset; // intentionally too little
        back.resize(limited_length);
        back.shrink_to_fit();
        simdutf::result r = simdutf::base64_to_binary_safe(
            buffer.data(), buffer.size(), back.data(), limited_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::OUTPUT_BUFFER_TOO_SMALL);
        for (size_t i = 0; i < limited_length; i++) {
          ASSERT_EQUAL(source[i], back[i]);
        }
        // Now let us decode the rest !!!
        size_t input_index = r.count;
        back.resize(simdutf::maximal_binary_length_from_base64(
            buffer.data() + input_index, buffer.size() - input_index));
        size_t second_length = back.size();
        r = simdutf::base64_to_binary_safe(buffer.data() + input_index,
                                           buffer.size() - input_index,
                                           back.data(), second_length);
        ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
        back.resize(second_length);
        ASSERT_EQUAL(second_length + limited_length, len);
        for (size_t i = 0; i < second_length; i++) {
          ASSERT_EQUAL(source[i + limited_length], back[i]);
        }
      }
    }
  }
}

TEST(streaming_base64_roundtrip) {
  size_t len = 2048;
  std::vector<char> source(len, 0);
  std::vector<char> buffer;
  buffer.resize(simdutf::base64_length_from_binary(len));
  std::mt19937 gen((std::mt19937::result_type)(seed));
  std::uniform_int_distribution<int> byte_generator{0, 255};
  for (size_t i = 0; i < len; i++) {
    source[i] = byte_generator(gen);
  }
  size_t size = implementation.binary_to_base64(source.data(), source.size(),
                                                buffer.data());
  for (size_t window = 16; window <= 2048; window += 7) {
    buffer.resize(size);
    // build a buffer with enough space to receive the decoded base64
    std::vector<char> back(len);
    size_t outpos = 0;
    size_t pos = 0;
    for (; pos < buffer.size();) {
      size_t count = simdutf::detail::min(window, buffer.size() - pos);

      simdutf::full_result r = implementation.base64_to_binary_details(
          buffer.data() + pos, count, back.data() + outpos,
          simdutf::base64_default,
          simdutf::last_chunk_handling_options::only_full_chunks);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      ASSERT_TRUE(r.input_count <= count);
      ASSERT_TRUE(r.output_count <= back.size() - outpos);
      ASSERT_TRUE(r.output_count % 3 == 0);
      ASSERT_TRUE(r.input_count % 4 == 0);

      outpos += r.output_count;
      pos += r.input_count;
      if (r.input_count == 0) {
        break; // no more input
      }
    }
    if (pos < buffer.size()) {
      // we have a remainder

      simdutf::full_result r = implementation.base64_to_binary_details(
          buffer.data() + pos, buffer.size() - pos, back.data() + outpos,
          simdutf::base64_default,
          simdutf::last_chunk_handling_options::strict);
      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
      outpos += r.output_count;
      pos += r.input_count;
    }
    back.resize(outpos);
    ASSERT_TRUE(back == source);
  }
}

TEST(readme_test) {
  size_t len = 2048;
  std::vector<char> base64(len, 'a');
  std::vector<char> back((len + 3) / 4 * 3);
  size_t outpos = 0;
  size_t window = 512;
  for (size_t pos = 0; pos < base64.size(); pos += window) {
    // how many base64 characters we can process in this iteration
    size_t count = simdutf::detail::min(window, base64.size() - pos);
    simdutf::result r = simdutf::base64_to_binary(base64.data() + pos, count,
                                                  back.data() + outpos);
    if (r.error == simdutf::error_code::INVALID_BASE64_CHARACTER) {
      printf("Invalid base64 character at position %zu\n", pos + r.count);
      return;
    }
    // If we arrived at the end of the base64 input, we must check that the
    // number of characters processed is a multiple of 4, or that we have a
    // remainder of 0, 2 or 3.
    if (count + pos == base64.size() &&
        r.error == simdutf::error_code::BASE64_INPUT_REMAINDER) {
      puts("The base64 input contained an invalid number of characters");
    }
    // If we are not at then end, we may have to reprocess either 1, 2 or 3
    // bytes, and to drop the last 0, 2 or 3 bytes decoded.
    size_t tail_bytes_to_reprocess = 0;
    if (r.error == simdutf::error_code::BASE64_INPUT_REMAINDER) {
      tail_bytes_to_reprocess = 1;
    } else {
      tail_bytes_to_reprocess = (r.count % 3) == 0 ? 0 : (r.count % 3) + 1;
    }
    pos -= tail_bytes_to_reprocess;
    r.count -= (r.count % 3);
    outpos += r.count;
  }
  // At then end, we resize the buffer to the actual number of bytes decoded.
  back.resize(outpos);
}

TEST(readme_safe) {
  size_t len = 72;
  std::vector<char> base64(len, 'a');
  std::vector<char> back((len + 3) / 4 * 3);
  size_t limited_length = back.size() / 2; // Intentionally too small
  simdutf::result r = simdutf::base64_to_binary_safe(
      base64.data(), base64.size(), back.data(), limited_length);
  ASSERT_EQUAL(r.error, simdutf::error_code::OUTPUT_BUFFER_TOO_SMALL);

  // We decoded 'limited_length' bytes to back.
  // Now let us decode the rest !!!
  size_t input_index = r.count;
  size_t limited_length2 = back.size();
  r = simdutf::base64_to_binary_safe(base64.data() + input_index,
                                     base64.size() - input_index, back.data(),
                                     limited_length2);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  back.resize(limited_length2);
  ASSERT_EQUAL(limited_length2 + limited_length, (len + 3) / 4 * 3);
}

#if SIMDUTF_SPAN
TEST(base64_to_binary_safe_span_api_char) {
  const std::string input{"QWJyYWNhZGFicmEh"};
  const std::string expected_output{"Abracadabra!"};
  std::string output(expected_output.size() + 4, '\0');
  const auto [ret, outlen] = simdutf::base64_to_binary_safe(input, output);
  ASSERT_EQUAL(ret.error, simdutf::SUCCESS);
  ASSERT_EQUAL(ret.count, 16); // amount of consumed input
  ASSERT_EQUAL(outlen, 12);    // how much was written to output
}

TEST(base64_to_binary_safe_span_api_char16) {
  const std::u16string input{u"QWJyYWNhZGFicmEh"};
  const std::string expected_output{"Abracadabra!"};
  std::string output(expected_output.size() + 4, '\0');
  const auto [ret, outlen] = simdutf::base64_to_binary_safe(input, output);
  ASSERT_EQUAL(ret.error, simdutf::SUCCESS);
  ASSERT_EQUAL(ret.count, 16); // amount of consumed input
  ASSERT_EQUAL(outlen, 12);    // how much was written to output
}

TEST(binary_to_base64_with_lines_span_api_char) {
  const std::string input{"Abracadabra!"};
  const std::string expected_output{"QWJyY\nWNhZG\nFicmE\nh"};
  std::string output(expected_output.size() + 4, '\0');
  const auto outlen = simdutf::binary_to_base64_with_lines(input, output, 5);
  ASSERT_EQUAL(outlen,
               expected_output.size()); // how much was written to output
  output.resize(outlen);
  ASSERT_EQUAL(expected_output, output);
}

#endif

// Tests for binary_length_from_base64
TEST(binary_length_from_base64_basic) {
  // Test basic strings without spaces
  // "YQ==" decodes to "a" (1 byte)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("YQ==", 4), 1);
  // "YWI=" decodes to "ab" (2 bytes)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("YWI=", 4), 2);
  // "YWJj" decodes to "abc" (3 bytes)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("YWJj", 4), 3);
  // "YWJjZA==" decodes to "abcd" (4 bytes)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("YWJjZA==", 8), 4);
  // Empty string
  ASSERT_EQUAL(simdutf::binary_length_from_base64("", 0), 0);
}

TEST(binary_length_from_base64_with_spaces) {
  // Test strings with spaces - binary_length_from_base64 should return exact
  // length "Y Q = =" with spaces, should decode to "a" (1 byte)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("Y Q = =", 7), 1);
  // "  Y  Q  =  =  " with lots of spaces
  ASSERT_EQUAL(simdutf::binary_length_from_base64("  Y  Q  =  =  ", 14), 1);
  // "  A  A  " should decode to 1 byte (2 base64 chars = 1 byte)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("  A  A  ", 8), 1);
  // "  A  A  G  A  /  v  8  " should decode to 5 bytes (7 base64 chars)
  ASSERT_EQUAL(
      simdutf::binary_length_from_base64("  A  A  G  A  /  v  8  ", 23), 5);
}

TEST(binary_length_from_base64_matches_decode_result) {
  // Verify that binary_length_from_base64 matches the actual decode result
  std::vector<std::string> test_inputs = {
      "YQ==",
      "YWI=",
      "YWJj",
      "YWJjZA==",
      "  Y  Q  =  =  ",
      "  A  A  ",
      "  A  A  G  A  /  v  8  ",
      "SGVsbG8gV29ybGQh", // "Hello World!"
      "SGVs bG8g V29y bGQh",
      "dGVzdA==",    // "test"
      "dGVzdA",      // "test" without padding
      "dGVzdGluZw==" // "testing"
  };

  for (const auto &input : test_inputs) {
    size_t exact_len =
        simdutf::binary_length_from_base64(input.data(), input.size());
    size_t max_len =
        simdutf::maximal_binary_length_from_base64(input.data(), input.size());
    // exact length should be <= maximal length
    ASSERT_TRUE(exact_len <= max_len);

    // Now decode and verify the exact length matches
    std::vector<char> buffer(max_len);
    auto result =
        simdutf::base64_to_binary(input.data(), input.size(), buffer.data());
    if (result.error == simdutf::error_code::SUCCESS) {
      ASSERT_EQUAL(exact_len, result.count);
    }
  }
}

TEST(binary_length_from_base64_char16) {
  // Test with char16_t input
  std::u16string input16 = u"YWJj"; // "abc"
  ASSERT_EQUAL(
      simdutf::binary_length_from_base64(input16.data(), input16.size()), 3);

  std::u16string input16_spaces = u"  Y  Q  =  =  ";
  ASSERT_EQUAL(simdutf::binary_length_from_base64(input16_spaces.data(),
                                                  input16_spaces.size()),
               1);

  // Long input that exercises the vectorized path; "YWJj" decodes to "abc".
  std::u16string input16_long;
  for (int i = 0; i < 16; i++) {
    input16_long += u"YWJj";
  }
  ASSERT_EQUAL(implementation.binary_length_from_base64(input16_long.data(),
                                                        input16_long.size()),
               48);
}

TEST(binary_length_from_base64_url_variant) {
  // Test with URL-safe base64 input
  // The function counts non-whitespace characters regardless of variant
  std::string url_input = "YWJj"; // Same as standard for this input
  ASSERT_EQUAL(
      simdutf::binary_length_from_base64(url_input.data(), url_input.size()),
      3);

  // Test with actual URL-safe characters
  // "abc?" in URL-safe base64 is "YWJjPw" (no special chars needed here)
  std::string url_input2 = "YWJjPw";
  ASSERT_EQUAL(
      simdutf::binary_length_from_base64(url_input2.data(), url_input2.size()),
      4);
}

TEST(binary_length_from_base64_various_remainders) {
  // Test various remainder cases
  // 0 base64 chars = 0 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("", 0), 0);
  // 1 base64 char (invalid, but function still computes) = 0 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("A", 1), 0);
  // 2 base64 chars = 1 byte
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AA", 2), 1);
  // 3 base64 chars = 2 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AAA", 3), 2);
  // 4 base64 chars = 3 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AAAA", 4), 3);
  // 5 base64 chars = 3 bytes (remainder 1 contributes 0)
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AAAAA", 5), 3);
  // 6 base64 chars = 4 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AAAAAA", 6), 4);
  // 7 base64 chars = 5 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AAAAAAA", 7), 5);
  // 8 base64 chars = 6 bytes
  ASSERT_EQUAL(simdutf::binary_length_from_base64("AAAAAAAA", 8), 6);
}

TEST(base64_details_padding_error_consistency) {
  const char input[] = "www";
  const size_t input_len = 3;

  const auto opt = simdutf::base64_default;
  const auto lco = simdutf::last_chunk_handling_options::strict;

  const size_t maxbinary =
      implementation.maximal_binary_length_from_base64(input, input_len);
  std::vector<char> output(maxbinary);

  const simdutf::full_result fr = implementation.base64_to_binary_details(
      input, input_len, output.data(), opt, lco);

  ASSERT_TRUE(fr.error != simdutf::error_code::SUCCESS);
  ASSERT_TRUE(fr.padding_error);
}

TEST(base64_details_padding_error_various_inputs) {
  const char *cases[] = {"w", "ww", "www", "wwww=", "====", "A"};
  const auto opt = simdutf::base64_default;
  const auto lco = simdutf::last_chunk_handling_options::strict;

  for (const char *input : cases) {
    const size_t input_len = std::strlen(input);
    const size_t maxbinary =
        implementation.maximal_binary_length_from_base64(input, input_len);
    std::vector<char> output(maxbinary + 1);

    const simdutf::full_result fr = implementation.base64_to_binary_details(
        input, input_len, output.data(), opt, lco);

    std::vector<char> output2(maxbinary + 1);
    const simdutf::result r = implementation.base64_to_binary(
        input, input_len, output2.data(), opt, lco);

    const simdutf::result r_from_fr = static_cast<simdutf::result>(fr);
    ASSERT_EQUAL(r.error, r_from_fr.error);
    ASSERT_EQUAL(r.count, r_from_fr.count);

    // On success, output bytes must match.
    if (fr.error == simdutf::error_code::SUCCESS) {
      ASSERT_TRUE(std::equal(output.begin(), output.begin() + fr.output_count,
                             output2.begin()));
    }
  }
}

TEST(base64_details_padding_error_char16) {
  const char16_t input[] = u"www";
  const size_t input_len = 3;

  const auto opt = simdutf::base64_default;
  const auto lco = simdutf::last_chunk_handling_options::strict;

  const size_t maxbinary =
      implementation.maximal_binary_length_from_base64(input, input_len);
  std::vector<char> output(maxbinary);

  const simdutf::full_result fr = implementation.base64_to_binary_details(
      input, input_len, output.data(), opt, lco);

  ASSERT_TRUE(fr.error != simdutf::error_code::SUCCESS);
  ASSERT_TRUE(fr.padding_error);
}

TEST(base64_details_input_count_on_padding_error) {
  std::string input(62, 'R');
  input += '\n';
  input += '=';
  const size_t input_len = input.size();

  const auto opt = simdutf::base64_default_no_padding;
  const auto lco = simdutf::last_chunk_handling_options::loose;

  const size_t maxbinary =
      implementation.maximal_binary_length_from_base64(input.data(), input_len);
  std::vector<char> output(maxbinary + 1);

  const simdutf::full_result fr = implementation.base64_to_binary_details(
      input.data(), input_len, output.data(), opt, lco);

  ASSERT_TRUE(fr.error == simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_TRUE(fr.padding_error);
  ASSERT_EQUAL(fr.input_count, size_t(63));
}

TEST(base64_details_input_count_padding_error_various_sizes) {
  const auto opt = simdutf::base64_default_no_padding;
  const auto lco = simdutf::last_chunk_handling_options::loose;

  for (size_t n_rs = 2; n_rs <= 130; n_rs += 1) {
    std::string input(n_rs, 'R');
    input += '\n';
    input += '=';
    const size_t input_len = input.size();
    const size_t equal_pos = n_rs + 1;

    const size_t maxbinary = implementation.maximal_binary_length_from_base64(
        input.data(), input_len);
    std::vector<char> output(maxbinary + 1);

    const simdutf::full_result fr = implementation.base64_to_binary_details(
        input.data(), input_len, output.data(), opt, lco);

    if (fr.padding_error) {
      ASSERT_EQUAL(fr.input_count, equal_pos);
    }
  }
}

TEST(base64_to_binary_details_basic) {
  // Test the free function simdutf::base64_to_binary_details
  const std::string base64_input = "QWJyYWNhZGFicmEh"; // "Abracadabra!"
  const std::string expected = "Abracadabra!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  ASSERT_EQUAL(r.input_count, base64_input.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_utf16) {
  // Test the free function simdutf::base64_to_binary_details with char16_t
  const std::u16string base64_input = u"QWJyYWNhZGFicmEh"; // "Abracadabra!"
  const std::string expected = "Abracadabra!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  ASSERT_EQUAL(r.input_count, base64_input.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_with_spaces) {
  const std::string base64_input = "  QWJy  YWNh  ZGFi  cmEh  ";
  const std::string expected = "Abracadabra!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_stop_before_partial) {
  // "QWJy" decodes to "Abr", and "YQ" is an incomplete group (2 chars).
  // With stop_before_partial, only the first complete 4-char group is decoded.
  const std::string base64_input = "QWJy YQ";
  const std::string expected = "Abr";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data(),
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  // input_count should stop before the incomplete group
  ASSERT_TRUE(r.input_count < base64_input.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_stop_before_partial_all_consumed) {
  // When the input is a complete multiple of 4 base64 chars,
  // stop_before_partial consumes everything.
  const std::string base64_input = "QWJyYWNhZGFicmEh"; // "Abracadabra!"
  const std::string expected = "Abracadabra!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data(),
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  ASSERT_EQUAL(r.input_count, base64_input.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_invalid_character) {
  // '!' at position 4 is not a valid base64 character
  const std::string base64_input = "QWJy!!!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.input_count, 4); // position of first '!'
}

TEST(base64_to_binary_details_input_remainder) {
  // 5 base64 chars: "QWJyY" -> 4 chars form a group, 1 remainder.
  // A single remainder character cannot encode anything, so this is an error.
  const std::string base64_input = "QWJyY";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
}

TEST(base64_to_binary_details_with_spaces_utf16) {
  const std::u16string base64_input = u"  QWJy  YWNh  ZGFi  cmEh  ";
  const std::string expected = "Abracadabra!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_stop_before_partial_utf16) {
  // "QWJy" decodes to "Abr", and "YQ" is an incomplete group (2 chars).
  // With stop_before_partial, only the first complete 4-char group is decoded.
  const std::u16string base64_input = u"QWJy YQ";
  const std::string expected = "Abr";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data(),
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  // input_count should stop before the incomplete group
  ASSERT_TRUE(r.input_count < base64_input.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_stop_before_partial_all_consumed_utf16) {
  // When the input is a complete multiple of 4 base64 chars,
  // stop_before_partial consumes everything.
  const std::u16string base64_input = u"QWJyYWNhZGFicmEh"; // "Abracadabra!"
  const std::string expected = "Abracadabra!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data(),
      simdutf::base64_default,
      simdutf::last_chunk_handling_options::stop_before_partial);
  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
  ASSERT_EQUAL(r.output_count, expected.size());
  ASSERT_EQUAL(r.input_count, base64_input.size());
  ASSERT_TRUE(std::string(output.data(), r.output_count) == expected);
}

TEST(base64_to_binary_details_invalid_character_utf16) {
  // '!' at position 4 is not a valid base64 character
  const std::u16string base64_input = u"QWJy!!!";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::INVALID_BASE64_CHARACTER);
  ASSERT_EQUAL(r.input_count, 4); // position of first '!'
}

TEST(base64_to_binary_details_input_remainder_utf16) {
  // 5 base64 chars: "QWJyY" -> 4 chars form a group, 1 remainder.
  // A single remainder character cannot encode anything, so this is an error.
  const std::u16string base64_input = u"QWJyY";
  std::vector<char> output(simdutf::maximal_binary_length_from_base64(
      base64_input.data(), base64_input.size()));
  simdutf::full_result r = simdutf::base64_to_binary_details(
      base64_input.data(), base64_input.size(), output.data());
  ASSERT_EQUAL(r.error, simdutf::error_code::BASE64_INPUT_REMAINDER);
}

TEST(base64_valid_runtime) {
  // Test that base64_valid correctly identifies valid/invalid characters
  for (char c = 'A'; c <= 'Z'; c++) {
    ASSERT_TRUE(simdutf::base64_valid(c));
  }
  for (char c = 'a'; c <= 'z'; c++) {
    ASSERT_TRUE(simdutf::base64_valid(c));
  }
  for (char c = '0'; c <= '9'; c++) {
    ASSERT_TRUE(simdutf::base64_valid(c));
  }
  ASSERT_TRUE(simdutf::base64_valid('+'));
  ASSERT_TRUE(simdutf::base64_valid('/'));
  ASSERT_TRUE(!simdutf::base64_valid(' '));
  ASSERT_TRUE(!simdutf::base64_valid('='));
  ASSERT_TRUE(!simdutf::base64_valid('!'));

  // base64url
  ASSERT_TRUE(simdutf::base64_valid('-', simdutf::base64_url));
  ASSERT_TRUE(simdutf::base64_valid('_', simdutf::base64_url));
}

int main(int argc, char *argv[]) {
  const auto cmdline = simdutf::test::CommandLine::parse(argc, argv);
  seed = cmdline.seed;

  simdutf::test::run(cmdline);

  return 0;
}
