react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/tests/readme_tests.cpp

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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