react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/helpers/transcode_test_base.h

@@ -1,683 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-#include <functional>
-#include <cstdio>
-#include "utf16.h"
-#include "simdutf/encoding_types.h"
-
-std::vector<std::vector<char16_t>>
-all_utf16_combinations(simdutf::endianness byte_order);
-
-namespace simdutf {
-namespace tests {
-namespace helpers {
-
-/**
- * It would be nice to use a single helper for both UTF-8 => UTF-16LE
- * and UTF-8 <= UTF-16LE, but the function signatures differ when you
- * represent UTF8 with char8_t and UTF-16LE with char16_t.
- */
-class transcode_test_base {
-protected:
-  endianness utf16_endianness;
-
-protected:
-  transcode_test_base() : utf16_endianness{endianness::LITTLE} {}
-  transcode_test_base(endianness utf16) : utf16_endianness{utf16} {}
-
-  void encode_utf8(uint32_t codepoint, std::vector<char> &target);
-  void encode_utf16(uint32_t codepoint, std::vector<char16_t> &target);
-  void encode_utf32(uint32_t codepoint, std::vector<char32_t> &target);
-  void encode_latin1(uint32_t codepoint, std::vector<char> &target);
-};
-
-/**
- * This class can be used to test Latin1 => UTF-8 transcoding.
- */
-class transcode_latin1_to_utf8_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> output_utf8; // what the procedure under test produced
-  std::vector<char> reference_output_utf8; // what we are expecting
-
-  std::vector<char>
-      input_latin1; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_latin1_to_utf8_test_base(GenerateCodepoint generate,
-                                     size_t input_size);
-
-  template <typename COLLECTION>
-  transcode_latin1_to_utf8_test_base(COLLECTION &&collection) {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf8.resize(reference_output_utf8.size() + output_size_margin);
-    output_utf8.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    const size_t saved_chars =
-        procedure(input_latin1.data(), input_latin1.size(), output_utf8.data());
-    return validate(saved_chars);
-  }
-
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_latin1.data(), input_latin1.size());
-    if (saved_chars != reference_output_utf8.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf8.size()));
-
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test Latin1 => UTF-16LE transcoding.
- */
-class transcode_latin1_to_utf16_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> input_latin1;
-  std::vector<char16_t> output_utf16;
-  std::vector<char16_t> reference_output_utf16;
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_latin1_to_utf16_test_base(endianness utf16_endianness,
-                                      GenerateCodepoint generate,
-                                      size_t input_size);
-
-  template <typename COLLECTION>
-  transcode_latin1_to_utf16_test_base(endianness utf16_endianness,
-                                      COLLECTION &&collection)
-      : transcode_test_base{utf16_endianness} {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf16.resize(reference_output_utf16.size() + output_size_margin);
-    output_utf16.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_latin1.data(), input_latin1.size(),
-                                   output_utf16.data());
-    return validate(saved_chars);
-  }
-
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_latin1.data(), input_latin1.size());
-    if (saved_chars != reference_output_utf16.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf16.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-16LE => UTF-32 transcoding.
- */
-class transcode_utf16_to_latin1_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> output_latin1; // what the procedure under test produced
-  std::vector<char> reference_output_latin1; // what we are expecting
-
-  std::vector<char16_t>
-      input_utf16; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      16; // extra room for buggy procedures
-
-public:
-  transcode_utf16_to_latin1_test_base(endianness utf16_endianness,
-                                      GenerateCodepoint generate,
-                                      size_t input_size);
-
-  transcode_utf16_to_latin1_test_base(endianness utf16_endianness,
-                                      const std::vector<char16_t> &input_utf16);
-
-  template <typename COLLECTION>
-  transcode_utf16_to_latin1_test_base(endianness utf16_endianness,
-                                      COLLECTION &&collection)
-      : transcode_test_base{utf16_endianness} {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_latin1.resize(reference_output_latin1.size() + output_size_margin);
-    output_latin1.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf16.data(), input_utf16.size(), output_latin1.data());
-    return validate(saved_chars);
-  }
-
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf16.data(), input_utf16.size());
-    if (saved_chars != reference_output_latin1.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_latin1.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test Latin1 => UTF-32 transcoding.
- */
-class transcode_latin1_to_utf32_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char32_t> output_utf32; // what the procedure under test produced
-  std::vector<char32_t> reference_output_utf32; // what we are expecting
-
-  std::vector<char>
-      input_latin1; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_latin1_to_utf32_test_base(GenerateCodepoint generate,
-                                      size_t input_size); // constructor
-
-  template <typename COLLECTION>
-  transcode_latin1_to_utf32_test_base(COLLECTION &&collection) {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf32.resize(reference_output_utf32.size() + output_size_margin);
-    output_utf32.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_latin1.data(), input_latin1.size(),
-                                   output_utf32.data());
-    return validate(saved_chars);
-  }
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_latin1.data(), input_latin1.size());
-    if (saved_chars != reference_output_utf32.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf32.size()));
-
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-8 => Latin1 transcoding.
- */
-class transcode_utf8_to_latin1_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> output_latin1; // what the procedure under test produced
-  std::vector<char> reference_output_latin1; // what we are expecting
-
-  std::vector<char>
-      input_utf8; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf8_to_latin1_test_base(GenerateCodepoint generate,
-                                     size_t input_size); // constructor
-
-  template <typename COLLECTION>
-  transcode_utf8_to_latin1_test_base(COLLECTION &&collection) {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_latin1.resize(reference_output_latin1.size() + output_size_margin);
-    output_latin1.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf8.data(), input_utf8.size(), output_latin1.data());
-    return validate(saved_chars);
-  }
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf8.data(), input_utf8.size());
-    if (saved_chars != reference_output_latin1.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_latin1.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-8 => UTF-16LE transcoding.
- */
-class transcode_utf8_to_utf16_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char>
-      input_utf8; // source-encoded message: what we're going to transcode
-  std::vector<char16_t> output_utf16; // what the procedure under test produced
-  std::vector<char16_t> reference_output_utf16; // what we are expecting
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf8_to_utf16_test_base(endianness utf16_endianness,
-                                    GenerateCodepoint generate,
-                                    size_t input_size);
-
-  template <typename COLLECTION>
-  transcode_utf8_to_utf16_test_base(endianness utf16_endianness,
-                                    COLLECTION &&collection)
-      : transcode_test_base{utf16_endianness} {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf16.resize(reference_output_utf16.size() + output_size_margin);
-    output_utf16.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf8.data(), input_utf8.size(), output_utf16.data());
-    return validate(saved_chars);
-  }
-
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf8.data(), input_utf8.size());
-    if (saved_chars != reference_output_utf16.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf16.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-8 => UTF-32 transcoding.
- */
-class transcode_utf8_to_utf32_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char>
-      input_utf8; // source-encoded message: what we're going to transcode
-  std::vector<char32_t> output_utf32; // what the procedure under test produced
-  std::vector<char32_t> reference_output_utf32; // what we are expecting
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf8_to_utf32_test_base(GenerateCodepoint generate,
-                                    size_t input_size);
-
-  template <typename COLLECTION>
-  transcode_utf8_to_utf32_test_base(COLLECTION &&collection) {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf32.resize(reference_output_utf32.size() + output_size_margin);
-    output_utf32.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf8.data(), input_utf8.size(), output_utf32.data());
-    return validate(saved_chars);
-  }
-
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf8.data(), input_utf8.size());
-    if (saved_chars != reference_output_utf32.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf32.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-16LE => UTF-8 transcoding.
- */
-class transcode_utf16_to_utf8_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> output_utf8; // what the procedure under test produced
-  std::vector<char> reference_output_utf8; // what we are expecting
-
-  std::vector<char16_t>
-      input_utf16; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf16_to_utf8_test_base(endianness utf16_endianness,
-                                    GenerateCodepoint generate,
-                                    size_t input_size);
-
-  transcode_utf16_to_utf8_test_base(endianness utf16_endianness,
-                                    const std::vector<char16_t> &input_utf16);
-
-  template <typename COLLECTION>
-  transcode_utf16_to_utf8_test_base(endianness utf16_endianness,
-                                    COLLECTION &&collection)
-      : transcode_test_base{utf16_endianness} {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf8.resize(reference_output_utf8.size() + output_size_margin);
-    output_utf8.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf16.data(), input_utf16.size(), output_utf8.data());
-    return validate(saved_chars);
-  }
-
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf16.data(), input_utf16.size());
-    if (saved_chars != reference_output_utf8.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf8.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-32 => Latin1 transcoding.
- */
-class transcode_utf32_to_latin1_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> output_latin1; // what the procedure under test produced
-  std::vector<char> reference_output_latin1; // what we are expecting
-
-  std::vector<char32_t>
-      input_utf32; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf32_to_latin1_test_base(GenerateCodepoint generate,
-                                      size_t input_size); // constructor
-
-  template <typename COLLECTION>
-  transcode_utf32_to_latin1_test_base(COLLECTION &&collection) {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_latin1.resize(reference_output_latin1.size() + output_size_margin);
-    output_latin1.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf32.data(), input_utf32.size(), output_latin1.data());
-    return validate(saved_chars);
-  }
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf32.data(), input_utf32.size());
-    if (saved_chars != reference_output_latin1.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_latin1.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-32 => UTF-8 transcoding.
- */
-class transcode_utf32_to_utf8_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char> output_utf8; // what the procedure under test produced
-  std::vector<char> reference_output_utf8; // what we are expecting
-
-  std::vector<char32_t>
-      input_utf32; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf32_to_utf8_test_base(GenerateCodepoint generate,
-                                    size_t input_size);
-
-  transcode_utf32_to_utf8_test_base(const std::vector<char32_t> &input_utf32);
-
-  template <typename COLLECTION>
-  transcode_utf32_to_utf8_test_base(COLLECTION &&collection) {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf8.resize(reference_output_utf8.size() + output_size_margin);
-    output_utf8.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf32.data(), input_utf32.size(), output_utf8.data());
-    return validate(saved_chars);
-  }
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf32.data(), input_utf32.size());
-    if (saved_chars != reference_output_utf8.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf8.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-32 => UTF-16LE transcoding.
- */
-class transcode_utf32_to_utf16_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char16_t> output_utf16; // what the procedure under test produced
-  std::vector<char16_t> reference_output_utf16; // what we are expecting
-
-  std::vector<char32_t>
-      input_utf32; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      0; // extra room for buggy procedures
-
-public:
-  transcode_utf32_to_utf16_test_base(endianness utf16_endianness,
-                                     GenerateCodepoint generate,
-                                     size_t input_size);
-
-  template <typename COLLECTION>
-  transcode_utf32_to_utf16_test_base(endianness utf16_endianness,
-                                     COLLECTION &&collection)
-      : transcode_test_base{utf16_endianness} {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf16.resize(reference_output_utf16.size() + output_size_margin);
-    output_utf16.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf32.data(), input_utf32.size(), output_utf16.data());
-    return validate(saved_chars);
-  }
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf32.data(), input_utf32.size());
-    if (saved_chars != reference_output_utf16.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf16.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-/**
- * This class can be used to test UTF-16LE => UTF-32 transcoding.
- */
-class transcode_utf16_to_utf32_test_base : transcode_test_base {
-public:
-  using GenerateCodepoint = std::function<uint32_t()>;
-
-  std::vector<char32_t> output_utf32; // what the procedure under test produced
-  std::vector<char32_t> reference_output_utf32; // what we are expecting
-
-  std::vector<char16_t>
-      input_utf16; // source-encoded message: what we're going to transcode
-
-  static constexpr size_t output_size_margin =
-      16; // extra room for buggy procedures
-
-public:
-  transcode_utf16_to_utf32_test_base(endianness utf16_endianness,
-                                     GenerateCodepoint generate,
-                                     size_t input_size);
-
-  transcode_utf16_to_utf32_test_base(endianness utf16_endianness,
-                                     const std::vector<char16_t> &input_utf16);
-
-  template <typename COLLECTION>
-  transcode_utf16_to_utf32_test_base(endianness utf16_endianness,
-                                     COLLECTION &&collection)
-      : transcode_test_base{utf16_endianness} {
-    for (const uint32_t codepoint : collection) {
-      prepare_input(codepoint);
-    }
-    output_utf32.resize(reference_output_utf32.size() + output_size_margin);
-    output_utf32.shrink_to_fit(); // to help detect overruns.
-  }
-
-  template <typename PROCEDURE> bool operator()(PROCEDURE procedure) {
-    size_t saved_chars =
-        procedure(input_utf16.data(), input_utf16.size(), output_utf32.data());
-    return validate(saved_chars);
-  }
-  template <typename PROCEDURE> bool check_size(PROCEDURE procedure) {
-    size_t saved_chars = procedure(input_utf16.data(), input_utf16.size());
-    if (saved_chars != reference_output_utf32.size()) {
-      printf("wrong saved bytes value: procedure returned %zu bytes, it should "
-             "be %zu\n",
-             size_t(saved_chars), size_t(reference_output_utf32.size()));
-      return false;
-    }
-    return true;
-  }
-
-private:
-  void prepare_input(uint32_t codepoint);
-  bool validate(size_t procedure_result) const;
-  bool is_input_valid() const;
-};
-
-} // namespace helpers
-} // namespace tests
-} // namespace simdutf

package/deps/simdutf/tests/helpers/utf16.h

@@ -1,27 +0,0 @@
-#pragma once
-
-#include "simdutf/encoding_types.h"
-
-template <typename = void>
-char16_t to_utf16(simdutf::endianness byte_order, char16_t chr) {
-  if (!match_system(byte_order)) {
-    return char16_t((uint16_t(chr) << 8) | (uint16_t(chr) >> 8));
-  } else {
-    return chr;
-  }
-}
-
-template <typename = void> char16_t to_utf16be(char16_t chr) {
-  return to_utf16(simdutf::endianness::BIG, chr);
-}
-
-template <typename = void> char16_t to_utf16le(char16_t chr) {
-  return to_utf16(simdutf::endianness::LITTLE, chr);
-}
-
-template <typename = void>
-void to_utf16le_inplace(char16_t *data, size_t size) {
-  for (size_t i = 0; i < size; i++) {
-    data[i] = to_utf16le(data[i]);
-  }
-}