react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/straight_c_test.c

@@ -0,0 +1,187 @@
+#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

@@ -0,0 +1,77 @@
+#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

@@ -0,0 +1,377 @@
+#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