react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/utf8_length_from_utf16_tests.cpp

@@ -0,0 +1,202 @@
+// 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

@@ -0,0 +1,165 @@
+#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

@@ -0,0 +1,77 @@
+#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

@@ -0,0 +1,175 @@
+#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