react-native-quick-crypto 1.1.0 → 1.1.2

package/deps/simdutf/tests/convert_valid_utf16le_to_utf32_tests.cpp

@@ -1,122 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/transcode_test_base.h>
-#include <tests/reference/validate_utf16.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_utf16_to_utf32_test_base;
-
-} // namespace
-
-TEST_LOOP(convert_2_UTF16_bytes) {
-  // range for 2-byte UTF-16 (no surrogate pairs)
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0000, 0x007f}, {0x0080, 0x07ff}, {0x0800, 0xd7ff}, {0xe000, 0xffff}},
-      seed);
-
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char32_t *utf32) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf32(utf16, size, utf32);
-  };
-
-  for (size_t size : input_size) {
-    transcode_utf16_to_utf32_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_with_surrogate_pairs) {
-  // some surrogate pairs
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0800, 0xd800 - 1}, {0xe000, 0x10ffff}}, seed);
-
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char32_t *utf32) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf32(utf16, size, utf32);
-  };
-
-  for (size_t size : input_size) {
-    transcode_utf16_to_utf32_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-#if 0 // XXX
-TEST(all_possible_8_codepoint_combinations) {
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char32_t *utf32) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf32(utf16, size, utf32);
-  };
-
-  std::vector<char> output_utf32(256, ' ');
-  const auto &combinations = all_utf16_combinations(LE);
-  for (const auto &input_utf16 : combinations) {
-    if (simdutf::tests::reference::validate_utf16(LE, input_utf16.data(),
-                                                  input_utf16.size())) {
-      transcode_utf16_to_utf32_test_base test(LE, input_utf16);
-      ASSERT_TRUE(test(procedure));
-    }
-  }
-}
-#endif
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-template <auto input> constexpr auto size() {
-  return simdutf::utf32_length_from_utf16(input);
-}
-
-template <auto input> constexpr auto convert() {
-  using namespace simdutf::tests::helpers;
-  CTString<char32_t, size<input>()> tmp;
-  const auto ret = simdutf::convert_valid_utf16_to_utf32(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_valid_utf16_to_utf32) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto input = u"köttbulle"_utf16;
-  constexpr auto expected = U"köttbulle"_utf32;
-  constexpr auto output = convert<input>();
-}
-
-namespace {
-template <auto input> constexpr auto size_le() {
-  return simdutf::utf32_length_from_utf16le(input);
-}
-
-template <auto input> constexpr auto convert_le() {
-  using namespace simdutf::tests::helpers;
-  CTString<char32_t, size_le<input>()> tmp;
-  const auto ret = simdutf::convert_valid_utf16le_to_utf32(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_valid_utf16le_to_utf32) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto input = u"köttbulle"_utf16le;
-  constexpr auto expected = U"köttbulle"_utf32;
-  constexpr auto output = convert_le<input>();
-  static_assert(output == expected);
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/convert_valid_utf16le_to_utf8_tests.cpp

@@ -1,244 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-#include <vector>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/transcode_test_base.h>
-#include <tests/reference/validate_utf16.h>
-
-namespace {
-constexpr std::array<size_t, 9> input_size{7,   12,  16,  64,  67,
-                                           128, 256, 511, 1000};
-constexpr simdutf::endianness LE = simdutf::endianness::LITTLE;
-
-using simdutf::tests::helpers::transcode_utf16_to_utf8_test_base;
-
-} // namespace
-
-TEST(issue_a73) {
-  char16_t utf16[] =
-      u"\ubced\uf799\u8794\uf0a6\u8a83\uf0bb\uad82\ufb82\u9797\u9bf0\uadaf"
-      u"\ua0e0\u85e0\ueab5\uf2a2\uacab\ub7ed\ue0a8\uac8c\ue657\uf3bd\uaeb6"
-      u"\u87ac\ubb39\ua719\ua5ed\uc09f\ue080\u869e\u87f0\ua99a\ub7fd\uff88"
-      u"\u0cad\ufa98\u98a1\u92e0\uc29a\ud790\ua6b1\ua4f9\uf3b7\u97b5\ua495"
-      u"\uadf0\ua6b5\uc6ab\uf885\uf7ae\ub7bf\ue99d\uebbd\ued87\ua2ac\ua5f0"
-      u"\ub29b\ua5f7\u9080\u8eec\u84da\u4ebd\uf9ad\u868f\u81f9\u8fbb\ue9d9"
-      u"\uf0b1\ua183\uc0b8\uc688\ub6f3\uc094\u3482\u97c4\uc792\ue089\u9898"
-      u"\u9af2\uaf81\ued9e\ub7b9\uadf7\u9abd\ue041\ub79c\ubed0\ub8b5\u8cf0"
-      u"\ub79b\uf3de\uba8e\u98f7\u8190\uafcc\ub2ff\uf4b1\u8e89\ua6fb\ua8e1"
-      u"\u8cfc\u96f8\u94ac\u8cf2\u85a9\ubef2\ufcbd\ufa9d\ucdbc\ufb6d\ufe8d"
-      u"\ue3a5\uf284\ua8ba\u86a8\uf89b\u8bac\uaefb\u8589\u8af3\ua08f\uba3b"
-      u"\u80f2\ue0b0\ua79e\u9eff\u9e80\ua9f4\u8db1\ua8c0\ub7ee\u8df4\u928e"
-      u"\ud386\ua28d\u86fc\u9182\u1bd9\uedb5\ubaac\u9cf5\ub69e\u98d6\uedbd"
-      u"\u9da9\u88e0\uf290\ua1ae\u93fb\ubbc7\u8aee\ua3f8\u85bd\u9bf1\ud3b8"
-      u"\ubcb8\uadd8\uff89\u919b\u8a77\u8bfa\uafad\ub6cf\ub5c6\uf096\ubd8f"
-      u"\uceae\ua8ab\u81f0\ub194\ua4c0\ua4c0\ub2f6\ub8a5\u9ff3\u3cbd\u81f4"
-      u"\u82ae\u9efc\ufe88\ufabe\u9980\uf9b1\u8e95\u80df\ubdf6\ub4ad";
-  size_t len = sizeof(utf16) / sizeof(char16_t);
-  to_utf16le_inplace(utf16, len);
-
-  size_t expected_length = implementation.utf8_length_from_utf16le(utf16, len);
-  std::vector<char> output(expected_length);
-  const char expected[] =
-      "\xeb\xb3\xad\xef\x9e\x99\xe8\x9e\x94\xef\x82\xa6\xe8\xaa\x83\xef\x82\xbb"
-      "\xea\xb6\x82\xef\xae\x82\xe9\x9e\x97\xe9\xaf\xb0\xea\xb6\xaf\xea\x83\xa0"
-      "\xe8\x97\xa0\xee\xaa\xb5\xef\x8a\xa2\xea\xb2\xab\xeb\x9f\xad\xee\x82\xa8"
-      "\xea\xb2\x8c\xee\x99\x97\xef\x8e\xbd\xea\xba\xb6\xe8\x9e\xac\xeb\xac\xb9"
-      "\xea\x9c\x99\xea\x97\xad\xec\x82\x9f\xee\x82\x80\xe8\x9a\x9e\xe8\x9f\xb0"
-      "\xea\xa6\x9a\xeb\x9f\xbd\xef\xbe\x88\xe0\xb2\xad\xef\xaa\x98\xe9\xa2\xa1"
-      "\xe9\x8b\xa0\xec\x8a\x9a\xed\x9e\x90\xea\x9a\xb1\xea\x93\xb9\xef\x8e\xb7"
-      "\xe9\x9e\xb5\xea\x92\x95\xea\xb7\xb0\xea\x9a\xb5\xec\x9a\xab\xef\xa2\x85"
-      "\xef\x9e\xae\xeb\x9e\xbf\xee\xa6\x9d\xee\xae\xbd\xee\xb6\x87\xea\x8a\xac"
-      "\xea\x97\xb0\xeb\x8a\x9b\xea\x97\xb7\xe9\x82\x80\xe8\xbb\xac\xe8\x93\x9a"
-      "\xe4\xba\xbd\xef\xa6\xad\xe8\x9a\x8f\xe8\x87\xb9\xe8\xbe\xbb\xee\xa7\x99"
-      "\xef\x82\xb1\xea\x86\x83\xec\x82\xb8\xec\x9a\x88\xeb\x9b\xb3\xec\x82\x94"
-      "\xe3\x92\x82\xe9\x9f\x84\xec\x9e\x92\xee\x82\x89\xe9\xa2\x98\xe9\xab\xb2"
-      "\xea\xbe\x81\xee\xb6\x9e\xeb\x9e\xb9\xea\xb7\xb7\xe9\xaa\xbd\xee\x81\x81"
-      "\xeb\x9e\x9c\xeb\xbb\x90\xeb\xa2\xb5\xe8\xb3\xb0\xeb\x9e\x9b\xef\x8f\x9e"
-      "\xeb\xaa\x8e\xe9\xa3\xb7\xe8\x86\x90\xea\xbf\x8c\xeb\x8b\xbf\xef\x92\xb1"
-      "\xe8\xba\x89\xea\x9b\xbb\xea\xa3\xa1\xe8\xb3\xbc\xe9\x9b\xb8\xe9\x92\xac"
-      "\xe8\xb3\xb2\xe8\x96\xa9\xeb\xbb\xb2\xef\xb2\xbd\xef\xaa\x9d\xec\xb6\xbc"
-      "\xef\xad\xad\xef\xba\x8d\xee\x8e\xa5\xef\x8a\x84\xea\xa2\xba\xe8\x9a\xa8"
-      "\xef\xa2\x9b\xe8\xae\xac\xea\xbb\xbb\xe8\x96\x89\xe8\xab\xb3\xea\x82\x8f"
-      "\xeb\xa8\xbb\xe8\x83\xb2\xee\x82\xb0\xea\x9e\x9e\xe9\xbb\xbf\xe9\xba\x80"
-      "\xea\xa7\xb4\xe8\xb6\xb1\xea\xa3\x80\xeb\x9f\xae\xe8\xb7\xb4\xe9\x8a\x8e"
-      "\xed\x8e\x86\xea\x8a\x8d\xe8\x9b\xbc\xe9\x86\x82\xe1\xaf\x99\xee\xb6\xb5"
-      "\xeb\xaa\xac\xe9\xb3\xb5\xeb\x9a\x9e\xe9\xa3\x96\xee\xb6\xbd\xe9\xb6\xa9"
-      "\xe8\xa3\xa0\xef\x8a\x90\xea\x86\xae\xe9\x8f\xbb\xeb\xaf\x87\xe8\xab\xae"
-      "\xea\x8f\xb8\xe8\x96\xbd\xe9\xaf\xb1\xed\x8e\xb8\xeb\xb2\xb8\xea\xb7\x98"
-      "\xef\xbe\x89\xe9\x86\x9b\xe8\xa9\xb7\xe8\xaf\xba\xea\xbe\xad\xeb\x9b\x8f"
-      "\xeb\x97\x86\xef\x82\x96\xeb\xb6\x8f\xec\xba\xae\xea\xa2\xab\xe8\x87\xb0"
-      "\xeb\x86\x94\xea\x93\x80\xea\x93\x80\xeb\x8b\xb6\xeb\xa2\xa5\xe9\xbf\xb3"
-      "\xe3\xb2\xbd\xe8\x87\xb4\xe8\x8a\xae\xe9\xbb\xbc\xef\xba\x88\xef\xaa\xbe"
-      "\xe9\xa6\x80\xef\xa6\xb1\xe8\xba\x95\xe8\x83\x9f\xeb\xb7\xb6\xeb\x92"
-      "\xad";
-  size_t utf8size =
-      implementation.convert_valid_utf16le_to_utf8(utf16, len, output.data());
-  ASSERT_EQUAL(utf8size, expected_length);
-  for (size_t i = 0; i < expected_length; i++) {
-    ASSERT_EQUAL(output[i], expected[i]);
-  }
-}
-
-TEST(issue_a72) {
-  char16_t utf16[] =
-      u"\ufb8f\ua092\ub1cb\ufd99\u0dad\ud2be\u87ab\u88f0\u8a88\ua127\ua4f9"
-      u"\uaf9d\ufeca\u8095\u90dc\ud497\uc0b3\ud6b1\ueda5\ubca4\ubfd8\ue98a"
-      u"\uf2ba\ua8a3\u7e85\ufcbc\u9b83\ub7ed\ueda7\u99bb\u94e1\u91ff";
-  const char expected[] =
-      "\xef\xae\x8f\xea\x82\x92\xeb\x87\x8b\xef\xb6\x99\xe0\xb6\xad\xed\x8a\xbe"
-      "\xe8\x9e\xab\xe8\xa3\xb0\xe8\xaa\x88\xea\x84\xa7\xea\x93\xb9\xea\xbe\x9d"
-      "\xef\xbb\x8a\xe8\x82\x95\xe9\x83\x9c\xed\x92\x97\xec\x82\xb3\xed\x9a\xb1"
-      "\xee\xb6\xa5\xeb\xb2\xa4\xeb\xbf\x98\xee\xa6\x8a\xef\x8a\xba\xea\xa2\xa3"
-      "\xe7\xba\x85\xef\xb2\xbc\xe9\xae\x83\xeb\x9f\xad\xee\xb6\xa7\xe9\xa6\xbb"
-      "\xe9\x93\xa1\xe9\x87\xbf";
-  const size_t utf16_len = 32;
-  to_utf16le_inplace(utf16, utf16_len);
-
-  char utf8[96];
-  const size_t utf8size =
-      implementation.convert_valid_utf16le_to_utf8(utf16, utf16_len, utf8);
-  ASSERT_EQUAL(utf8size, 96);
-  for (size_t i = 0; i < 96; i++) {
-    ASSERT_EQUAL(utf8[i], expected[i]);
-  }
-}
-
-TEST(convert_pure_ASCII) {
-  size_t counter = 0;
-  auto generator = [&counter]() -> uint32_t { return counter++ & 0x7f; };
-
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char *utf8) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf8(utf16, size, utf8);
-  };
-
-  std::array<size_t, 1> input_size{16};
-  for (size_t size : input_size) {
-    transcode_utf16_to_utf8_test_base test(LE, generator, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_1_or_2_UTF8_bytes) {
-  simdutf::tests::helpers::RandomInt random(
-      0x0000, 0x07ff, seed); // range for 1 or 2 UTF-8 bytes
-
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char *utf8) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf8(utf16, size, utf8);
-  };
-
-  for (size_t size : input_size) {
-    transcode_utf16_to_utf8_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_1_or_2_or_3_UTF8_bytes) {
-  // range for 1, 2 or 3 UTF-8 bytes
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0000, 0x007f}, {0x0080, 0x07ff}, {0x0800, 0xd7ff}, {0xe000, 0xffff}},
-      seed);
-
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char *utf8) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf8(utf16, size, utf8);
-  };
-
-  for (size_t size : input_size) {
-    transcode_utf16_to_utf8_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_3_or_4_UTF8_bytes) {
-  // range for 3 or 4 UTF-8 bytes
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0800, 0xd800 - 1}, {0xe000, 0x10ffff}}, seed);
-
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char *utf8) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf8(utf16, size, utf8);
-  };
-
-  for (size_t size : input_size) {
-    transcode_utf16_to_utf8_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-#if 0 // XXX
-TEST(all_possible_8_codepoint_combinations) {
-  auto procedure = [&implementation](const char16_t *utf16, size_t size,
-                                     char *utf8) -> size_t {
-    return implementation.convert_valid_utf16le_to_utf8(utf16, size, utf8);
-  };
-
-  std::vector<char> output_utf8(256, ' ');
-  const auto &combinations = all_utf16_combinations(LE);
-  for (const auto &input_utf16 : combinations) {
-    if (simdutf::tests::reference::validate_utf16(LE, input_utf16.data(),
-                                                  input_utf16.size())) {
-      transcode_utf16_to_utf8_test_base test(LE, input_utf16);
-      ASSERT_TRUE(test(procedure));
-    }
-  }
-}
-#endif
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-template <auto input> constexpr auto size() {
-  return simdutf::utf8_length_from_utf16(input);
-}
-
-template <auto input> constexpr auto convert() {
-  using namespace simdutf::tests::helpers;
-  CTString<char8_t, size<input>()> tmp;
-  const auto ret = simdutf::convert_valid_utf16_to_utf8(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_valid_utf16_to_utf8) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto input = u"köttbulle"_utf16;
-  constexpr auto expected = u8"köttbulle"_utf8;
-  constexpr auto output = convert<input>();
-  static_assert(output == expected);
-}
-
-namespace {
-template <auto input> constexpr auto size_le() {
-  return simdutf::utf8_length_from_utf16le(input);
-}
-template <auto input> constexpr auto convert_le() {
-  using namespace simdutf::tests::helpers;
-  CTString<char8_t, size_le<input>()> tmp;
-  const auto ret = simdutf::convert_valid_utf16le_to_utf8(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_utf16le_to_utf8_with_errors) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto input = u"köttbulle"_utf16le;
-  constexpr auto expected = u8"köttbulle"_utf8;
-  constexpr auto output = convert_le<input>();
-  static_assert(output == expected);
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/convert_valid_utf32_to_latin1_tests.cpp

@@ -1,49 +0,0 @@
-#include "simdutf.h"
-#include "tests/helpers/fixed_string.h"
-
-#include <array>
-
-#include <tests/helpers/transcode_test_base.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/compiletime_conversions.h>
-
-namespace {
-std::array<size_t, 7> input_size{7, 16, 12, 64, 67, 128, 256};
-
-using simdutf::tests::helpers::transcode_utf8_to_utf16_test_base;
-} // namespace
-
-TEST(convert_latin1_only) {
-  size_t counter = 0;
-  auto generator = [&counter]() -> uint32_t { return counter++ & 0xFF; };
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char *latin1) -> size_t {
-    return implementation.convert_valid_utf32_to_latin1(utf32, size, latin1);
-  };
-  auto size_procedure =
-      [&implementation](simdutf_maybe_unused const char32_t *utf32,
-                        size_t size) -> size_t {
-    return implementation.latin1_length_from_utf32(size);
-  };
-  for (size_t size : input_size) {
-    simdutf::tests::helpers::transcode_utf32_to_latin1_test_base test(generator,
-                                                                      size);
-    ASSERT_TRUE(test(procedure));
-    ASSERT_TRUE(test.check_size(size_procedure));
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-TEST(compile_time_test) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto utf32input = U"hello!"_utf32;
-
-  constexpr auto latin1 = to_latin1(utf32input);
-  static_assert(latin1 == "hello!"_latin1);
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/convert_valid_utf32_to_utf16be_tests.cpp

@@ -1,92 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#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_utf32_to_utf16_test_base;
-
-} // namespace
-
-TEST_LOOP(convert_into_2_UTF16_bytes) {
-  // range for 2 UTF-16 bytes
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0000, 0xd7ff}, {0xe000, 0xffff}}, seed);
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char16_t *utf16be) -> size_t {
-    return implementation.convert_valid_utf32_to_utf16be(utf32, size, utf16be);
-  };
-  for (size_t size : input_size) {
-    transcode_utf32_to_utf16_test_base test(BE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_4_UTF16_bytes) {
-  // range for 4 UTF-16 bytes
-  simdutf::tests::helpers::RandomIntRanges random({{0x10000, 0x10ffff}}, seed);
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char16_t *utf16be) -> size_t {
-    return implementation.convert_valid_utf32_to_utf16be(utf32, size, utf16be);
-  };
-  for (size_t size : input_size) {
-    transcode_utf32_to_utf16_test_base test(BE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_2_or_4_UTF16_bytes) {
-  // range for 2 or 4 UTF-16 bytes (all codepoints)
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0000, 0xd7ff}, {0xe000, 0xffff}, {0x10000, 0x10ffff}}, seed);
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char16_t *utf16be) -> size_t {
-    return implementation.convert_valid_utf32_to_utf16be(utf32, size, utf16be);
-  };
-  for (size_t size : input_size) {
-    transcode_utf32_to_utf16_test_base test(BE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-template <auto input> constexpr auto size() {
-  return simdutf::utf16_length_from_utf32(input);
-}
-
-template <auto input> constexpr auto convert_be() {
-  using namespace simdutf::tests::helpers;
-  CTString<char16_t, size<input>(), std::endian::big> tmp;
-  const auto ret = simdutf::convert_valid_utf32_to_utf16be(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_valid_utf32_to_utf16be) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto input = U"köttbulle"_utf32;
-  constexpr auto expected = u"köttbulle"_utf16be;
-  constexpr bool with_errors = true;
-  constexpr auto output = convert_be<input>();
-  static_assert(output == expected);
-}
-
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/convert_valid_utf32_to_utf16le_tests.cpp

@@ -1,114 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/transcode_test_base.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/test.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_utf32_to_utf16_test_base;
-
-} // namespace
-
-TEST_LOOP(convert_into_2_UTF16_bytes) {
-  // range for 2 UTF-16 bytes
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0000, 0xd7ff}, {0xe000, 0xffff}}, seed);
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char16_t *utf16) -> size_t {
-    return implementation.convert_valid_utf32_to_utf16le(utf32, size, utf16);
-  };
-  for (size_t size : input_size) {
-    transcode_utf32_to_utf16_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_4_UTF16_bytes) {
-  // range for 4 UTF-16 bytes
-  simdutf::tests::helpers::RandomIntRanges random({{0x10000, 0x10ffff}}, seed);
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char16_t *utf16) -> size_t {
-    return implementation.convert_valid_utf32_to_utf16le(utf32, size, utf16);
-  };
-  for (size_t size : input_size) {
-    transcode_utf32_to_utf16_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-TEST_LOOP(convert_into_2_or_4_UTF16_bytes) {
-  // range for 2 or 4 UTF-16 bytes (all codepoints)
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x0000, 0xd7ff}, {0xe000, 0xffff}, {0x10000, 0x10ffff}}, seed);
-
-  auto procedure = [&implementation](const char32_t *utf32, size_t size,
-                                     char16_t *utf16) -> size_t {
-    return implementation.convert_valid_utf32_to_utf16le(utf32, size, utf16);
-  };
-  for (size_t size : input_size) {
-    transcode_utf32_to_utf16_test_base test(LE, random, size);
-    ASSERT_TRUE(test(procedure));
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-template <auto input> constexpr auto size() {
-  return simdutf::utf16_length_from_utf32(input);
-}
-template <auto input> constexpr auto convert() {
-  using namespace simdutf::tests::helpers;
-  CTString<char16_t, size<input>()> tmp;
-  const auto ret = simdutf::convert_valid_utf32_to_utf16(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_valid_utf32_to_utf16) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto input = U"köttbulle"_utf32;
-  constexpr auto expected = u"köttbulle"_utf16;
-  constexpr bool with_errors = true;
-  constexpr auto output = convert<input>();
-  static_assert(output == expected);
-}
-
-namespace {
-
-template <auto input> constexpr auto convert_le() {
-  using namespace simdutf::tests::helpers;
-  CTString<char16_t, size<input>(), std::endian::little> tmp;
-  const auto ret = simdutf::convert_valid_utf32_to_utf16le(input, tmp);
-  if (ret != tmp.size()) {
-    throw "unexpected write size";
-  }
-  return tmp;
-}
-} // namespace
-
-TEST(compile_time_convert_valid_utf32_to_utf16le) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto input = U"köttbulle"_utf32;
-  constexpr auto expected = u"köttbulle"_utf16le;
-  constexpr bool with_errors = true;
-  constexpr auto output = convert_le<input>();
-  static_assert(output == expected);
-}
-
-#endif
-
-TEST_MAIN