react-native-quick-crypto 1.0.18 → 1.1.0

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <random>
+#include <vector>
+#include <initializer_list>
+#include <utility>
+#include <cstdint>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+class RandomInt {
+  std::mt19937 gen;
+  std::uniform_int_distribution<uint64_t> distr;
+
+public:
+  RandomInt(uint64_t lo, uint64_t hi, uint64_t seed) noexcept;
+
+  uint32_t operator()() noexcept;
+};
+
+class RandomIntRanges {
+  std::mt19937 gen;
+  using Distribution = std::uniform_int_distribution<uint64_t>;
+
+  Distribution range_index;
+  std::vector<Distribution> ranges;
+
+public:
+  RandomIntRanges(std::initializer_list<std::pair<uint64_t, uint64_t>> ranges,
+                  uint64_t seed) noexcept;
+
+  uint32_t operator()() noexcept;
+};
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,123 @@
+#include "random_utf16.h"
+#include "simdutf.h"
+#include "../reference/encode_utf16.h"
+
+#include <stdexcept>
+#include <vector>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+std::vector<char16_t> random_utf16::generate_le(size_t size) {
+  auto result = generate_counted(size).first;
+  if simdutf_constexpr (!match_system(endianness::LITTLE)) {
+    change_endianness_utf16(result.data(), result.size(), result.data());
+  }
+
+  return result;
+}
+
+void random_utf16::to_ascii_le(std::vector<char16_t> &output) {
+  char16_t mask = 0x7F;
+  if simdutf_constexpr (!match_system(endianness::LITTLE)) {
+    mask = 0x7F00;
+  }
+  for (auto &ch : output) {
+    ch &= mask;
+  }
+}
+
+void random_utf16::to_ascii_be(std::vector<char16_t> &output) {
+  char16_t mask = 0x7F;
+  if simdutf_constexpr (!match_system(endianness::BIG)) {
+    mask = 0x7F00;
+  }
+  for (auto &ch : output) {
+    ch &= mask;
+  }
+}
+
+std::vector<char16_t> random_utf16::generate_be(size_t size) {
+  auto result = generate_counted(size).first;
+  if simdutf_constexpr (!match_system(endianness::BIG)) {
+    change_endianness_utf16(result.data(), result.size(), result.data());
+  }
+
+  return result;
+}
+
+std::vector<char16_t> random_utf16::generate_le(size_t size, long seed) {
+  gen.seed(seed);
+  return generate_le(size);
+}
+
+std::vector<char16_t> random_utf16::generate_be(size_t size, long seed) {
+  gen.seed(seed);
+  return generate_be(size);
+}
+
+std::pair<std::vector<char16_t>, size_t>
+random_utf16::generate_counted_le(size_t size) {
+  auto res = generate_counted(size);
+  if simdutf_constexpr (!match_system(endianness::LITTLE)) {
+    change_endianness_utf16(res.first.data(), res.first.size(),
+                            res.first.data());
+  }
+
+  return res;
+}
+
+std::pair<std::vector<char16_t>, size_t>
+random_utf16::generate_counted_be(size_t size) {
+  auto res = generate_counted(size);
+  if simdutf_constexpr (!match_system(endianness::BIG)) {
+    change_endianness_utf16(res.first.data(), res.first.size(),
+                            res.first.data());
+  }
+
+  return res;
+}
+
+std::pair<std::vector<char16_t>, size_t>
+random_utf16::generate_counted(size_t size) {
+  std::vector<char16_t> result;
+  result.reserve(size);
+
+  char16_t W1;
+  char16_t W2;
+  size_t count{0};
+  while (result.size() < size) {
+    count++;
+    const uint32_t value = generate();
+    switch (simdutf::tests::reference::utf16::encode(value, W1, W2)) {
+    case 0:
+      throw std::runtime_error("Random UTF-16 generator is broken");
+    case 1:
+      result.push_back(W1);
+      break;
+    case 2:
+      result.push_back(W1);
+      result.push_back(W2);
+      break;
+    }
+  }
+  return make_pair(result, count);
+}
+
+uint32_t random_utf16::generate() {
+  switch (utf16_length(gen)) {
+  case 0:
+    return single_word0(gen);
+  case 1:
+    return single_word1(gen);
+  case 2:
+    return two_words(gen);
+  default:
+    abort();
+  }
+}
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <random>
+#include <vector>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+/*
+  Generates valid random UTF-16LE
+
+  It might generate streams consisting:
+  - only single 16-bit code units (random_utf16(..., 1, 0));
+  - only surrogate pairs, two 16-bit code units (random_utf16(..., 0, 1))
+  - mixed, depending on given probabilities (random_utf16(..., 1, 1))
+*/
+class random_utf16 {
+  std::mt19937 gen;
+
+public:
+  random_utf16(uint32_t seed, int single_word_prob, int two_words_probability)
+      : gen{seed},
+        utf16_length({double(single_word_prob), double(single_word_prob),
+                      double(2 * two_words_probability)}) {}
+
+  std::vector<char16_t> generate_le(size_t size);
+  std::vector<char16_t> generate_be(size_t size);
+  std::vector<char16_t> generate_le(size_t size, long seed);
+  std::vector<char16_t> generate_be(size_t size, long seed);
+  std::pair<std::vector<char16_t>, size_t> generate_counted_le(size_t size);
+  std::pair<std::vector<char16_t>, size_t> generate_counted_be(size_t size);
+
+  static void to_ascii_le(std::vector<char16_t> &output);
+  static void to_ascii_be(std::vector<char16_t> &output);
+
+private:
+  std::pair<std::vector<char16_t>, size_t> generate_counted(size_t size);
+
+private:
+  std::discrete_distribution<> utf16_length;
+  std::uniform_int_distribution<uint32_t> single_word0{0x00000000, 0x0000d7ff};
+  std::uniform_int_distribution<uint32_t> single_word1{0x0000e000, 0x0000ffff};
+  std::uniform_int_distribution<uint32_t> two_words{0x00010000, 0x0010ffff};
+  uint32_t generate();
+};
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,41 @@
+#include "random_utf32.h"
+
+#include <vector>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+std::vector<char32_t> random_utf32::generate(size_t size) {
+
+  std::vector<char32_t> result;
+  result.reserve(size);
+
+  size_t count{0};
+  for (; count < size; count++) {
+    const uint32_t value = generate();
+    result.push_back(value);
+  }
+
+  return result;
+}
+
+std::vector<char32_t> random_utf32::generate(size_t size, long seed) {
+  gen.seed(seed);
+  return generate(size);
+}
+
+uint32_t random_utf32::generate() {
+  switch (range(gen)) {
+  case 0:
+    return first_range(gen);
+  case 1:
+    return second_range(gen);
+  default:
+    abort();
+  }
+}
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <random>
+#include <vector>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+constexpr int32_t number_code_points = 0x0010ffff - (0xdfff - 0xd800);
+constexpr int32_t length_first_range = 0x0000d7ff;
+constexpr int32_t length_second_range = 0x0010ffff - 0x0000e000;
+/*
+  Generates valid random UTF-32
+*/
+class random_utf32 {
+  std::mt19937 gen;
+
+public:
+  random_utf32(uint32_t seed)
+      : gen{seed},
+        range({double(length_first_range) / double(number_code_points),
+               double(length_second_range) / double(number_code_points)}) {}
+  // Uniformly randomize over the two ranges
+
+  std::vector<char32_t> generate(size_t size);
+  std::vector<char32_t> generate(size_t size, long seed);
+
+private:
+  std::discrete_distribution<> range;
+  std::uniform_int_distribution<uint32_t> first_range{0x00000000, 0x0000d7ff};
+  std::uniform_int_distribution<uint32_t> second_range{0x0000e000, 0x0010ffff};
+  uint32_t generate();
+};
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,93 @@
+#include "random_utf8.h"
+
+#include <vector>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+random_utf8::random_utf8(uint32_t seed, int prob_1byte, int prob_2bytes,
+                         int prob_3bytes, int prob_4bytes)
+    : gen(seed), bytes_count({double(prob_1byte), double(prob_2bytes),
+                              double(prob_3bytes), double(prob_4bytes)}) {}
+
+std::pair<std::vector<uint8_t>, size_t>
+random_utf8::generate_counted(size_t output_bytes) {
+  std::vector<uint8_t> result;
+  result.reserve(output_bytes);
+  uint8_t candidate, head;
+  size_t count{0};
+  while (result.size() < output_bytes) {
+    count++;
+    switch (bytes_count(gen)) {
+    case 0: // 1 byte
+      candidate = uint8_t(val_7bit(gen));
+      while (candidate == 0) { // though strictly speaking, a stream of nulls is
+                               // UTF8, it tends to break some code
+        candidate = uint8_t(val_7bit(gen));
+      }
+      result.push_back(candidate);
+      break;
+    case 1: // 2 bytes
+      candidate = 0xc0 | uint8_t(val_5bit(gen));
+      while (candidate < 0xC2) {
+        candidate = 0xc0 | uint8_t(val_5bit(gen));
+      }
+      result.push_back(candidate);
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      break;
+    case 2: // 3 bytes
+      head = 0xe0 | uint8_t(val_4bit(gen));
+      result.push_back(head);
+      candidate = 0x80 | uint8_t(val_6bit(gen));
+      if (head == 0xE0) {
+        while (candidate < 0xA0) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      } else if (head == 0xED) {
+        while (candidate > 0x9F) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      }
+      result.push_back(candidate);
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      break;
+    case 3: // 4 bytes
+      head = 0xf0 | uint8_t(val_3bit(gen));
+      while (head > 0xF4) {
+        head = 0xf0 | uint8_t(val_3bit(gen));
+      }
+      result.push_back(head);
+      candidate = 0x80 | uint8_t(val_6bit(gen));
+      if (head == 0xF0) {
+        while (candidate < 0x90) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      } else if (head == 0xF4) {
+        while (candidate > 0x8F) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      }
+      result.push_back(candidate);
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      break;
+    }
+  }
+  result.push_back(0); // EOS for scalar code
+
+  return make_pair(result, count);
+}
+
+std::vector<uint8_t> random_utf8::generate(size_t output_bytes) {
+  return generate_counted(output_bytes).first;
+}
+
+std::vector<uint8_t> random_utf8::generate(size_t output_bytes, long seed) {
+  gen.seed(uint32_t(seed));
+  return generate(output_bytes);
+}
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <random>
+#include <vector>
+
+namespace simdutf {
+namespace tests {
+namespace helpers {
+
+class random_utf8 final {
+public:
+  random_utf8(uint32_t seed, int prob_1byte, int prob_2bytes, int prob_3bytes,
+              int prob_4bytes);
+
+  std::vector<uint8_t> generate(size_t output_bytes);
+  // include the number of code points
+  std::pair<std::vector<uint8_t>, size_t> generate_counted(size_t output_bytes);
+  std::vector<uint8_t> generate(size_t output_bytes, long seed);
+
+private:
+  uint32_t generate();
+
+  std::mt19937 gen;
+  std::discrete_distribution<> bytes_count;
+  std::uniform_int_distribution<int> val_7bit{0x00, 0x7f}; // 0b0xxxxxxx
+  std::uniform_int_distribution<int> val_6bit{0x00, 0x3f}; // 0b10xxxxxx
+  std::uniform_int_distribution<int> val_5bit{0x00, 0x1f}; // 0b110xxxxx
+  std::uniform_int_distribution<int> val_4bit{0x00, 0x0f}; // 0b1110xxxx
+  std::uniform_int_distribution<int> val_3bit{0x00, 0x07}; // 0b11110xxx
+};
+
+} // namespace helpers
+} // namespace tests
+} // namespace simdutf

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

