react-native-quick-crypto 1.1.0 → 1.1.2

package/deps/simdutf/tests/validate_utf16le_with_errors_tests.cpp

@@ -1,274 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-#include <fstream>
-
-#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_utf16le_with_errors_returns_success_for_valid_input_single_words) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  const auto utf16{generator.generate_le(512, seed)};
-
-  simdutf::result res = implementation.validate_utf16le_with_errors(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size());
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, utf16.size());
-}
-
-TEST_LOOP(
-    validate_utf16le_with_errors_returns_success_for_valid_input_surrogate_pairs_short) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_le(8)};
-
-  simdutf::result res = implementation.validate_utf16le_with_errors(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size());
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, utf16.size());
-}
-
-TEST_LOOP(
-    validate_utf16le_with_errors_returns_success_for_valid_input_surrogate_pairs) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_le(512)};
-
-  simdutf::result res = implementation.validate_utf16le_with_errors(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size());
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, utf16.size());
-}
-
-TEST(provoke_integer_wraparound_in_icelake) {
-  // this is to prove signed integer wraparound in the icelake implementation
-  unsigned char cleaned_crash[] = {
-      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, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20};
-  unsigned int cleaned_crash_len = 62;
-  ASSERT_EQUAL(
-      reinterpret_cast<std::uintptr_t>(cleaned_crash) % alignof(char16_t), 0);
-
-  const auto size = cleaned_crash_len / sizeof(char16_t);
-
-  auto r = simdutf::validate_utf16le_with_errors(
-      (const char16_t *)cleaned_crash, size);
-  ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
-}
-
-// mixed = either 16-bit or 32-bit codewords
-TEST(validate_utf16le_with_errors_returns_success_for_valid_input_mixed) {
-  uint32_t seed{1234};
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 1};
-  const auto utf16{generator.generate_le(512)};
-
-  simdutf::result res = implementation.validate_utf16le_with_errors(
-      reinterpret_cast<const char16_t *>(utf16.data()), utf16.size());
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, utf16.size());
-}
-
-TEST(validate_utf16le_with_errors_returns_success_for_empty_string) {
-  const char16_t *buf = (char16_t *)"";
-
-  simdutf::result res = implementation.validate_utf16le_with_errors(
-      reinterpret_cast<const char16_t *>(buf), 0);
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, 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_utf16le_with_errors_returns_error_when_input_has_wrong_first_word_value) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-
-  auto utf16{generator.generate_le(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_utf16le(wrong_value);
-
-      simdutf::result res =
-          implementation.validate_utf16le_with_errors(utf16.data(), len);
-
-      ASSERT_EQUAL(res.error, simdutf::error_code::SURROGATE);
-      ASSERT_EQUAL(res.count, i);
-
-      utf16[i] = old;
-    }
-  }
-}
-
-/*
- RFC-2781:
-
- 3) [..] if W2 is not between 0xDC00 and 0xDFFF, the sequence is in error.
-    Terminate.
-*/
-TEST(
-    validate_utf16le_with_errors_returns_error_when_input_has_wrong_second_word_value) {
-  uint32_t seed{1234};
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 0};
-  auto utf16{generator.generate_le(128)};
-  const size_t len = utf16.size();
-
-  const std::array<char16_t, 5> sample_wrong_second_word{0x0000, 0x1000, 0xdbff,
-                                                         0xe000, 0xffff};
-
-  const char16_t valid_surrogate_W1 = 0xd800;
-  for (char16_t W2 : sample_wrong_second_word) {
-    for (size_t i = 0; i < utf16.size() - 1; i++) {
-      const char16_t old_W1 = utf16[i + 0];
-      const char16_t old_W2 = utf16[i + 1];
-
-      utf16[i + 0] = to_utf16le(valid_surrogate_W1);
-      utf16[i + 1] = to_utf16le(W2);
-
-      simdutf::result res =
-          implementation.validate_utf16le_with_errors(utf16.data(), len);
-
-      ASSERT_EQUAL(res.error, simdutf::error_code::SURROGATE);
-      ASSERT_EQUAL(res.count, i);
-
-      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_utf16le_with_errors_returns_error_when_input_is_truncated) {
-  const char16_t valid_surrogate_W1 = 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_le(128)};
-    const size_t len = utf16.size();
-
-    utf16[size - 1] = to_utf16le(valid_surrogate_W1);
-
-    simdutf::result res =
-        implementation.validate_utf16le_with_errors(utf16.data(), len);
-
-    ASSERT_EQUAL(res.error, simdutf::error_code::SURROGATE);
-    ASSERT_EQUAL(res.count, size - 1);
-  }
-}
-
-TEST(validate_utf16le_with_errors_extensive_tests) {
-#ifdef RUN_IN_SPIKE_SIMULATOR
-  printf("skipping, cannot be run under Spike");
-  return;
-#endif
-  const std::string path{"validate_utf16_testcases.txt"};
-  std::ifstream file{path};
-  if (not file) {
-    printf("File '%s' cannot be open, skipping test\n", path.c_str());
-    return;
-  }
-
-  const uint16_t V = to_utf16le(0xfaea);
-  const uint16_t L = to_utf16le(0xd852);
-  const uint16_t H = to_utf16le(0xde12);
-
-  constexpr size_t len = 32;
-  char16_t buf[len];
-
-  long lineno = 0;
-  while (file) {
-    std::string line;
-    std::getline(file, line);
-    lineno += 1;
-    if (line.empty() or line[0] == '#')
-      continue;
-
-    // format: [TF][VLH]{16}
-    simdutf::error_code valid = simdutf::error_code::SURROGATE;
-    switch (line[0]) {
-    case 'T':
-      valid = simdutf::error_code::SUCCESS;
-      break;
-    case 'F':
-      valid = simdutf::error_code::SURROGATE;
-      break;
-    default:
-      throw std::invalid_argument(
-          "Error at line #" + std::to_string(lineno) +
-          ": the first character must be either 'T' or 'F'");
-    }
-
-    // prepare input
-    for (size_t i = 0; i < len; i++) {
-      buf[i] = V;
-    }
-
-    for (size_t i = 1; i < line.size(); i++) {
-      switch (line[i]) {
-      case 'L':
-        buf[i - 1] = L;
-        break;
-      case 'H':
-        buf[i - 1] = H;
-        break;
-      case 'V':
-        buf[i - 1] = V;
-        break;
-      default:
-        throw std::invalid_argument(
-            "Error at line #" + std::to_string(lineno) +
-            ": allowed characters are 'L', 'H' and 'V'");
-      }
-    }
-
-    // check
-    const simdutf::result res = implementation.validate_utf16le_with_errors(
-        reinterpret_cast<const char16_t *>(buf), len);
-
-    ASSERT_EQUAL(res.error, valid);
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_validation_with_errors_native) {
-  using namespace simdutf::tests::helpers;
-  static_assert(simdutf::validate_utf16_with_errors(u"hello!"_utf16).is_ok());
-}
-
-TEST(compile_time_validation_with_errors_little) {
-  using namespace simdutf::tests::helpers;
-  static_assert(
-      simdutf::validate_utf16le_with_errors(u"hello!"_utf16le).is_ok());
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/validate_utf32_basic_tests.cpp

@@ -1,92 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_utf32.h>
-#include <tests/helpers/test.h>
-
-TEST_LOOP(validate_utf32_returns_true_for_valid_input) {
-  simdutf::tests::helpers::random_utf32 generator{seed};
-  const auto utf32{generator.generate(256, seed)};
-
-  for (size_t i = 0; i < utf32.size(); i++) {
-    ASSERT_TRUE(implementation.validate_utf32(
-        reinterpret_cast<const char32_t *>(utf32.data()), i + 1));
-  }
-  ASSERT_TRUE(implementation.validate_utf32(
-      reinterpret_cast<const char32_t *>(utf32.data()), utf32.size()));
-}
-
-TEST(validate_utf32_returns_true_for_empty_string) {
-  const char32_t *buf = (char32_t *)"";
-
-  ASSERT_TRUE(implementation.validate_utf32(buf, 0));
-}
-
-TEST_LOOP(validate_utf32_returns_false_when_input_in_forbidden_range) {
-  simdutf::tests::helpers::random_utf32 generator{seed};
-  auto utf32{generator.generate(128)};
-  const char32_t *buf = reinterpret_cast<const char32_t *>(utf32.data());
-  const size_t len = utf32.size();
-
-  for (char32_t wrong_value = 0xd800; wrong_value <= 0xdfff; wrong_value++) {
-    for (size_t i = 0; i < utf32.size(); i++) {
-      const char32_t old = utf32[i];
-      utf32[i] = wrong_value;
-
-      ASSERT_FALSE(implementation.validate_utf32(buf, len));
-      ASSERT_FALSE(implementation.validate_utf32(buf, i + 1));
-
-      utf32[i] = old;
-    }
-  }
-}
-
-TEST_LOOP(validate_utf32_returns_false_when_input_too_large) {
-  simdutf::tests::helpers::random_utf32 generator{seed};
-
-  std::uniform_int_distribution<uint32_t> bad_range{0x110000, 0xffffffff};
-  std::mt19937 gen{seed};
-
-  auto utf32{generator.generate(128)};
-  const char32_t *buf = reinterpret_cast<const char32_t *>(utf32.data());
-  const size_t len = utf32.size();
-
-  for (size_t r = 0; r < 10; r++) {
-    uint32_t wrong_value = bad_range(gen);
-    for (size_t i = 0; i < utf32.size(); i++) {
-      const char32_t old = utf32[i];
-      utf32[i] = wrong_value;
-
-      ASSERT_FALSE(implementation.validate_utf32(buf, len));
-      ASSERT_FALSE(implementation.validate_utf32(buf, i + 1));
-
-      utf32[i] = old;
-    }
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-constexpr auto make_bad() {
-  using namespace simdutf::tests::helpers;
-  auto bad = U"I am bad: ?"_utf32;
-  bad[bad.size() - 1] = 0x10FFFF + 1;
-  return bad;
-}
-
-} // namespace
-
-TEST(compile_time_validate) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto good = U"I am a nice and wellbehaved string"_utf32;
-  static_assert(simdutf::validate_utf32(good));
-
-  constexpr auto bad = make_bad();
-  static_assert(not simdutf::validate_utf32(bad));
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/validate_utf32_with_errors_tests.cpp

@@ -1,114 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_utf32.h>
-#include <tests/helpers/test.h>
-
-TEST(issue_531) {
-  const char32_t data[] = {0xdbdb,     0xff380000, 0xffffffff, 0xffffffff,
-                           0xffffffff, 0xffffffff, 0x00ff,     0x0000,
-                           0x0000,     0x0000,     0x0000,     0x0000,
-                           0x0000,     0x0000,     0x0000,     0x0000,
-                           0x0000,     0x0000,     0x0000,     0x0000};
-  constexpr std::size_t data_len = sizeof(data);
-  const auto validation1 = implementation.validate_utf32_with_errors(
-      (const char32_t *)data, data_len);
-  // got return [count=1, error=TOO_LARGE] from implementation rvv
-  // got return [count=0, error=SURROGATE] from implementation fallback
-  ASSERT_EQUAL(validation1.error, simdutf::error_code::SURROGATE);
-  ASSERT_EQUAL(validation1.count, 0);
-}
-
-TEST_LOOP(validate_utf32_with_errors_returns_success_for_valid_input) {
-  simdutf::tests::helpers::random_utf32 generator{seed};
-  const auto utf32{generator.generate(256, seed)};
-
-  simdutf::result res = implementation.validate_utf32_with_errors(
-      reinterpret_cast<const char32_t *>(utf32.data()), utf32.size());
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, utf32.size());
-}
-
-TEST(validate_utf32_with_errors_returns_success_for_empty_string) {
-  const char32_t *buf = (char32_t *)"";
-
-  simdutf::result res = implementation.validate_utf32_with_errors(buf, 0);
-
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, 0);
-}
-
-TEST_LOOP(
-
-    validate_utf32_with_errors_returns_error_when_input_in_forbidden_range) {
-  simdutf::tests::helpers::random_utf32 generator{seed};
-
-  auto utf32{generator.generate(128)};
-  const char32_t *buf = reinterpret_cast<const char32_t *>(utf32.data());
-  const size_t len = utf32.size();
-
-  for (char32_t wrong_value = 0xd800; wrong_value <= 0xdfff; wrong_value++) {
-    for (size_t i = 0; i < utf32.size(); i++) {
-      const char32_t old = utf32[i];
-      utf32[i] = wrong_value;
-
-      simdutf::result res = implementation.validate_utf32_with_errors(buf, len);
-
-      ASSERT_EQUAL(res.error, simdutf::error_code::SURROGATE);
-      ASSERT_EQUAL(res.count, i);
-
-      utf32[i] = old;
-    }
-  }
-}
-
-TEST_LOOP(validate_utf32_with_errors_returns_error_when_input_too_large) {
-  simdutf::tests::helpers::random_utf32 generator{seed};
-
-  std::uniform_int_distribution<uint32_t> bad_range{0x110000, 0xffffffff};
-  std::mt19937 gen{seed};
-
-  auto utf32{generator.generate(128)};
-  const char32_t *buf = reinterpret_cast<const char32_t *>(utf32.data());
-  const size_t len = utf32.size();
-
-  for (size_t r = 0; r < 1000; r++) {
-    uint32_t wrong_value = bad_range(gen);
-    for (size_t i = 0; i < utf32.size(); i++) {
-      const char32_t old = utf32[i];
-      utf32[i] = wrong_value;
-
-      simdutf::result res = implementation.validate_utf32_with_errors(buf, len);
-
-      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LARGE);
-      ASSERT_EQUAL(res.count, i);
-
-      utf32[i] = old;
-    }
-  }
-}
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-constexpr auto make_bad() {
-  using namespace simdutf::tests::helpers;
-  auto bad = U"I am bad: ?"_utf32;
-  bad[bad.size() - 1] = 0x10FFFF + 1;
-  return bad;
-}
-
-} // namespace
-
-TEST(compile_time_validate) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto good = U"I am a nice and wellbehaved string"_utf32;
-  static_assert(simdutf::validate_utf32_with_errors(good).is_ok());
-
-  constexpr auto bad = make_bad();
-  static_assert(simdutf::validate_utf32_with_errors(bad).is_err());
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/validate_utf8_basic_tests.cpp

