react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/reference/validate_utf16_to_latin1.cpp

@@ -0,0 +1,35 @@
+#include "validate_utf16.h"
+
+#ifndef SIMDUTF_IS_BIG_ENDIAN
+  #error "SIMDUTF_IS_BIG_ENDIAN should be defined."
+#endif
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool
+validate_utf16_to_latin1(simdutf::endianness utf16_endianness,
+                         const char16_t *buf, size_t len) noexcept {
+  const char16_t *curr = buf;
+  const char16_t *end = buf + len;
+
+  while (curr != end) {
+    uint16_t W1;
+    if (!match_system(utf16_endianness)) {
+      W1 = (uint16_t(*curr) << 8) | (uint16_t(*curr) >> 8);
+    } else {
+      W1 = *curr;
+    }
+
+    curr += 1;
+    if (0xff < W1) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf16_to_latin1.h

@@ -0,0 +1,13 @@
+#include "simdutf/common_defs.h"
+#include "simdutf/encoding_types.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+simdutf_warn_unused bool
+validate_utf16_to_latin1(simdutf::endianness utf16_endianness,
+                         const char16_t *buf, size_t len) noexcept;
+
+}
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf32.cpp

@@ -0,0 +1,27 @@
+#include "validate_utf32.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool validate_utf32(const char32_t *buf,
+                                        size_t len) noexcept {
+  const char32_t *curr = buf;
+  const char32_t *end = buf + len;
+
+  while (curr != end) {
+    const uint32_t word = *curr;
+
+    if (word > 0x10FFFF || (word >= 0xD800 && word <= 0xDFFF)) {
+      return false;
+    }
+
+    curr++;
+  }
+
+  return true;
+}
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf32.h

@@ -0,0 +1,12 @@
+#include "simdutf/common_defs.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool validate_utf32(const char32_t *buf,
+                                        size_t len) noexcept;
+
+}
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf32_to_latin1.cpp

@@ -0,0 +1,27 @@
+#include "validate_utf32.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool validate_utf32_to_latin1(const char32_t *buf,
+                                                  size_t len) noexcept {
+  const char32_t *curr = buf;
+  const char32_t *end = buf + len;
+
+  while (curr != end) {
+    const uint32_t word = *curr;
+
+    if (word > 0xFF) {
+      return false;
+    }
+
+    curr++;
+  }
+
+  return true;
+}
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf32_to_latin1.h

@@ -0,0 +1,12 @@
+#include "simdutf/common_defs.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool validate_utf32_to_latin1(const char32_t *buf,
+                                                  size_t len) noexcept;
+
+}
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf8.cpp

@@ -0,0 +1,82 @@
+#include "validate_utf8.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+// credit: based on code from Google Fuchsia (Apache Licensed)
+simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) noexcept {
+  const uint8_t *data = (const uint8_t *)buf;
+  uint64_t pos = 0;
+  uint64_t next_pos = 0;
+  uint32_t code_point = 0;
+  while (pos < len) {
+    unsigned char byte = data[pos];
+    if (byte < 0b10000000) {
+      pos++;
+      continue;
+    } else if ((byte & 0b11100000) == 0b11000000) {
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if (code_point < 0x80 || 0x7ff < code_point) {
+        return false;
+      }
+    } else if ((byte & 0b11110000) == 0b11100000) {
+      next_pos = pos + 3;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00001111) << 12 |
+                   (data[pos + 1] & 0b00111111) << 6 |
+                   (data[pos + 2] & 0b00111111);
+      if (code_point < 0x800 || 0xffff < code_point ||
+          (0xd7ff < code_point && code_point < 0xe000)) {
+        return false;
+      }
+    } else if ((byte & 0b11111000) == 0b11110000) { // 0b11110000
+      next_pos = pos + 4;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point =
+          (byte & 0b00000111) << 18 | (data[pos + 1] & 0b00111111) << 12 |
+          (data[pos + 2] & 0b00111111) << 6 | (data[pos + 3] & 0b00111111);
+      if (code_point <= 0xffff || 0x10ffff < code_point) {
+        return false;
+      }
+    } else {
+      // we may have a continuation
+      return false;
+    }
+    pos = next_pos;
+  }
+  return true;
+}
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf8.h

@@ -0,0 +1,11 @@
+#include "simdutf/common_defs.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) noexcept;
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf8_to_latin1.cpp

