react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/tests/count_utf16be.cpp

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

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

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

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

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

package/deps/simdutf/tests/embed_tests.cpp

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

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