react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/readme_tests.cpp

@@ -1,274 +0,0 @@
-/**
- * Special tests. Specific cases.
- */
-#include "simdutf.h"
-#include <memory>
-#include <iostream>
-#include <vector>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/test.h>
-
-TEST(base64_fun) {
-  std::cout << "==== base64_fun ====\n" << std::endl;
-  std::vector<std::string> sources = {
-      "  A  A  ", "  A  A  G  A  /  v  8  ",
-      "  A  A  G  A  /  v  8  =  ", "  A  A  G  A  /  v  8  =  =  "};
-  std::vector<std::vector<uint8_t>> expected = {{0},
-                                                {0, 0x1, 0x80, 0xfe, 0xff},
-                                                {0, 0x1, 0x80, 0xfe, 0xff},
-                                                {}}; // last one is in error
-  for (size_t i = 0; i < sources.size(); i++) {
-    const std::string &source = sources[i];
-    std::cout << "source: '" << source << "'" << std::endl;
-    // allocate enough memory for the maximal binary length
-    std::vector<uint8_t> buffer(simdutf::maximal_binary_length_from_base64(
-        source.data(), source.size()));
-    // convert to binary and check for errors
-    simdutf::result r = simdutf::base64_to_binary(source.data(), source.size(),
-                                                  (char *)buffer.data());
-    if (r.error != simdutf::error_code::SUCCESS) {
-      ASSERT_TRUE(expected[i].empty());
-      std::cout << "output: error" << std::endl;
-    } else {
-      buffer.resize(
-          r.count); // in case of success, r.count contains the output length
-      ASSERT_TRUE(buffer == expected[i]);
-      std::cout << "output: " << r.count << " bytes" << std::endl;
-    }
-  }
-}
-
-TEST(base64_fun_safe) {
-  std::cout << "==== base64_fun ====\n" << std::endl;
-  std::vector<std::string> sources = {
-      "  A  A  ", "  A  A  G  A  /  v  8  ",
-      "  A  A  G  A  /  v  8  =  ", "  A  A  G  A  /  v  8  =  =  "};
-  std::vector<std::vector<uint8_t>> expected = {{0},
-                                                {0, 0x1, 0x80, 0xfe, 0xff},
-                                                {0, 0x1, 0x80, 0xfe, 0xff},
-                                                {}}; // last one is in error
-  for (size_t i = 0; i < sources.size(); i++) {
-    const std::string &source = sources[i];
-    std::cout << "source: '" << source << "'" << std::endl;
-    // allocate enough memory for the maximal binary length
-    std::vector<uint8_t> buffer(simdutf::maximal_binary_length_from_base64(
-        source.data(), source.size()));
-    // convert to binary and check for errors
-    size_t output_length = buffer.size();
-    simdutf::result r = simdutf::base64_to_binary_safe(
-        source.data(), source.size(), (char *)buffer.data(), output_length);
-    if (r.error != simdutf::error_code::SUCCESS) {
-      ASSERT_TRUE(expected[i].empty());
-      std::cout << "output: error" << std::endl;
-    } else {
-      buffer.resize(output_length); // in case of success, output_length
-                                    // contains the output length
-      ASSERT_TRUE(buffer == expected[i]);
-      std::cout << "output: " << output_length << " bytes" << std::endl;
-      std::cout << "input (consumed): " << r.count << " bytes" << std::endl;
-    }
-  }
-}
-
-// this is a compile test
-void check_simdutf_result() { simdutf::result r; }
-
-// this is a compile test
-int main_demo() {
-  const char *source = "1234";
-  // 4 == strlen(source)
-  bool validutf8 = simdutf::validate_utf8(source, 4);
-  if (validutf8) {
-    puts("valid UTF-8");
-  } else {
-    puts("invalid UTF-8");
-    return EXIT_FAILURE;
-  }
-  // We need a buffer where to write the UTF-16LE code units.
-  size_t expected_utf16words = simdutf::utf16_length_from_utf8(source, 4);
-  std::unique_ptr<char16_t[]> utf16_output{new char16_t[expected_utf16words]};
-  // convert to UTF-16LE
-  size_t utf16words =
-      simdutf::convert_utf8_to_utf16le(source, 4, utf16_output.get());
-  printf("wrote %zu UTF-16LE code units.", utf16words);
-  // It wrote utf16words * sizeof(char16_t) bytes.
-  bool validutf16 = simdutf::validate_utf16le(utf16_output.get(), utf16words);
-  if (validutf16) {
-    puts("valid UTF-16LE");
-  } else {
-    puts("invalid UTF-16LE");
-    return EXIT_FAILURE;
-  }
-  // convert it back:
-  // We need a buffer where to write the UTF-8 code units.
-  size_t expected_utf8words =
-      simdutf::utf8_length_from_utf16le(utf16_output.get(), utf16words);
-  std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-  // convert to UTF-8
-  size_t utf8words = simdutf::convert_utf16le_to_utf8(
-      utf16_output.get(), utf16words, utf8_output.get());
-  printf("wrote %zu UTF-8 code units.", utf8words);
-  std::string final_string(utf8_output.get(), utf8words);
-  puts(final_string.c_str());
-  if (final_string != source) {
-    puts("bad conversion");
-    return EXIT_FAILURE;
-  } else {
-    puts("perfect round trip");
-  }
-  return EXIT_SUCCESS;
-}
-
-TEST(utf8_streaming) {
-  const char unicode[] = "\xc3\xa9\x63ole d'\xc3\xa9t\xc3\xa9";
-  // suppose you want to decode only the start of this string.
-  size_t length = 10;
-  // Picking 10 bytes is problematic because we might end up in the middle of a
-  // code point. But we can rewind to the previous code point.
-  length = simdutf::trim_partial_utf8(unicode, length);
-  // Now we can transcode safely
-  size_t budget_utf16 = simdutf::utf16_length_from_utf8(unicode, length);
-  std::unique_ptr<char16_t[]> utf16{new char16_t[budget_utf16]};
-  size_t utf16words =
-      simdutf::convert_utf8_to_utf16le(unicode, length, utf16.get());
-  // We can then transcode the next batch
-  const char *next = unicode + length;
-  size_t next_length = sizeof(unicode) - length;
-  size_t next_budget_utf16 = simdutf::utf16_length_from_utf8(next, next_length);
-  std::unique_ptr<char16_t[]> next_utf16{new char16_t[next_budget_utf16]};
-  size_t next_utf16words =
-      simdutf::convert_utf8_to_utf16le(next, next_length, next_utf16.get());
-  ASSERT_EQUAL(next_utf16words, next_budget_utf16);
-  ASSERT_EQUAL(utf16words, budget_utf16);
-}
-
-TEST(issue829) {
-  alignas(char16_t) const char unicode_char[] = "\x3c\xd8";
-  const char16_t *unicode = reinterpret_cast<const char16_t *>(unicode_char);
-  size_t length = 1;
-  length = simdutf::trim_partial_utf16le(unicode, length);
-  ASSERT_EQUAL(length, 0);
-}
-
-TEST(utf16_streaming) {
-  // We have three sequences of surrogate pairs (UTF-16).
-  alignas(char16_t) const char unicode_char[] =
-      "\x3c\xd8\x10\xdf\x3c\xd8\x10\xdf\x3c\xd8\x10\xdf";
-  const char16_t *unicode = reinterpret_cast<const char16_t *>(unicode_char);
-  // suppose you want to decode only the start of this string.
-  size_t length = 3;
-  // Picking 3 units is problematic because we might end up in the middle of a
-  // surrogate pair. But we can rewind to the previous code point.
-  length = simdutf::trim_partial_utf16le(unicode, length);
-  // Now we can transcode safely
-  size_t budget_utf8 = simdutf::utf8_length_from_utf16le(unicode, length);
-  std::unique_ptr<char[]> utf8{new char[budget_utf8]};
-  size_t utf8words =
-      simdutf::convert_utf16le_to_utf8(unicode, length, utf8.get());
-  // We can then transcode the next batch
-  const char16_t *next = unicode + length;
-  size_t next_length = 6 - length;
-  size_t next_budget_utf8 =
-      simdutf::utf8_length_from_utf16le(next, next_length);
-  std::unique_ptr<char[]> next_utf8{new char[next_budget_utf8]};
-  size_t next_utf8words =
-      simdutf::convert_utf16le_to_utf8(next, next_length, next_utf8.get());
-  ASSERT_EQUAL(next_utf8words, next_budget_utf8);
-  ASSERT_EQUAL(utf8words, budget_utf8);
-}
-
-TEST(error_location_badascii) {
-  // this ASCII string has a bad byte at index 5
-  std::string bad_ascii = "\x20\x20\x20\x20\x20\xff\x20\x20\x20";
-  simdutf::result res = implementation.validate_ascii_with_errors(
-      bad_ascii.data(), bad_ascii.size());
-  if (res.error != simdutf::error_code::SUCCESS) {
-    printf("error at index %zu\n", res.count);
-  }
-  ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LARGE);
-  ASSERT_EQUAL(res.count, 5);
-}
-
-TEST(error_location_badutf8) {
-  // this UTF-8 string has a bad byte at index 5
-  std::string bad_utf8 = "\xc3\xa9\xc3\xa9\x20\xff\xc3\xa9";
-  simdutf::result res = implementation.validate_utf8_with_errors(
-      bad_utf8.data(), bad_utf8.size());
-  if (res.error != simdutf::error_code::SUCCESS) {
-    printf("error at index %zu\n", res.count);
-  }
-  ASSERT_EQUAL(res.error, simdutf::error_code::HEADER_BITS);
-  ASSERT_EQUAL(res.count, 5);
-  res = implementation.validate_utf8_with_errors(bad_utf8.data(), res.count);
-  if (res.error == simdutf::error_code::SUCCESS) {
-    printf("we have transcoded %zu valid bytes", res.count);
-  }
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, 5);
-}
-
-TEST(error_location_badutf8_transcoding) {
-  // this UTF-8 string has a bad byte at index 5
-  std::string bad_utf8 = "\xc3\xa9\xc3\xa9\x20\xff\xc3\xa9";
-  size_t budget_utf16 =
-      simdutf::utf16_length_from_utf8(bad_utf8.data(), bad_utf8.size());
-  std::unique_ptr<char16_t[]> utf16{new char16_t[budget_utf16]};
-
-  simdutf::result res = simdutf::convert_utf8_to_utf16_with_errors(
-      bad_utf8.data(), bad_utf8.size(), utf16.get());
-
-  if (res.error != simdutf::error_code::SUCCESS) {
-    printf("error at index %zu\n", res.count);
-  }
-  ASSERT_EQUAL(res.error, simdutf::error_code::HEADER_BITS);
-  ASSERT_EQUAL(res.count, 5);
-  res = simdutf::convert_utf8_to_utf16_with_errors(bad_utf8.data(), res.count,
-                                                   utf16.get());
-  if (res.error == simdutf::error_code::SUCCESS) {
-    printf("we have transcoded %zu characters", res.count);
-  }
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-  ASSERT_EQUAL(res.count, 3);
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_trim_partial_utf8) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto str = u8"\xc3\xa9\xc3\xa9\x20\xff\xc3\xa9"_utf8;
-  constexpr auto compile_time = simdutf::trim_partial_utf8(str);
-  const auto runtime = simdutf::trim_partial_utf8(str);
-  ASSERT_EQUAL(compile_time, runtime);
-}
-
-TEST(compile_time_trim_partial_utf16) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto str = u"\xd800"_utf16;
-  constexpr auto compile_time = simdutf::trim_partial_utf16(str);
-  const auto runtime = simdutf::trim_partial_utf16(str);
-  ASSERT_EQUAL(compile_time, runtime);
-}
-
-TEST(compile_time_trim_partial_utf16le) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto str = u"\xd800"_utf16le;
-  constexpr auto compile_time = simdutf::trim_partial_utf16le(str);
-  const auto runtime = simdutf::trim_partial_utf16le(str);
-  ASSERT_EQUAL(compile_time, runtime);
-}
-
-TEST(compile_time_trim_partial_utf16be) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto str = u"\xd800"_utf16be;
-  constexpr auto compile_time = simdutf::trim_partial_utf16be(str);
-  const auto runtime = simdutf::trim_partial_utf16be(str);
-  ASSERT_EQUAL(compile_time, runtime);
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/reference/CMakeLists.txt

