react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/tests/basic_fuzzer.cpp

@@ -0,0 +1,805 @@
+#include "simdutf.h"
+
+#include <fstream>
+#include <random>
+#include <memory>
+#include <vector>
+
+#include <tests/reference/encode_utf8.h>
+#include <tests/helpers/test.h>
+
+static uint32_t seed = 123;
+const size_t MAX_SIZE = 1025;
+
+#ifndef SIMDUTF_TEST_FUZZER_TRIALS
+  #error "SIMDUTF_TEST_FUZZER_TRIALS not set."
+#endif
+constexpr std::size_t trials = SIMDUTF_TEST_FUZZER_TRIALS;
+
+std::vector<char> input;
+std::pair<bool, bool> is_ok_utf8 = std::make_pair(false, false);
+std::pair<bool, bool> is_ok_utf16 = std::make_pair(false, false);
+std::pair<bool, bool> is_ok_utf32 = std::make_pair(false, false);
+
+std::pair<bool, size_t> utf8_to_utf16 = std::make_pair(false, 0);
+std::pair<bool, size_t> utf8_to_utf32 = std::make_pair(false, 0);
+std::pair<bool, size_t> utf16_to_utf8 = std::make_pair(false, 0);
+std::pair<bool, size_t> utf16_to_utf32 = std::make_pair(false, 0);
+std::pair<bool, size_t> utf32_to_utf8 = std::make_pair(false, 0);
+std::pair<bool, size_t> utf32_to_utf16 = std::make_pair(false, 0);
+
+void reset() {
+  is_ok_utf8.first = false;
+  is_ok_utf16.first = false;
+  is_ok_utf32.first = false;
+
+  utf8_to_utf16.first = false;
+  utf8_to_utf32.first = false;
+  utf16_to_utf8.first = false;
+  utf16_to_utf32.first = false;
+  utf32_to_utf8.first = false;
+  utf32_to_utf16.first = false;
+}
+
+extern "C" {
+void __asan_on_error() {
+  std::fstream log;
+  log.open("fuzzer_log.txt", std::ios::app);
+  const size_t buf_size = 4 * MAX_SIZE + 3;
+  char buffer[buf_size];
+  for (unsigned int i = 0; i < input.size(); i++) {
+    SIMDUTF_PUSH_DISABLE_WARNINGS
+    SIMDUTF_DISABLE_DEPRECATED_WARNING
+    sprintf(buffer + 4 * i + 1, "\\x%02x", input[i]);
+    SIMDUTF_POP_DISABLE_WARNINGS
+  }
+  buffer[0] = '"';
+  buffer[buf_size - 2] = '"';
+  buffer[buf_size - 1] = '\0';
+  log << std::boolalpha;
+  log << "Input: " << buffer << '\n';
+  if (is_ok_utf8.first) {
+    log << "validate_utf8:" << is_ok_utf8.second << '\n';
+  }
+  if (is_ok_utf16.first) {
+    log << "validate_utf16le:" << is_ok_utf16.second << '\n';
+  }
+  if (is_ok_utf32.first) {
+    log << "validate_utf32:" << is_ok_utf32.second << '\n';
+  }
+  if (utf8_to_utf16.first) {
+    log << "convert_utf8_to_utf16le:" << utf8_to_utf16.second << '\n';
+  }
+  if (utf8_to_utf32.first) {
+    log << "convert_utf8_to_utf32:" << utf8_to_utf32.second << '\n';
+  }
+  if (utf16_to_utf8.first) {
+    log << "convert_utf16le_to_utf8:" << utf16_to_utf8.second << '\n';
+  }
+  if (utf16_to_utf32.first) {
+    log << "convert_utf16le_to_utf32:" << utf16_to_utf32.second << '\n';
+  }
+  if (utf32_to_utf8.first) {
+    log << "convert_utf32_to_utf8:" << utf32_to_utf8.second << '\n';
+  }
+  if (utf32_to_utf16.first) {
+    log << "convert_utf32_to_utf16le:" << utf32_to_utf16.second << '\n';
+  }
+  log << '\n';
+  log.close();
+}
+}
+
+/**
+ * We should be able to receive random data without any problem
+ * when using the validating transcoder. It is difficult to test
+ * extensively, but it is easy to try many thousands of random test
+ * cases.
+ */
+
+namespace {
+std::vector<size_t> input_size{7,   16,  12,  64,   67,
+                               128, 129, 256, 1024, MAX_SIZE};
+int weights[6][2] = {{10, 90}, {25, 75}, {50, 50}, {75, 25}, {90, 10}, {99, 1}};
+} // namespace
+
+//  Possible states.
+//  Format: xxx_yyy where xxx is the number of bytes (in UTF-8) and yyy is the
+//  error encoded (if any).
+enum state {
+  ONE_VALID = 0,
+  ONE_TOO_LONG,
+  ONE_TOO_LARGE,
+  TWO_VALID, // 3
+  TWO_HEADER,
+  TWO_TOO_SHORT,
+  TWO_TOO_LONG,
+  TWO_OVERLONG,
+  THREE_VALID, // 8
+  THREE_HEADER,
+  THREE_TOO_SHORT,
+  THREE_TOO_LONG,
+  THREE_OVERLONG,
+  THREE_SURROGATE,
+  FOUR_VALID, // 14
+  FOUR_HEADER,
+  FOUR_TOO_SHORT,
+  FOUR_TOO_LONG,
+  FOUR_OVERLONG,
+  FOUR_TOO_LARGE
+};
+
+struct state_tracker {
+private:
+  enum state current_state;
+  enum state first_error;
+  double state_weights[20];
+  std::mt19937 gen;
+
+public:
+  state_tracker(uint64_t seed, double onevalid, double onetoolong,
+                double onetoolarge, double twovalid, double twoheader,
+                double twotooshort, double twotoolong, double twooverlong,
+                double threevalid, double threeheader, double threetooshort,
+                double threetoolong, double threeoverlong,
+                double threesurrogate, double fourvalid, double fourheader,
+                double fourtooshort, double fourtoolong, double fouroverlong,
+                double fourtoolarge) noexcept
+      : state_weights{onevalid,      onetoolong,     onetoolarge,
+                      twovalid,      twoheader,      twotooshort,
+                      twotoolong,    twooverlong,    threevalid,
+                      threeheader,   threetooshort,  threetoolong,
+                      threeoverlong, threesurrogate, fourvalid,
+                      fourheader,    fourtooshort,   fourtoolong,
+                      fouroverlong,  fourtoolarge},
+        gen(std::mt19937::result_type(seed)) {
+    current_state = next_state();
+    first_error = current_state;
+  }
+
+  // valid_weight is the weight of having a valid state (4 valid states) and
+  // invalid_weight is the weight of having a invalid state (16 invalid states)
+  state_tracker(uint64_t seed, double valid_weight, double invalid_weight)
+      : state_tracker(
+            seed, valid_weight / 4, invalid_weight / 16, invalid_weight / 16,
+            valid_weight / 4, invalid_weight / 16, invalid_weight / 16,
+            invalid_weight / 16, invalid_weight / 16, valid_weight / 4,
+            invalid_weight / 16, invalid_weight / 16, invalid_weight / 16,
+            invalid_weight / 16, invalid_weight / 16, valid_weight / 4,
+            invalid_weight / 16, invalid_weight / 16, invalid_weight / 16,
+            invalid_weight / 16, invalid_weight / 16) {}
+
+  size_t next(std::vector<char> &output) {
+    // Write current state to output
+    auto consume = [&output](uint8_t byte) { output.push_back(byte); };
+    size_t count{0};
+    switch (current_state) {
+    case ONE_VALID: {
+      simdutf::tests::reference::utf8::encode(generate(0x0, 0x7f), consume);
+      count = 1;
+      break;
+    }
+    case ONE_TOO_LONG: {
+      simdutf::tests::reference::utf8::encode(generate(0x0, 0x7f), consume);
+      output.push_back(generate(0x80, 0xbf)); // Add random continuation byte
+      count = 2;
+      break;
+    }
+    case ONE_TOO_LARGE: {
+      output.push_back(generate(0x80, 0xff));
+      count = 1;
+      break;
+    }
+    case TWO_VALID: {
+      simdutf::tests::reference::utf8::encode(generate(0x80, 0x7ff), consume);
+      count = 2;
+      break;
+    }
+    case TWO_HEADER: {
+      uint32_t codepoint = generate(0x80, 0x7ff);
+      output.push_back(0xf8 | (codepoint >> 6)); // Corrupt leading byte
+      output.push_back(0x80 | (codepoint & 0x3f));
+      count = 2;
+      break;
+    }
+    case TWO_TOO_SHORT: {
+      output.push_back(
+          generate(0xc1, 0xdf)); // Only produce normal leading byte
+      count = 1;
+      break;
+    }
+    case TWO_TOO_LONG: {
+      simdutf::tests::reference::utf8::encode(generate(0x80, 0x7ff), consume);
+      output.push_back(generate(0x80, 0xbf)); // Add random continuation byte
+      count = 3;
+      break;
+    }
+    case TWO_OVERLONG: {
+      output.push_back(char(0xc0));           // Add "empty" leading byte
+      output.push_back(generate(0x80, 0xbf)); // Add random continuation byte
+      count = 2;
+      break;
+    }
+    case THREE_VALID: {
+      uint32_t codepoint = generate(0x800, 0xffff);
+      // Hacky, but there is only a ~3.2% to generate a codepoint in the
+      // forbidden range each time
+      while (codepoint >= 0xd800 && codepoint <= 0xdfff) {
+        codepoint = generate(0x800, 0xffff);
+      }
+      simdutf::tests::reference::utf8::encode(generate(0x80, 0x7ff), consume);
+      count = 3;
+      break;
+    }
+    case THREE_HEADER: {
+      uint32_t codepoint = generate(0x800, 0xffff);
+      while (codepoint >= 0xd800 && codepoint <= 0xdfff) {
+        codepoint = generate(0x800, 0xffff);
+      }
+      output.push_back(0xf8 | (codepoint >> 12)); // Corrupt leading byte
+      output.push_back(0x80 | ((codepoint >> 6) & 0x3f));
+      output.push_back(0x80 | (codepoint & 0x3f));
+      count = 3;
+      break;
+    }
+    case THREE_TOO_SHORT: {
+      uint32_t codepoint = generate(0x800, 0xffff);
+      while (codepoint >= 0xd800 && codepoint <= 0xdfff) {
+        codepoint = generate(0x800, 0xffff);
+      }
+      output.push_back(0xe0 | (codepoint >> 12)); // Corrupt leading byte
+      output.push_back(0x80 | ((codepoint >> 6) & 0x3f));
+      count = 2;
+      break;
+    }
+    case THREE_TOO_LONG: {
+      uint32_t codepoint = generate(0x800, 0xffff);
+      while (codepoint >= 0xd800 && codepoint <= 0xdfff) {
+        codepoint = generate(0x800, 0xffff);
+      }
+      simdutf::tests::reference::utf8::encode(generate(0x80, 0x7ff), consume);
+      output.push_back(generate(0x80, 0xbf)); // Add random continuation byte
+      count = 4;
+      break;
+    }
+    case THREE_OVERLONG: {
+      output.push_back(char(0xe0)); // Add "empty" leading byte
+      output.push_back(generate(
+          0x80, 0x9f)); // First continuation byte must start by 0x8_ or 0x9_
+      output.push_back(generate(0x80, 0xbf)); // Add random continuation byte
+      count = 3;
+      break;
+    }
+    case THREE_SURROGATE: {
+      simdutf::tests::reference::utf8::encode(generate(0xd800, 0xdfff),
+                                              consume);
+      count = 3;
+      break;
+    }
+    case FOUR_VALID: {
+      simdutf::tests::reference::utf8::encode(generate(0x10000, 0x10ffff),
+                                              consume);
+      count = 4;
+      break;
+    }
+    case FOUR_HEADER: {
+      uint32_t codepoint = generate(0x10000, 0x10ffff);
+      output.push_back(0xf8 | (codepoint >> 18)); // Corrupt leading byte
+      output.push_back(0x80 | ((codepoint >> 12) & 0x3f));
+      output.push_back(0x80 | ((codepoint >> 6) & 0x3f));
+      output.push_back(0x80 | (codepoint & 0x3f));
+      count = 4;
+      break;
+    }
+    case FOUR_TOO_SHORT: {
+      uint32_t codepoint = generate(0x10000, 0x10ffff);
+      output.push_back(0xf0 | (codepoint >> 18));
+      output.push_back(0x80 | ((codepoint >> 12) & 0x3f));
+      output.push_back(0x80 | ((codepoint >> 6) & 0x3f));
+      count = 3;
+      break;
+    }
+    case FOUR_TOO_LONG: {
+      simdutf::tests::reference::utf8::encode(generate(0x10000, 0x10ffff),
+                                              consume);
+      output.push_back(generate(0x80, 0xbf)); // Add random continuation byte
+      count = 5;
+      break;
+    }
+    case FOUR_OVERLONG: {
+      output.push_back(char(0xf0)); // Add "empty" leading byte
+      output.push_back(generate(
+          0x80, 0x8f)); // First continuation byte must have start by 0x8_
+      output.push_back(
+          generate(0x80, 0xbf)); // Add two random continuation bytes
+      output.push_back(generate(0x80, 0xbf));
+      count = 4;
+      break;
+    }
+    case FOUR_TOO_LARGE: {
+      simdutf::tests::reference::utf8::encode(generate(0x110000, 0x1fffff),
+                                              consume);
+      count = 4;
+      break;
+    }
+    }
+    if (first_error == ONE_VALID || first_error == TWO_VALID ||
+        first_error == THREE_VALID || first_error == FOUR_VALID) {
+      if (current_state != ONE_VALID && current_state != TWO_VALID &&
+          current_state != THREE_VALID && current_state != FOUR_VALID) {
+        first_error = current_state;
+      }
+    }
+    // Move to next state
+    current_state = next_state();
+
+    return count;
+  }
+
+private:
+  uint32_t generate(uint32_t lo, uint32_t hi) {
+    return std::uniform_int_distribution<uint32_t>{lo, hi}(gen);
+  }
+
+  enum state next_state() {
+    return static_cast<state>(std::discrete_distribution<>{
+        state_weights[0],  state_weights[1],  state_weights[2],
+        state_weights[3],  state_weights[4],  state_weights[5],
+        state_weights[6],  state_weights[7],  state_weights[8],
+        state_weights[9],  state_weights[10], state_weights[11],
+        state_weights[12], state_weights[13], state_weights[14],
+        state_weights[15], state_weights[16], state_weights[17],
+        state_weights[18], state_weights[19]}(gen));
+  }
+};
+
+TEST(garbage_utf8_fuzz_with_errors) {
+  // Here we generate fully random inputs and try transcoding from UTF-8.
+  // The inputs are almost certainly *NOT* valid UTF-8.
+  std::mt19937 gen((std::mt19937::result_type)(seed));
+  std::uniform_int_distribution<size_t> length_generator{1, 65};
+  std::uniform_int_distribution<uint32_t> byte_generator{0, 256};
+
+  for (size_t counter = 0; counter < trials; counter++) {
+    if ((counter % 10000) == 0) {
+      printf("-");
+      fflush(NULL);
+    }
+    size_t length = length_generator(gen);
+    std::unique_ptr<char[]> utf8_buffer(new char[length]);
+    for (size_t i = 0; i < length; i++) {
+      utf8_buffer.get()[i] = byte_generator(gen);
+    }
+    size_t expected_utf16_length =
+        implementation.utf16_length_from_utf8(utf8_buffer.get(), length);
+    std::unique_ptr<char16_t[]> utf16_buffer(
+        new char16_t[expected_utf16_length]);
+    auto r = implementation.convert_utf8_to_utf16le_with_errors(
+        utf8_buffer.get(), length, utf16_buffer.get());
+    // r.count: In case of error, indicates the position of the error in the
+    // input. In case of success, indicates the number of code units
+    // validated/written.
+    if (r.error == simdutf::SUCCESS) {
+      ASSERT_EQUAL(r.count, expected_utf16_length);
+    } else {
+      ASSERT_TRUE(r.count < length);
+    }
+    r = implementation.convert_utf8_to_utf16be_with_errors(
+        utf8_buffer.get(), length, utf16_buffer.get());
+    if (r.error == simdutf::SUCCESS) {
+      ASSERT_EQUAL(r.count, expected_utf16_length);
+    } else {
+      ASSERT_TRUE(r.count < length);
+    }
+    size_t expected_utf32_length =
+        implementation.utf32_length_from_utf8(utf8_buffer.get(), length);
+    std::unique_ptr<char32_t[]> utf32_buffer(
+        new char32_t[expected_utf32_length]);
+    r = implementation.convert_utf8_to_utf32_with_errors(
+        utf8_buffer.get(), length, utf32_buffer.get());
+    if (r.error == simdutf::SUCCESS) {
+      ASSERT_EQUAL(r.count, expected_utf32_length);
+    } else {
+      ASSERT_TRUE(r.count < length);
+    }
+  }
+}
+
+TEST(garbage_utf8_fuzz) {
+  // Here we generate fully random inputs and try transcoding from UTF-8.
+  // The inputs are almost certainly *NOT* valid UTF-8.
+  std::mt19937 gen((std::mt19937::result_type)(seed));
+  std::uniform_int_distribution<size_t> length_generator{1, 65};
+  std::uniform_int_distribution<uint32_t> byte_generator{0, 256};
+
+  for (size_t counter = 0; counter < trials; counter++) {
+    if ((counter % 10000) == 0) {
+      printf("-");
+      fflush(NULL);
+    }
+    size_t length = length_generator(gen);
+    std::unique_ptr<char[]> utf8_buffer(new char[length]);
+    for (size_t i = 0; i < length; i++) {
+      utf8_buffer.get()[i] = byte_generator(gen);
+    }
+    size_t expected_utf16_length =
+        implementation.utf16_length_from_utf8(utf8_buffer.get(), length);
+    std::unique_ptr<char16_t[]> utf16_buffer(
+        new char16_t[expected_utf16_length]);
+    auto r = implementation.convert_utf8_to_utf16le(utf8_buffer.get(), length,
+                                                    utf16_buffer.get());
+    if (r != 0) {
+      ASSERT_EQUAL(r, expected_utf16_length);
+    }
+    r = implementation.convert_utf8_to_utf16be(utf8_buffer.get(), length,
+                                               utf16_buffer.get());
+    if (r != 0) {
+      ASSERT_EQUAL(r, expected_utf16_length);
+    }
+    size_t expected_utf32_length =
+        implementation.utf32_length_from_utf8(utf8_buffer.get(), length);
+    std::unique_ptr<char32_t[]> utf32_buffer(
+        new char32_t[expected_utf32_length]);
+    r = implementation.convert_utf8_to_utf32(utf8_buffer.get(), length,
+                                             utf32_buffer.get());
+    if (r != 0) {
+      ASSERT_EQUAL(r, expected_utf32_length);
+    }
+  }
+}
+
+TEST(overflow_fuzz) {
+  size_t counter{0};
+  for (int i = 0; i < 6; i++) {
+    state_tracker tracker(seed, weights[i][0], weights[i][1]);
+    while (counter < trials) {
+      for (size_t size : input_size) {
+        input.clear();
+        std::vector<char> output(4 * size);
+        while (input.size() < size) {
+          tracker.next(input);
+        }
+        input.shrink_to_fit(); // make sure we don't have superfluous space
+        counter++;
+        if ((counter % 10000) == 0) {
+          printf("-");
+          fflush(NULL);
+        }
+        reset();
+        is_ok_utf8.first = true;
+        is_ok_utf8.second =
+            implementation.validate_utf8(input.data(), input.size());
+        is_ok_utf16.first = true;
+        is_ok_utf16.second = implementation.validate_utf16le(
+            reinterpret_cast<char16_t *>(input.data()),
+            input.size() / sizeof(char16_t));
+        is_ok_utf32.first = true;
+        is_ok_utf32.second = implementation.validate_utf32(
+            reinterpret_cast<char32_t *>(input.data()),
+            input.size() / sizeof(char32_t));
+        if (is_ok_utf8.second) {
+          size_t expected_length =
+              implementation.utf16_length_from_utf8(input.data(), input.size());
+          output.resize(expected_length * sizeof(char16_t));
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          utf8_to_utf16.first = true;
+          utf8_to_utf16.second = implementation.convert_utf8_to_utf16le(
+              input.data(), input.size(),
+              reinterpret_cast<char16_t *>(output.data()));
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char16_t) == output.size()) &&
+                      expected_length == utf8_to_utf16.second);
+
+          expected_length =
+              implementation.utf32_length_from_utf8(input.data(), input.size());
+          output.resize(expected_length * sizeof(char32_t));
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          utf8_to_utf32.first = true;
+          utf8_to_utf32.second = implementation.convert_utf8_to_utf32(
+              input.data(), input.size(),
+              reinterpret_cast<char32_t *>(output.data()));
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char32_t) == output.size()) &&
+                      expected_length == utf8_to_utf32.second);
+        }
+        if (is_ok_utf16.second) {
+          size_t expected_length = implementation.utf8_length_from_utf16le(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t));
+          output.resize(expected_length);
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          utf16_to_utf8.first = true;
+          utf16_to_utf8.second = implementation.convert_utf16le_to_utf8(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t), output.data());
+          ASSERT_TRUE(expected_length > 0 && expected_length == output.size() &&
+                      expected_length == utf16_to_utf8.second);
+
+          expected_length = implementation.utf32_length_from_utf16le(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t));
+          output.resize(expected_length * sizeof(char32_t));
+
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          utf16_to_utf32.first = true;
+          utf16_to_utf32.second = implementation.convert_utf16le_to_utf32(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t),
+              reinterpret_cast<char32_t *>(output.data()));
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char32_t) == output.size()) &&
+                      expected_length == utf16_to_utf32.second);
+        }
+        if (is_ok_utf32.second) {
+          size_t expected_length = implementation.utf8_length_from_utf32(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t));
+          output.resize(expected_length);
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          utf32_to_utf8.first = true;
+          utf32_to_utf8.second = implementation.convert_utf32_to_utf8(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t), output.data());
+          ASSERT_TRUE(expected_length > 0 && expected_length == output.size() &&
+                      expected_length == utf32_to_utf8.second);
+
+          expected_length = implementation.utf16_length_from_utf32(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t));
+          output.resize(expected_length * sizeof(char16_t));
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          utf32_to_utf16.first = true;
+          utf32_to_utf16.second = implementation.convert_utf32_to_utf16le(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t),
+              reinterpret_cast<char16_t *>(output.data()));
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char16_t) == output.size()) &&
+                      expected_length == utf32_to_utf16.second);
+        }
+      }
+    }
+  }
+}
+
+TEST(overflow_with_errors_fuzz) {
+  size_t counter{0};
+  for (int i = 0; i < 6; i++) {
+    state_tracker tracker(seed, weights[i][0], weights[i][1]);
+    while (counter < trials) {
+      for (size_t size : input_size) {
+        input.clear();
+        std::vector<char> output(4 * size);
+        while (input.size() < size) {
+          tracker.next(input);
+        }
+        input.shrink_to_fit(); // make sure we don't have superfluous space
+        counter++;
+        if ((counter % 10000) == 0) {
+          printf("-");
+          fflush(NULL);
+        }
+        reset();
+        is_ok_utf8.first = true;
+        is_ok_utf8.second =
+            implementation.validate_utf8(input.data(), input.size());
+        is_ok_utf16.first = true;
+        is_ok_utf16.second = implementation.validate_utf16le(
+            reinterpret_cast<char16_t *>(input.data()),
+            input.size() / sizeof(char16_t));
+        is_ok_utf32.first = true;
+        is_ok_utf32.second = implementation.validate_utf32(
+            reinterpret_cast<char32_t *>(input.data()),
+            input.size() / sizeof(char32_t));
+        if (is_ok_utf8.second) {
+          size_t expected_length =
+              implementation.utf16_length_from_utf8(input.data(), input.size());
+          output.resize(expected_length * sizeof(char16_t));
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          auto r = implementation.convert_utf8_to_utf16le_with_errors(
+              input.data(), input.size(),
+              reinterpret_cast<char16_t *>(output.data()));
+          utf8_to_utf16.second = r.count;
+          utf8_to_utf16.first = (r.error == simdutf::SUCCESS);
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char16_t) == output.size()) &&
+                      expected_length == utf8_to_utf16.second);
+
+          expected_length =
+              implementation.utf32_length_from_utf8(input.data(), input.size());
+          output.resize(expected_length * sizeof(char32_t));
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          r = implementation.convert_utf8_to_utf32_with_errors(
+              input.data(), input.size(),
+              reinterpret_cast<char32_t *>(output.data()));
+          utf8_to_utf32.second = r.count;
+          utf8_to_utf32.first = (r.error == simdutf::SUCCESS);
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char32_t) == output.size()) &&
+                      expected_length == utf8_to_utf32.second);
+        }
+        if (is_ok_utf16.second) {
+          size_t expected_length = implementation.utf8_length_from_utf16le(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t));
+          output.resize(expected_length);
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          auto r = implementation.convert_utf16le_to_utf8_with_errors(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t), output.data());
+          utf16_to_utf8.second = r.count;
+          utf16_to_utf8.first = (r.error == simdutf::SUCCESS);
+          ASSERT_TRUE(expected_length > 0 && expected_length == output.size() &&
+                      expected_length == utf16_to_utf8.second);
+
+          expected_length = implementation.utf32_length_from_utf16le(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t));
+          output.resize(expected_length * sizeof(char32_t));
+
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          r = implementation.convert_utf16le_to_utf32_with_errors(
+              reinterpret_cast<char16_t *>(input.data()),
+              input.size() / sizeof(char16_t),
+              reinterpret_cast<char32_t *>(output.data()));
+          utf16_to_utf32.first = true;
+          utf16_to_utf32.second = r.count;
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char32_t) == output.size()) &&
+                      expected_length == utf16_to_utf32.second);
+        }
+        if (is_ok_utf32.second) {
+          size_t expected_length = implementation.utf8_length_from_utf32(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t));
+          output.resize(expected_length);
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          auto r = implementation.convert_utf32_to_utf8_with_errors(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t), output.data());
+          utf32_to_utf8.first = (r.error == simdutf::SUCCESS);
+          utf32_to_utf8.second = r.count;
+          ASSERT_TRUE(expected_length > 0 && expected_length == output.size() &&
+                      expected_length == utf32_to_utf8.second);
+
+          expected_length = implementation.utf16_length_from_utf32(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t));
+          output.resize(expected_length * sizeof(char16_t));
+          output.shrink_to_fit(); // make sure we don't have superfluous space
+          r = implementation.convert_utf32_to_utf16le_with_errors(
+              reinterpret_cast<char32_t *>(input.data()),
+              input.size() / sizeof(char32_t),
+              reinterpret_cast<char16_t *>(output.data()));
+          utf32_to_utf16.first = (r.error == simdutf::SUCCESS);
+          utf32_to_utf16.second = r.count;
+          ASSERT_TRUE(expected_length > 0 &&
+                      (expected_length * sizeof(char16_t) == output.size()) &&
+                      expected_length == utf32_to_utf16.second);
+        }
+      }
+    }
+  }
+}
+
+TEST(basic_fuzz) {
+  size_t counter{0};
+  for (int i = 0; i < 6; i++) {
+    state_tracker tracker(seed, weights[i][0], weights[i][1]);
+    while (counter < trials) {
+      for (size_t size : input_size) {
+        input.clear();
+        std::vector<char> output(4 * size);
+        while (input.size() < size) {
+          tracker.next(input);
+        }
+        input.shrink_to_fit(); // make sure we don't have superfluous space
+        counter++;
+        if ((counter % 10000) == 0) {
+          printf("-");
+          fflush(NULL);
+        }
+        reset();
+        is_ok_utf8.first = true;
+        is_ok_utf8.second =
+            implementation.validate_utf8(input.data(), input.size());
+        is_ok_utf16.first = true;
+        is_ok_utf16.second = implementation.validate_utf16le(
+            reinterpret_cast<char16_t *>(input.data()),
+            input.size() / sizeof(char16_t));
+        is_ok_utf32.first = true;
+        is_ok_utf32.second = implementation.validate_utf32(
+            reinterpret_cast<char32_t *>(input.data()),
+            input.size() / sizeof(char32_t));
+        utf8_to_utf16.first = true;
+        utf8_to_utf16.second = implementation.convert_utf8_to_utf16le(
+            input.data(), input.size(),
+            reinterpret_cast<char16_t *>(output.data()));
+        utf8_to_utf32.first = true;
+        utf8_to_utf32.second = implementation.convert_utf8_to_utf32(
+            input.data(), input.size(),
+            reinterpret_cast<char32_t *>(output.data()));
+        utf16_to_utf8.first = true;
+        utf16_to_utf8.second = implementation.convert_utf16le_to_utf8(
+            reinterpret_cast<char16_t *>(input.data()),
+            input.size() / sizeof(char16_t), output.data());
+        utf16_to_utf32.first = true;
+        utf16_to_utf32.second = implementation.convert_utf16le_to_utf32(
+            reinterpret_cast<char16_t *>(input.data()),
+            input.size() / sizeof(char16_t),
+            reinterpret_cast<char32_t *>(output.data()));
+        utf32_to_utf8.first = true;
+        utf32_to_utf8.second = implementation.convert_utf32_to_utf8(
+            reinterpret_cast<char32_t *>(input.data()),
+            input.size() / sizeof(char32_t), output.data());
+        utf32_to_utf16.first = true;
+        utf32_to_utf16.second = implementation.convert_utf32_to_utf16le(
+            reinterpret_cast<char32_t *>(input.data()),
+            input.size() / sizeof(char32_t),
+            reinterpret_cast<char16_t *>(output.data()));
+        if (is_ok_utf8.second
+                ? (utf8_to_utf16.second == 0 || utf8_to_utf32.second == 0)
+                : (utf8_to_utf16.second > 0 || utf8_to_utf32.second > 0)) {
+          printf("%s\n",
+                 (is_ok_utf8.second ? "UTF-8 is ok" : "UTF-8 is not ok"));
+          printf(" size = %zu\n", input.size());
+          printf("  implementation.convert_utf8_to_utf16.second return %zu\n",
+                 utf8_to_utf16.second);
+          printf("  implementation.convert_utf8_to_utf32.second return %zu\n",
+                 utf8_to_utf32.second);
+        }
+        ASSERT_TRUE(
+            is_ok_utf8.second
+                ? (utf8_to_utf16.second > 0 && utf8_to_utf32.second > 0)
+                : (utf8_to_utf16.second == 0 && utf8_to_utf32.second == 0));
+        if (is_ok_utf16.second
+                ? (utf16_to_utf8.second == 0 || utf16_to_utf32.second == 0)
+                : (utf16_to_utf8.second > 0 || utf16_to_utf32.second > 0)) {
+          printf("%s\n",
+                 (is_ok_utf16.second ? "UTF-16 is ok" : "UTF-16 is not ok"));
+          printf(" size = %zu\n", input.size() / sizeof(char16_t));
+          printf("  implementation.convert_utf16_to_utf8.second return %zu\n",
+                 utf16_to_utf8.second);
+          printf("  implementation.convert_utf16_to_utf32.second return %zu\n",
+                 utf16_to_utf32.second);
+        }
+        ASSERT_TRUE(
+            is_ok_utf16.second
+                ? (utf16_to_utf8.second > 0 && utf16_to_utf32.second > 0)
+                : (utf16_to_utf8.second == 0 && utf16_to_utf32.second == 0));
+        if (is_ok_utf32.second
+                ? (utf32_to_utf8.second == 0 || utf32_to_utf16.second == 0)
+                : (utf32_to_utf8.second > 0 || utf32_to_utf16.second > 0)) {
+          printf("%s\n",
+                 (is_ok_utf32.second ? "UTF-32 is ok" : "UTF-32 is not ok"));
+          printf(" size = %zu\n", input.size() / sizeof(char32_t));
+          printf("  implementation.convert_utf32_to_utf8.second return %zu\n",
+                 utf32_to_utf8.second);
+          printf("  implementation.convert_utf32_to_utf16.second return %zu\n",
+                 utf32_to_utf16.second);
+        }
+        ASSERT_TRUE(
+            is_ok_utf32.second
+                ? (utf32_to_utf8.second > 0 && utf32_to_utf16.second > 0)
+                : (utf32_to_utf8.second == 0 && utf32_to_utf16.second == 0));
+      }
+    }
+  }
+}
+
+int main(int argc, char *argv[]) {
+  if (argc == 2) {
+    try {
+      seed = std::stoi(argv[1]);
+    } catch (const std::exception &e) {
+      printf("%s\n", e.what());
+      return EXIT_FAILURE;
+    }
+  }
+  std::mt19937 gen{seed};
+  for (int i = 0; i < 20; i++) {
+    input_size.push_back(std::uniform_int_distribution<uint32_t>{50, 800}(
+        gen)); // Range must be less than max_size
+  }
+  return simdutf::test::main((argc == 2) ? 1 : argc, argv);
+}