react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/bele_tests.cpp

@@ -1,182 +0,0 @@
-/**
- * Big-Endian/Little-endian tests.
- */
-#include "simdutf.h"
-#include <tests/helpers/test.h>
-
-// We use explicit arrays so that no funny business is possible.
-const unsigned char utf8_string[] = {0x40, 0xc2, 0xa7, 0xe2, 0x88,
-                                     0x88, 0xf0, 0x9d, 0x92, 0xaa};
-const char *utf8 = reinterpret_cast<const char *>(utf8_string);
-const size_t utf8_size = sizeof(utf8_string) / sizeof(uint8_t);
-
-alignas(char16_t) const unsigned char utf16le_string[] = {
-    0x40, 0x00, 0xa7, 0x00, 0x08, 0x22, 0x35, 0xd8, 0xaa, 0xdc};
-const char16_t *utf16le = reinterpret_cast<const char16_t *>(utf16le_string);
-const size_t utf16_size = sizeof(utf16le_string) / sizeof(uint16_t);
-
-alignas(char16_t) const unsigned char utf16be_string[] = {
-    0x00, 0x40, 0x00, 0xa7, 0x22, 0x08, 0xd8, 0x35, 0xdc, 0xaa};
-const char16_t *utf16be = reinterpret_cast<const char16_t *>(utf16be_string);
-#if SIMDUTF_IS_BIG_ENDIAN
-const char16_t *utf16 = utf16be;
-#else
-const char16_t *utf16 = utf16le;
-#endif
-
-// Native order
-#if SIMDUTF_IS_BIG_ENDIAN
-alignas(char32_t) const unsigned char utf32_string[] = {
-    0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0xa7,
-    0x00, 0x00, 0x22, 0x08, 0x00, 0x01, 0xd4, 0xaa};
-const char32_t *utf32 = reinterpret_cast<const char32_t *>(utf32_string);
-#else
-alignas(char32_t) const unsigned char utf32_string[] = {
-    0x40, 0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00,
-    0x08, 0x22, 0x00, 0x00, 0xaa, 0xd4, 0x01, 0x00};
-const char32_t *utf32 = reinterpret_cast<const char32_t *>(utf32_string);
-#endif
-const size_t utf32_size = sizeof(utf32_string) / sizeof(char32_t);
-const size_t number_of_code_points = utf32_size;
-
-TEST(validate_utf8) {
-  simdutf::result res =
-      implementation.validate_utf8_with_errors(utf8, utf8_size);
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-}
-
-TEST(validate_utf16le) {
-  simdutf::result res =
-      implementation.validate_utf16le_with_errors(utf16le, utf16_size);
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-}
-
-TEST(validate_utf16be) {
-  simdutf::result res =
-      implementation.validate_utf16be_with_errors(utf16be, utf16_size);
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-}
-
-TEST(validate_utf32) {
-  simdutf::result res =
-      implementation.validate_utf32_with_errors(utf32, utf32_size);
-  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
-}
-
-TEST(count_utf8) {
-  size_t count = implementation.count_utf8(utf8, utf8_size);
-  ASSERT_EQUAL(count, number_of_code_points);
-}
-
-TEST(count_utf16le) {
-  size_t count = implementation.count_utf16le(utf16le, utf16_size);
-  ASSERT_EQUAL(count, number_of_code_points);
-}
-
-TEST(count_utf16be) {
-  size_t count = implementation.count_utf16be(
-      reinterpret_cast<const char16_t *>(utf16be_string),
-      sizeof(utf16be_string) / sizeof(uint16_t));
-  ASSERT_EQUAL(count, number_of_code_points);
-}
-
-TEST(convert_utf8_to_utf16le) {
-  char16_t buffer[utf16_size];
-  size_t count =
-      implementation.convert_utf8_to_utf16le(utf8, utf8_size, buffer);
-  ASSERT_EQUAL(count, utf16_size);
-  for (size_t i = 0; i < utf16_size; i++) {
-    ASSERT_EQUAL(uint16_t(buffer[i]), uint16_t(utf16le[i]));
-  }
-}
-
-TEST(convert_utf8_to_utf16be) {
-  char16_t buffer[utf16_size];
-  size_t count =
-      implementation.convert_utf8_to_utf16be(utf8, utf8_size, buffer);
-  ASSERT_EQUAL(count, utf16_size);
-  for (size_t i = 0; i < utf16_size; i++) {
-    ASSERT_EQUAL(uint16_t(buffer[i]), uint16_t(utf16be[i]));
-  }
-}
-
-TEST(convert_utf8_to_utf32) {
-  char32_t buffer[utf32_size];
-  size_t count = implementation.convert_utf8_to_utf32(utf8, utf8_size, buffer);
-  ASSERT_EQUAL(count, utf32_size);
-  for (size_t i = 0; i < utf32_size; i++) {
-    ASSERT_EQUAL(uint32_t(buffer[i]), uint32_t(utf32[i]));
-  }
-}
-
-TEST(convert_utf32_to_utf8) {
-  char buffer[utf8_size];
-  size_t count =
-      implementation.convert_utf32_to_utf8(utf32, utf32_size, buffer);
-  ASSERT_EQUAL(count, utf8_size);
-  for (size_t i = 0; i < utf8_size; i++) {
-    ASSERT_EQUAL(buffer[i], utf8[i]);
-  }
-}
-
-TEST(convert_utf32_to_utf16be) {
-  char buffer[utf8_size];
-  size_t count =
-      implementation.convert_utf32_to_utf8(utf32, utf32_size, buffer);
-  ASSERT_EQUAL(count, utf8_size);
-  for (size_t i = 0; i < utf8_size; i++) {
-    ASSERT_EQUAL(buffer[i], utf8[i]);
-  }
-}
-
-TEST(convert_utf32_to_utf16le) {
-  char buffer[utf8_size];
-  size_t count =
-      implementation.convert_utf32_to_utf8(utf32, utf32_size, buffer);
-  ASSERT_EQUAL(count, utf8_size);
-  for (size_t i = 0; i < utf8_size; i++) {
-    ASSERT_EQUAL(buffer[i], utf8[i]);
-  }
-}
-
-TEST(convert_utf16le_to_utf8) {
-  char buffer[utf8_size];
-  size_t count =
-      implementation.convert_utf16le_to_utf8(utf16le, utf16_size, buffer);
-  ASSERT_EQUAL(count, utf8_size);
-  for (size_t i = 0; i < utf8_size; i++) {
-    ASSERT_EQUAL(buffer[i], utf8[i]);
-  }
-}
-
-TEST(convert_utf16le_to_utf32) {
-  char32_t buffer[utf32_size];
-  size_t count =
-      implementation.convert_utf16le_to_utf32(utf16le, utf16_size, buffer);
-  ASSERT_EQUAL(count, utf32_size);
-  for (size_t i = 0; i < utf32_size; i++) {
-    ASSERT_EQUAL(uint32_t(buffer[i]), uint32_t(utf32[i]));
-  }
-}
-
-TEST(convert_utf16be_to_utf8) {
-  char buffer[utf8_size];
-  size_t count =
-      implementation.convert_utf16be_to_utf8(utf16be, utf16_size, buffer);
-  ASSERT_EQUAL(count, utf8_size);
-  for (size_t i = 0; i < utf8_size; i++) {
-    ASSERT_EQUAL(buffer[i], utf8[i]);
-  }
-}
-
-TEST(convert_utf16be_to_utf32) {
-  char32_t buffer[utf32_size];
-  size_t count =
-      implementation.convert_utf16be_to_utf32(utf16be, utf16_size, buffer);
-  ASSERT_EQUAL(count, utf32_size);
-  for (size_t i = 0; i < utf32_size; i++) {
-    ASSERT_EQUAL(uint32_t(buffer[i]), uint32_t(utf32[i]));
-  }
-}
-
-TEST_MAIN