@@ -0,0 +1,43 @@
+#include "validate_utf8_to_latin1.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+// credit: based on code from Google Fuchsia (Apache Licensed)
+simdutf_warn_unused bool validate_utf8_to_latin1(const char *buf,
+                                                 size_t len) noexcept {
+  const uint8_t *data = (const uint8_t *)buf;
+  uint64_t pos = 0;
+  uint64_t next_pos = 0;
+  uint32_t code_point = 0;
+  while (pos < len) {
+    unsigned char byte = data[pos];
+    if (byte < 0b10000000) { // ASCII
+      pos++;
+      continue;
+    } else if ((byte & 0b11100000) == 0b11000000) { // two bytes
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return false;
+      } // EOF thus no continuation byte :(
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) { // No continuation byte
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if (code_point < 0x80 || 0xff < code_point) {
+        return false;
+      }
+    } else {
+      // we may have a continuation
+      return false;
+    }
+    pos = next_pos;
+  }
+  return true;
+}
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/reference/validate_utf8_to_latin1.h

@@ -0,0 +1,12 @@
+#include "simdutf/common_defs.h"
+
+namespace simdutf {
+namespace tests {
+namespace reference {
+
+simdutf_warn_unused bool validate_utf8_to_latin1(const char *buf,
+                                                 size_t len) noexcept;
+
+} // namespace reference
+} // namespace tests
+} // namespace simdutf

package/deps/simdutf/tests/select_implementation.cpp

@@ -0,0 +1,43 @@
+#include "simdutf.h"
+
+#include <cstdlib>
+#include <cstdio>
+#include <string>
+
+int main() {
+  // This is just a demonstration, not actual testing required.
+  std::string source = "La vie est belle.";
+  std::string chosen_implementation;
+  for (auto &implementation : simdutf::get_available_implementations()) {
+    if (!implementation->supported_by_runtime_system()) {
+      continue;
+    }
+    bool validutf8 =
+        implementation->validate_utf8(source.c_str(), source.size());
+    if (!validutf8) {
+      return EXIT_FAILURE;
+    }
+    printf("%s: %s\n", implementation->name().c_str(),
+           implementation->description().c_str());
+    chosen_implementation = implementation->name();
+  }
+  auto my_implementation =
+      simdutf::get_available_implementations()[chosen_implementation];
+  if (!my_implementation) {
+    return EXIT_FAILURE;
+  }
+  if (!my_implementation->supported_by_runtime_system()) {
+    return EXIT_FAILURE;
+  }
+  simdutf::get_active_implementation() = my_implementation;
+  bool validutf8 = simdutf::validate_utf8(source.c_str(), source.size());
+  if (!validutf8) {
+    return EXIT_FAILURE;
+  }
+  if (simdutf::get_active_implementation()->name() != chosen_implementation) {
+    return EXIT_FAILURE;
+  }
+  printf("Manually selected: %s\n",
+         simdutf::get_active_implementation()->name().c_str());
+  return EXIT_SUCCESS;
+}

package/deps/simdutf/tests/simdutf_c_tests.cpp

