react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/fixed_string_tests.cpp

@@ -1,153 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/test.h>
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(construct_from_user_defined_literals) {
-  using namespace simdutf::tests::helpers;
-
-  constexpr auto utf32 = U"köttbulle"_utf32;
-  static_assert(utf32 == CTString(U"köttbulle"));
-  static_assert(utf32.size() == 9);
-  static_assert(utf32[0] == char32_t{'k'});
-  static_assert(std::is_same_v<decltype(utf32[0]), char32_t>);
-
-  constexpr auto utf16 = u"köttbulle"_utf16;
-  static_assert(utf16 == CTString(u"köttbulle"));
-  static_assert(utf16.size() == 9);
-  static_assert(utf16[0] == char16_t{'k'});
-  static_assert(std::is_same_v<decltype(utf16[0]), char16_t>);
-
-  static_assert(sizeof(utf32) == 2 * sizeof(utf16));
-
-  constexpr auto utf8 = u8"köttbulle"_utf8;
-  static_assert(utf8 == CTString(u8"köttbulle"));
-  static_assert(utf8.size() == 9 + 1);
-  static_assert(utf8[0] == char8_t{'k'});
-  static_assert(std::is_same_v<decltype(utf8[0]), char8_t>);
-
-  constexpr auto latin1 = "kottbulle"_latin1;
-  static_assert(latin1 == CTString("kottbulle"));
-  // intentionally fails at compile time due to not being latin1:
-  // constexpr auto latin1_fail = "köttbulle"_latin1;
-  static_assert(latin1.size() == 9);
-  static_assert(sizeof(latin1) == 9);
-  static_assert(latin1[0] == char8_t{'k'});
-  static_assert(std::is_same_v<decltype(latin1[0]), char>);
-
-  static_assert(sizeof(utf8) == sizeof(latin1) + 1);
-  static_assert(sizeof(utf32) == 4 * sizeof(latin1));
-}
-
-namespace {
-template <typename T>
-concept test_construct_from_range = requires(const std::array<T, 3> &dummy) {
-  {
-    // this tries to ensure that the following compiles:
-    // constexpr simdutf::tests::helpers::CTString tmp{dummy};
-
-    std::integral_constant<
-        std::size_t, sizeof(simdutf::tests::helpers::CTString{dummy}) * 0>{}
-  } -> std::same_as<std::integral_constant<std::size_t, 0>>;
-};
-} // namespace
-
-TEST(construct_from_range) {
-  using namespace simdutf::tests::helpers;
-  constexpr std::array<char32_t, 5> tmp{'h', 'e', 'l', 'l', 'o'};
-  constexpr CTString fromrange(tmp);
-  static_assert(fromrange[0] == 'h');
-  static_assert(fromrange[1] == 'e');
-  static_assert(fromrange[2] == 'l');
-  static_assert(fromrange[3] == 'l');
-  static_assert(fromrange[4] == 'o');
-  static_assert(std::is_same_v<decltype(fromrange[0]), char32_t>);
-
-  static_assert(test_construct_from_range<char>);
-  static_assert(test_construct_from_range<const char>);
-
-  static_assert(test_construct_from_range<char8_t>);
-  static_assert(test_construct_from_range<const char8_t>);
-
-  static_assert(test_construct_from_range<char16_t>);
-  static_assert(test_construct_from_range<const char16_t>);
-
-  static_assert(test_construct_from_range<char32_t>);
-  static_assert(test_construct_from_range<const char32_t>);
-
-  static_assert(not test_construct_from_range<int>);
-}
-
-// this also tests the concepts
-TEST(construct_from_literals) {
-  using namespace simdutf::tests::helpers;
-
-  static_assert(CTString("abc").size() == 3);
-
-  static_assert(not any_ctstring<int>);
-  static_assert(not latin1_ctstring<int>);
-  static_assert(not any_ctstring<const int>);
-  static_assert(not latin1_ctstring<const int>);
-
-  constexpr CTString a("this is a latin1 string");
-  using A = std::remove_cvref_t<decltype(a)>;
-  static_assert(latin1_ctstring<A>);
-  static_assert(latin1_ctstring<const A>);
-  static_assert(latin1_ctstring<A &>);
-  static_assert(latin1_ctstring<A &&>);
-  static_assert(latin1_ctstring<const A &>);
-  static_assert(not utf8_ctstring<A>);
-  static_assert(not utf16_ctstring<A>);
-  static_assert(not utf32_ctstring<A>);
-
-  constexpr CTString b(u8"this is a utf-8 string");
-  static_assert(not latin1_ctstring<decltype(b)>);
-  static_assert(utf8_ctstring<decltype(b)>);
-  static_assert(not utf16_ctstring<decltype(b)>);
-  static_assert(not utf32_ctstring<decltype(b)>);
-
-  constexpr CTString c(u"this is a utf-16 string");
-  static_assert(not latin1_ctstring<decltype(c)>);
-  static_assert(not utf8_ctstring<decltype(c)>);
-  static_assert(utf16_ctstring<decltype(c)>);
-  static_assert(not utf32_ctstring<decltype(c)>);
-
-  constexpr CTString d(U"this is a utf-32 string");
-  static_assert(not latin1_ctstring<decltype(d)>);
-  static_assert(not utf8_ctstring<decltype(d)>);
-  static_assert(not utf16_ctstring<decltype(d)>);
-  static_assert(utf32_ctstring<decltype(d)>);
-}
-
-TEST(test_endianness) {
-  using namespace simdutf::tests::helpers;
-  // make them equally long so we can compare the type (the length is encoded in
-  // the type)
-  constexpr auto native = u"NATIVE"_utf16;
-  constexpr auto little = u"BIGBIG"_utf16le;
-  constexpr auto bigbig = u"LITTLE"_utf16be;
-  using Native = decltype(native);
-  using Big = decltype(bigbig);
-  using Little = decltype(little);
-  static_assert(utf16_ctstring<Native>);
-  static_assert(utf16_ctstring<Big>);
-  static_assert(utf16_ctstring<Little>);
-  constexpr bool is_little = (std::endian::native == std::endian::little);
-  static_assert(utf16le_ctstring<Native> == is_little);
-  static_assert(utf16be_ctstring<Native> == !is_little);
-
-  static_assert(!std::is_same_v<Big, Little>);
-  static_assert(std::is_same_v<Big, Native> || std::is_same_v<Little, Native>);
-
-  static_assert(little[0] != bigbig[0]);
-}
-
-#else
-TEST(nothing_happens_when_not_in_cxx23_mode) {}
-#endif
-
-TEST_MAIN

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