@@ -1,178 +0,0 @@
-#include "simdutf.h"
-
-#if SIMDUTF_CPLUSPLUS17
-  #include <string_view>
-#endif
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/test.h>
-
-// https://github.com/nodejs/node/issues/48995
-TEST(node48995) {
-  const char bad[1] = {'\x80'};
-  size_t length = 1;
-  ASSERT_FALSE(implementation.validate_utf8(bad, length));
-}
-
-TEST(copyright) {
-  const char good[2] = {'\xC2', '\xA9'};
-  size_t length = 2;
-  ASSERT_TRUE(implementation.validate_utf8(good, length));
-}
-
-namespace {
-// additional tests are from autobahn websocket testsuite
-// https://github.com/crossbario/autobahn-testsuite/tree/master/autobahntestsuite/autobahntestsuite/case
-constexpr const char *goodsequences[] = {"a",
-                                         "\xc3\xb1",
-                                         "\xe2\x82\xa1",
-                                         "\xf0\x90\x8c\xbc",
-                                         "\xc2\x80",         // 6.7.2
-                                         "\xf0\x90\x80\x80", // 6.7.4
-                                         "\xee\x80\x80",     // 6.11.2
-                                         "\xef\xbb\xbf"};
-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",                      // 11
-    "123456789012345\xf1",                      // 12
-    "123456789012345\xc2",                      // 13
-    "\xC2\x7F",                                 // 14
-    "\xce",                                     // 6.6.1
-    "\xce\xba\xe1",                             // 6.6.3
-    "\xce\xba\xe1\xbd",                         // 6.6.4
-    "\xce\xba\xe1\xbd\xb9\xcf",                 // 6.6.6
-    "\xce\xba\xe1\xbd\xb9\xcf\x83\xce",         // 6.6.8
-    "\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce", // 6.6.10
-    "\xdf",                                     // 6.14.6
-    "\xef\xbf",                                 // 6.14.7
-    "\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"};
-} // namespace
-
-TEST(good_bad_sequences) {
-
-  for (size_t i = 0; i < sizeof(goodsequences) / sizeof(goodsequences[0]);
-       i++) {
-    size_t len = std::strlen(goodsequences[i]);
-    if (!implementation.validate_utf8(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_utf8(badsequences[i], len)) {
-      printf("bug lookup2 badsequences[%zu]\n", i);
-      ASSERT_TRUE(false);
-    }
-  }
-
-  puts("OK");
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_validation_goodsequences) {
-  static_assert(std::ranges::all_of(goodsequences, [](std::string_view v) {
-    return simdutf::validate_utf8(v);
-  }));
-}
-
-TEST(compile_time_validation_badsequences) {
-
-  static_assert(!std::ranges::all_of(badsequences, [](std::string_view v) {
-    return simdutf::validate_utf8(v);
-  }));
-}
-
-TEST(compile_time_validation_casts_of_good) {
-
-  using namespace simdutf::tests::helpers;
-  constexpr auto good = u8"My favourite dish is köttbullar"_utf8;
-  static_assert(simdutf::validate_utf8(good));
-  static_assert(simdutf::validate_utf8(good.as_array<std::int8_t>()));
-  static_assert(simdutf::validate_utf8(good.as_array<std::uint8_t>()));
-  static_assert(simdutf::validate_utf8(good.as_array<std::byte>()));
-}
-
-TEST(compile_time_validation_casts_of_bad) {
-
-  using namespace simdutf::tests::helpers;
-
-  // this is the emoji U+1F373 COOKING
-  constexpr auto good = u8"\U0001F373"_utf8;
-  static_assert(simdutf::validate_utf8(good));
-
-  // cut off the last byte to make it bad
-  constexpr auto bad = good.shrink<good.size() - 1>();
-
-  static_assert(not simdutf::validate_utf8(bad));
-  static_assert(not simdutf::validate_utf8(bad.as_array<std::int8_t>()));
-  static_assert(not simdutf::validate_utf8(bad.as_array<std::uint8_t>()));
-  static_assert(not simdutf::validate_utf8(bad.as_array<std::byte>()));
-}
-
-#endif
-
-TEST_MAIN