react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/fixed_string_tests.cpp

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

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

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

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

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