@@ -1,23 +0,0 @@
-add_library(simdutf_tests_reference STATIC
-  encode_utf8.h
-  encode_utf8.cpp
-  encode_utf16.h
-  encode_utf16.cpp
-  encode_utf32.h
-  encode_utf32.cpp
-  encode_latin1.h
-  encode_latin1.cpp
-  validate_utf8_to_latin1.h
-  validate_utf8_to_latin1.cpp
-  validate_utf16_to_latin1.h
-  validate_utf16_to_latin1.cpp
-  validate_utf32_to_latin1.h
-  validate_utf32_to_latin1.cpp
-  validate_utf8.h
-  validate_utf8.cpp
-  validate_utf16.h
-  validate_utf16.cpp
-  validate_utf32.h
-  validate_utf32.cpp)
-add_library(simdutf::tests::reference ALIAS simdutf_tests_reference)
-target_link_libraries(simdutf_tests_reference PRIVATE simdutf)

package/deps/simdutf/tests/reference/decode_utf16.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <cstdio>
-#include "simdutf/encoding_types.h"
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace utf16 {
-
-enum class Error {
-  high_surrogate_out_of_range,
-  low_surrogate_out_of_range,
-  missing_low_surrogate
-};
-
-template <typename CONSUMER, typename ERROR_HANDLER>
-bool decode(endianness utf16_endianness, const char16_t *codepoints,
-            size_t size, CONSUMER consumer, ERROR_HANDLER error_handler) {
-  const char16_t *curr = codepoints;
-  const char16_t *end = codepoints + size;
-
-  // RFC2781, chapter 2.2
-  while (curr != end) {
-    uint16_t W1;
-    if (!match_system(utf16_endianness)) {
-      W1 = char16_t((uint16_t(*curr) << 8) | (uint16_t(*curr) >> 8));
-    } else {
-      W1 = *curr;
-    }
-
-    curr += 1;
-
-    if (W1 < 0xd800 ||
-        W1 > 0xdfff) { // fast path, code point is equal to character's value
-      consumer(W1);
-      continue;
-    }
-
-    if (W1 > 0xdbff) { // W1 must be in range 0xd800 .. 0xdbff
-      if (!error_handler(codepoints, curr, Error::high_surrogate_out_of_range))
-        return false;
-
-      continue;
-    }
-
-    if (curr ==
-        end) { // required the next word, but we're already at the end of data
-      if (!error_handler(codepoints, curr, Error::missing_low_surrogate))
-        return false;
-
-      break;
-    }
-
-    uint16_t W2;
-    if (!match_system(utf16_endianness)) {
-      W2 = char16_t((uint16_t(*curr) << 8) | (uint16_t(*curr) >> 8));
-    } else {
-      W2 = *curr;
-    }
-    if (W2 < 0xdc00 || W2 > 0xdfff) { // W2 = 0xdc00 .. 0xdfff
-      if (!error_handler(codepoints, curr, Error::low_surrogate_out_of_range))
-        return false;
-    } else {
-      const uint32_t hi = W1 & 0x3ff; // take lower 10 bits of W1 and W2
-      const uint32_t lo = W2 & 0x3ff;
-      const uint32_t tmp = lo | (hi << 10); // build a 20-bit temporary value U'
-
-      consumer(tmp + 0x10000);
-    }
-
-    curr += 1;
-  }
-
-  return true;
-}
-
-} // namespace utf16
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/decode_utf32.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <cstdio>
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace utf32 {
-
-enum class Error { too_large, forbidden_range };
-
-template <typename CONSUMER, typename ERROR_HANDLER>
-bool decode(const char32_t *codepoints, size_t size, CONSUMER consumer,
-            ERROR_HANDLER error_handler) {
-  const char32_t *curr = codepoints;
-  const char32_t *end = codepoints + size;
-
-  while (curr != end) {
-    const uint32_t word = *curr;
-
-    if (word > 0x10FFFF) {
-      if (!error_handler(codepoints, curr, Error::too_large))
-        return false;
-
-      continue;
-    }
-
-    if (word >= 0xD800 && word <= 0xDFFF) { // required the next word, but we're
-                                            // already at the end of data
-      if (!error_handler(codepoints, curr, Error::forbidden_range))
-        return false;
-
-      break;
-    }
-
-    consumer(word);
-
-    curr++;
-  }
-
-  return true;
-}
-
-} // namespace utf32
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/encode_latin1.cpp

