react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/validate_utf16le_with_errors_tests.cpp

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

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

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

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