react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/tests/count_utf16be.cpp

@@ -1,64 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-#include <vector>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/random_utf16.h>
-#include <tests/helpers/test.h>
-
-namespace {
-std::array<size_t, 7> input_size{7, 16, 12, 64, 67, 128, 256};
-
-} // namespace
-
-TEST_LOOP(count_just_one_word) {
-  simdutf::tests::helpers::random_utf16 random(seed, 1, 0);
-
-  for (size_t size : input_size) {
-    const auto g = random.generate_counted_be(size);
-    const auto &utf16 = g.first;
-    const auto utf16_count = g.second;
-
-    const size_t count = implementation.count_utf16be(utf16.data(), size);
-    ASSERT_EQUAL(count, utf16_count);
-  }
-}
-
-TEST_LOOP(count_1_or_2_UTF16_words) {
-  simdutf::tests::helpers::random_utf16 random(seed, 1, 1);
-
-  for (size_t size : input_size) {
-    const auto g = random.generate_counted_be(size);
-    const auto &utf16 = g.first;
-    const auto utf16_count = g.second;
-
-    const size_t count = implementation.count_utf16be(utf16.data(), size);
-    ASSERT_EQUAL(count, utf16_count);
-  }
-}
-
-TEST_LOOP(count_2_UTF16_words) {
-  simdutf::tests::helpers::random_utf16 random(seed, 0, 1);
-
-  for (size_t size : input_size) {
-    const auto g = random.generate_counted_be(size);
-    const auto &utf16 = g.first;
-    const auto utf16_count = g.second;
-
-    const size_t count = implementation.count_utf16be(utf16.data(), size);
-    ASSERT_EQUAL(count, utf16_count);
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_count_utf16be) {
-  using namespace simdutf::tests::helpers;
-
-  static_assert(simdutf::count_utf16be(u"köttbulle"_utf16be) == 9);
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/count_utf16le.cpp

@@ -1,61 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/random_utf16.h>
-#include <tests/helpers/test.h>
-
-namespace {
-constexpr std::array<size_t, 9> input_size{7,   12,  16,  64,  67,
-                                           128, 256, 511, 1000};
-
-} // namespace
-
-TEST_LOOP(count_just_one_word) {
-  simdutf::tests::helpers::random_utf16 random(seed, 1, 0);
-
-  for (size_t size : input_size) {
-    const auto generated = random.generate_counted_le(size);
-    ASSERT_EQUAL(implementation.count_utf16le(generated.first.data(), size),
-                 generated.second);
-  }
-}
-
-TEST_LOOP(count_1_or_2_UTF16_words) {
-  simdutf::tests::helpers::random_utf16 random(seed, 1, 1);
-
-  for (size_t size : input_size) {
-    auto generated = random.generate_counted_le(size);
-    ASSERT_EQUAL(implementation.count_utf16le(generated.first.data(), size),
-                 generated.second);
-  }
-}
-
-TEST_LOOP(count_2_UTF16_words) {
-  simdutf::tests::helpers::random_utf16 random(seed, 0, 1);
-
-  for (size_t size : input_size) {
-    const auto generated = random.generate_counted_le(size);
-    ASSERT_EQUAL(implementation.count_utf16le(generated.first.data(), size),
-                 generated.second);
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_count_utf16) {
-  using namespace simdutf::tests::helpers;
-
-  static_assert(simdutf::count_utf16(u"köttbulle"_utf16) == 9);
-}
-
-TEST(compile_time_count_utf16le) {
-  using namespace simdutf::tests::helpers;
-
-  static_assert(simdutf::count_utf16(u"köttbulle"_utf16le) == 9);
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/count_utf8.cpp

@@ -1,87 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/random_utf8.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/transcode_test_base.h>
-
-namespace {
-std::array<size_t, 10> input_size{7,
-                                  12,
-                                  16,
-                                  64,
-                                  67,
-                                  128,
-                                  256
-#if !SIMDUTF_FAST_TEST
-                                  ,
-                                  511,
-                                  1000,
-                                  2000
-#endif
-};
-
-using simdutf::tests::helpers::transcode_utf8_to_utf16_test_base;
-} // namespace
-
-TEST_LOOP(count_pure_ASCII) {
-  simdutf::tests::helpers::random_utf8 random(seed, 1, 0, 0, 0);
-
-  for (size_t size : input_size) {
-    auto generated = random.generate_counted(size);
-    ASSERT_EQUAL(
-        implementation.count_utf8(
-            reinterpret_cast<const char *>(generated.first.data()), size),
-        generated.second);
-  }
-}
-
-TEST_LOOP(count_1_or_2_UTF8_bytes) {
-  simdutf::tests::helpers::random_utf8 random(seed, 1, 1, 0, 0);
-
-  for (size_t size : input_size) {
-    auto generated = random.generate_counted(size);
-    ASSERT_EQUAL(
-        implementation.count_utf8(
-            reinterpret_cast<const char *>(generated.first.data()), size),
-        generated.second);
-  }
-}
-
-TEST_LOOP(count_1_or_2_or_3_UTF8_bytes) {
-  simdutf::tests::helpers::random_utf8 random(seed, 1, 1, 1, 0);
-
-  for (size_t size : input_size) {
-    auto generated = random.generate_counted(size);
-    ASSERT_EQUAL(
-        implementation.count_utf8(
-            reinterpret_cast<const char *>(generated.first.data()), size),
-        generated.second);
-  }
-}
-
-TEST_LOOP(count_1_2_3_or_4_UTF8_bytes) {
-  simdutf::tests::helpers::random_utf8 random(seed, 1, 1, 1, 1);
-
-  for (size_t size : input_size) {
-    auto generated = random.generate_counted(size);
-    ASSERT_EQUAL(
-        implementation.count_utf8(
-            reinterpret_cast<const char *>(generated.first.data()), size),
-        generated.second);
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_count_utf8) {
-  using namespace simdutf::tests::helpers;
-
-  static_assert(simdutf::count_utf8(u8"köttbulle"_utf8) == 9);
-}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/detect_encodings_tests.cpp

@@ -1,312 +0,0 @@
-#include "simdutf.h"
-
-#include <array>
-#include <vector>
-
-#include <tests/reference/encode_utf16.h>
-#include <tests/helpers/random_int.h>
-#include <tests/helpers/random_utf8.h>
-#include <tests/helpers/random_utf16.h>
-#include <tests/helpers/test.h>
-#include <tests/helpers/utf16.h>
-
-namespace {
-std::array<size_t, 7> input_size{8, 16, 12, 64, 68, 128, 256};
-
-template <typename Pointer> bool has_bom(Pointer *data, size_t size) {
-  return (simdutf::BOM::check_bom(data, size) !=
-          simdutf::encoding_type::unspecified);
-}
-
-template <typename RandomGenerator>
-std::vector<uint8_t> generate_utf8(RandomGenerator random, size_t size) {
-  // This is quite ugly workaround, but we expect almost none repeats
-  while (true) {
-    const auto generated = random.generate(size);
-    if (!has_bom(generated.data(), generated.size())) {
-      return generated;
-    }
-  }
-}
-
-template <typename RandomGenerator>
-std::vector<char16_t> generate_utf16_le(RandomGenerator random, size_t size) {
-  // This is quite ugly workaround, but we expect almost none repeats
-  while (true) {
-    const auto generated = random.generate_le(size);
-    if (!has_bom(reinterpret_cast<const char *>(generated.data()),
-                 generated.size())) {
-      return generated;
-    }
-  }
-}
-
-template <typename RandomGenerator>
-std::vector<uint16_t> generate_u16(RandomGenerator &random, size_t count) {
-  std::vector<uint16_t> result;
-  result.reserve(count);
-
-  union {
-    uint16_t word[2];
-    char string[4];
-  } first;
-
-  static_assert(sizeof(first) == 4, "union got an unexpected size");
-
-  // Make sure our random data does not start with a BOM marker.
-  do {
-    first.word[0] = random();
-    first.word[1] = random();
-  } while (has_bom(first.string, 4));
-
-  result.push_back(first.word[0]);
-  result.push_back(first.word[1]);
-  for (size_t i = 2; i < count; i++) {
-    result.push_back(random());
-  }
-
-  return result;
-}
-
-template <typename RandomGenerator>
-std::vector<uint32_t> generate_u32(RandomGenerator &random, size_t count) {
-  std::vector<uint32_t> result;
-  result.reserve(count);
-
-  union {
-    uint32_t word;
-    char string[4];
-  } first;
-
-  static_assert(sizeof(first) == 4, "union got an unexpected size");
-
-  // Make sure our random data does not start with a BOM marker.
-  do {
-    first.word = random();
-  } while (has_bom(first.string, 4));
-
-  result.push_back(first.word);
-  for (size_t i = 1; i < count; i++) {
-    result.push_back(random());
-  }
-
-  return result;
-}
-
-} // namespace
-
-TEST(issue_519) {
-  // implementation icelake gave 0
-  // implementation haswell gave 0
-  // implementation westmere gave 0
-  // implementation fallback gave 1
-  std::vector<unsigned char> data{
-      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,  32,  32,
-      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 223, 164, 32,
-      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,  32,  32,
-      32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,  32,  32,
-  };
-  const auto r =
-      implementation.detect_encodings((const char *)data.data(), data.size());
-  ASSERT_EQUAL(r, 1);
-}
-
-TEST(issue_516) {
-  std::vector<unsigned char> data{0x20, 0xd8, 0x00, 0x00};
-  const auto r =
-      implementation.detect_encodings((const char *)data.data(), data.size());
-  ASSERT_EQUAL(r, 0);
-}
-
-TEST(issue818) {
-  std::string data = "\xEF\xBB\xBF";
-  const auto r = simdutf::BOM::check_bom(data.data(), data.size());
-  ASSERT_EQUAL(r, simdutf::encoding_type::UTF8);
-}
-
-TEST(boommmmm) {
-  const char *utf8_bom = "\xef\xbb\xbf";
-  const char *utf16be_bom = "\xfe\xff";
-  const char *utf16le_bom = "\xff\xfe";
-  ASSERT_EQUAL(implementation.detect_encodings(utf8_bom, 3),
-               simdutf::encoding_type::UTF8);
-  ASSERT_EQUAL(implementation.detect_encodings(utf16be_bom, 2),
-               simdutf::encoding_type::UTF16_BE);
-  ASSERT_EQUAL(implementation.detect_encodings(utf16le_bom, 2),
-               simdutf::encoding_type::UTF16_LE);
-}
-
-#if !SIMDUTF_IS_BIG_ENDIAN
-TEST(issue_627) {
-  std::vector<unsigned char> data{
-      251, 219, 37,  222, 0,   199, 218, 0,   157, 0,   0, 255, 8,   8,
-      8,   8,   227, 8,   8,   8,   8,   8,   8,   255, 0, 0,   248, 0,
-      255, 8,   8,   8,   8,   10,  8,   8,   8,   8,   8, 8,   8,   0,
-      219, 0,   0,   122, 0,   255, 0,   5,   0,   0,   0, 0,   0,   0,
-      0,   255, 243, 159, 129, 172, 1,   219, 37,  222,
-  };
-  const auto r1 =
-      implementation.detect_encodings((const char *)data.data(), data.size());
-  ASSERT_EQUAL(r1, 2);
-
-  std::vector<unsigned char> data2{
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 219,
-  };
-  const auto r2 =
-      implementation.detect_encodings((const char *)data2.data(), data2.size());
-  ASSERT_EQUAL(r2, 0);
-}
-#endif
-
-TEST_LOOP(pure_utf8_ASCII) {
-  simdutf::tests::helpers::random_utf8 random(seed, 1, 0, 0, 0);
-
-  for (size_t size : input_size) {
-    const auto generated = generate_utf8(random, size);
-    auto expected =
-        simdutf::encoding_type::UTF8 | simdutf::encoding_type::UTF16_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_EQUAL(actual, expected);
-  }
-}
-
-TEST_LOOP(pure_utf16_ASCII) {
-  simdutf::tests::helpers::RandomInt random(0, 127, seed);
-
-  for (size_t size : input_size) {
-    const auto generated = generate_u16(random, size / 2);
-    auto expected =
-        simdutf::encoding_type::UTF8 | simdutf::encoding_type::UTF16_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_TRUE((actual & expected) ==
-                expected); // Must be at least UTF8 and UTF16_LE.
-  }
-}
-
-TEST_LOOP(pure_utf32_ASCII) {
-  simdutf::tests::helpers::RandomInt random(0, 0x7f, seed);
-
-  for (size_t size : input_size) {
-    const auto generated = generate_u32(random, size / 4);
-    auto expected = simdutf::encoding_type::UTF8 |
-                    simdutf::encoding_type::UTF16_LE |
-                    simdutf::encoding_type::UTF32_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_TRUE((actual & expected) ==
-                expected); // Must be at least UTF8 and UTF16_LE and UTF32_LE.
-  }
-}
-
-#if 0 // XXX
-TEST_LOOP(no_utf8_bytes_no_surrogates) {
-  simdutf::tests::helpers::RandomIntRanges random(
-      {{0x007f, 0xd800 - 1}, {0xe000, 0xffff}}, seed);
-
-  for (size_t size : input_size) {
-    auto generated = generate_u32(random, size / 4);
-    if (!simdutf::match_system(simdutf::endianness::LITTLE)) {
-        for (auto& val: generated) {
-            val = ((val & 0xff) << 8) | (val >> 8);
-        }
-    }
-
-    auto expected =
-        simdutf::encoding_type::UTF16_LE | simdutf::encoding_type::UTF32_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_EQUAL((actual & expected),
-                 expected); // Must be at least UTF16_LE and UTF32_LE.
-  }
-}
-#endif
-
-TEST_LOOP(two_utf8_bytes) {
-  simdutf::tests::helpers::random_utf8 random(seed, 0, 1, 0, 0);
-
-  for (size_t size : input_size) {
-    const auto generated = generate_utf8(random, size);
-    auto expected =
-        simdutf::encoding_type::UTF8 | simdutf::encoding_type::UTF16_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    if (actual != expected) {
-      if ((actual & simdutf::encoding_type::UTF8) == 0) {
-        puts("failed to detect valid UTF-8.");
-      }
-      if ((actual & simdutf::encoding_type::UTF16_LE) == 0) {
-        puts("failed to detect valid UTF-16LE.");
-      }
-    }
-    ASSERT_TRUE((actual & expected) ==
-                expected); // Must be at least UTF8 and UTF16_LE.
-  }
-}
-
-TEST_LOOP(utf_16_surrogates) {
-  simdutf::tests::helpers::random_utf16 random(seed, 0, 1);
-
-  for (size_t size : input_size) {
-    const auto generated = generate_utf16_le(random, size / 2);
-    auto expected = simdutf::encoding_type::UTF16_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_TRUE((actual & expected) == expected); // Must be at least UTF16_LE.
-  }
-}
-
-TEST_LOOP(utf32_surrogates) {
-  simdutf::tests::helpers::RandomInt random_prefix(0x10000, 0x10ffff, seed);
-  simdutf::tests::helpers::RandomInt random_suffix(0xd800, 0xdfff, seed);
-
-  for (size_t size : input_size) {
-    std::vector<uint32_t> generated;
-    for (unsigned int i = 0; i < size / 4; i++) {
-      generated.push_back((random_prefix() & 0xffff0000) + random_suffix());
-    }
-    auto expected = simdutf::encoding_type::UTF32_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_TRUE((actual & expected) == expected); // Must be at least UTF32_LE.
-  }
-}
-
-TEST_LOOP(edge_surrogate) {
-  simdutf::tests::helpers::RandomInt random(0x10000, 0x10ffff, seed);
-
-  const size_t size = 512;
-  std::vector<uint16_t> generated(size / 2, 0);
-  unsigned int i = 31;
-  while (i + 32 < (size / 2) - 1) {
-    char16_t W1;
-    char16_t W2;
-    ASSERT_EQUAL(simdutf::tests::reference::utf16::encode(random(), W1, W2), 2);
-    generated[i + 0] = to_utf16le(W1);
-    generated[i + 1] = to_utf16le(W2);
-    i += 32;
-  }
-  auto expected = simdutf::encoding_type::UTF16_LE;
-  auto actual = implementation.detect_encodings(
-      reinterpret_cast<const char *>(generated.data()), size);
-  ASSERT_TRUE((actual & expected) == expected); // Must be at least UTF16_LE.
-}
-
-TEST_LOOP(tail_utf8) {
-  simdutf::tests::helpers::random_utf8 random(seed, 0, 0, 1, 0);
-  std::array<size_t, 5> multiples_three{12, 54, 66, 126, 252};
-  for (size_t size : multiples_three) {
-    const auto generated = generate_utf8(random, size);
-    auto expected =
-        simdutf::encoding_type::UTF8 | simdutf::encoding_type::UTF16_LE;
-    auto actual = implementation.detect_encodings(
-        reinterpret_cast<const char *>(generated.data()), size);
-    ASSERT_TRUE((actual & expected) ==
-                expected); // Must be at least UTF8 and UTF16_LE.
-  }
-}
-
-TEST_MAIN

package/deps/simdutf/tests/embed/valid_utf8.txt

@@ -1 +0,0 @@
-köttbulle!

package/deps/simdutf/tests/embed_tests.cpp

@@ -1,22 +0,0 @@
-#include "simdutf.h"
-
-#include <span>
-
-#include <tests/helpers/test.h>
-
-#if __cpp_pp_embed
-
-TEST(test_embed) {
-  // clang-format off
-  constexpr unsigned char binary[]{
-  #embed <embed/valid_utf8.txt>
-  };
-  // clang-format on
-  static_assert(simdutf::validate_utf8(std::span(binary)));
-}
-
-#else
-TEST(embed_is_not_available_in_older_cpp_versions) {}
-#endif
-
-TEST_MAIN

package/deps/simdutf/tests/find_tests.cpp

@@ -1,77 +0,0 @@
-#include "simdutf.h"
-
-#include <algorithm>
-#include <random>
-#include <vector>
-
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/test.h>
-
-const uint64_t seed = 0x123456789ABCDEF0;
-
-template <typename char_type, typename impl>
-void random_char_search(impl &implementation) {
-  // Random number generator
-  std::random_device rd;
-  std::mt19937 gen(rd());
-
-  // Generate random size between 0 and 1024
-  std::uniform_int_distribution<size_t> size_dist(0, 1024);
-  size_t size = size_dist(gen);
-
-  // Create vector of random characters
-  std::vector<char_type> arr(size);
-  std::uniform_int_distribution<int> char_dist(32, 126);
-
-  for (size_t i = 0; i < size; ++i) {
-    arr[i] = static_cast<char_type>(char_dist(gen));
-  }
-
-  // Pick a random character to search for
-  char_type search_char = static_cast<char_type>(char_dist(gen));
-
-  // Use std::find to search for the character
-  auto result = std::find(arr.data(), arr.data() + size, search_char);
-
-  // Nest use simdutf::find to search for the character
-  auto simd_result =
-      implementation.find(arr.data(), arr.data() + size, search_char);
-  // Check if the results are the same
-  ASSERT_TRUE(simd_result == result);
-  simd_result = simdutf::find(arr.data(), arr.data() + size, search_char);
-  // Check if the results are the same
-  ASSERT_TRUE(simd_result == result);
-}
-
-TEST(random_char_search_char) {
-  for (size_t i = 0; i < 1000; ++i) {
-    random_char_search<char>(implementation);
-  }
-}
-TEST(random_char_search_char16_t) {
-  for (size_t i = 0; i < 1000; ++i) {
-    random_char_search<char16_t>(implementation);
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-TEST(compile_time_find_char) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto s = "ensure find() is constexpr"_latin1;
-  constexpr auto loc = std::distance(
-      s.data(), simdutf::find(s.data(), s.data() + s.size(), 'c'));
-  static_assert(loc == 17);
-}
-
-TEST(compile_time_find_utf16) {
-  using namespace simdutf::tests::helpers;
-  constexpr auto s = u"ensure find() is constexpr"_utf16;
-  constexpr auto loc = std::distance(
-      s.data(), simdutf::find(s.data(), s.data() + s.size(), 'c'));
-  static_assert(loc == 17);
-}
-
-#endif
-
-TEST_MAIN