package/deps/simdutf/tests/constexpr_base64_tests.cpp

@@ -1,387 +0,0 @@
-#include "simdutf.h"
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <tuple>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/test.h>
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_length_from_binary) {
-  using namespace simdutf::tests::helpers;
-  const auto binary = "Abracadabra!"_latin1;
-  const auto encoded = "QWJyYWNhZGFicmEh"_latin1;
-  constexpr auto encoded_length =
-      simdutf::base64_length_from_binary(binary.size());
-  static_assert(encoded_length == encoded.size());
-}
-
-TEST(compile_time_maximal_binary_length) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto binary = "Abracadabra!"_latin1;
-
-  constexpr auto encoded = "QWJyYWNhZGFicmEh"_latin1;
-  // char
-  static_assert(simdutf::maximal_binary_length_from_base64(encoded) ==
-                binary.size());
-  // unsigned char
-  static_assert(simdutf::maximal_binary_length_from_base64(
-                    encoded.as_array<unsigned char>()) == binary.size());
-  // signed char
-  static_assert(simdutf::maximal_binary_length_from_base64(
-                    encoded.as_array<signed char>()) == binary.size());
-}
-
-TEST(compile_time_maximal_binary_length16) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto binary = "Abracadabra!"_latin1;
-  constexpr auto encoded = u"QWJyYWNhZGFicmEh"_utf16;
-  static_assert(simdutf::maximal_binary_length_from_base64(encoded) ==
-                binary.size());
-}
-
-TEST(compile_time_binary_length_from_base64) {
-  using namespace std::string_view_literals;
-
-  // empty input
-  static_assert(simdutf::binary_length_from_base64(""sv) == 0);
-  static_assert(simdutf::binary_length_from_base64(" "sv) == 0);
-
-  // increasing length of "a" repeated
-  static_assert(simdutf::binary_length_from_base64("YQ=="sv) == 1);
-  static_assert(simdutf::binary_length_from_base64("YWE="sv) == 2);
-  static_assert(simdutf::binary_length_from_base64("YWFh"sv) == 3);
-  static_assert(simdutf::binary_length_from_base64("YWFhYQ=="sv) == 4);
-  static_assert(simdutf::binary_length_from_base64("YWFhYWE="sv) == 5);
-
-  // all these are base64 of 'a', mixed with whitespace in different ways
-  constexpr std::array mixedwithspaces{
-      " YQ=="sv,     //
-      "Y Q=="sv,     //
-      "YQ =="sv,     //
-      "YQ= ="sv,     //
-      "YQ== "sv,     //
-      " Y Q = = "sv, //
-      " YQ = ="sv,   //
-  };
-  static_assert(std::ranges::all_of(mixedwithspaces, [](auto s) {
-    return simdutf::binary_length_from_base64(s) == 1;
-  }));
-}
-
-TEST(compile_time_binary_length_from_base64_utf16) {
-  using namespace std::string_view_literals;
-
-  // empty input
-  static_assert(simdutf::binary_length_from_base64(u""sv) == 0);
-  static_assert(simdutf::binary_length_from_base64(u" "sv) == 0);
-
-  // increasing length of "a" repeated
-  static_assert(simdutf::binary_length_from_base64(u"YQ=="sv) == 1);
-  static_assert(simdutf::binary_length_from_base64(u"YWE="sv) == 2);
-  static_assert(simdutf::binary_length_from_base64(u"YWFh"sv) == 3);
-  static_assert(simdutf::binary_length_from_base64(u"YWFhYQ=="sv) == 4);
-  static_assert(simdutf::binary_length_from_base64(u"YWFhYWE="sv) == 5);
-
-  // all these are base64 of 'a', mixed with whitespace in different ways
-  constexpr std::array mixedwithspaces{
-      u" YQ=="sv,     //
-      u"Y Q=="sv,     //
-      u"YQ =="sv,     //
-      u"YQ= ="sv,     //
-      u"YQ== "sv,     //
-      u" Y Q = = "sv, //
-      u" YQ = ="sv,   //
-  };
-  static_assert(std::ranges::all_of(mixedwithspaces, [](auto s) {
-    return simdutf::binary_length_from_base64(s) == 1;
-  }));
-}
-
-namespace {
-
-template <auto input>
-  requires simdutf::tests::helpers::any_ctstring<decltype(input)>
-constexpr auto b64_to_bin_impl() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto Nmax = simdutf::maximal_binary_length_from_base64(input);
-  CTString<char, Nmax> buffer{};
-  auto res = simdutf::base64_to_binary(input, buffer);
-  if (res.is_err()) {
-    throw "failed convert";
-  }
-  if (res.count > Nmax) {
-    throw "weird";
-  }
-  return std::tuple(res.count, buffer);
-}
-
-/**
- * converts base64 to binary. ideally the input should be passed as a
- * function parameter but I could not get that to work.
- */
-template <auto input>
-  requires simdutf::tests::helpers::any_ctstring<decltype(input)>
-constexpr auto b64_to_binary() {
-  constexpr auto r = b64_to_bin_impl<input>();
-  constexpr auto N = std::get<0>(r);
-  constexpr auto ret = std::get<1>(r);
-  if constexpr (ret.size() != N) {
-    return ret.template shrink<N>();
-  } else {
-    return ret;
-  }
-}
-
-} // namespace
-
-TEST(compile_time_length_from_binary_with_lines) {
-  static_assert(4 == simdutf::base64_length_from_binary_with_lines(1));
-  static_assert(137 == simdutf::base64_length_from_binary_with_lines(100));
-}
-
-TEST(compile_time_base64_to_binary) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto binary = "Abracadabra!"_latin1;
-
-  // tightly packed base64 works fine
-  {
-    constexpr auto base64 = "QWJyYWNhZGFicmEh"_latin1;
-    constexpr auto binary_again = b64_to_binary<base64>();
-    static_assert(binary_again == binary);
-  }
-
-  // extra spaces is no problem
-  {
-    constexpr auto base64 = "   QWJyYWNhZGF icmEh   "_latin1;
-    constexpr auto binary_again = b64_to_binary<base64>();
-    static_assert(binary_again == binary);
-  }
-}
-
-TEST(compile_time_base64_utf16_to_binary) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto binary = "Abracadabra!"_latin1;
-
-  // tightly packed base64 works fine
-  {
-    constexpr auto base64 = u"QWJyYWNhZGFicmEh"_utf16;
-    constexpr auto binary_again = b64_to_binary<base64>();
-    static_assert(binary_again == binary);
-  }
-
-  // extra spaces is no problem
-  {
-    constexpr auto base64 = u"   QWJyYWNhZGF icmEh   "_utf16;
-    constexpr auto binary_again = b64_to_binary<base64>();
-    static_assert(binary_again == binary);
-  }
-}
-
-namespace {
-template <auto input>
-  requires simdutf::tests::helpers::any_ctstring<decltype(input)>
-constexpr auto binary_to_b64() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto N = simdutf::base64_length_from_binary(input.size());
-  CTString<char, N> buffer{};
-  const auto r1 = simdutf::binary_to_base64(input, buffer);
-  if (r1 != N) {
-    throw "oops, size mismatch";
-  }
-  return buffer;
-}
-} // namespace
-
-TEST(compile_time_binary_to_base64_char) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto binary = "Abracadabra!"_latin1;
-  constexpr auto expected = "QWJyYWNhZGFicmEh"_latin1;
-  constexpr auto encoded = binary_to_b64<binary>();
-  static_assert(expected == encoded);
-}
-
-namespace {
-// this is just to demo that it is possible to do _base64 literals.
-template <std::size_t N> struct Base64LiteralHelper {
-  char storage[N - 1];
-
-  static constexpr std::size_t size() noexcept { return N - 1; }
-
-  constexpr Base64LiteralHelper(const char (&str)[N]) {
-    static_assert(N > 1, "weird size");
-    std::copy(str, str + size(), storage);
-  }
-};
-
-template <Base64LiteralHelper a> constexpr auto operator""_base64() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto N = a.size();
-  constexpr std::span data(a.storage);
-  constexpr CTString<char, N> tmp(data);
-  return b64_to_binary<tmp>().template as_array<std::uint8_t>();
-}
-
-} // namespace
-
-TEST(compile_time_base64_literal_demo) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr std::array decoded = "QWJyYWNhZGFicmEh"_base64;
-  const auto readable = std::string(begin(decoded), end(decoded));
-  ASSERT_EQUAL(readable, "Abracadabra!");
-
-  static_assert(decoded.size() == 12);
-  static_assert(decoded[0] == 'A');
-  static_assert(decoded[1] == 'b');
-  static_assert(decoded[2] == 'r');
-  static_assert(decoded[3] == 'a');
-  static_assert(decoded[4] == 'c');
-  static_assert(decoded[5] == 'a');
-  static_assert(decoded[6] == 'd');
-  static_assert(decoded[7] == 'a');
-  static_assert(decoded[8] == 'b');
-  static_assert(decoded[9] == 'r');
-  static_assert(decoded[10] == 'a');
-  static_assert(decoded[11] == '!');
-}
-
-namespace {
-template <auto input, std::size_t lines>
-  requires simdutf::tests::helpers::any_ctstring<decltype(input)>
-constexpr auto binary_to_b64_with_lines() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto N = simdutf::base64_length_from_binary_with_lines(
-      input.size(), simdutf::base64_default, lines);
-  CTString<char, N> buffer{};
-  const auto r1 = simdutf::binary_to_base64_with_lines(input, buffer, lines,
-                                                       simdutf::base64_default);
-  if (r1 != N) {
-    throw "oops, size mismatch";
-  }
-  return buffer;
-}
-} // namespace
-
-TEST(compile_time_binary_to_base64_with_lines_char) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr std::size_t lines = 4;
-  constexpr auto binary = "Abracadabra!"_latin1;
-  constexpr auto expected = "QWJy\nYWNh\nZGFi\ncmEh"_latin1;
-  constexpr auto encoded = binary_to_b64_with_lines<binary, lines>();
-  static_assert(expected == encoded);
-}
-
-TEST(compile_time_base64_ignorable) {
-  static_assert(simdutf::base64_ignorable(' '));
-  static_assert(not simdutf::base64_ignorable('x'));
-
-  static_assert(simdutf::base64_ignorable(char16_t{' '}));
-  static_assert(not simdutf::base64_ignorable(char16_t{'x'}));
-}
-
-TEST(compile_time_base64_valid) {
-  static_assert(not simdutf::base64_valid(' '));
-  static_assert(simdutf::base64_valid('x'));
-
-  static_assert(not simdutf::base64_valid(char16_t{' '}));
-  static_assert(simdutf::base64_valid(char16_t{'x'}));
-}
-
-TEST(compile_time_base64_valid_or_padding) {
-  static_assert(not simdutf::base64_valid_or_padding(' '));
-  static_assert(simdutf::base64_valid_or_padding('x'));
-  static_assert(simdutf::base64_valid_or_padding('='));
-
-  static_assert(not simdutf::base64_valid_or_padding(char16_t{' '}));
-  static_assert(simdutf::base64_valid_or_padding(char16_t{'x'}));
-  static_assert(simdutf::base64_valid_or_padding(char16_t{'='}));
-}
-
-namespace {
-
-template <auto input>
-  requires simdutf::tests::helpers::any_ctstring<decltype(input)>
-constexpr auto b64_to_bin_safe_impl() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto Nmax = simdutf::maximal_binary_length_from_base64(input);
-  CTString<char, Nmax> buffer{};
-  auto [res, outlen] = simdutf::base64_to_binary_safe(input, buffer);
-  if (res.is_err()) {
-    throw "failed convert";
-  }
-  if (res.count > input.size()) {
-    throw "res.count > input.size()";
-  }
-  if (outlen > Nmax) {
-    throw "outlen > Nmax";
-  }
-  return std::tuple(res.count, buffer, outlen);
-}
-
-/**
- * converts base64 to binary. ideally the input should be passed as a
- * function parameter but I could not get that to work.
- */
-template <auto input>
-  requires simdutf::tests::helpers::any_ctstring<decltype(input)>
-constexpr auto b64_to_binary_safe() {
-  constexpr auto r = b64_to_bin_safe_impl<input>();
-  constexpr auto N_read_from_input = std::get<0>(r);
-  constexpr auto ret = std::get<1>(r);
-  constexpr auto outputbuffer_size = ret.size();
-  constexpr auto outlen = std::get<2>(r);
-  static_assert(N_read_from_input <= input.size());
-  static_assert(outputbuffer_size >= outlen);
-  if constexpr (ret.size() != outlen) {
-    return ret.template shrink<outlen>();
-  } else {
-    return ret;
-  }
-}
-
-} // namespace
-
-TEST(compile_time_base64_to_binary_safe) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto binary = "Abracadabra!"_latin1;
-  static_assert(binary.size() == 12);
-
-  // tightly packed base64 works fine
-  {
-    constexpr auto base64 = "QWJyYWNhZGFicmEh"_latin1;
-    constexpr auto binary_again = b64_to_binary_safe<base64>();
-    static_assert(binary_again == binary);
-  }
-
-  // extra spaces is no problem
-  {
-    constexpr auto base64 = "   QWJyYWNhZGF icmEh   "_latin1;
-    constexpr auto binary_again = b64_to_binary_safe<base64>();
-    static_assert(binary_again == binary);
-  }
-
-  // tightly packed base64 works fine also in utf-16
-  {
-    constexpr auto base64 = u"QWJyYWNhZGFicmEh"_utf16;
-    constexpr auto binary_again = b64_to_binary_safe<base64>();
-    static_assert(binary_again == binary);
-  }
-
-  // extra spaces is no problem also in utf-16
-  {
-    constexpr auto base64 = u"   QWJyYWNhZGF icmEh   "_utf16;
-    constexpr auto binary_again = b64_to_binary_safe<base64>();
-    static_assert(binary_again == binary);
-  }
-}
-
-#else
-TEST(no_compile_time_tests_below_cpp23) {}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/convert_latin1_to_utf16be_tests.cpp