@@ -1 +0,0 @@
-#include "encode_latin1.h"

package/deps/simdutf/tests/reference/encode_latin1.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace latin1 {
-
-// returns whether the value can be represented in the latin1
-bool valid_value(uint32_t value) {
-  if (value > 0xFF) {
-    return false;
-  }
-  return true; // Each possible combination in a bit represent a latin1 value
-}
-
-// Encodes the value in UTF-32
-// Returns 1 if the value can be encoded
-// Returns 0 if the value cannot be encoded
-template <typename CONSUMER> int encode(uint8_t value, CONSUMER consumer) {
-  if (!valid_value(value)) {
-    return 0;
-  }
-  consumer(value);
-  return 1;
-}
-
-} // namespace latin1
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/encode_utf16.cpp

@@ -1,49 +0,0 @@
-#include "encode_utf16.h"
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace utf16 {
-
-// returns whether the value can be represented in the UTF-16
-bool valid_value(uint32_t value) {
-  /*
-    RFC-2781 (2. UTF-16 definition):
-
-    Characters with values greater than 0x10FFFF cannot be encoded in UTF-16.
-  */
-  if (value > 0x10FFFF)
-    return false;
-
-  /*
-    RFC-2781 (2. UTF-16 definition):
-
-    Note: Values between 0xD800 and 0xDFFF are specifically reserved for
-    use with UTF-16, and don't have any characters assigned to them.
-  */
-  if ((value >= 0xD800) && (value <= 0xDFFF))
-    return false;
-
-  return true;
-}
-
-// Encodes the value using either one or two code units (returns 1 or 2
-// respectively) Returns 0 if the value cannot be encoded
-int encode(uint32_t value, char16_t &W1, char16_t &W2) {
-  if (!valid_value(value))
-    return 0;
-
-  if (value <= 0xffff) {
-    W1 = char16_t(value);
-    return 1;
-  } else {
-    value -= 0x10000;
-    W1 = char16_t(0xd800 | ((value >> 10) & 0x03ff));
-    W2 = char16_t(0xdc00 | (value & 0x03ff));
-    return 2;
-  }
-}
-} // namespace utf16
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/encode_utf16.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace utf16 {
-
-// returns whether the value can be represented in the UTF-16
-bool valid_value(uint32_t value);
-
-// Encodes the value using either one or two code units (returns 1 or 2
-// respectively) Returns 0 if the value cannot be encoded
-int encode(uint32_t value, char16_t &W1, char16_t &W2);
-
-} // namespace utf16
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/encode_utf32.cpp

