react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/installation_tests/find/CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(test_simdutf_install VERSION 0.1.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(MSVC_VERSION GREATER 1910)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -permissive-")
+endif()
+find_package(simdutf REQUIRED)
+
+
+
+file(WRITE main.cpp "
+#include <iostream>
+#include \"simdutf.h\"
+
+int main(int argc, char *argv[]) {
+   const char * ascii = \"1234\";
+   bool validutf8 = simdutf::validate_utf8(ascii, 4);
+   if(validutf8) {
+       std::cout << \"valid UTF-8\" << std::endl;
+   } else {
+       std::cout << \"invalid UTF-8\" << std::endl;
+       return EXIT_FAILURE;
+   }
+   char16_t utf16_output[4];
+   // convert to UTF-16LE
+   size_t utf16words = simdutf::convert_utf8_to_utf16le(ascii, 4, utf16_output);
+   std::cout << \"wrote \" << utf16words << \" UTF-16 code units.\" << std::endl;
+   // It wrote utf16words * sizeof(char16_t) bytes.
+   //
+   // convert it back:
+   char buffer[4];
+   size_t utf8words = simdutf::convert_utf16le_to_utf8(utf16_output, utf16words, buffer);
+   std::cout << \"wrote \" << utf8words << \" UTF-8 code units.\" << std::endl;
+   return EXIT_SUCCESS;
+}")
+
+
+
+add_executable(repro main.cpp)
+target_link_libraries(repro PUBLIC simdutf::simdutf)

package/deps/simdutf/tests/installation_tests/from_fetch/CMakeLists.txt

@@ -0,0 +1,47 @@
+
+cmake_minimum_required(VERSION 3.15)
+
+project(simdutf_demo_install VERSION 0.1.0 LANGUAGES CXX)
+
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+include(FetchContent)
+
+FetchContent_Declare(
+  simdutf
+  GIT_REPOSITORY git@github.com:simdutf/simdutf.git
+  GIT_SHALLOW TRUE
+  GIT_TAG tags/v3.2.7
+  )
+FetchContent_MakeAvailable(simdutf)
+
+file(WRITE main.cpp "
+#include <iostream>
+#include \"simdutf.h\"
+int main(int argc, char *argv[]) {
+   const char * ascii = \"1234\";
+   bool validutf8 = simdutf::validate_utf8(ascii, 4);
+   if(validutf8) {
+       std::cout << \"valid UTF-8\" << std::endl;
+   } else {
+       std::cout << \"invalid UTF-8\" << std::endl;
+       return EXIT_FAILURE;
+   }
+   char16_t utf16_output[4];
+   // convert to UTF-16LE
+   size_t utf16words = simdutf::convert_utf8_to_utf16le(ascii, 4, utf16_output);
+   std::cout << \"wrote \" << utf16words << \" UTF-16 code units.\" << std::endl;
+   // It wrote utf16words * sizeof(char16_t) bytes.
+   //
+   // convert it back:
+   char buffer[4];
+   size_t utf8words = simdutf::convert_utf16le_to_utf8(utf16_output, utf16words, buffer);
+   std::cout << \"wrote \" << utf8words << \" UTF-8 code units.\" << std::endl;
+   return EXIT_SUCCESS;
+}")
+
+
+
+add_executable(repro main.cpp)
+target_link_libraries(repro PUBLIC simdutf::simdutf)

package/deps/simdutf/tests/internal_tests.cpp

@@ -0,0 +1,27 @@
+#include "simdutf.h"
+
+#include <tests/helpers/test.h>
+
+int main(int argc, char *argv[]) {
+#ifdef SIMDUTF_INTERNAL_TESTS
+  bool any_added = false;
+  for (const auto &implementation : simdutf::get_available_implementations()) {
+    for (const auto &test : implementation->internal_tests()) {
+      simdutf::test::test_procedures().push_back(simdutf::test::test_entry{
+          test.name,
+          test.procedure,
+      });
+      any_added = true;
+    }
+  }
+
+  if (not any_added) {
+    puts("None of implementations provides internal tests, skipping.");
+    return 0;
+  }
+
+  const auto cmdline = simdutf::test::CommandLine::parse(argc, argv);
+  simdutf::test::run(cmdline);
+#endif
+  return 0;
+}

package/deps/simdutf/tests/null_safety_tests.cpp

@@ -0,0 +1,94 @@
+#include "simdutf.h"
+
+#include <vector>
+
+#include <tests/helpers/test.h>
+TEST(test_empty) {
+  // zero storage size gives a nullptr as input which is of interest to test
+  for (std::size_t inputstoragesize : {0, 1}) {
+    // inputs
+    const std::vector<char> i8data(inputstoragesize);
+    const std::vector<char16_t> i16data(inputstoragesize);
+    const std::vector<char32_t> i32data(inputstoragesize);
+    // outputs
+    std::vector<char> o8data;
+    std::vector<char16_t> o16data;
+    std::vector<char32_t> o32data;
+
+    const auto *i8 = i8data.data();
+    const auto *i16 = i16data.data();
+    const auto *i32 = i32data.data();
+    auto *o8 = o8data.data();
+    auto *o16 = o16data.data();
+    auto *o32 = o32data.data();
+
+    // empty input is interpreted as utf-8
+    ASSERT_EQUAL(simdutf::encoding_type::UTF8,
+                 implementation.autodetect_encoding(i8, 0));
+    ASSERT_EQUAL(0, simdutf::base64_length_from_binary(0));
+
+    auto test_base64 = [](const simdutf::result &r) {
+      ASSERT_EQUAL(r.count, 0);
+      ASSERT_EQUAL(r.error, simdutf::error_code::SUCCESS);
+    };
+
+    test_base64(implementation.base64_to_binary(i16, 0, o8));
+    test_base64(implementation.base64_to_binary(i8, 0, o8));
+    ASSERT_EQUAL(0, implementation.binary_to_base64(i8, 0, o8));
+
+    /* returns void */ implementation.change_endianness_utf16(i16, 0, o16);
+    ASSERT_EQUAL(0, implementation.convert_latin1_to_utf16be(i8, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_latin1_to_utf16le(i8, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_utf32_to_utf16be(i32, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_utf32_to_utf16le(i32, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_utf8_to_utf16be(i8, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_utf8_to_utf16le(i8, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf16be_to_latin1(i16, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf16be_to_utf32(i16, 0, o32));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf16be_to_utf8(i16, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf16le_to_latin1(i16, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf16le_to_utf32(i16, 0, o32));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf16le_to_utf8(i16, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf32_to_latin1(i32, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf32_to_utf16be(i32, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf32_to_utf16le(i32, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf32_to_utf8(i32, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf8_to_latin1(i8, 0, o8));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf8_to_utf16be(i8, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf8_to_utf16le(i8, 0, o16));
+    ASSERT_EQUAL(0, implementation.convert_valid_utf8_to_utf32(i8, 0, o32));
+    ASSERT_EQUAL(0, implementation.count_utf16be(i16, 0));
+    ASSERT_EQUAL(0, implementation.count_utf16le(i16, 0));
+    ASSERT_EQUAL(0, implementation.count_utf8(i8, 0));
+    ASSERT_EQUAL(0, implementation.latin1_length_from_utf16(0));
+    ASSERT_EQUAL(0, implementation.latin1_length_from_utf32(0));
+    ASSERT_EQUAL(0, implementation.latin1_length_from_utf8(i8, 0));
+    ASSERT_EQUAL(0, implementation.maximal_binary_length_from_base64(i16, 0));
+    ASSERT_EQUAL(0, implementation.utf16_length_from_latin1(0));
+    ASSERT_EQUAL(0, implementation.utf16_length_from_utf32(i32, 0));
+    ASSERT_EQUAL(0, implementation.utf16_length_from_utf8(i8, 0));
+    ASSERT_EQUAL(0, implementation.utf32_length_from_latin1(0));
+    ASSERT_EQUAL(0, implementation.utf32_length_from_utf16be(i16, 0));
+    ASSERT_EQUAL(0, implementation.utf32_length_from_utf16le(i16, 0));
+    ASSERT_EQUAL(0, implementation.utf32_length_from_utf8(i8, 0));
+    ASSERT_EQUAL(0, implementation.utf8_length_from_latin1(i8, 0));
+    ASSERT_EQUAL(0, implementation.utf8_length_from_utf16be(i16, 0));
+    ASSERT_EQUAL(0, implementation.utf8_length_from_utf16le(i16, 0));
+    ASSERT_EQUAL(0, implementation.utf8_length_from_utf32(i32, 0));
+
+    auto is_valid = [](const simdutf::result &r) {
+      return r.count == 0 && r.error == simdutf::error_code::SUCCESS;
+    };
+
+    ASSERT_TRUE(implementation.validate_utf16be(i16, 0));
+    ASSERT_TRUE(is_valid(implementation.validate_utf16be_with_errors(i16, 0)));
+    ASSERT_TRUE(implementation.validate_utf16le(i16, 0));
+    ASSERT_TRUE(is_valid(implementation.validate_utf16le_with_errors(i16, 0)));
+    ASSERT_TRUE(implementation.validate_utf32(i32, 0));
+    ASSERT_TRUE(is_valid(implementation.validate_utf32_with_errors(i32, 0)));
+    ASSERT_TRUE(implementation.validate_utf8(i8, 0));
+    ASSERT_TRUE(is_valid(implementation.validate_utf8_with_errors(i8, 0)));
+  }
+}
+
+TEST_MAIN