@@ -1,52 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/compiletime_conversions.h>
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/transcode_test_base.h>
-
-namespace {
-constexpr std::array<size_t, 7> input_size{7, 16, 12, 64, 67, 128, 256};
-constexpr simdutf::endianness BE = simdutf::endianness::BIG;
-
-using simdutf::tests::helpers::transcode_latin1_to_utf16_test_base;
-
-} // namespace
-
-TEST_LOOP(convert_all_latin) {
-  // range for 2 UTF-16 bytes
-  simdutf::tests::helpers::RandomIntRanges random({{0x00, 0xff}}, seed);
-
-  auto procedure = [&implementation](const char *latin1, size_t size,
-                                     char16_t *utf16) -> size_t {
-    return implementation.convert_latin1_to_utf16be(latin1, size, utf16);
-  };
-  auto size_procedure =
-      [&implementation](simdutf_maybe_unused const char *latin1,
-                        size_t size) -> size_t {
-    return implementation.utf16_length_from_latin1(size);
-  };
-  for (size_t size : input_size) {
-    transcode_latin1_to_utf16_test_base test(BE, random, size);
-    ASSERT_TRUE(test(procedure));
-    ASSERT_TRUE(test.check_size(size_procedure));
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_convert_latin1_to_utf16be) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto input = "hello"_latin1;
-  constexpr auto expected = u"hello"_utf16be;
-  constexpr auto output = latin1_to_utf16<std::endian::big>(input);
-  static_assert(output == expected);
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/convert_latin1_to_utf16le_tests.cpp

@@ -1,80 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/compiletime_conversions.h>
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/transcode_test_base.h>
-
-namespace {
-constexpr std::array<size_t, 7> input_size{7, 16, 12, 64, 67, 128, 256};
-constexpr simdutf::endianness LE = simdutf::endianness::LITTLE;
-
-using simdutf::tests::helpers::transcode_latin1_to_utf16_test_base;
-
-} // namespace
-
-TEST_LOOP(convert_all_latin) {
-  // range for 2 UTF-16 bytes
-  simdutf::tests::helpers::RandomIntRanges random({{0x00, 0xff}}, seed);
-
-  auto procedure = [&implementation](const char *latin1, size_t size,
-                                     char16_t *utf16) -> size_t {
-    return implementation.convert_latin1_to_utf16le(latin1, size, utf16);
-  };
-  auto size_procedure =
-      [&implementation](simdutf_maybe_unused const char *latin1,
-                        size_t size) -> size_t {
-    return implementation.utf16_length_from_latin1(size);
-  };
-  for (size_t size : input_size) {
-    transcode_latin1_to_utf16_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-    ASSERT_TRUE(test.check_size(size_procedure));
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_convert_latin1_to_utf16le) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto input = "hello"_latin1;
-  constexpr auto expected = u"hello"_utf16le;
-  constexpr auto output = latin1_to_utf16<std::endian::little>(input);
-  static_assert(output == expected);
-}
-
-namespace {
-
-template <auto input> constexpr auto convert() {
-  using namespace simdutf::tests::helpers;
-  CTString<char16_t, input.size()> tmp;
-  auto N = simdutf::convert_latin1_to_utf16(input, tmp);
-  if (N != input.size()) {
-    throw "oops";
-  }
-  return tmp;
-}
-
-} // namespace
-
-// this is here to execute the simdutf::convert_latin1_to_utf16(), to ensure
-// it is constexpr
-TEST(compile_time_convert_latin1_to_utf16) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto input = "hello"_latin1;
-  constexpr auto expected = u"hello"_utf16;
-  constexpr auto output = latin1_to_utf16<std::endian::native>(input);
-  static_assert(output == expected);
-
-  constexpr auto native = convert<input>();
-  static_assert(native == output);
-}
-
-#endif
-
-TEST_MAIN