react-native-quick-crypto 1.1.0 → 1.1.2

package/deps/simdutf/fuzz/roundtrip.cpp

@@ -1,588 +0,0 @@
-#include <cstring>
-#include <fuzzer/FuzzedDataProvider.h>
-#include <memory>
-#include <string>
-#include <iostream>
-
-#include "simdutf.h"
-
-// useful for debugging
-static void print_input(const std::string& s,
-                        const simdutf::implementation* const e) {
-  printf("We are about to abort on the following input: ");
-  for (auto c : s) {
-    printf("%02x ", (unsigned char)c);
-  }
-  printf("\n");
-  std::cout << "string length : " << s.size() << " bytes" << std::endl;
-  std::cout << "implementation->name() = " << e->name() << std::endl;
-}
-
-/**
- * We do round trips from UTF-8 to UTF-16, from UTF-8 to UTF-32, from UTF-16 to
- * UTF-8.
- * We do round trips from Latin 1 to UTF-8, from Latin 1 to UTF-16, from Latin 1
- * to UTF-32. We test all available kernels. We also try to transcode invalid
- * inputs.
- */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  FuzzedDataProvider fdp(data, size);
-  constexpr int kMaxStringSize = 1024;
-  std::string source = fdp.ConsumeRandomLengthString(kMaxStringSize);
-  for (auto& e : simdutf::get_available_implementations()) {
-    if (!e->supported_by_runtime_system()) {
-      continue;
-    }
-    /**
-     * Transcoding from UTF-8 to UTF-16LE.
-     */
-    bool validutf8 = e->validate_utf8(source.c_str(), source.size());
-    auto rutf8 = e->validate_utf8_with_errors(source.c_str(), source.size());
-    if (validutf8 != (rutf8.error == simdutf::SUCCESS)) { // they should agree
-      print_input(source, e);
-      abort();
-    }
-    if (validutf8) {
-      // We need a buffer of size where to write the UTF-16LE words.
-      size_t expected_utf16words =
-          e->utf16_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char16_t[]> utf16_output{
-          new char16_t[expected_utf16words]};
-      // convert to UTF-16LE
-      size_t utf16words = e->convert_utf8_to_utf16le(
-          source.c_str(), source.size(), utf16_output.get());
-      // It wrote utf16words * sizeof(char16_t) bytes.
-      bool validutf16 = e->validate_utf16le(utf16_output.get(), utf16words);
-      if (!validutf16) {
-        print_input(source, e);
-        abort();
-      }
-      // convert it back:
-      // We need a buffer of size where to write the UTF-8 words.
-      size_t expected_utf8words =
-          e->utf8_length_from_utf16le(utf16_output.get(), utf16words);
-      std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-      // convert to UTF-8
-      size_t utf8words = e->convert_utf16le_to_utf8(
-          utf16_output.get(), utf16words, utf8_output.get());
-      std::string final_string(utf8_output.get(), utf8words);
-      if (final_string != source) {
-        print_input(source, e);
-        abort();
-      }
-    } else {
-      // invalid input!!!
-      // We need a buffer of size where to write the UTF-16LE words.
-      size_t expected_utf16words =
-          e->utf16_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char16_t[]> utf16_output{
-          new char16_t[expected_utf16words]};
-      // convert to UTF-16LE
-      size_t utf16words = e->convert_utf8_to_utf16le(
-          source.c_str(), source.size(), utf16_output.get());
-      if (utf16words != 0) {
-        print_input(source, e);
-        abort();
-      }
-    }
-
-    /**
-     * Transcoding from UTF-8 to UTF-16BE.
-     */
-    if (validutf8) {
-      // We need a buffer of size where to write the UTF-16BE words.
-      size_t expected_utf16words =
-          e->utf16_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char16_t[]> utf16_output{
-          new char16_t[expected_utf16words]};
-      // convert to UTF-16BE
-      size_t utf16words = e->convert_utf8_to_utf16be(
-          source.c_str(), source.size(), utf16_output.get());
-      // It wrote utf16words * sizeof(char16_t) bytes.
-      bool validutf16 = e->validate_utf16be(utf16_output.get(), utf16words);
-      if (!validutf16) {
-        print_input(source, e);
-        abort();
-      }
-      // convert it back:
-      // We need a buffer of size where to write the UTF-8 words.
-      size_t expected_utf8words =
-          e->utf8_length_from_utf16be(utf16_output.get(), utf16words);
-      std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-      // convert to UTF-8
-      size_t utf8words = e->convert_utf16be_to_utf8(
-          utf16_output.get(), utf16words, utf8_output.get());
-      std::string final_string(utf8_output.get(), utf8words);
-      if (final_string != source) {
-        print_input(source, e);
-        abort();
-      }
-    } else {
-      // invalid input!!!
-      // We need a buffer of size where to write the UTF-16BE words.
-      size_t expected_utf16words =
-          e->utf16_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char16_t[]> utf16_output{
-          new char16_t[expected_utf16words]};
-      // convert to UTF-16BE
-      size_t utf16words = e->convert_utf8_to_utf16be(
-          source.c_str(), source.size(), utf16_output.get());
-      if (utf16words != 0) {
-        print_input(source, e);
-        abort();
-      }
-    }
-    /**
-     * Transcoding from UTF-8 to UTF-32.
-     */
-    if (validutf8) {
-      // We need a buffer of size where to write the UTF-32 words.
-      size_t expected_utf32words =
-          e->utf32_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char32_t[]> utf32_output{
-          new char32_t[expected_utf32words]};
-      // convert to UTF-32
-      size_t utf32words = e->convert_utf8_to_utf32(
-          source.c_str(), source.size(), utf32_output.get());
-      // It wrote utf32words * sizeof(char32_t) bytes.
-      bool validutf32 = e->validate_utf32(utf32_output.get(), utf32words);
-      if (!validutf32) {
-        return -1;
-      }
-      // convert it back:
-      // We need a buffer of size where to write the UTF-8 words.
-      size_t expected_utf8words =
-          e->utf8_length_from_utf32(utf32_output.get(), utf32words);
-      std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-      // convert to UTF-8
-      size_t utf8words = e->convert_utf32_to_utf8(
-          utf32_output.get(), utf32words, utf8_output.get());
-      std::string final_string(utf8_output.get(), utf8words);
-      if (source != final_string) {
-        print_input(source, e);
-        abort();
-      }
-    } else {
-      // invalid input!!!
-      size_t expected_utf32words =
-          e->utf32_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char32_t[]> utf32_output{
-          new char32_t[expected_utf32words]};
-      // convert to UTF-32
-      size_t utf32words = e->convert_utf8_to_utf32(
-          source.c_str(), source.size(), utf32_output.get());
-      if (utf32words != 0) {
-        print_input(source, e);
-        abort();
-      }
-    }
-
-    /**
-     * Transcoding from UTF-8 to Latin 1
-     */
-    if (validutf8) {
-      // We need a buffer of size where to write the UTF-16LE words.
-      size_t expected_latin1words =
-          e->latin1_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char[]> latin1_output{new char[expected_latin1words]};
-      // convert to latin1
-      size_t latin1words = e->convert_utf8_to_latin1(
-          source.c_str(), source.size(), latin1_output.get());
-      if (latin1words != 0) {
-        // convert it back:
-        // We need a buffer of size where to write the UTF-8 words.
-        size_t expected_utf8words =
-            e->utf8_length_from_latin1(latin1_output.get(), latin1words);
-        std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-        // convert to UTF-8
-        size_t utf8words = e->convert_latin1_to_utf8(
-            latin1_output.get(), latin1words, utf8_output.get());
-        std::string final_string(utf8_output.get(), utf8words);
-        if (final_string != source) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    } else {
-      // invalid input!!!
-      // We need a buffer of size where to write the Latin 1 words.
-      size_t expected_latin1words =
-          e->latin1_length_from_utf8(source.c_str(), source.size());
-      std::unique_ptr<char[]> latin1_output{new char[expected_latin1words]};
-      // convert to Latin 1
-      size_t latin1words = e->convert_utf8_to_latin1(
-          source.c_str(), source.size(), latin1_output.get());
-      if (latin1words != 0) {
-        print_input(source, e);
-        abort();
-      }
-    }
-    /**
-     * Transcoding from UTF-16LE to UTF-8.
-     */
-    {
-      // Get new source data here as this will allow the fuzzer to optimize it's
-      // input for UTF16-LE.
-      source = fdp.ConsumeRandomLengthString(kMaxStringSize);
-      // We copy to avoid alignment issues.
-      std::unique_ptr<char16_t[]> utf16_source{new char16_t[source.size() / 2]};
-      if (source.data() != nullptr) {
-        std::memcpy(utf16_source.get(), source.data(), source.size() / 2 * 2);
-      }
-      bool validutf16le =
-          e->validate_utf16le(utf16_source.get(), source.size() / 2);
-      auto rutf16le = e->validate_utf16le_with_errors(utf16_source.get(),
-                                                      source.size() / 2);
-      if (validutf16le !=
-          (rutf16le.error == simdutf::SUCCESS)) { // they should agree
-        print_input(source, e);
-        abort();
-      }
-      if (validutf16le) {
-        // We need a buffer of size where to write the UTF-16 words.
-        size_t expected_utf8words =
-            e->utf8_length_from_utf16le(utf16_source.get(), source.size() / 2);
-        std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-        size_t utf8words = e->convert_utf16le_to_utf8(
-            utf16_source.get(), source.size() / 2, utf8_output.get());
-        // It wrote utf16words * sizeof(char16_t) bytes.
-        bool validutf8 = e->validate_utf8(utf8_output.get(), utf8words);
-        if (!validutf8) {
-          print_input(source, e);
-          abort();
-        }
-        // convert it back:
-        // We need a buffer of size where to write the UTF-16 words.
-        size_t expected_utf16words =
-            e->utf16_length_from_utf8(utf8_output.get(), utf8words);
-        std::unique_ptr<char16_t[]> utf16_output{
-            new char16_t[expected_utf16words]};
-        // convert to UTF-8
-        size_t utf16words = e->convert_utf8_to_utf16le(
-            utf8_output.get(), utf8words, utf16_output.get());
-        for (size_t i = 0; i < source.size() / 2; i++) {
-          if (utf16_output.get()[i] != (utf16_source.get())[i]) {
-            print_input(source, e);
-            abort();
-          }
-        }
-      } else {
-        // invalid input!!!
-        // We need a buffer of size where to write the UTF-16 words.
-        size_t expected_utf8words =
-            e->utf8_length_from_utf16le(utf16_source.get(), source.size() / 2);
-        std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-        size_t utf8words = e->convert_utf16le_to_utf8(
-            utf16_source.get(), source.size() / 2, utf8_output.get());
-        if (utf8words != 0) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    }
-
-    /**
-     * Transcoding from UTF-16BE to UTF-8.
-     */
-    {
-      // Get new source data here as this will allow the fuzzer to optimize it's
-      // input for UTF16-BE.
-      source = fdp.ConsumeRandomLengthString(kMaxStringSize);
-      std::unique_ptr<char16_t[]> utf16_source{new char16_t[source.size() / 2]};
-      if (source.data() != nullptr) {
-        std::memcpy(utf16_source.get(), source.data(), source.size() / 2 * 2);
-      }
-      bool validutf16be =
-          e->validate_utf16be(utf16_source.get(), source.size() / 2);
-      auto rutf16be = e->validate_utf16be_with_errors(utf16_source.get(),
-                                                      source.size() / 2);
-      if (validutf16be !=
-          (rutf16be.error == simdutf::SUCCESS)) { // they should agree
-        print_input(source, e);
-        abort();
-      }
-      if (validutf16be) {
-        // We need a buffer of size where to write the UTF-16 words.
-        size_t expected_utf8words =
-            e->utf8_length_from_utf16be(utf16_source.get(), source.size() / 2);
-        std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-        size_t utf8words = e->convert_utf16be_to_utf8(
-            utf16_source.get(), source.size() / 2, utf8_output.get());
-        // It wrote utf16words * sizeof(char16_t) bytes.
-        bool validutf8 = e->validate_utf8(utf8_output.get(), utf8words);
-        if (!validutf8) {
-          print_input(source, e);
-          abort();
-        }
-        // convert it back:
-        // We need a buffer of size where to write the UTF-16 words.
-        size_t expected_utf16words =
-            e->utf16_length_from_utf8(utf8_output.get(), utf8words);
-        std::unique_ptr<char16_t[]> utf16_output{
-            new char16_t[expected_utf16words]};
-        // convert to UTF-8
-        size_t utf16words = e->convert_utf8_to_utf16be(
-            utf8_output.get(), utf8words, utf16_output.get());
-        for (size_t i = 0; i < source.size() / 2; i++) {
-          if (utf16_output.get()[i] != (utf16_source.get())[i]) {
-            print_input(source, e);
-            abort();
-          }
-        }
-      } else {
-        // invalid input!!!
-        // We need a buffer of size where to write the UTF-16 words.
-        size_t expected_utf8words =
-            e->utf8_length_from_utf16be(utf16_source.get(), source.size() / 2);
-        std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-        size_t utf8words = e->convert_utf16be_to_utf8(
-            utf16_source.get(), source.size() / 2, utf8_output.get());
-        if (utf8words != 0) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    }
-
-    /**
-     * Transcoding from latin1 to UTF-8.
-     */
-    // Get new source data here as this will allow the fuzzer to optimize it's
-    // input for latin1.
-    source = fdp.ConsumeRandomLengthString(kMaxStringSize);
-    bool validlatin1 = true; // has to be
-    if (validlatin1) {
-      // We need a buffer of size where to write the UTF-8 words.
-      size_t expected_utf8words =
-          e->utf8_length_from_latin1(source.c_str(), source.size());
-      std::unique_ptr<char[]> utf8_output{new char[expected_utf8words]};
-      size_t utf8words = e->convert_latin1_to_utf8(
-          source.c_str(), source.size(), utf8_output.get());
-      // It wrote utf8words * sizeof(char) bytes.
-      bool validutf8 = e->validate_utf8(utf8_output.get(), utf8words);
-      if (!validutf8) {
-        print_input(source, e);
-        abort();
-      }
-      // convert it back:
-      // We need a buffer of size where to write the latin1 words.
-      size_t expected_latin1words =
-          e->latin1_length_from_utf8(utf8_output.get(), utf8words);
-      std::unique_ptr<char[]> latin1_output{new char[expected_latin1words]};
-      // convert to latin1
-      size_t latin1words = e->convert_utf8_to_latin1(
-          utf8_output.get(), utf8words, latin1_output.get());
-      for (size_t i = 0; i < source.size(); i++) {
-        if (latin1_output.get()[i] != (source.c_str())[i]) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    }
-    if (validlatin1) {
-      // We need a buffer of size where to write the UTF-16 words.
-      size_t expected_utf16words = e->utf16_length_from_latin1(source.size());
-      std::unique_ptr<char16_t[]> utf16_output{
-          new char16_t[expected_utf16words]};
-      size_t utf16words = e->convert_latin1_to_utf16le(
-          source.c_str(), source.size(), utf16_output.get());
-      // It wrote utf16words * sizeof(char16_t) bytes.
-      bool validutf16 = e->validate_utf16le(utf16_output.get(), utf16words);
-      if (!validutf16) {
-        print_input(source, e);
-        abort();
-      }
-      // convert it back:
-      // We need a buffer of size where to write the latin1 words.
-      size_t expected_latin1words = e->latin1_length_from_utf16(utf16words);
-      std::unique_ptr<char[]> latin1_output{new char[expected_latin1words]};
-      // convert to latin1
-      size_t latin1words = e->convert_utf16le_to_latin1(
-          utf16_output.get(), utf16words, latin1_output.get());
-      for (size_t i = 0; i < source.size(); i++) {
-        if (latin1_output.get()[i] != (source.c_str())[i]) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    }
-    if (validlatin1) {
-      // We need a buffer of size where to write the UTF-16 words.
-      size_t expected_utf16words = e->utf16_length_from_latin1(source.size());
-      std::unique_ptr<char16_t[]> utf16_output{
-          new char16_t[expected_utf16words]};
-      size_t utf16words = e->convert_latin1_to_utf16be(
-          source.c_str(), source.size(), utf16_output.get());
-      // It wrote utf16words * sizeof(char16_t) bytes.
-      bool validutf16 = e->validate_utf16be(utf16_output.get(), utf16words);
-      if (!validutf16) {
-        print_input(source, e);
-        abort();
-      }
-      // convert it back:
-      // We need a buffer of size where to write the latin1 words.
-      size_t expected_latin1words = e->latin1_length_from_utf16(utf16words);
-      std::unique_ptr<char[]> latin1_output{new char[expected_latin1words]};
-      // convert to latin1
-      size_t latin1words = e->convert_utf16be_to_latin1(
-          utf16_output.get(), utf16words, latin1_output.get());
-      for (size_t i = 0; i < source.size(); i++) {
-        if (latin1_output.get()[i] != (source.c_str())[i]) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    }
-
-    if (validlatin1) {
-      // We need a buffer of size where to write the UTF-16 words.
-      size_t expected_utf32words = e->utf32_length_from_latin1(source.size());
-      std::unique_ptr<char32_t[]> utf32_output{
-          new char32_t[expected_utf32words]};
-      size_t utf32words = e->convert_latin1_to_utf32(
-          source.c_str(), source.size(), utf32_output.get());
-      // It wrote utf16words * sizeof(char16_t) bytes.
-      bool validutf32 = e->validate_utf32(utf32_output.get(), utf32words);
-      if (!validutf32) {
-        print_input(source, e);
-        abort();
-      }
-      // convert it back:
-      // We need a buffer of size where to write the latin1 words.
-      size_t expected_latin1words = e->latin1_length_from_utf32(utf32words);
-      std::unique_ptr<char[]> latin1_output{new char[expected_latin1words]};
-      // convert to latin1
-      size_t latin1words = e->convert_utf32_to_latin1(
-          utf32_output.get(), utf32words, latin1_output.get());
-      for (size_t i = 0; i < source.size(); i++) {
-        if (latin1_output.get()[i] != (source.c_str())[i]) {
-          print_input(source, e);
-          abort();
-        }
-      }
-    }
-
-    /// Base64 tests. We begin by trying to decode the input, even if we
-    /// expect it to fail.
-    {
-      size_t max_length_needed =
-          e->maximal_binary_length_from_base64(source.data(), source.size());
-      std::vector<char> back(max_length_needed);
-      simdutf::result r =
-          e->base64_to_binary(source.data(), source.size(), back.data());
-      if (r.error == simdutf::error_code::SUCCESS) {
-        // We expect failure but if we succeed, then we should have a roundtrip.
-        back.resize(r.count);
-        std::vector<char> back2(e->base64_length_from_binary(back.size()));
-        size_t base64size =
-            e->binary_to_base64(back.data(), back.size(), back2.data());
-        back2.resize(base64size);
-        std::vector<char> back3(
-            e->maximal_binary_length_from_base64(back2.data(), back2.size()));
-        simdutf::result r2 =
-            e->base64_to_binary(back2.data(), back2.size(), back3.data());
-        if (r2.error != simdutf::error_code::SUCCESS) {
-          print_input(source, e);
-          return false;
-        }
-        if (r2.count != back.size()) {
-          print_input(source, e);
-          return false;
-        }
-        if (back3.size() != back.size()) {
-          print_input(source, e);
-          return false;
-        }
-      }
-    }
-
-    // Same as above, but we use the safe decoder version.
-    {
-      size_t max_length_needed =
-          e->maximal_binary_length_from_base64(source.data(), source.size());
-      std::vector<char> back(max_length_needed);
-      simdutf::result r = simdutf::base64_to_binary_safe(
-          source.data(), source.size(), back.data(), max_length_needed);
-      if (r.error == simdutf::error_code::SUCCESS) {
-        // We expect failure but if we succeed, then we should have a roundtrip.
-        back.resize(max_length_needed);
-        std::vector<char> back2(e->base64_length_from_binary(back.size()));
-        size_t base64size =
-            e->binary_to_base64(back.data(), back.size(), back2.data());
-        back2.resize(base64size);
-        size_t max_length_needed2 =
-            e->maximal_binary_length_from_base64(back2.data(), back2.size());
-        std::vector<char> back3(max_length_needed2);
-        simdutf::result r2 = simdutf::base64_to_binary_safe(
-            back2.data(), back2.size(), back3.data(), max_length_needed2);
-        if (r2.error != simdutf::error_code::SUCCESS) {
-          print_input(source, e);
-          return false;
-        }
-        if (max_length_needed != back.size()) {
-          print_input(source, e);
-          return false;
-        }
-        if (back3.size() != back.size()) {
-          print_input(source, e);
-          return false;
-        }
-      }
-    }
-    /// Base64 tests. We encode the content as binary in base64 and we decode
-    /// it, it should always succeed.
-    {
-      source = fdp.ConsumeRandomLengthString(kMaxStringSize);
-      std::vector<char> base64buffer(
-          e->base64_length_from_binary(source.size()));
-      size_t base64size = e->binary_to_base64(source.data(), source.size(),
-                                              base64buffer.data());
-      if (base64size != base64buffer.size()) {
-        print_input(source, e);
-        abort();
-      }
-      std::vector<char> back(e->maximal_binary_length_from_base64(
-          base64buffer.data(), base64buffer.size()));
-      simdutf::result r = e->base64_to_binary(base64buffer.data(),
-                                              base64buffer.size(), back.data());
-      if (r.error != simdutf::error_code::SUCCESS) {
-        print_input(source, e);
-        abort();
-      }
-      if (r.count != source.size()) {
-        print_input(source, e);
-        abort();
-      }
-      for (size_t i = 0; i < source.size(); i++) {
-        if (back[i] != (source.c_str())[i]) {
-          print_input(source, e);
-          abort();
-        }
-      }
-      size_t max_length = back.size();
-      r = simdutf::base64_to_binary_safe(
-          base64buffer.data(), base64buffer.size(), back.data(), max_length);
-      if (r.error != simdutf::error_code::SUCCESS) {
-        printf("base64 round trip failed, error code %d\n", r.error);
-        print_input(source, e);
-        return false;
-      }
-      if (max_length != source.size()) {
-        printf("base64 safe round trip failed, not the same size %zu %zu\n",
-               max_length, source.size());
-        print_input(source, e);
-        return false;
-      }
-      for (size_t i = 0; i < source.size(); i++) {
-        if (back[i] != (source.c_str())[i]) {
-          printf("base64 round trip failed, same size, different content\n");
-          print_input(source, e);
-          return false;
-        }
-      }
-    }
-
-  } // for (auto &e : simdutf::get_available_implementations()) {
-
-  return 0;
-} // extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

package/deps/simdutf/fuzz/safe_conversion.cpp

@@ -1,104 +0,0 @@
-#include <cassert>
-#include <vector>
-
-#include "simdutf.h"
-
-void test_latin1_to_utf8(std::span<const uint8_t> input_bytes,
-                         std::size_t output_size) {
-  std::vector<char> output(output_size);
-  const auto written_bytes_safe =
-      simdutf::convert_latin1_to_utf8_safe(input_bytes, output);
-  if (written_bytes_safe > output_size) {
-    std::abort();
-  }
-  const auto needed_size = simdutf::utf8_length_from_latin1(input_bytes);
-  std::vector<char> reference(needed_size);
-  const auto written_bytes_unsafe =
-      simdutf::convert_latin1_to_utf8(input_bytes, reference);
-  if (written_bytes_unsafe != needed_size) {
-    std::abort();
-  }
-  if (written_bytes_safe > needed_size) {
-    // convert_latin1_to_utf8_safe wrote more output buffer than the unsafe
-    // version needed!
-    std::abort();
-  }
-  // ensure output is equal to the beginning of reference
-  if (!std::ranges::equal(
-          std::span(output).subspan(0, written_bytes_safe),
-          std::span(reference).subspan(0, written_bytes_safe))) {
-    std::abort();
-  }
-}
-
-void test_utf16_to_utf8(std::span<const char16_t> input,
-                        std::size_t output_size) {
-  std::vector<char> output(output_size);
-  const auto written_bytes_safe =
-      simdutf::convert_utf16_to_utf8_safe(input, output);
-  if (written_bytes_safe > output_size) {
-    std::abort();
-  }
-  // result is implementation defined in case of garbage input
-  const auto unreliable_needed_size = simdutf::utf8_length_from_utf16(input);
-  std::vector<char> reference(unreliable_needed_size);
-  const auto written_bytes_unsafe =
-      simdutf::convert_utf16_to_utf8(input, reference);
-
-  // ensure output is equal to the beginning of reference
-  const auto Ncompare = std::min(written_bytes_safe, written_bytes_unsafe);
-  const auto matches =
-      std::ranges::equal(std::span(output).subspan(0, Ncompare),
-                         std::span(reference).subspan(0, Ncompare));
-  assert(matches);
-  if (!matches) {
-    std::abort();
-  }
-}
-
-void select_implementation(auto index) {
-  static const auto implementations = []() {
-    const auto list = simdutf::get_available_implementations();
-    using Impl = std::decay_t<decltype(*list.begin())>;
-    std::vector<Impl> ret;
-    for (auto& e : list) {
-      if (e->supported_by_runtime_system()) {
-        ret.push_back(e);
-      }
-    }
-    return ret;
-  }();
-  assert(!implementations.empty());
-  simdutf::get_active_implementation() =
-      implementations.at(index % implementations.size());
-}
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-
-  if (size < 4) {
-    return 0;
-  }
-
-  const auto action = data[0] & 0x1;
-  const auto output_size = (data[1] << 8 | data[2]);
-  const auto implementation_index = data[3] & 0b0111;
-  data += 4;
-  size -= 4;
-
-  const std::span<const uint8_t> input_bytes{data, data + size};
-
-  select_implementation(implementation_index);
-
-  switch (action) {
-  case 0:
-    test_latin1_to_utf8(input_bytes, output_size);
-    break;
-  case 1: {
-    const auto* ptr = reinterpret_cast<const char16_t*>(input_bytes.data());
-    test_utf16_to_utf8(std::span(ptr, ptr + input_bytes.size() / 2),
-                       output_size);
-  } break;
-  }
-
-  return 0;
-}