@@ -1 +0,0 @@
-#include "encode_utf32.h"

package/deps/simdutf/tests/reference/encode_utf32.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace utf32 {
-
-// returns whether the value can be represented in the UTF-32
-bool valid_value(uint32_t value) {
-
-  if (value > 0x10FFFF)
-    return false;
-
-  if ((value >= 0xD800) && (value <= 0xDFFF))
-    return false;
-
-  return true;
-}
-
-// Encodes the value in UTF-32
-// Returns 1 if the value can be encoded
-// Returns 0 if the value cannot be encoded
-template <typename CONSUMER> int encode(uint32_t value, CONSUMER consumer) {
-  if (!valid_value(value))
-    return 0;
-
-  consumer(value);
-  return 1;
-}
-
-} // namespace utf32
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/encode_utf8.cpp

@@ -1 +0,0 @@
-#include "encode_utf8.h"

package/deps/simdutf/tests/reference/encode_utf8.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-namespace utf8 {
-
-template <typename CONSUMER> int encode(uint32_t value, CONSUMER consumer) {
-  if (value < 0x00000080) {
-    consumer(uint8_t(value));
-    return 1;
-  }
-
-  if (value < 0x00000800) {
-    consumer(0xc0 | (value >> 6));
-    consumer(0x80 | (value & 0x3f));
-    return 2;
-  }
-
-  if (value < 0x00010000) {
-    consumer(0xe0 | (value >> 12));
-    consumer(0x80 | ((value >> 6) & 0x3f));
-    consumer(0x80 | (value & 0x3f));
-    return 3;
-  }
-
-  {
-    consumer(0xf0 | (value >> 18));
-    consumer(0x80 | ((value >> 12) & 0x3f));
-    consumer(0x80 | ((value >> 6) & 0x3f));
-    consumer(0x80 | (value & 0x3f));
-    return 4;
-  }
-}
-} // namespace utf8
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf16.cpp

