react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/utf8_length_from_utf16_tests.cpp

@@ -1,202 +0,0 @@
-// The goal of these tests is to trigger the case when a low surrogate (the
-// first one) is the last char handled by a vectorized code, and the remaining
-// single one char16_t is passed to scalar code.
-
-#include "simdutf.h"
-
-#include <tests/helpers/compiletime_conversions.h>
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/test.h>
-
-TEST(utf16le_surrogate_pair) {
-  for (size_t size = 0; size < 512; size++) {
-    std::vector<uint8_t> input(size * 2, 0);
-
-    // low surrogate
-    input.push_back(0x01);
-    input.push_back(0xd8);
-
-    // high surrogate
-    input.push_back(0x01);
-    input.push_back(0xdc);
-
-    const size_t want = size + 4;
-    const size_t got = implementation.utf8_length_from_utf16le(
-        reinterpret_cast<const char16_t *>(input.data()), input.size() / 2);
-
-    ASSERT_EQUAL(want, got);
-
-    const simdutf::result got_with_replacement =
-        implementation.utf8_length_from_utf16le_with_replacement(
-            reinterpret_cast<const char16_t *>(input.data()), input.size() / 2);
-    ASSERT_EQUAL(want, got_with_replacement.count);
-    ASSERT_EQUAL(simdutf::SURROGATE, got_with_replacement.error);
-  }
-}
-
-TEST(utf16be_surrogate_pair) {
-  for (size_t size = 0; size < 512; size++) {
-    std::vector<uint8_t> input(size * 2, 0);
-
-    // low surrogate
-    input.push_back(0xd8);
-    input.push_back(0x01);
-
-    // high surrogate
-    input.push_back(0xdc);
-    input.push_back(0x01);
-
-    const size_t want = size + 4;
-    const size_t got = implementation.utf8_length_from_utf16be(
-        reinterpret_cast<const char16_t *>(input.data()), input.size() / 2);
-
-    ASSERT_EQUAL(want, got);
-
-    const simdutf::result got_with_replacement =
-        implementation.utf8_length_from_utf16be_with_replacement(
-            reinterpret_cast<const char16_t *>(input.data()), input.size() / 2);
-    ASSERT_EQUAL(want, got_with_replacement.count);
-    ASSERT_EQUAL(simdutf::SURROGATE, got_with_replacement.error);
-  }
-}
-
-TEST(issue001) {
-  // There are surrogates but they are well formed.
-  std::vector<char16_t> input = {0x004e, 0x000e, 0xdbba, 0xdd90,
-                                 0x030b, 0x0035, 0x004f, 0x0045};
-#if SIMDUTF_IS_BIG_ENDIAN
-  const size_t standard =
-      implementation.utf8_length_from_utf16be(input.data(), input.size());
-  ASSERT_EQUAL(standard, 11);
-  const auto result1 = implementation.utf8_length_from_utf16be_with_replacement(
-      input.data(), input.size());
-  ASSERT_EQUAL(result1.count, 11);
-  ASSERT_EQUAL(simdutf::SURROGATE, result1.error);
-#else
-  const size_t standard =
-      implementation.utf8_length_from_utf16le(input.data(), input.size());
-  ASSERT_EQUAL(standard, 11);
-  const auto result2 = implementation.utf8_length_from_utf16le_with_replacement(
-      input.data(), input.size());
-  ASSERT_EQUAL(result2.count, 11);
-  ASSERT_EQUAL(simdutf::SURROGATE, result2.error);
-#endif
-}
-
-TEST(issue002) {
-  // There are surrogates but they are well formed.
-  std::vector<char16_t> input = {0xd950, 0xdd9a, 0x002d};
-#if SIMDUTF_IS_BIG_ENDIAN
-  const size_t standard =
-      implementation.utf8_length_from_utf16be(input.data(), input.size());
-  ASSERT_EQUAL(standard, 5);
-  const auto result1 = implementation.utf8_length_from_utf16be_with_replacement(
-      input.data(), input.size());
-  ASSERT_EQUAL(result1.count, 5);
-  ASSERT_EQUAL(simdutf::SURROGATE, result1.error);
-#else
-  const size_t standard =
-      implementation.utf8_length_from_utf16le(input.data(), input.size());
-  ASSERT_EQUAL(standard, 5);
-  const auto result2 = implementation.utf8_length_from_utf16le_with_replacement(
-      input.data(), input.size());
-  ASSERT_EQUAL(result2.count, 5);
-  ASSERT_EQUAL(simdutf::SURROGATE, result2.error);
-#endif
-}
-
-TEST(bug_found_in_release_7_7_0) {
-
-  // this is invalid input in native endian, such that
-  // utf8_length_from_utf16_with_replacement happens to give a different answer
-  // than utf8_length_from_utf16. It is implementation defined what
-  // utf8_length_from_utf16 gives, but it is sufficient to demonstrate the bug
-  // to prove the bug in the current implementation.
-
-  const std::vector<char16_t> input = {0xD800, 0xDC00, 0xDFFF, 0xD800, 0xDC00};
-  const bool valid = simdutf::validate_utf16(input.data(), input.size());
-  ASSERT_FALSE(valid);
-
-  const auto native_length =
-      simdutf::utf8_length_from_utf16(input.data(), input.size());
-  const auto be_length =
-      simdutf::utf8_length_from_utf16be(input.data(), input.size());
-  const auto le_length =
-      simdutf::utf8_length_from_utf16le(input.data(), input.size());
-#if SIMDUTF_IS_BIG_ENDIAN
-  ASSERT_EQUAL(native_length, be_length);
-  (void)le_length;
-#else
-  (void)be_length;
-  ASSERT_EQUAL(native_length, le_length);
-#endif
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-// makes a malformed string in the requested endianness
-template <simdutf::endianness e> constexpr auto make_malformed() {
-  simdutf::tests::helpers::CTString<
-      char16_t, 5,
-      e == simdutf::endianness::BIG ? std::endian::big : std::endian::little>
-      data{};
-  data[2] = simdutf::scalar::utf16::swap_if_needed<e>(0xD800);
-  return data;
-}
-} // namespace
-
-TEST(compile_time_utf8_length_from_utf16_with_replacement) {
-  using namespace simdutf::tests::helpers;
-  using enum simdutf::endianness;
-
-  {
-    constexpr auto malformed = make_malformed<NATIVE>();
-    constexpr simdutf::result utf8_length =
-        simdutf::utf8_length_from_utf16_with_replacement(malformed);
-    static_assert(utf8_length.count == malformed.size() + 2);
-    static_assert(utf8_length.error == simdutf::SURROGATE);
-    constexpr auto wellformed = to_wellformed(malformed);
-    constexpr size_t utf8_length_check =
-        simdutf::utf8_length_from_utf16(wellformed);
-    static_assert(utf8_length.count == utf8_length_check);
-  }
-}
-
-TEST(compile_time_utf8_length_from_utf16le_with_replacement) {
-  using namespace simdutf::tests::helpers;
-  using enum simdutf::endianness;
-
-  {
-    constexpr auto malformed = make_malformed<LITTLE>();
-    constexpr simdutf::result utf8_length =
-        simdutf::utf8_length_from_utf16le_with_replacement(malformed);
-    static_assert(utf8_length.count == malformed.size() + 2);
-    static_assert(utf8_length.error == simdutf::SURROGATE);
-    constexpr auto wellformed = to_wellformed(malformed);
-    constexpr size_t utf8_length_check =
-        simdutf::utf8_length_from_utf16le(wellformed);
-    static_assert(utf8_length.count == utf8_length_check);
-  }
-}
-
-TEST(compile_time_utf8_length_from_utf16be_with_replacement) {
-  using namespace simdutf::tests::helpers;
-  using enum simdutf::endianness;
-
-  {
-    constexpr auto malformed = make_malformed<BIG>();
-    constexpr simdutf::result utf8_length =
-        simdutf::utf8_length_from_utf16be_with_replacement(malformed);
-    static_assert(utf8_length.count == malformed.size() + 2);
-    static_assert(utf8_length.error == simdutf::SURROGATE);
-    constexpr auto wellformed = to_wellformed(malformed);
-    constexpr size_t utf8_length_check =
-        simdutf::utf8_length_from_utf16be(wellformed);
-    static_assert(utf8_length.count == utf8_length_check);
-  }
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/validate_ascii_basic_tests.cpp

@@ -1,165 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/test.h>
-#include <tests/helpers/fixed_string.h>
-
-namespace {
-// additional tests are from autobahn websocket testsuite
-// https://github.com/crossbario/autobahn-testsuite/tree/master/autobahntestsuite/autobahntestsuite/case
-constexpr const char *goodsequences[] = {
-    "a", "abcde12345", "\x71", "\x75\x4c",
-    "\x7f\x4c\x23\x3c\x3a\x6f\x5d\x44\x13\x70"};
-constexpr const char *badsequences[] = {
-    "\xc3\x28",             // 0
-    "\xa0\xa1",             // 1
-    "\xe2\x28\xa1",         // 2
-    "\xe2\x82\x28",         // 3
-    "\xf0\x28\x8c\xbc",     // 4
-    "\xf0\x90\x28\xbc",     // 5
-    "\xf0\x28\x8c\x28",     // 6
-    "\xc0\x9f",             // 7
-    "\xf5\xff\xff\xff",     // 8
-    "\xed\xa0\x81",         // 9
-    "\xf8\x90\x80\x80\x80", // 10
-    "123456789012345\xed",
-    "123456789012345\xf1",
-    "123456789012345\xc2",
-    "\xC2\x7F",
-    "\xce",
-    "\xce\xba\xe1",
-    "\xce\xba\xe1\xbd",
-    "\xce\xba\xe1\xbd\xb9\xcf",
-    "\xce\xba\xe1\xbd\xb9\xcf\x83\xce",
-    "\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce",
-    "\xdf",
-    "\xef\xbf",
-    "\x80",
-    "\x91\x85\x95\x9e",
-    "\x6c\x02\x8e\x18",
-    "\x25\x5b\x6e\x2c\x32\x2c\x5b\x5b\x33\x2c\x34\x2c\x05\x29\x2c\x33\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b"
-    "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5d\x2c\x35\x2e\x33\x2c\x39\x2e\x33"
-    "\x2c\x37\x2e\x33\x2c\x39\x2e\x34\x2c\x37\x2e\x33\x2c\x39\x2e\x33\x2c\x37"
-    "\x2e\x33\x2c\x39\x2e\x34\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d"
-    "\x5d\x5d\x5d\x5d\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x20\x01\x01"
-    "\x01\x01\x01\x02\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x23\x0a\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x7e\x7e\x0a\x0a\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x5b\x5b"
-    "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5d\x2c\x37"
-    "\x2e\x33\x2c\x39\x2e\x33\x2c\x37\x2e\x33\x2c\x39\x2e\x34\x2c\x37\x2e\x33"
-    "\x2c\x39\x2e\x33\x2c\x37\x2e\x33\x2c\x39\x2e\x34\x5d\x5d\x5d\x5d\x5d\x5d"
-    "\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x01\x01\x80\x01\x01\x01\x79\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01",
-    "[[[[[[[[[[[[[[["
-    "\x80\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x010\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01",
-    "\x20\x0b\x01\x01\x01\x64\x3a\x64\x3a\x64\x3a\x5b\x5b\x5b\x5b\x5b\x5b\x5b"
-    "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b"
-    "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x30\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x80\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
-    "\x01\x01\x01\x01\x01",
-    "\x80",
-    "\x90",
-    "\xa1",
-    "\xb2",
-    "\xc3",
-    "\xd4",
-    "\xe5",
-    "\xf6",
-    "\xc3\xb1",
-    "\xe2\x82\xa1",
-    "\xf0\x90\x8c\xbc",
-    "\xc2\x80",
-    "\xf0\x90\x80\x80",
-    "\xee\x80\x80",
-    "\xef\xbb\xbf"};
-
-} // namespace
-
-TEST(hard_coded) {
-  for (size_t i = 0; i < sizeof(goodsequences) / sizeof(goodsequences[0]);
-       i++) {
-    size_t len = std::strlen(goodsequences[i]);
-    if (!implementation.validate_ascii(goodsequences[i], len)) {
-      printf("bug goodsequences[%zu]\n", i);
-      ASSERT_TRUE(false);
-    }
-  }
-  for (size_t i = 0; i < sizeof(badsequences) / sizeof(badsequences[0]); i++) {
-    size_t len = std::strlen(badsequences[i]);
-    if (implementation.validate_ascii(badsequences[i], len)) {
-      printf("bug lookup2 badsequences[%zu]\n", i);
-      ASSERT_TRUE(false);
-    }
-  }
-
-  puts("OK");
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-// for negative compilation tests
-template <class InputPtr>
-concept passable_to_validate =
-    requires(InputPtr p) { simdutf::scalar::ascii::validate(p, 10u); };
-
-} // namespace
-
-TEST(compile_time_valid) {
-  static_assert(std::ranges::all_of(goodsequences, [](std::string_view input) {
-    return simdutf::validate_ascii(input);
-  }));
-
-  using namespace simdutf::tests::helpers;
-  constexpr auto ascii = "a normal ascii text"_latin1;
-
-  static_assert(simdutf::validate_ascii(ascii));
-  static_assert(simdutf::validate_ascii(ascii.as_array<unsigned char>()));
-  static_assert(simdutf::validate_ascii(ascii.as_array<signed char>()));
-  static_assert(simdutf::validate_ascii(ascii.as_array<std::byte>()));
-
-  static_assert(passable_to_validate<char *>);
-  static_assert(passable_to_validate<unsigned char *>);
-  static_assert(passable_to_validate<const char *>);
-  static_assert(!passable_to_validate<int *>);
-  static_assert(passable_to_validate<std::array<char, 10>>);
-  static_assert(!passable_to_validate<std::array<int, 10>>);
-}
-
-TEST(compile_time_invalid) {
-  static_assert(
-      not std::ranges::any_of(badsequences, [](std::string_view input) {
-        return simdutf::validate_ascii(input);
-      }));
-}
-#endif
-TEST_MAIN

package/deps/simdutf/tests/validate_ascii_with_errors_tests.cpp

@@ -1,77 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_utf8.h>
-#include <tests/helpers/test.h>
-
-TEST_LOOP(no_error_ASCII) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 0, 0, 0};
-  const auto ascii{generator.generate(512)};
-
-  simdutf::result res = implementation.validate_ascii_with_errors(
-      reinterpret_cast<const char *>(ascii.data()), ascii.size());
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, ascii.size());
-}
-
-TEST_LOOP(error_ASCII) {
-  simdutf::tests::helpers::random_utf8 generator{seed, 1, 0, 0, 0};
-
-  auto ascii{generator.generate(512)};
-
-  for (unsigned int i = 0; i < ascii.size(); i++) {
-    ascii[i] += 0b10000000;
-
-    simdutf::result res = implementation.validate_ascii_with_errors(
-        reinterpret_cast<const char *>(ascii.data()), ascii.size());
-
-    ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LARGE);
-    ASSERT_EQUAL(res.count, i);
-
-    ascii[i] -= 0b10000000;
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-// for negative compilation tests
-template <class InputPtr>
-concept passable_to_validate = requires(InputPtr p) {
-  simdutf::scalar::ascii::validate_with_errors(p, 10u);
-};
-
-} // namespace
-
-TEST(compile_time_valid) {
-
-  using namespace simdutf::tests::helpers;
-  constexpr auto ascii = "a normal ascii text"_latin1;
-
-  static_assert(simdutf::validate_ascii_with_errors(ascii).is_ok());
-  static_assert(
-      simdutf::validate_ascii_with_errors(ascii.as_array<unsigned char>())
-          .is_ok());
-  static_assert(
-      simdutf::validate_ascii_with_errors(ascii.as_array<signed char>())
-          .is_ok());
-  static_assert(
-      simdutf::validate_ascii_with_errors(ascii.as_array<std::byte>()).is_ok());
-
-  static_assert(passable_to_validate<char *>);
-  static_assert(passable_to_validate<unsigned char *>);
-  static_assert(passable_to_validate<const char *>);
-  static_assert(!passable_to_validate<int *>);
-  static_assert(passable_to_validate<std::array<char, 10>>);
-  static_assert(!passable_to_validate<std::array<int, 10>>);
-}
-
-TEST(compile_time_invalid) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto not_ascii = u8"not ascii: köttbulle"_utf8;
-  static_assert(simdutf::validate_ascii_with_errors(not_ascii).is_err());
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/validate_utf16be_basic_tests.cpp