@@ -1,25 +0,0 @@
-add_library(simdutf_tests_helpers STATIC
-  compiletime_conversions.h
-  fixed_string.h
-  test.h
-  test.cpp
-  random_int.h
-  random_int.cpp
-  transcode_test_base.h
-  transcode_test_base.cpp
-  random_utf8.h
-  random_utf8.cpp
-  random_utf16.h
-  random_utf16.cpp
-  random_utf32.h
-  random_utf32.cpp)
-
-if(SIMDUTF_FAST_TESTS)
-  target_compile_definitions(simdutf_tests_helpers PUBLIC SIMDUTF_TEST_LOOP_TRIALS=10)
-else()
-  target_compile_definitions(simdutf_tests_helpers PUBLIC SIMDUTF_TEST_LOOP_TRIALS=1000)
-endif()
-target_include_directories(simdutf_tests_helpers PUBLIC ${SIMDUTF_TEST_INCLUDE_DIR})
-target_link_libraries(simdutf_tests_helpers PUBLIC simdutf simdutf::tests::reference)
-
-add_library(simdutf::tests::helpers ALIAS simdutf_tests_helpers)

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

@@ -1,222 +0,0 @@
-#ifndef SIMDUTF_COMPILETIME_CONVERSIONS_H
-#define SIMDUTF_COMPILETIME_CONVERSIONS_H
-
-#include "simdutf/compiler_check.h"
-
-#if SIMDUTF_CPLUSPLUS23
-
-  #include <simdutf.h>
-
-  #include <tests/helpers/fixed_string.h>
-
-namespace simdutf {
-namespace tests {
-namespace helpers {
-
-/**
- * creates a copy of input with the same endianness but with
- * illformed data replaced.
- */
-template <typename CharType, std::size_t N, std::endian endianness>
-constexpr auto to_wellformed(const CTString<CharType, N, endianness> &input) {
-  CTString<CharType, N, endianness> output;
-  if constexpr (endianness == std::endian::little) {
-    simdutf::to_well_formed_utf16le(input, output);
-  } else {
-    simdutf::to_well_formed_utf16be(input, output);
-  }
-  return output;
-}
-
-/// converts valid input to latin1
-template <typename CharType, std::size_t N, std::endian endianness>
-constexpr auto to_latin1(const CTString<CharType, N, endianness> &input) {
-  CTString<char, N> tmp;
-  std::size_t ret;
-  if constexpr (std::is_same_v<CharType, char32_t>) {
-    ret = simdutf::convert_valid_utf32_to_latin1(input, tmp);
-  } else if constexpr (std::is_same_v<CharType, char16_t> &&
-                       endianness == std::endian::little) {
-    ret = simdutf::convert_valid_utf16le_to_latin1(input, tmp);
-  } else if constexpr (std::is_same_v<CharType, char16_t> &&
-                       endianness == std::endian::big) {
-    ret = simdutf::convert_valid_utf16be_to_latin1(input, tmp);
-  } else {
-    throw "unknown type";
-  }
-  if (!input.empty() && ret == 0) {
-    throw "failed conversion";
-  }
-  return tmp;
-}
-
-/// converts latin1 input to utf8
-template <auto input>
-  requires latin1_ctstring<decltype(input)>
-constexpr auto to_utf8() {
-  constexpr auto N = utf8_length_from_latin1(input);
-  CTString<char8_t, N> tmp;
-  auto ret = simdutf::convert_latin1_to_utf8(input, tmp);
-  if (!input.empty() && ret == 0) {
-    throw "failed conversion";
-  }
-  return tmp;
-}
-
-namespace detail {
-template <std::endian output_endianness, typename CharType, std::size_t N,
-          std::endian input_endianness>
-constexpr auto
-to_utf16_impl(const CTString<CharType, N, input_endianness> &input) {
-
-  if constexpr (std::is_same_v<CharType, char16_t>) {
-    if constexpr (output_endianness == input_endianness) {
-      // no-op
-      return input;
-    } else {
-      // byteswap
-      CTString<CharType, N, output_endianness> output;
-      simdutf::change_endianness_utf16(input, output);
-      return output;
-    }
-  }
-}
-} // namespace detail
-
-/// converts valid input to utf16
-template <typename CharType, std::size_t N, std::endian endianness>
-constexpr auto to_utf16(const CTString<CharType, N, endianness> &input) {
-  return detail::to_utf16_impl<std::endian::native>(input);
-}
-
-/// converts valid input to utf16le
-template <typename CharType, std::size_t N, std::endian endianness>
-constexpr auto to_utf16le(const CTString<CharType, N, endianness> &input) {
-  return detail::to_utf16_impl<std::endian::little>(input);
-}
-
-/// converts valid input to utf16be
-template <typename CharType, std::size_t N, std::endian endianness>
-constexpr auto to_utf16be(const CTString<CharType, N, endianness> &input) {
-  return detail::to_utf16_impl<std::endian::big>(input);
-}
-
-template <std::endian target_endianness>
-constexpr auto latin1_to_utf16(latin1_ctstring auto &&input) {
-  using I = decltype(input);
-  constexpr auto N = I{}.size();
-  CTString<char16_t, N, target_endianness> output;
-  std::size_t converted;
-  if constexpr (target_endianness == std::endian::little) {
-    converted = convert_latin1_to_utf16le(input, output);
-  } else {
-    converted = convert_latin1_to_utf16be(input, output);
-  }
-  if (converted != N) {
-    throw "oops";
-  }
-  return output;
-}
-
-template <std::endian target_endianness, bool with_errors, auto input>
-constexpr auto utf8_to_utf16() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto Nout = simdutf::utf16_length_from_utf8(input);
-  CTString<char16_t, Nout, target_endianness> tmp{};
-  std::size_t N;
-  if constexpr (target_endianness == std::endian::little) {
-    if constexpr (with_errors) {
-      auto res = simdutf::convert_utf8_to_utf16le_with_errors(input, tmp);
-      if (res.is_err()) {
-        throw "fail";
-      }
-      N = res.count;
-    } else {
-      N = simdutf::convert_utf8_to_utf16le(input, tmp);
-    }
-  } else {
-    if constexpr (with_errors) {
-      auto res = simdutf::convert_utf8_to_utf16be_with_errors(input, tmp);
-      if (res.is_err()) {
-        throw "fail";
-      }
-      N = res.count;
-    } else {
-      N = simdutf::convert_utf8_to_utf16be(input, tmp);
-    }
-  }
-  if (N != input.size()) {
-    throw "oops";
-  }
-  return tmp;
-}
-
-template <std::endian target_endianness, auto input>
-constexpr auto valid_utf8_to_utf16() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto Nout = simdutf::utf16_length_from_utf8(input);
-  CTString<char16_t, Nout, target_endianness> tmp{};
-  std::size_t N;
-  if constexpr (target_endianness == std::endian::little) {
-    N = simdutf::convert_valid_utf8_to_utf16le(input, tmp);
-  } else {
-    N = simdutf::convert_valid_utf8_to_utf16be(input, tmp);
-  }
-  if (N != input.size()) {
-    throw "oops";
-  }
-  return tmp;
-}
-
-namespace detail {
-template <auto input> constexpr auto utf8_length_from_utf16_helper() {
-  if constexpr (decltype(input)::endianness == std::endian::little) {
-    return simdutf::utf8_length_from_utf16le(input);
-  } else {
-    return simdutf::utf8_length_from_utf16be(input);
-  }
-}
-} // namespace detail
-
-template <auto input, bool with_errors> constexpr auto valid_utf16_to_utf8() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto Nout = detail::utf8_length_from_utf16_helper<input>();
-  CTString<char8_t, Nout> tmp{};
-  std::size_t N;
-  if constexpr (decltype(input)::endianness == std::endian::little) {
-    N = simdutf::convert_valid_utf16le_to_utf8(input, tmp);
-  } else {
-    N = simdutf::convert_valid_utf16be_to_utf8(input, tmp);
-  }
-  if (N != input.size()) {
-    throw "oops";
-  }
-  return tmp;
-}
-
-template <auto input, bool with_errors> constexpr auto utf16_to_utf8() {
-  using namespace simdutf::tests::helpers;
-  constexpr auto Nout = detail::utf8_length_from_utf16_helper<input>();
-  CTString<char8_t, Nout> tmp{};
-  std::size_t N;
-  if constexpr (decltype(input)::endianness == std::endian::little) {
-    N = simdutf::convert_utf16le_to_utf8(input, tmp);
-  } else {
-    N = simdutf::convert_utf16be_to_utf8(input, tmp);
-  }
-  if (N == 0) {
-    throw "failed";
-  }
-  if (N != tmp.size()) {
-    throw "oops";
-  }
-  return tmp;
-}
-
-} // namespace helpers
-} // namespace tests
-} // namespace simdutf
-
-#endif // SIMDUTF_CPLUSPLUS23
-
-#endif // SIMDUTF_COMPILETIME_CONVERSIONS_H

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