@@ -1,60 +0,0 @@
-#include "validate_utf16.h"
-
-#ifndef SIMDUTF_IS_BIG_ENDIAN
-  #error "SIMDUTF_IS_BIG_ENDIAN should be defined."
-#endif
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-
-simdutf_warn_unused bool validate_utf16(endianness utf16_endianness,
-                                        const char16_t *buf,
-                                        size_t len) noexcept {
-  const char16_t *curr = buf;
-  const char16_t *end = buf + len;
-
-  while (curr != end) {
-    uint16_t W1;
-    if (!match_system(utf16_endianness)) {
-      W1 = uint16_t((uint16_t(*curr) << 8) | (uint16_t(*curr) >> 8));
-    } else {
-      W1 = *curr;
-    }
-
-    curr += 1;
-
-    // fast path, code point is equal to character's value
-    if (W1 < 0xd800 || W1 > 0xdfff) {
-      continue;
-    }
-
-    // W1 must be in range 0xd800 .. 0xdbff
-    if (W1 > 0xdbff) {
-      return false;
-    }
-
-    // required the next word, but we're already at the end of data
-    if (curr == end) {
-      return false;
-    }
-
-    uint16_t W2;
-    if (!match_system(utf16_endianness)) {
-      W2 = uint16_t((uint16_t(*curr) << 8) | (uint16_t(*curr) >> 8));
-    } else {
-      W2 = *curr;
-    }
-
-    if (W2 < 0xdc00 || W2 > 0xdfff) // W2 = 0xdc00 .. 0xdfff
-      return false;
-
-    curr += 1;
-  }
-
-  return true;
-}
-
-} // namespace reference
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf16.h

@@ -1,14 +0,0 @@
-#include "simdutf/common_defs.h"
-#include "simdutf/encoding_types.h"
-
-namespace simdutf {
-namespace tests {
-namespace reference {
-// validate UTF-16
-simdutf_warn_unused bool validate_utf16(endianness utf16_endianness,
-                                        const char16_t *buf,
-                                        size_t len) noexcept;
-
-} // namespace reference
-} // namespace tests
-} // namespace simdutf