@@ -1,175 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-#include <vector>
-
-#include <tests/helpers/compiletime_conversions.h>
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_utf16.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/utf16.h>
-
-TEST_LOOP(validate_utf16be_ascii) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  auto utf16{generator.generate_be(512, seed)};
-  generator.to_ascii_be(utf16);
-  ASSERT_TRUE(
-      implementation.validate_utf16be_as_ascii(utf16.data(), utf16.size()));
-  utf16[utf16.size() / 2] = 0xC0C0;
-  ASSERT_FALSE(
-      implementation.validate_utf16be_as_ascii(utf16.data(), utf16.size()));
-}
-
-TEST_LOOP(validate_utf16be_returns_true_for_valid_input_single_words) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  const auto utf16{generator.generate_be(512, seed)};
-
-  ASSERT_TRUE(implementation.validate_utf16be(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size()));
-}
-
-TEST_LOOP(validate_utf16be_returns_true_for_valid_input_surrogate_pairs_short) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_be(8)};
-  ASSERT_TRUE(implementation.validate_utf16be(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size()));
-}
-
-TEST_LOOP(validate_utf16be_returns_true_for_valid_input_surrogate_pairs) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_be(512)};
-  ASSERT_TRUE(implementation.validate_utf16be(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size()));
-}
-
-// mixed = either 16-bit or 32-bit codewords
-TEST(validate_utf16be_returns_true_for_valid_input_mixed) {
-  uint32_t seed{1234};
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 1};
-  const auto utf16{generator.generate_be(512)};
-  ASSERT_TRUE(implementation.validate_utf16be(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size()));
-}
-
-TEST(validate_utf16be_returns_true_for_empty_string) {
-  const char16_t *buf = (char16_t *)"";
-
-  ASSERT_TRUE(implementation.validate_utf16be(buf, 0));
-}
-
-// The first word must not be in range [0xDC00 .. 0xDFFF]
-/*
-2.2 Decoding UTF-16
-
-   [...]
-
-   1) If W1 < 0xD800 or W1 > 0xDFFF, the character value U is the value
-      of W1. Terminate.
-
-   2) Determine if W1 is between 0xD800 and 0xDBFF. If not, the sequence
-      is in error [...]
-*/
-TEST_LOOP(
-    validate_utf16be_returns_false_when_input_has_wrong_first_word_value) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  auto utf16{generator.generate_be(128)};
-  const size_t len = utf16.size();
-
-  for (char16_t wrong_value = 0xdc00; wrong_value <= 0xdfff; wrong_value++) {
-    for (size_t i = 0; i < utf16.size(); i++) {
-      const char16_t old = utf16[i];
-      utf16[i] = to_utf16be(wrong_value);
-
-      ASSERT_FALSE(implementation.validate_utf16be(
-          reinterpret_cast<const char16_t *>(utf16.data()), len));
-
-      utf16[i] = old;
-    }
-  }
-}
-
-/*
- RFC-2781:
-
- 3) [..] if W2 is not between 0xDC00 and 0xDFFF, the sequence is in error.
-    Terminate.
-*/
-TEST(validate_utf16be_returns_false_when_input_has_wrong_second_word_value) {
-  uint32_t seed{1234};
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  auto utf16{generator.generate_be(128)};
-  const size_t len = utf16.size();
-
-  const std::array<char16_t, 5> sample_wrong_second_word{
-      to_utf16be(0x0000), to_utf16be(0x0010), to_utf16be(0xffdb),
-      to_utf16be(0x00e0), to_utf16be(0xffff)};
-
-  const char16_t valid_surrogate_W1 = to_utf16be(0xd800);
-  for (char16_t W2 : sample_wrong_second_word) {
-    for (size_t i = 0; i < len - 1; i++) {
-      const char16_t old_W1 = utf16[i + 0];
-      const char16_t old_W2 = utf16[i + 1];
-
-      utf16[i + 0] = valid_surrogate_W1;
-      utf16[i + 1] = W2;
-
-      ASSERT_FALSE(implementation.validate_utf16be(
-          reinterpret_cast<const char16_t *>(utf16.data()), len));
-
-      utf16[i + 0] = old_W1;
-      utf16[i + 1] = old_W2;
-    }
-  }
-}
-
-/*
- RFC-2781:
-
- 3) If there is no W2 (that is, the sequence ends with W1) [...]
-    the sequence is in error. Terminate.
-*/
-TEST(validate_utf16be_returns_false_when_input_is_truncated) {
-  const char16_t valid_surrogate_W1 = to_utf16be(0xd800);
-  uint32_t seed{1234};
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  for (size_t size = 1; size < 128; size++) {
-    auto utf16{generator.generate_be(128)};
-    const size_t len = utf16.size();
-
-    utf16[size - 1] = valid_surrogate_W1;
-
-    ASSERT_FALSE(implementation.validate_utf16be(
-        reinterpret_cast<const char16_t *>(utf16.data()), len));
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_validation) {
-  using namespace simdutf::tests::helpers;
-
-  static_assert(simdutf::validate_utf16be(u"hello!"_utf16be));
-
-  // invalid - two high surrogates following each other
-  constexpr auto invalid = u"\xd800\xd800"_utf16;
-  constexpr auto invalid_be = to_utf16be(invalid);
-  static_assert(not simdutf::validate_utf16be(invalid_be));
-}
-
-TEST(compile_time_ascii_validation_native_endian) {
-  using namespace simdutf::tests::helpers;
-  static_assert(
-      simdutf::validate_utf16_as_ascii(u"I am ascii, I promise!"_utf16));
-  static_assert(
-      not simdutf::validate_utf16_as_ascii(u"But this isn't: köttbulle"_utf16));
-}
-
-TEST(compile_time_ascii_validation_be) {
-  using namespace simdutf::tests::helpers;
-  static_assert(
-      simdutf::validate_utf16be_as_ascii(u"I am ascii, I promise!"_utf16be));
-  static_assert(not simdutf::validate_utf16be_as_ascii(
-      u"But this isn't: köttbulle"_utf16be));
-}
-#endif
-TEST_MAIN