@@ -1,267 +0,0 @@
-#ifndef SIMDUTF_FIXED_STRING_H
-#define SIMDUTF_FIXED_STRING_H
-
-#include <simdutf/compiler_check.h>
-
-#if SIMDUTF_CPLUSPLUS23
-
-  #include <bit>
-  #include <string>
-  #include <cstddef>
-  #include <span>
-  #include <type_traits>
-  #include <algorithm>
-  #include <ranges>
-
-namespace simdutf {
-namespace tests {
-namespace helpers {
-
-namespace detail {
-/// a concept that is true for the char types that are valid for representing
-/// ascii/latin1, utf-8, utf-16 and utf-32
-template <typename CharType>
-concept valid_chartype = std::disjunction_v<std::is_same<CharType, char>,     //
-                                            std::is_same<CharType, char8_t>,  //
-                                            std::is_same<CharType, char16_t>, //
-                                            std::is_same<CharType, char32_t>>;
-
-/**
- * an internal helper type for use with user defined literals.
- *
- * implementation note: the reason for this is that the literal operator
- * template deduces the size including the null character. that makes the
- * template parameter N be the size+1, which is annoying.
- */
-template <detail::valid_chartype CharType, std::size_t N>
-struct TmpStringLiteral {
-  CharType storage[N - 1];
-
-  using type = CharType;
-
-  static constexpr std::size_t size() noexcept { return N - 1; }
-
-  /**
-   * constructs from a string literal
-   *
-   * StringLiteral a("this is an ascii string");
-   * StringLiteral b(u8"this is a utf-8 string");
-   * StringLiteral c(u"this is a utf-16 string");
-   * StringLiteral d(U"this is a utf-32 string");
-   */
-  constexpr /*explicit*/ TmpStringLiteral(CharType const (&str)[N]) {
-    static_assert(N > 1, "weird size");
-    std::copy(str, str + size(), storage);
-  }
-};
-} // namespace detail
-
-/**
- * A compile time string with fixed size, aimed to simplify testing since
- * std::string is hard to use at compile time due to it internally
- * allocating memory.
- *
- * clang-format off
- *
- * CharType implicitly determines the content:
- * char     - ascii/latin1
- * char8_t  - utf8
- * char16_t - utf16
- * char32_t - utf32
- *
- * clang-format on
- */
-template <detail::valid_chartype CharType, std::size_t N,
-          std::endian endianness_ = std::endian::native>
-struct CTString {
-  /// the string, not null terminated
-  CharType storage[N];
-
-  using type = CharType;
-  static constexpr std::endian endianness = endianness_;
-
-  constexpr CTString() = default;
-
-  /// construction from a string literal (includes a null character)
-  constexpr explicit CTString(CharType const (&str)[N + 1]) {
-    std::copy(str, str + size(), storage);
-  }
-
-  /// construct from a range with the appropriate type
-  constexpr explicit CTString(std::ranges::input_range auto &&range)
-    requires detail::valid_chartype<
-                 std::ranges::range_value_t<decltype(range)>> &&
-             std::ranges::sized_range<decltype(range)>
-  {
-  #if !defined(_MSVC_LANG) && !defined(__clang__)
-    constexpr auto Ninput = std::ranges::size(range);
-    static_assert(Ninput == size());
-  #endif
-    std::ranges::copy(range, storage);
-  }
-
-  constexpr bool operator==(const CTString &other) const noexcept = default;
-
-  /// size in number of code units
-  static constexpr std::size_t size() noexcept { return N; }
-  static constexpr bool empty() noexcept { return size() == 0; }
-  constexpr CharType *data() noexcept { return storage; }
-  constexpr const CharType *data() const noexcept { return storage; }
-  constexpr auto span() noexcept { return std::span(storage); }
-  constexpr auto span() const noexcept { return std::span(storage); }
-
-  constexpr auto begin() noexcept { return data(); }
-  constexpr auto end() noexcept { return data() + size(); }
-  constexpr auto begin() const noexcept { return data(); }
-  constexpr auto end() const noexcept { return data() + size(); }
-  constexpr CharType operator[](auto index) const noexcept {
-    return storage[index];
-  }
-  constexpr CharType &operator[](auto index) noexcept { return storage[index]; }
-  template <typename DestCharType> constexpr auto as_array() const noexcept {
-    std::array<DestCharType, size()> ret;
-    for (std::size_t i = 0; i < size(); ++i) {
-      ret[i] = static_cast<DestCharType>(storage[i]);
-    }
-    return ret;
-  }
-
-  /**
-   * returns a copy of the first NewSize code units
-   */
-  template <std::size_t NewSize>
-    requires(NewSize <= N)
-  constexpr auto shrink() const noexcept {
-    CTString<CharType, NewSize, endianness_> ret;
-    std::ranges::copy_n(storage, NewSize, ret.storage);
-    return ret;
-  }
-};
-
-/// Class template argument deduction (CTAD) for a string literal (null
-/// terminated)
-template <detail::valid_chartype CharType, std::size_t N>
-CTString(const CharType (&str)[N]) -> CTString<CharType, N - 1>;
-
-/// Class template argument deduction (CTAD) for a range (must have size known
-/// at compile time)
-template <std::ranges::input_range R>
-CTString(R &&)
-    -> CTString<std::ranges::range_value_t<R>, std::ranges::size(R{})>;
-
-/// creates a fixed size string of UTF-32
-template <detail::TmpStringLiteral a> constexpr auto operator""_utf32() {
-  using C = typename decltype(a)::type;
-  static_assert(
-      std::is_same_v<C, char32_t>,
-      "_utf32 user defined literal must be on the form U\"text...\"_utf32");
-  return CTString<C, a.size()>(a.storage);
-}
-
-/// creates a fixed size string of UTF-16 (native endian)
-template <detail::TmpStringLiteral a> constexpr auto operator""_utf16() {
-  using C = typename decltype(a)::type;
-  static_assert(
-      std::is_same_v<C, char16_t>,
-      "_utf16 user defined literal must be on the form u\"text...\"_utf16");
-  return CTString<C, a.size()>(a.storage);
-}
-
-/// creates a fixed size string of UTF-16 (little endian)
-template <detail::TmpStringLiteral a> constexpr auto operator""_utf16le() {
-  using C = typename decltype(a)::type;
-  static_assert(
-      std::is_same_v<C, char16_t>,
-      "_utf16 user defined literal must be on the form u\"text...\"_utf16le");
-  auto ret = CTString<C, a.size(), std::endian::little>(a.storage);
-  if constexpr (std::endian::little != std::endian::native) {
-    for (auto &e : ret) {
-      e = std::byteswap(e);
-    }
-  }
-  return ret;
-}
-
-/// creates a fixed size string of UTF-16 (big endian)
-template <detail::TmpStringLiteral a> constexpr auto operator""_utf16be() {
-  using C = typename decltype(a)::type;
-  static_assert(
-      std::is_same_v<C, char16_t>,
-      "_utf16 user defined literal must be on the form u\"text...\"_utf16be");
-  auto ret = CTString<C, a.size(), std::endian::big>(a.storage);
-  if constexpr (std::endian::big != std::endian::native) {
-    for (auto &e : ret) {
-      e = std::byteswap(e);
-    }
-  }
-  return ret;
-}
-
-/// creates a fixed size string of UTF-8
-template <detail::TmpStringLiteral a> constexpr auto operator""_utf8() {
-  using C = typename decltype(a)::type;
-  static_assert(
-      std::is_same_v<C, char8_t>,
-      "_utf8 user defined literal must be on the form u8\"text...\"_utf8");
-  return CTString<C, a.size()>(a.storage);
-}
-
-/// creates a fixed size string of ascii/latin1
-template <detail::TmpStringLiteral a> constexpr auto operator""_latin1() {
-  using C = typename decltype(a)::type;
-  static_assert(
-      std::is_same_v<C, char>,
-      "_latin1 user defined literal must be on the form \"text...\"_latin1");
-  return CTString<C, a.size()>(a.storage);
-}
-
-namespace detail {
-template <class T> struct is_CTString : std::false_type {};
-
-template <typename CharType, std::size_t N, std::endian endianness>
-struct is_CTString<CTString<CharType, N, endianness>> : std::true_type {};
-
-} // namespace detail
-
-/// concept which gives true for any CTString (regardless of if it is latin1,
-/// utf-8, utf-16 or utf-32)
-template <class T>
-concept any_ctstring = detail::is_CTString<std::decay_t<T>>::value;
-
-template <class T>
-concept latin1_ctstring =
-    (detail::is_CTString<std::decay_t<T>>::value &&
-     std::is_same_v<std::decay_t<typename std::decay_t<T>::type>, char>);
-
-template <class T>
-concept utf8_ctstring =
-    (detail::is_CTString<std::decay_t<T>>::value &&
-     std::is_same_v<typename std::decay_t<T>::type, char8_t>);
-
-template <class T>
-concept utf16_ctstring =
-    (detail::is_CTString<std::decay_t<T>>::value &&
-     std::is_same_v<typename std::decay_t<T>::type, char16_t>);
-
-template <class T>
-concept utf16le_ctstring =
-    (detail::is_CTString<std::decay_t<T>>::value &&
-     std::is_same_v<typename std::decay_t<T>::type, char16_t> &&
-     T::endianness == std::endian::little);
-
-template <class T>
-concept utf16be_ctstring =
-    (detail::is_CTString<std::decay_t<T>>::value &&
-     std::is_same_v<typename std::decay_t<T>::type, char16_t> &&
-     T::endianness == std::endian::big);
-
-template <class T>
-concept utf32_ctstring =
-    (detail::is_CTString<std::decay_t<T>>::value &&
-     std::is_same_v<typename std::decay_t<T>::type, char32_t>);
-
-} // namespace helpers
-} // namespace tests
-} // namespace simdutf
-#endif // SIMDUTF_CPLUSPLUS23
-#endif // SIMDUTF_FIXED_STRING_H

package/deps/simdutf/tests/helpers/random_int.cpp

@@ -1,30 +0,0 @@
-#include "random_int.h"
-
-namespace simdutf {
-namespace tests {
-namespace helpers {
-
-RandomInt::RandomInt(uint64_t lo, uint64_t hi, uint64_t seed) noexcept
-    : gen(std::mt19937::result_type(seed)), distr{lo, hi} {}
-
-uint32_t RandomInt::operator()() noexcept { return uint32_t(distr(gen)); }
-
-RandomIntRanges::RandomIntRanges(
-    std::initializer_list<std::pair<uint64_t, uint64_t>> ranges_,
-    uint64_t seed) noexcept
-    : gen(std::mt19937::result_type(seed)) {
-
-  for (const auto &lohi : ranges_) {
-    ranges.emplace_back(lohi.first, lohi.second);
-  }
-
-  range_index = Distribution(0, ranges.size() - 1);
-}
-
-uint32_t RandomIntRanges::operator()() noexcept {
-  const size_t index = size_t(range_index(gen));
-  return uint32_t(ranges[index](gen));
-}
-} // namespace helpers
-} // namespace tests
-} // namespace simdutf