react-native-quick-crypto 1.1.0 → 1.1.2

package/deps/simdutf/tests/straight_c_test.c

@@ -1,187 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stddef.h>
-
-#include "simdutf_c.h"
-
-#define ASSERT_TRUE(cond)                                                      \
-  do {                                                                         \
-    if (!(cond)) {                                                             \
-      fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond);          \
-      return 1;                                                                \
-    }                                                                          \
-  } while (0)
-#define ASSERT_EQUAL_SIZE_T(a, b)                                              \
-  do {                                                                         \
-    if ((a) != (b)) {                                                          \
-      fprintf(stderr, "FAIL %s:%d: %s != %s (got %zu vs %zu)\n", __FILE__,     \
-              __LINE__, #a, #b, (size_t)(a), (size_t)(b));                     \
-      return 1;                                                                \
-    }                                                                          \
-  } while (0)
-#define ASSERT_EQUAL_INT(a, b)                                                 \
-  do {                                                                         \
-    if ((int)(a) != (int)(b)) {                                                \
-      fprintf(stderr, "FAIL %s:%d: %s != %s (got %d vs %d)\n", __FILE__,       \
-              __LINE__, #a, #b, (int)(a), (int)(b));                           \
-      return 1;                                                                \
-    }                                                                          \
-  } while (0)
-
-static const char *hello = "hello";
-static const size_t hello_len = 5;
-
-static int test_validate_utf8_c(void) {
-  bool ok = simdutf_validate_utf8(hello, hello_len);
-  ASSERT_TRUE(ok);
-  simdutf_result r = simdutf_validate_utf8_with_errors(hello, hello_len);
-  ASSERT_EQUAL_INT(r.error, SIMDUTF_ERROR_SUCCESS);
-  ASSERT_EQUAL_SIZE_T(r.count, hello_len);
-  return 0;
-}
-
-static int test_convert_utf8_to_utf16_c(void) {
-  char16_t out[16];
-  size_t n = simdutf_convert_utf8_to_utf16(hello, hello_len, out);
-  ASSERT_EQUAL_SIZE_T(n, hello_len);
-  for (size_t i = 0; i < n; i++) {
-    ASSERT_TRUE(out[i] == (char16_t)hello[i]);
-  }
-  return 0;
-}
-
-static int test_convert_utf8_to_utf32_c(void) {
-  char32_t out[16];
-  size_t n = simdutf_convert_utf8_to_utf32(hello, hello_len, out);
-  ASSERT_EQUAL_SIZE_T(n, hello_len);
-  for (size_t i = 0; i < n; i++) {
-    ASSERT_TRUE(out[i] == (char32_t)hello[i]);
-  }
-  return 0;
-}
-
-static int test_count_utf8_c(void) {
-  size_t cnt = simdutf_count_utf8(hello, hello_len);
-  ASSERT_EQUAL_SIZE_T(cnt, hello_len);
-  return 0;
-}
-
-static int test_find_c(void) {
-  const char *f = simdutf_find(hello, hello + hello_len, 'e');
-  ASSERT_TRUE(f == hello + 1);
-  return 0;
-}
-
-static int test_base64_c(void) {
-  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_INT(br.error, SIMDUTF_ERROR_SUCCESS);
-  ASSERT_EQUAL_SIZE_T(outlen, hello_len);
-  ASSERT_TRUE(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);
-  return 0;
-}
-
-static int test_ascii_and_detect_c(void) {
-  ASSERT_TRUE(simdutf_validate_ascii(hello, hello_len));
-  simdutf_result r = simdutf_validate_ascii_with_errors(hello, hello_len);
-  ASSERT_EQUAL_INT(r.error, SIMDUTF_ERROR_SUCCESS);
-
-  simdutf_encoding_type et = simdutf_autodetect_encoding(hello, hello_len);
-  ASSERT_EQUAL_INT(et, SIMDUTF_ENCODING_UTF8);
-  int encs = simdutf_detect_encodings(hello, hello_len);
-  ASSERT_TRUE(encs >= 0);
-  return 0;
-}
-
-static int test_lengths_and_conversions_c(void) {
-  char latin_out[8] = {0};
-  size_t latin_to_utf8 = simdutf_convert_latin1_to_utf8("abc", 3, latin_out);
-  ASSERT_EQUAL_SIZE_T(latin_to_utf8, 3);
-
-  /* prepare a UTF-16 sample */
-  char16_t u16[5] = {(char16_t)'h', (char16_t)'e', (char16_t)'l', (char16_t)'l',
-                     (char16_t)'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_SIZE_T(safelen, u16len);
-
-  /* convert with errors */
-  simdutf_result cr = simdutf_convert_utf16_to_utf8_with_errors(u16, 5, out8);
-  ASSERT_EQUAL_INT(cr.error, SIMDUTF_ERROR_SUCCESS);
-  return 0;
-}
-
-static int test_counts_and_find_utf16_c(void) {
-  char16_t u16[5] = {(char16_t)'h', (char16_t)'e', (char16_t)'l', (char16_t)'l',
-                     (char16_t)'o'};
-  size_t c16 = simdutf_count_utf16(u16, 5);
-  ASSERT_EQUAL_SIZE_T(c16, 5);
-
-  const char16_t *f16 = simdutf_find_utf16(u16, u16 + 5, (char16_t)'e');
-  ASSERT_TRUE(f16 != NULL);
-  ASSERT_TRUE(f16 == u16 + 1);
-  return 0;
-}
-
-static int test_base64_length_helpers_c(void) {
-  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);
-  return 0;
-}
-
-int main(void) {
-  struct {
-    const char *name;
-    int (*fn)(void);
-  } tests[] = {{"validate_utf8_c", test_validate_utf8_c},
-               {"convert_utf8_to_utf16_c", test_convert_utf8_to_utf16_c},
-               {"convert_utf8_to_utf32_c", test_convert_utf8_to_utf32_c},
-               {"count_utf8_c", test_count_utf8_c},
-               {"find_c", test_find_c},
-               {"base64_c", test_base64_c},
-               {"ascii_and_detect_c", test_ascii_and_detect_c},
-               {"lengths_and_conversions_c", test_lengths_and_conversions_c},
-               {"counts_and_find_utf16_c", test_counts_and_find_utf16_c},
-               {"base64_length_helpers_c", test_base64_length_helpers_c},
-               {NULL, NULL}};
-
-  for (int i = 0; tests[i].name != NULL; i++) {
-    printf("%s... ", tests[i].name);
-    fflush(stdout);
-    int r = tests[i].fn();
-    if (r != 0) {
-      printf("FAILED\n");
-      return EXIT_FAILURE;
-    }
-    printf("OK\n");
-  }
-
-  printf("All tests passed.\n");
-  return EXIT_SUCCESS;
-}

package/deps/simdutf/tests/text_encoding_tests.cpp

@@ -1,77 +0,0 @@
-#include "simdutf.h"
-
-#include <tests/helpers/test.h>
-
-#ifdef SIMDUTF_HAS_STD_TEXT_ENCODING
-
-TEST(to_std_encoding_unspecified) {
-  constexpr auto enc = simdutf::to_std_encoding(simdutf::unspecified);
-  static_assert(enc.mib() == std::text_encoding::id::unknown,
-                "unexpected unknown encoding");
-}
-
-TEST(from_std_encoding_unsupported) {
-  constexpr std::text_encoding enc(std::text_encoding::id::ShiftJIS);
-  constexpr auto result = simdutf::from_std_encoding(enc);
-  static_assert(result == simdutf::unspecified,
-                "unsupported encodings map to unspecified");
-}
-
-TEST(roundtrip_conversions) {
-  static_assert(simdutf::from_std_encoding(
-                    simdutf::to_std_encoding(simdutf::UTF8)) == simdutf::UTF8,
-                "UTF8 roundtrip failed");
-  static_assert(simdutf::from_std_encoding(simdutf::to_std_encoding(
-                    simdutf::UTF16_LE)) == simdutf::UTF16_LE,
-                "UTF16_LE roundtrip failed");
-  static_assert(simdutf::from_std_encoding(simdutf::to_std_encoding(
-                    simdutf::UTF16_BE)) == simdutf::UTF16_BE,
-                "UTF16_BE roundtrip failed");
-  static_assert(simdutf::from_std_encoding(simdutf::to_std_encoding(
-                    simdutf::UTF32_LE)) == simdutf::UTF32_LE,
-                "UTF32_LE roundtrip failed");
-  static_assert(simdutf::from_std_encoding(simdutf::to_std_encoding(
-                    simdutf::UTF32_BE)) == simdutf::UTF32_BE,
-                "UTF32_BE roundtrip failed");
-  static_assert(simdutf::from_std_encoding(simdutf::to_std_encoding(
-                    simdutf::Latin1)) == simdutf::Latin1,
-                "Latin1 roundtrip failed");
-}
-
-TEST(from_std_encoding_native_utf16) {
-  constexpr std::text_encoding enc(std::text_encoding::id::UTF16);
-  constexpr auto result = simdutf::from_std_encoding_native(enc);
-  #if SIMDUTF_IS_BIG_ENDIAN
-  static_assert(result == simdutf::UTF16_BE, "native UTF16 mapping mismatch");
-  #else
-  static_assert(result == simdutf::UTF16_LE, "native UTF16 mapping mismatch");
-  #endif
-}
-
-TEST(from_std_encoding_native_utf32) {
-  constexpr std::text_encoding enc(std::text_encoding::id::UTF32);
-  constexpr auto result = simdutf::from_std_encoding_native(enc);
-  #if SIMDUTF_IS_BIG_ENDIAN
-  static_assert(result == simdutf::UTF32_BE, "native UTF32 mapping mismatch");
-  #else
-  static_assert(result == simdutf::UTF32_LE, "native UTF32 mapping mismatch");
-  #endif
-}
-
-TEST(from_std_encoding_native_explicit_endian) {
-  constexpr std::text_encoding enc_le(std::text_encoding::id::UTF16LE);
-  constexpr std::text_encoding enc_be(std::text_encoding::id::UTF16BE);
-  static_assert(simdutf::from_std_encoding_native(enc_le) == simdutf::UTF16_LE,
-                "UTF16LE mapping mismatch");
-  static_assert(simdutf::from_std_encoding_native(enc_be) == simdutf::UTF16_BE,
-                "UTF16BE mapping mismatch");
-}
-
-#else
-TEST(text_encoding_not_available) {
-  // this test passes when c++26 not available
-  ASSERT_TRUE(true);
-}
-#endif // SIMDUTF_HAS_STD_TEXT_ENCODING
-
-TEST_MAIN

package/deps/simdutf/tests/to_well_formed_utf16_tests.cpp

@@ -1,377 +0,0 @@
-#include "simdutf.h"
-
-#include <random>
-#include <vector>
-
-#include <tests/helpers/compiletime_conversions.h>
-#include <tests/helpers/fixed_string.h>
-#include <tests/helpers/random_utf16.h>
-#include <tests/helpers/test.h>
-
-#if SIMDUTF_IS_BIG_ENDIAN
-constexpr char16_t replacement_le = 0xFDFF;
-constexpr char16_t replacement_be = 0xFFFD;
-#else
-constexpr char16_t replacement_le = 0xFFFD;
-constexpr char16_t replacement_be = 0xFDFF;
-#endif
-
-TEST_LOOP(to_well_formed_utf16le_single_surrogate) {
-  const size_t length = 128;
-  std::vector<uint16_t> utf16(length);
-#if SIMDUTF_IS_BIG_ENDIAN
-  std::vector<char16_t> surrogates = {0x00D8, 0x00DC, 0xFFDF, 0x00D8, 0x00DC};
-#else
-  std::vector<char16_t> surrogates = {0xD800, 0xDC00, 0xDFFF, 0xD800, 0xDC00};
-#endif
-  std::vector<char16_t> output(length);
-  for (size_t j = 0; j < length; j++)
-    utf16[j] = 0;
-  for (size_t j = 0; j < length; j++) {
-    for (char16_t surrogate : surrogates) {
-      utf16[j] = surrogate;
-      simdutf::result utf8_length =
-          implementation.utf8_length_from_utf16le_with_replacement(
-              (const char16_t *)utf16.data(), utf16.size());
-      std::fill(output.begin(), output.end(), 0);
-      implementation.to_well_formed_utf16le((const char16_t *)utf16.data(),
-                                            utf16.size(), output.data());
-      size_t utf8_length_check = implementation.utf8_length_from_utf16le(
-          (const char16_t *)output.data(), utf16.size());
-      ASSERT_EQUAL(output[j], replacement_le);
-      ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-
-      utf16[j] = 0x0000; // Reset to a valid character
-    }
-  }
-}
-
-TEST_LOOP(to_well_formed_utf16be_single_surrogate) {
-  const size_t length = 128;
-  std::vector<uint16_t> utf16(length);
-#if SIMDUTF_IS_BIG_ENDIAN
-  std::vector<char16_t> surrogates = {0xD800, 0xDC00, 0xDFFF, 0xD800, 0xDC00};
-#else
-  std::vector<char16_t> surrogates = {0x00D8, 0x00DC, 0xFFDF, 0x00D8, 0x00DC};
-#endif
-  std::vector<char16_t> output(length);
-  for (size_t j = 0; j < length; j++) {
-    for (char16_t surrogate : surrogates) {
-      utf16[j] = surrogate;
-      simdutf::result utf8_length =
-          implementation.utf8_length_from_utf16be_with_replacement(
-              (const char16_t *)utf16.data(), utf16.size());
-      std::fill(output.begin(), output.end(), 0);
-      implementation.to_well_formed_utf16be((const char16_t *)utf16.data(),
-                                            utf16.size(), output.data());
-      size_t utf8_length_check = implementation.utf8_length_from_utf16be(
-          (const char16_t *)output.data(), utf16.size());
-      ASSERT_EQUAL(output[j], replacement_be);
-      ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-      ASSERT_EQUAL(utf8_length.error, simdutf::SURROGATE);
-      utf16[j] = 0x0000; // Reset to a valid character
-    }
-  }
-}
-
-// Should be the identity on valid input
-TEST_LOOP(to_well_formed_utf16le_for_valid_input_surrogate_pairs_short) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_le(8)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output(len);
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16le_with_replacement(utf16.data(),
-                                                               len);
-  implementation.to_well_formed_utf16le(utf16.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16le(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16be_for_valid_input_surrogate_pairs_short) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_be(8)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output(len);
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16be_with_replacement(utf16.data(),
-                                                               len);
-  implementation.to_well_formed_utf16be(utf16.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16be(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16le_for_valid_input_surrogate_pairs_long) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_le(512)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output(len);
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16le_with_replacement(utf16.data(),
-                                                               len);
-  implementation.to_well_formed_utf16le(utf16.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16le(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16be_for_valid_input_surrogate_pairs_long) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 0, 1};
-  const auto utf16{generator.generate_be(512)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output(len);
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16be_with_replacement(utf16.data(),
-                                                               len);
-  implementation.to_well_formed_utf16be(utf16.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16be(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16le_for_valid_input_mixed_long) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 1};
-  const auto utf16{generator.generate_le(512)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output(len);
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16le_with_replacement(utf16.data(),
-                                                               len);
-  implementation.to_well_formed_utf16le(utf16.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16le(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16be_for_valid_input_mixed_long) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 1};
-  const auto utf16{generator.generate_be(512)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output(len);
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16be_with_replacement(utf16.data(),
-                                                               len);
-  implementation.to_well_formed_utf16be(utf16.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16be(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16le_for_valid_input_mixed_long_self) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 1};
-  const auto utf16{generator.generate_le(512)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output = utf16;
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16le_with_replacement(output.data(),
-                                                               len);
-  implementation.to_well_formed_utf16le(output.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16le(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-TEST_LOOP(to_well_formed_utf16be_for_valid_input_mixed_long_self) {
-  simdutf::tests::helpers::random_utf16 generator{seed, 1, 1};
-  const auto utf16{generator.generate_be(512)};
-  const auto len = utf16.size();
-  std::vector<char16_t> output = utf16;
-  simdutf::result utf8_length =
-      implementation.utf8_length_from_utf16be_with_replacement(output.data(),
-                                                               len);
-  implementation.to_well_formed_utf16be(output.data(), len, output.data());
-  size_t utf8_length_check =
-      implementation.utf8_length_from_utf16be(output.data(), len);
-  ASSERT_EQUAL(output, utf16);
-  ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-}
-
-std::vector<char16_t> random_testcase(size_t n, std::mt19937 &rng) {
-  std::uniform_int_distribution<int> dist(0, 0xFFFF);
-  std::uniform_int_distribution<int> disthl(0, 3);
-  std::vector<char16_t> buf(n);
-  for (size_t i = 0; i < n; ++i) {
-    uint16_t random_value(dist(rng));
-    uint8_t random_hl(disthl(rng));
-    if (random_hl == 0) { // 25% for low surrogate
-      buf[i] = 0xD800 | (random_value & 0x07FF);
-    } else if (random_hl == 1) { // Another 25% for high surrogate
-      buf[i] = 0xDC00 | (random_value & 0x07FF);
-    } else {
-      // Generate any other character in the char16_t range
-      // could be a surrogate pair...
-      buf[i] = random_value;
-    }
-  }
-  return buf;
-}
-
-TEST(to_well_formed_utf16le_bad_input) {
-  std::mt19937 gen((std::mt19937::result_type)(42));
-  for (size_t i = 0; i < 1000; i++) {
-    auto utf16 = random_testcase(512, gen);
-    auto len = utf16.size();
-    std::vector<char16_t> output(len);
-    simdutf::result utf8_length =
-        implementation.utf8_length_from_utf16le_with_replacement(utf16.data(),
-                                                                 len);
-    implementation.to_well_formed_utf16le(utf16.data(), len, output.data());
-    for (size_t j = 0; j < len; j++) {
-      if (utf16[j] != output[j]) {
-        ASSERT_EQUAL(output[j], replacement_le);
-        ASSERT_EQUAL(utf8_length.error, simdutf::SURROGATE);
-      }
-    }
-    size_t utf8_length_check =
-        implementation.utf8_length_from_utf16le(output.data(), len);
-    ASSERT_TRUE(implementation.validate_utf16le(output.data(), len));
-    ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-  }
-}
-
-TEST(to_well_formed_utf16be_bad_input) {
-  std::mt19937 gen((std::mt19937::result_type)(42));
-  for (size_t i = 0; i < 1000; i++) {
-    auto utf16 = random_testcase(512, gen);
-    auto len = utf16.size();
-    std::vector<char16_t> output(len);
-    simdutf::result utf8_length =
-        implementation.utf8_length_from_utf16be_with_replacement(utf16.data(),
-                                                                 len);
-    implementation.to_well_formed_utf16be(utf16.data(), len, output.data());
-    for (size_t j = 0; j < len; j++) {
-      if (utf16[j] != output[j]) {
-        ASSERT_EQUAL(output[j], replacement_be);
-        ASSERT_EQUAL(utf8_length.error, simdutf::SURROGATE);
-      }
-    }
-    size_t utf8_length_check =
-        implementation.utf8_length_from_utf16be(output.data(), len);
-    ASSERT_TRUE(implementation.validate_utf16be(output.data(), len));
-    ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-  }
-}
-
-TEST(to_well_formed_utf16le_bad_input_self) {
-  std::mt19937 gen((std::mt19937::result_type)(42));
-  for (size_t i = 0; i < 1000; i++) {
-    auto utf16 = random_testcase(512, gen);
-    auto len = utf16.size();
-    std::vector<char16_t> output = utf16;
-    simdutf::result utf8_length =
-        implementation.utf8_length_from_utf16le_with_replacement(output.data(),
-                                                                 len);
-    implementation.to_well_formed_utf16le(output.data(), len, output.data());
-    for (size_t j = 0; j < len; j++) {
-      if (utf16[j] != output[j]) {
-        ASSERT_EQUAL(output[j], replacement_le);
-        ASSERT_EQUAL(utf8_length.error, simdutf::SURROGATE);
-      }
-    }
-    size_t utf8_length_check =
-        implementation.utf8_length_from_utf16le(output.data(), len);
-    ASSERT_TRUE(implementation.validate_utf16le(output.data(), len));
-    ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-  }
-}
-
-TEST(to_well_formed_utf16be_bad_input_self) {
-  std::mt19937 gen((std::mt19937::result_type)(42));
-  for (size_t i = 0; i < 1000; i++) {
-    auto utf16 = random_testcase(512, gen);
-    auto len = utf16.size();
-    std::vector<char16_t> output = utf16;
-    simdutf::result utf8_length =
-        implementation.utf8_length_from_utf16be_with_replacement(output.data(),
-                                                                 len);
-    implementation.to_well_formed_utf16be(output.data(), len, output.data());
-    for (size_t j = 0; j < len; j++) {
-      if (utf16[j] != output[j]) {
-        ASSERT_EQUAL(output[j], replacement_be);
-        ASSERT_EQUAL(utf8_length.error, simdutf::SURROGATE);
-      }
-    }
-    size_t utf8_length_check =
-        implementation.utf8_length_from_utf16be(output.data(), len);
-    ASSERT_TRUE(implementation.validate_utf16be(output.data(), len));
-    ASSERT_EQUAL(utf8_length.count, utf8_length_check);
-  }
-}
-
-#if SIMDUTF_CPLUSPLUS23
-
-namespace {
-
-// makes a malformed string in the requested endianness
-template <simdutf::endianness e> constexpr auto make_malformed() {
-  simdutf::tests::helpers::CTString<
-      char16_t, 5,
-      e == simdutf::endianness::BIG ? std::endian::big : std::endian::little>
-      data{};
-  data[2] = simdutf::scalar::utf16::swap_if_needed<e>(0xD800);
-  return data;
-}
-
-// makes a wellformed string in the requested endianness
-template <simdutf::endianness e> constexpr auto make_wellformed() {
-  simdutf::tests::helpers::CTString<
-      char16_t, 5,
-      e == simdutf::endianness::BIG ? std::endian::big : std::endian::little>
-      data{};
-  data[2] = simdutf::scalar::utf16::swap_if_needed<e>(0xfffd);
-  return data;
-}
-} // namespace
-
-TEST(compile_time_to_wellformed_big) {
-  using namespace simdutf::tests::helpers;
-  using enum simdutf::endianness;
-
-  constexpr auto malformed = make_malformed<BIG>();
-  constexpr auto replaced = to_wellformed(malformed);
-  constexpr auto expected = make_wellformed<BIG>();
-  static_assert(replaced == expected);
-}
-
-TEST(compile_time_to_wellformed_little) {
-  using namespace simdutf::tests::helpers;
-  using enum simdutf::endianness;
-
-  constexpr auto malformed = make_malformed<LITTLE>();
-  constexpr auto replaced = to_wellformed(malformed);
-  constexpr auto expected = make_wellformed<LITTLE>();
-  static_assert(replaced == expected);
-}
-
-namespace {
-template <auto input> constexpr auto invoke_to_wellformed() {
-  auto output = input;
-  simdutf::to_well_formed_utf16(input, output);
-  return output;
-}
-} // namespace
-
-TEST(compile_time_to_wellformed_native) {
-
-  using namespace simdutf::tests::helpers;
-  using enum simdutf::endianness;
-
-  constexpr auto malformed = make_malformed<NATIVE>();
-  constexpr auto replaced = invoke_to_wellformed<malformed>();
-
-  constexpr auto expected = make_wellformed<NATIVE>();
-  static_assert(replaced == expected);
-}
-
-#endif
-
-TEST_MAIN