@@ -0,0 +1,244 @@
+#include <tests/helpers/test.h>
+#include <cstring>
+#include "simdutf_c.h"
+
+const char *hello = "hello";
+const size_t hello_len = 5;
+
+TEST(validate_utf8_c) {
+  bool ok = simdutf_validate_utf8(hello, hello_len);
+  ASSERT_TRUE(ok);
+  simdutf_result r = simdutf_validate_utf8_with_errors(hello, hello_len);
+  ASSERT_EQUAL(r.error, SIMDUTF_ERROR_SUCCESS);
+  ASSERT_EQUAL(r.count, hello_len);
+}
+
+TEST(convert_utf8_to_utf16_c) {
+  char16_t out[16];
+  size_t n = simdutf_convert_utf8_to_utf16(hello, hello_len, out);
+  ASSERT_EQUAL(n, hello_len);
+  for (size_t i = 0; i < n; i++) {
+    ASSERT_EQUAL(out[i], char16_t(hello[i]));
+  }
+}
+
+TEST(convert_utf8_to_utf32_c) {
+  char32_t out[16];
+  size_t n = simdutf_convert_utf8_to_utf32(hello, hello_len, out);
+  ASSERT_EQUAL(n, hello_len);
+  for (size_t i = 0; i < n; i++) {
+    ASSERT_EQUAL(out[i], char32_t(hello[i]));
+  }
+}
+
+TEST(count_utf8_c) {
+  size_t cnt = simdutf_count_utf8(hello, hello_len);
+  ASSERT_EQUAL(cnt, hello_len);
+}
+
+TEST(find_c) {
+  const char *f = simdutf_find(hello, hello + hello_len, 'e');
+  ASSERT_EQUAL(f, hello + 1);
+}
+
+TEST(base64_c) {
+  const char *b64 = "aGVsbG8="; // "hello"
+  char binout[16] = {0};
+  size_t outlen = sizeof(binout);
+  simdutf_result br = simdutf_base64_to_binary_safe(
+      b64, strlen(b64), binout, &outlen, SIMDUTF_BASE64_DEFAULT,
+      SIMDUTF_LAST_CHUNK_LOOSE, true);
+  ASSERT_EQUAL(br.error, SIMDUTF_ERROR_SUCCESS);
+  ASSERT_EQUAL(outlen, hello_len);
+  ASSERT_TRUE(std::memcmp(binout, "hello", hello_len) == 0);
+
+  char b64out[32] = {0};
+  size_t b64len = simdutf_binary_to_base64("hello", hello_len, b64out,
+                                           SIMDUTF_BASE64_DEFAULT);
+  ASSERT_TRUE(b64len >= 8);
+}
+
+TEST(ascii_and_detect_c) {
+  ASSERT_TRUE(simdutf_validate_ascii(hello, hello_len));
+  simdutf_result r = simdutf_validate_ascii_with_errors(hello, hello_len);
+  ASSERT_EQUAL(r.error, SIMDUTF_ERROR_SUCCESS);
+
+  simdutf_encoding_type et = simdutf_autodetect_encoding(hello, hello_len);
+  ASSERT_EQUAL(et, SIMDUTF_ENCODING_UTF8);
+  int encs = simdutf_detect_encodings(hello, hello_len);
+  ASSERT_TRUE(encs >= 0);
+}
+
+TEST(lengths_and_conversions_c) {
+  char latin_out[8] = {0};
+  size_t latin_to_utf8 = simdutf_convert_latin1_to_utf8("abc", 3, latin_out);
+  ASSERT_EQUAL(latin_to_utf8, 3);
+
+  // prepare a UTF-16 sample
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  size_t u16len = simdutf_utf8_length_from_utf16(u16, 5);
+
+  // convert utf16->utf8 safe
+  char out8[8] = {0};
+  size_t safelen =
+      simdutf_convert_utf16_to_utf8_safe(u16, 5, out8, sizeof(out8));
+  ASSERT_EQUAL(safelen, u16len);
+
+  // convert with errors
+  simdutf_result cr = simdutf_convert_utf16_to_utf8_with_errors(u16, 5, out8);
+  ASSERT_EQUAL(cr.error, SIMDUTF_ERROR_SUCCESS);
+}
+
+TEST(counts_and_find_utf16_c) {
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  size_t c16 = simdutf_count_utf16(u16, 5);
+  ASSERT_EQUAL(c16, 5);
+
+  const char16_t *f16 = simdutf_find_utf16(u16, u16 + 5, u'e');
+  if (f16 == nullptr) {
+    ASSERT_TRUE(false); // should not be null
+  } else {
+    if (f16 != u16 + 1) {
+      ASSERT_TRUE(false); // should point to second character
+    }
+  }
+}
+
+TEST(validate_utf16_c) {
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  bool ok = simdutf_validate_utf16(u16, 5);
+  ASSERT_TRUE(ok);
+  simdutf_result r = simdutf_validate_utf16_with_errors(u16, 5);
+  ASSERT_EQUAL(r.error, SIMDUTF_ERROR_SUCCESS);
+  ASSERT_EQUAL(r.count, 5);
+}
+
+TEST(validate_utf32_c) {
+  char32_t u32[5] = {U'h', U'e', U'l', U'l', U'o'};
+  bool ok = simdutf_validate_utf32(u32, 5);
+  ASSERT_TRUE(ok);
+  simdutf_result r = simdutf_validate_utf32_with_errors(u32, 5);
+  ASSERT_EQUAL(r.error, SIMDUTF_ERROR_SUCCESS);
+  ASSERT_EQUAL(r.count, 5);
+}
+
+TEST(convert_utf16_to_utf8_c) {
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  char out[8] = {0};
+  size_t n = simdutf_convert_utf16_to_utf8(u16, 5, out);
+  ASSERT_EQUAL(n, 5);
+  ASSERT_TRUE(std::memcmp(out, "hello", 5) == 0);
+}
+
+TEST(convert_utf32_to_utf8_c) {
+  char32_t u32[5] = {U'h', U'e', U'l', U'l', U'o'};
+  char out[8] = {0};
+  size_t n = simdutf_convert_utf32_to_utf8(u32, 5, out);
+  ASSERT_EQUAL(n, 5);
+  ASSERT_TRUE(std::memcmp(out, "hello", 5) == 0);
+}
+
+TEST(convert_utf16_to_utf32_c) {
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  char32_t out[8] = {0};
+  size_t n = simdutf_convert_utf16_to_utf32(u16, 5, out);
+  ASSERT_EQUAL(n, 5);
+  for (size_t i = 0; i < n; i++) {
+    ASSERT_EQUAL(out[i], char32_t(u16[i]));
+  }
+}
+
+TEST(convert_utf8_to_latin1_c) {
+  const char *input = "hello";
+  char out[8] = {0};
+  size_t n = simdutf_convert_utf8_to_latin1(input, 5, out);
+  ASSERT_EQUAL(n, 5);
+  ASSERT_TRUE(std::memcmp(out, "hello", 5) == 0);
+}
+
+TEST(convert_latin1_to_utf16_c) {
+  const char *input = "abc";
+  char16_t out[8] = {0};
+  size_t n = simdutf_convert_latin1_to_utf16(input, 3, out);
+  ASSERT_EQUAL(n, 3);
+  for (size_t i = 0; i < n; i++) {
+    ASSERT_EQUAL(out[i], char16_t(input[i]));
+  }
+}
+
+TEST(to_well_formed_utf16_c) {
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  char16_t out[8] = {0};
+  simdutf_to_well_formed_utf16(u16, 5, out);
+  // Since input is valid, output should be the same
+  for (size_t i = 0; i < 5; i++) {
+    ASSERT_EQUAL(out[i], u16[i]);
+  }
+}
+
+TEST(invalid_utf8_c) {
+  const char *invalid = "\xff\xfe"; // invalid UTF-8
+  bool ok = simdutf_validate_utf8(invalid, 2);
+  ASSERT_FALSE(ok);
+  simdutf_result r = simdutf_validate_utf8_with_errors(invalid, 2);
+  ASSERT_EQUAL(r.error, SIMDUTF_ERROR_HEADER_BITS);
+}
+
+TEST(base64_utf16_c) {
+  const char16_t *b64_u16 = u"aGVsbG8="; // "hello" in base64, as UTF-16
+  char binout[16] = {0};
+  size_t outlen = sizeof(binout);
+  simdutf_result br = simdutf_base64_to_binary_safe_utf16(
+      b64_u16, 8, binout, &outlen, SIMDUTF_BASE64_DEFAULT,
+      SIMDUTF_LAST_CHUNK_LOOSE, true);
+  ASSERT_EQUAL(br.error, SIMDUTF_ERROR_SUCCESS);
+  ASSERT_EQUAL(outlen, hello_len);
+  ASSERT_TRUE(std::memcmp(binout, "hello", hello_len) == 0);
+}
+
+TEST(base64_length_helpers_c) {
+  size_t maxbin = simdutf_maximal_binary_length_from_base64("aGVsbG8=", 8);
+  ASSERT_TRUE(maxbin >= 5);
+
+  size_t b64len = simdutf_base64_length_from_binary(5, SIMDUTF_BASE64_DEFAULT);
+  ASSERT_TRUE(b64len >= 8);
+
+  size_t with_lines = simdutf_base64_length_from_binary_with_lines(
+      5, SIMDUTF_BASE64_DEFAULT, 4);
+  ASSERT_TRUE(with_lines >= b64len);
+
+  char out[64] = {0};
+  size_t bl = simdutf_binary_to_base64_with_lines("hello", 5, out, 4,
+                                                  SIMDUTF_BASE64_DEFAULT);
+  ASSERT_TRUE(bl > 0);
+}
+
+TEST(length_calculations_c) {
+  // Test utf8_length_from_utf16
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  size_t utf8_len = simdutf_utf8_length_from_utf16(u16, 5);
+  ASSERT_EQUAL(utf8_len, 5);
+
+  // Test utf16_length_from_utf8
+  const char *utf8 = "hello";
+  size_t utf16_len = simdutf_utf16_length_from_utf8(utf8, 5);
+  ASSERT_EQUAL(utf16_len, 5);
+
+  // Test utf32_length_from_utf8
+  size_t utf32_len = simdutf_utf32_length_from_utf8(utf8, 5);
+  ASSERT_EQUAL(utf32_len, 5);
+
+  // Test latin1_length_from_utf8
+  size_t latin1_len = simdutf_latin1_length_from_utf8(utf8, 5);
+  ASSERT_EQUAL(latin1_len, 5);
+}
+
+TEST(convert_utf16_c) {
+  char16_t u16[5] = {u'h', u'e', u'l', u'l', u'o'};
+  char out[8] = {0};
+  size_t n = simdutf_convert_utf16_to_utf8(u16, 5, out);
+  ASSERT_EQUAL(n, 5);
+  ASSERT_TRUE(std::memcmp(out, "hello", 5) == 0);
+}
+
+TEST_MAIN