@@ -0,0 +1,231 @@
+#include "test.h"
+
+#include <cstdlib>
+#include <stdexcept>
+#include <cstdio>
+
+auto simdutf::test::CommandLine::parse(int argc, char *argv[])
+    -> simdutf::test::CommandLine {
+  CommandLine cmdline;
+  cmdline.seed = 42;
+
+  std::list<std::string> args;
+  for (int i = 1; i < argc; i++) {
+    std::string arg{argv[i]};
+    if ((arg == "-h") || (arg == "--help")) {
+      cmdline.show_help = true;
+      return cmdline;
+    }
+
+    if ((arg == "--show-architectures") or (arg == "-A")) {
+      cmdline.show_architectures = true;
+      continue;
+    }
+
+    if ((arg == "--show-tests") or (arg == "-l")) {
+      cmdline.show_tests = true;
+      continue;
+    }
+
+    args.push_back(std::move(arg));
+  }
+
+  if (cmdline.show_tests or cmdline.show_architectures) {
+    return cmdline;
+  }
+
+  while (not args.empty()) {
+    const auto arg = args.front();
+    args.pop_front();
+
+    if ((arg == "-a") or (arg == "--arch")) {
+      if (args.empty()) {
+        throw std::invalid_argument("Expected architecture name after " + arg);
+      }
+
+      cmdline.architectures.insert(args.front());
+      args.pop_front();
+    } else if ((arg == "-t") or (arg == "--test")) {
+      if (args.empty()) {
+        throw std::invalid_argument("Expected test name after " + arg);
+      }
+
+      cmdline.tests.push_back(args.front());
+      args.pop_front();
+    } else if ((arg == "-s") or (arg == "--seed")) {
+      if (args.empty()) {
+        throw std::invalid_argument("Expected seed value " + arg);
+      }
+
+      try {
+        cmdline.seed = std::stoi(args.front());
+      } catch (const std::exception &e) {
+        throw std::invalid_argument("Wrong number after " + arg);
+      }
+      args.pop_front();
+    } else {
+      throw std::invalid_argument("Unknown argument '" + arg + "'");
+    }
+  }
+
+  return cmdline;
+}
+
+void print_help(FILE *file) {
+  fputs(R"txt(
+Test utility for simdutf
+
+Usage:
+
+    -h, --help                      show help
+    -A, --show-architectures        show available architectures
+    -l, --show-tests                show name of available tests
+    -a [ARCH], --arch [ARCH]        run tests only for selected architecture(s)
+    -t [TEST], --test [TEST]        run tests matching all given strings
+    -s [SEED], --seed [SEED]        set the random seed
+
+Examples:
+
+    # Test haswell implementations with tests having strings 'convert'
+    # and 'utf8' in their name -- for instance 'convert_utf8_to_utf16' and
+    # 'convert_utf16_to_utf8'.
+
+    $ test --arch haswell --test convert --test utf8
+)txt",
+        file);
+}
+
+void print_help() { print_help(stdout); }
+
+void print_architectures(FILE *file) {
+#if SIMDUTF_IS_BIG_ENDIAN
+  fprintf(file, "Big-endian system detected.\n");
+#else
+  fprintf(file, "Little-endian system detected.\n");
+#endif
+  fprintf(file, "Available implementations:\n");
+  for (const auto &implementation : simdutf::get_available_implementations()) {
+    if (implementation == nullptr) {
+      puts("implementation is null which is unexpected.");
+      abort();
+    }
+    if (implementation->supported_by_runtime_system()) {
+      fprintf(file, "- %s\n", implementation->name().c_str());
+    } else {
+      fprintf(file, "- %s [unsupported by current processor]\n",
+              implementation->name().c_str());
+    }
+  }
+}
+
+void print_architectures() { print_architectures(stdout); }
+
+void print_tests(FILE *file) {
+  fprintf(file, "Available tests:\n");
+  for (const auto &test : simdutf::test::test_procedures()) {
+    fprintf(file, "- %s\n", test.name.c_str());
+  }
+}
+
+void print_tests() { print_tests(stdout); }
+
+namespace simdutf {
+namespace test {
+
+void test_entry::operator()(const simdutf::implementation &impl) {
+  std::string title = name;
+  std::replace(title.begin(), title.end(), '_', ' ');
+  printf("Running '%s'... ", title.c_str());
+  fflush(stdout);
+  procedure(impl);
+  puts(" OK");
+}
+
+void run(const CommandLine &cmdline) {
+  if (cmdline.show_help) {
+    print_help();
+    return;
+  }
+
+  if (cmdline.show_architectures) {
+    print_architectures();
+    return;
+  }
+
+  if (cmdline.show_tests) {
+    print_tests();
+    return;
+  }
+  size_t matching_implementation{0};
+
+  for (const auto &implementation : simdutf::get_available_implementations()) {
+    if (implementation == nullptr) {
+      puts("implementation is null which is unexpected");
+      abort();
+    }
+    if (!implementation->supported_by_runtime_system()) {
+      printf("Implementation %s is unsupported by the current processor.\n",
+             implementation->name().c_str());
+      continue;
+    }
+    if (not cmdline.architectures.empty()) {
+      if (cmdline.architectures.count(implementation->name()) == 0) {
+        continue;
+      }
+    }
+    matching_implementation++;
+
+    printf("Checking implementation %s\n", implementation->name().c_str());
+
+    auto filter = [&cmdline](const simdutf::test::test_entry &test) -> bool {
+      if (cmdline.tests.empty())
+        return true;
+
+      for (const auto &str : cmdline.tests) {
+        if (test.name.find(str) != std::string::npos)
+          return true;
+      }
+
+      return false;
+    };
+
+    for (auto test : simdutf::test::test_procedures()) {
+      if (filter(test)) {
+        test(*implementation);
+      }
+    }
+  }
+  if (matching_implementation == 0) {
+    throw std::runtime_error("not a single compatible implementation found");
+  }
+}
+
+std::list<test_entry> &test_procedures() {
+  static std::list<test_entry> singleton;
+
+  return singleton;
+}
+
+register_test::register_test(const char *name, test_procedure proc) {
+  test_procedures().push_back({name, proc});
+}
+
+int main(int argc, char *argv[]) {
+  try {
+    const auto cmdline = CommandLine::parse(argc, argv);
+
+    run(cmdline);
+
+  } catch (const std::exception &e) {
+    fprintf(stderr, "Error: %s\n", e.what());
+    return EXIT_FAILURE;
+  } catch (...) {
+    fprintf(stderr, "Unknown error\n");
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
+
+} // namespace test
+} // namespace simdutf