react-native-quick-crypto 1.1.0 → 1.1.1

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

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

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

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

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

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

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

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

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