react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/tests/convert_latin1_to_utf32_tests.cpp

@@ -0,0 +1,66 @@
+#include "simdutf.h"
+
+#include <tests/helpers/fixed_string.h>
+#include <tests/helpers/random_int.h>
+#include <tests/helpers/test.h>
+#include <tests/helpers/transcode_test_base.h>
+
+namespace {
+using simdutf::tests::helpers::transcode_utf8_to_utf16_test_base;
+
+} // namespace
+
+TEST_LOOP(convert_all_latin1) {
+  size_t counter = 0;
+  auto generator = [&counter]() -> uint32_t { return counter++ & 0xFF; };
+
+  auto procedure = [&implementation](const char *latin1, size_t size,
+                                     char32_t *utf32) -> size_t {
+    return implementation.convert_latin1_to_utf32(latin1, size, utf32);
+  };
+  auto size_procedure =
+      [&implementation](simdutf_maybe_unused const char *latin1,
+                        size_t size) -> size_t {
+    return implementation.utf32_length_from_latin1(size);
+  };
+  // Check varying length inputs for upto 16 bytes
+  for (size_t i = 240; i <= 256; i++) {
+    simdutf::tests::helpers::transcode_latin1_to_utf32_test_base test(generator,
+                                                                      i);
+    ASSERT_TRUE(test(procedure));
+    ASSERT_TRUE(test.check_size(size_procedure));
+  }
+}
+
+#if SIMDUTF_CPLUSPLUS23
+
+namespace {
+
+template <auto input> constexpr auto convert() {
+  using namespace simdutf::tests::helpers;
+  CTString<char32_t, input.size()> tmp;
+  auto N = simdutf::convert_latin1_to_utf32(input, tmp);
+  if (N != input.size()) {
+    throw "oops";
+  }
+  return tmp;
+}
+
+} // namespace
+
+TEST(compile_time_convert_latin1_to_utf32) {
+  using namespace simdutf::tests::helpers;
+
+  constexpr auto input = "hello"_latin1;
+  constexpr auto expected = U"hello"_utf32;
+  constexpr auto output = convert<input>();
+  static_assert(output == expected);
+}
+
+TEST(compile_time_utf32_length_from_latin1) {
+  static_assert(simdutf::utf32_length_from_latin1(42) == 42);
+}
+
+#endif
+
+TEST_MAIN

package/deps/simdutf/tests/convert_latin1_to_utf8_tests.cpp

@@ -0,0 +1,120 @@
+#include "simdutf.h"
+
+#include <vector>
+
+#include <tests/helpers/compiletime_conversions.h>
+#include <tests/helpers/fixed_string.h>
+#include <tests/helpers/test.h>
+#include <tests/helpers/transcode_test_base.h>
+
+namespace {
+using simdutf::tests::helpers::transcode_utf8_to_utf16_test_base;
+
+} // namespace
+
+TEST_LOOP(convert_all_latin1) {
+  size_t counter = 0;
+  auto generator = [&counter]() -> uint8_t { return counter++ & 0xFF; };
+
+  auto procedure = [&implementation](const char *latin1, size_t size,
+                                     char *utf8) -> size_t {
+    return implementation.convert_latin1_to_utf8(latin1, size, utf8);
+  };
+  auto size_procedure = [&implementation](const char *latin1,
+                                          size_t size) -> size_t {
+    return implementation.utf8_length_from_latin1(latin1, size);
+  };
+
+  simdutf::tests::helpers::transcode_latin1_to_utf8_test_base test(generator,
+                                                                   256);
+  ASSERT_TRUE(test(procedure));
+  ASSERT_TRUE(test.check_size(size_procedure));
+}
+
+TEST(convert_all_latin1_safe) {
+  std::vector<char> latin1(1024);
+  for (size_t i = 0; i < latin1.size(); i++) {
+    latin1[i] = i & 0xff;
+  }
+  size_t utf8_length =
+      implementation.utf8_length_from_latin1(latin1.data(), latin1.size());
+  std::vector<char> utf8(utf8_length);
+  const auto result = implementation.convert_latin1_to_utf8(
+      latin1.data(), latin1.size(), utf8.data());
+  ASSERT_EQUAL(result, utf8_length);
+  for (size_t output_size = 0; output_size < utf8.size(); output_size++) {
+    std::vector<char> utf8_buffer(output_size);
+    size_t used_size = simdutf::convert_latin1_to_utf8_safe(
+        latin1.data(), latin1.size(), utf8_buffer.data(), output_size);
+    for (size_t i = 0; i < used_size; i++) {
+      ASSERT_EQUAL(utf8_buffer[i], utf8[i]);
+    }
+    if (used_size < output_size) {
+      ASSERT_EQUAL(used_size, output_size - 1);
+      ASSERT_TRUE(uint8_t(utf8[used_size]) >= 0x80);
+    }
+  }
+}
+
+#if SIMDUTF_CPLUSPLUS23
+
+TEST(compile_time_utf8_length_from_latin1) {
+  using namespace simdutf::tests::helpers;
+  static_assert(simdutf::utf8_length_from_latin1("x"_latin1) == 1);
+  // swedish character "ö":
+  static_assert(simdutf::utf8_length_from_latin1("\xF6"_latin1) == 2);
+}
+
+TEST(compile_time_convert_latin1_to_utf8) {
+  using namespace simdutf::tests::helpers;
+
+  constexpr auto input = "I am a nice and wellbehaved string"_latin1;
+  constexpr auto expected = u8"I am a nice and wellbehaved string"_utf8;
+  static_assert(simdutf::utf8_length_from_latin1(input) == expected.size());
+  constexpr auto converted = to_utf8<input>();
+  static_assert(converted == expected);
+}
+
+TEST(compile_time_convert_latin1_to_utf8_harder) {
+  using namespace simdutf::tests::helpers;
+
+  constexpr auto input = "k\xF6ttbulle"_latin1;
+  constexpr auto expected = u8"köttbulle"_utf8;
+  static_assert(simdutf::utf8_length_from_latin1(input) == expected.size());
+  constexpr auto converted = to_utf8<input>();
+  static_assert(converted == expected);
+}
+
+namespace {
+template <auto input, std::size_t N> constexpr auto convert_safe() {
+  simdutf::tests::helpers::CTString<char8_t, N> ret{};
+  auto written = simdutf::convert_latin1_to_utf8_safe(input, ret);
+  return std::tuple(written, ret);
+}
+} // namespace
+
+TEST(compile_time_convert_latin1_to_utf8_safe) {
+  using namespace simdutf::tests::helpers;
+
+  constexpr auto input = "k\xF6ttbulle"_latin1;
+  constexpr auto expected = u8"köttbulle"_utf8;
+
+  // convert using a too small buffer
+  {
+    constexpr auto small = convert_safe<input, 2>();
+    constexpr auto written = std::get<0>(small);
+    static_assert(written == 1);
+  }
+
+  // use a large enough buffer
+  {
+    constexpr auto large = convert_safe<input, 100>();
+    constexpr auto written = std::get<0>(large);
+    static_assert(written == expected.size());
+    constexpr auto output = std::get<1>(large).shrink<written>();
+    static_assert(output == expected);
+  }
+}
+#endif
+
+TEST_MAIN

package/deps/simdutf/tests/convert_utf16_to_utf8_safe_tests.cpp

@@ -0,0 +1,203 @@
+#include "simdutf.h"
+
+#include <array>
+#include <vector>
+
+#include <tests/helpers/fixed_string.h>
+#include <tests/helpers/random_int.h>
+#include <tests/helpers/test.h>
+#include <tests/helpers/transcode_test_base.h>
+#include <tests/reference/validate_utf16.h>
+
+namespace {
+constexpr std::array<size_t, 7> input_size{7, 16, 12, 64, 67, 128, 256};
+#if SIMDUTF_IS_BIG_ENDIAN
+constexpr simdutf::endianness BE = simdutf::endianness::BIG;
+#else
+constexpr simdutf::endianness BE = simdutf::endianness::LITTLE;
+#endif
+using simdutf::tests::helpers::transcode_utf16_to_utf8_test_base;
+
+} // namespace
+
+inline void verify_subset(std::vector<char16_t> &utf16,
+                          std::vector<char> &utf8) {
+  size_t max_budget =
+      simdutf::utf8_length_from_utf16(utf16.data(), utf16.size());
+  std::vector<char> output_utf8(max_budget, ' ');
+  size_t previous_size = 0;
+  size_t i = 0;
+  for (; i < max_budget; i += 7) {
+    size_t ret = simdutf::convert_utf16_to_utf8_safe(
+        utf16.data(), utf16.size(), output_utf8.data(), max_budget);
+    ASSERT_TRUE(ret <= max_budget);
+    ASSERT_TRUE(ret >= previous_size);
+    for (size_t j = 0; j < ret; j++) {
+      ASSERT_EQUAL(output_utf8[j], utf8[j]);
+    }
+    previous_size = ret;
+  }
+  for (; i < max_budget; i++) {
+    size_t ret = simdutf::convert_utf16_to_utf8_safe(
+        utf16.data(), utf16.size(), output_utf8.data(), max_budget);
+    ASSERT_TRUE(ret <= max_budget);
+    ASSERT_TRUE(ret >= previous_size);
+    for (size_t j = 0; j < ret; j++) {
+      ASSERT_EQUAL(output_utf8[j], utf8[j]);
+    }
+    previous_size = ret;
+  }
+  {
+    size_t ret = simdutf::convert_utf16_to_utf8_safe(
+        utf16.data(), utf16.size(), output_utf8.data(), max_budget);
+    ASSERT_EQUAL(ret, max_budget);
+    for (size_t j = 0; j < max_budget; j++) {
+      ASSERT_EQUAL(output_utf8[j], utf8[j]);
+    }
+  }
+}
+
+TEST(issue911) {
+  char16_t input[] = {0x00E9, 'A'};
+  char output[2];
+  size_t written = simdutf::convert_utf16_to_utf8_safe(input, 2, output, 2);
+  ASSERT_TRUE(written <= 2);
+}
+
+TEST(convert_pure_ASCII) {
+  size_t counter = 0;
+  auto generator = [&counter]() -> uint32_t { return counter++ & 0x7f; };
+
+  auto procedure = [&implementation](const char16_t *utf16, size_t size,
+                                     char *utf8) -> size_t {
+    return simdutf::convert_utf16_to_utf8_safe(
+        utf16, size, utf8, simdutf::utf8_length_from_utf16(utf16, size));
+  };
+  auto size_procedure = [&implementation](const char16_t *utf16,
+                                          size_t size) -> size_t {
+    return simdutf::utf8_length_from_utf16(utf16, size);
+  };
+  for (size_t size : input_size) {
+    transcode_utf16_to_utf8_test_base test(BE, generator, size);
+    verify_subset(test.input_utf16, test.reference_output_utf8);
+    ASSERT_TRUE(test(procedure));
+    ASSERT_TRUE(test.check_size(size_procedure));
+  }
+}
+
+TEST_LOOP(convert_into_1_or_2_UTF8_bytes) {
+  simdutf::tests::helpers::RandomInt random(
+      0x0000, 0x07ff, seed); // range for 1 or 2 UTF-8 bytes
+
+  auto procedure = [&implementation](const char16_t *utf16, size_t size,
+                                     char *utf8) -> size_t {
+    return simdutf::convert_utf16_to_utf8_safe(
+        utf16, size, utf8, simdutf::utf8_length_from_utf16(utf16, size));
+  };
+  auto size_procedure = [&implementation](const char16_t *utf16,
+                                          size_t size) -> size_t {
+    return simdutf::utf8_length_from_utf16(utf16, size);
+  };
+  for (size_t size : input_size) {
+    transcode_utf16_to_utf8_test_base test(BE, random, size);
+    verify_subset(test.input_utf16, test.reference_output_utf8);
+    ASSERT_TRUE(test(procedure));
+    ASSERT_TRUE(test.check_size(size_procedure));
+  }
+}
+
+TEST_LOOP(convert_into_1_or_2_or_3_UTF8_bytes) {
+  // range for 1, 2 or 3 UTF-8 bytes
+  simdutf::tests::helpers::RandomIntRanges random(
+      {{0x0000, 0x007f}, {0x0080, 0x07ff}, {0x0800, 0xd7ff}, {0xe000, 0xffff}},
+      seed);
+  auto procedure = [&implementation](const char16_t *utf16, size_t size,
+                                     char *utf8) -> size_t {
+    return simdutf::convert_utf16_to_utf8_safe(
+        utf16, size, utf8, simdutf::utf8_length_from_utf16(utf16, size));
+  };
+  auto size_procedure = [&implementation](const char16_t *utf16,
+                                          size_t size) -> size_t {
+    return simdutf::utf8_length_from_utf16(utf16, size);
+  };
+  for (size_t size : input_size) {
+    transcode_utf16_to_utf8_test_base test(BE, random, size);
+    verify_subset(test.input_utf16, test.reference_output_utf8);
+    ASSERT_TRUE(test(procedure));
+    ASSERT_TRUE(test.check_size(size_procedure));
+  }
+}
+
+TEST_LOOP(convert_into_3_or_4_UTF8_bytes) {
+  // range for 3 or 4 UTF-8 bytes
+  simdutf::tests::helpers::RandomIntRanges random(
+      {{0x0800, 0xd800 - 1}, {0xe000, 0x10ffff}}, seed);
+
+  auto procedure = [&implementation](const char16_t *utf16, size_t size,
+                                     char *utf8) -> size_t {
+    return simdutf::convert_utf16_to_utf8_safe(
+        utf16, size, utf8, simdutf::utf8_length_from_utf16(utf16, size));
+  };
+  auto size_procedure = [&implementation](const char16_t *utf16,
+                                          size_t size) -> size_t {
+    return simdutf::utf8_length_from_utf16(utf16, size);
+  };
+  for (size_t size : input_size) {
+    transcode_utf16_to_utf8_test_base test(BE, random, size);
+    verify_subset(test.input_utf16, test.reference_output_utf8);
+    ASSERT_TRUE(test(procedure));
+    ASSERT_TRUE(test.check_size(size_procedure));
+  }
+}
+
+#if SIMDUTF_CPLUSPLUS23
+
+namespace {
+template <auto input> constexpr auto convert() {
+  using namespace simdutf::tests::helpers;
+  constexpr auto Noutput = simdutf::utf8_length_from_utf16(input);
+  CTString<char8_t, Noutput> output{};
+  const auto ret = simdutf::convert_utf16_to_utf8_safe(input, output);
+  if (ret == 0) {
+    throw "failed conversion";
+  }
+  if (ret != Noutput) {
+    throw "mismatch in write length";
+  }
+  return output;
+}
+} // namespace
+
+TEST(compile_time_convert_utf16_to_utf8_safe) {
+  using namespace simdutf::tests::helpers;
+  constexpr auto input = u"köttbulle"_utf16;
+  constexpr auto expected = u8"köttbulle"_utf8;
+  constexpr auto actual = convert<input>();
+  static_assert(actual == expected);
+}
+
+namespace {
+template <auto input, std::size_t buflen>
+constexpr auto convert_insufficient_buf() {
+  using namespace simdutf::tests::helpers;
+  constexpr auto Noutput = simdutf::utf8_length_from_utf16(input);
+  CTString<char8_t, buflen> output{};
+  const auto ret = simdutf::convert_utf16_to_utf8_safe(input, output);
+  if (ret == 0) {
+    throw "failed conversion";
+  }
+  return output;
+}
+} // namespace
+TEST(compile_time_check_of_issue_911) {
+  using namespace simdutf::tests::helpers;
+  constexpr auto input = u"\u00E9A"_utf16;
+  constexpr auto expected = u8"\u00E9A"_utf8;
+  constexpr auto actual = convert_insufficient_buf<input, 2>();
+  constexpr auto N = std::min(actual.size(), expected.size());
+  static_assert(expected.shrink<N>() == actual.shrink<N>());
+}
+
+#endif
+
+TEST_MAIN

package/deps/simdutf/tests/convert_utf16_to_utf8_with_replacement_tests.cpp

@@ -0,0 +1,276 @@
+#include "simdutf.h"
+
+#include <cstring>
+#include <random>
+#include <vector>
+
+#include <tests/helpers/random_utf16.h>
+#include <tests/helpers/test.h>
+#include <tests/helpers/utf16.h>
+
+#if SIMDUTF_CPLUSPLUS23
+  #include <tests/helpers/fixed_string.h>
+#endif
+
+// U+FFFD in UTF-8 is 0xEF 0xBF 0xBD
+constexpr char fffd_utf8[] = {char(0xef), char(0xbf), char(0xbd)};
+
+// Test: valid UTF-16 should produce the same output as convert_utf16_to_utf8
+TEST(valid_utf16le_roundtrip) {
+  // ASCII + BMP characters
+  std::vector<char16_t> input = {u'H',      u'e', u'l', u'l', u'o', u' ',
+                                 u'\u00e9',  // e-acute (2-byte UTF-8)
+                                 u'\u4e16',  // CJK character (3-byte UTF-8)
+                                 u'\u754c'}; // CJK character (3-byte UTF-8)
+  size_t expected_len =
+      simdutf::utf8_length_from_utf16le(input.data(), input.size());
+  std::vector<char> expected(expected_len);
+  size_t written_expected = implementation.convert_utf16le_to_utf8(
+      input.data(), input.size(), expected.data());
+
+  std::vector<char> actual(expected_len + 10);
+  size_t written_actual =
+      implementation.convert_utf16le_to_utf8_with_replacement(
+          input.data(), input.size(), actual.data());
+
+  ASSERT_EQUAL(written_expected, written_actual);
+  ASSERT_TRUE(std::memcmp(expected.data(), actual.data(), written_actual) == 0);
+}
+
+// Test: valid surrogate pairs should produce correct 4-byte UTF-8
+TEST(valid_surrogate_pair_le) {
+  // U+1F600 (grinning face) = D83D DE00
+  std::vector<char16_t> input = {to_utf16le(char16_t(0xD83D)),
+                                 to_utf16le(char16_t(0xDE00))};
+  std::vector<char> output(8);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  ASSERT_EQUAL(written, size_t(4));
+  // U+1F600 in UTF-8: F0 9F 98 80
+  ASSERT_EQUAL(uint8_t(output[0]), uint8_t(0xF0));
+  ASSERT_EQUAL(uint8_t(output[1]), uint8_t(0x9F));
+  ASSERT_EQUAL(uint8_t(output[2]), uint8_t(0x98));
+  ASSERT_EQUAL(uint8_t(output[3]), uint8_t(0x80));
+}
+
+// Test: unpaired high surrogate should be replaced with U+FFFD
+TEST(unpaired_high_surrogate_le) {
+  // D800 followed by a regular character
+  std::vector<char16_t> input = {to_utf16le(char16_t(0xD800)),
+                                 to_utf16le(u'A')};
+  std::vector<char> output(8);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  // U+FFFD (3 bytes) + 'A' (1 byte) = 4
+  ASSERT_EQUAL(written, size_t(4));
+  ASSERT_TRUE(std::memcmp(output.data(), fffd_utf8, 3) == 0);
+  ASSERT_EQUAL(output[3], 'A');
+}
+
+// Test: unpaired low surrogate should be replaced with U+FFFD
+TEST(unpaired_low_surrogate_le) {
+  // DC00 (low surrogate without preceding high surrogate)
+  std::vector<char16_t> input = {to_utf16le(u'B'), to_utf16le(char16_t(0xDC00)),
+                                 to_utf16le(u'C')};
+  std::vector<char> output(16);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  // 'B' (1) + U+FFFD (3) + 'C' (1) = 5
+  ASSERT_EQUAL(written, size_t(5));
+  ASSERT_EQUAL(output[0], 'B');
+  ASSERT_TRUE(std::memcmp(output.data() + 1, fffd_utf8, 3) == 0);
+  ASSERT_EQUAL(output[4], 'C');
+}
+
+// Test: high surrogate at end of string
+TEST(high_surrogate_at_end_le) {
+  std::vector<char16_t> input = {to_utf16le(u'X'),
+                                 to_utf16le(char16_t(0xD800))};
+  std::vector<char> output(8);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  // 'X' (1) + U+FFFD (3) = 4
+  ASSERT_EQUAL(written, size_t(4));
+  ASSERT_EQUAL(output[0], 'X');
+  ASSERT_TRUE(std::memcmp(output.data() + 1, fffd_utf8, 3) == 0);
+}
+
+// Test: two consecutive unpaired high surrogates
+TEST(consecutive_unpaired_high_surrogates_le) {
+  std::vector<char16_t> input = {to_utf16le(char16_t(0xD800)),
+                                 to_utf16le(char16_t(0xD801))};
+  std::vector<char> output(16);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  // Two U+FFFD = 6 bytes
+  ASSERT_EQUAL(written, size_t(6));
+  ASSERT_TRUE(std::memcmp(output.data(), fffd_utf8, 3) == 0);
+  ASSERT_TRUE(std::memcmp(output.data() + 3, fffd_utf8, 3) == 0);
+}
+
+// Test: low surrogate followed by high surrogate (reversed pair)
+TEST(reversed_surrogate_pair_le) {
+  std::vector<char16_t> input = {to_utf16le(char16_t(0xDC00)),
+                                 to_utf16le(char16_t(0xD800))};
+  std::vector<char> output(16);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  // Both unpaired: two U+FFFD = 6 bytes
+  ASSERT_EQUAL(written, size_t(6));
+  ASSERT_TRUE(std::memcmp(output.data(), fffd_utf8, 3) == 0);
+  ASSERT_TRUE(std::memcmp(output.data() + 3, fffd_utf8, 3) == 0);
+}
+
+// Test: empty input
+TEST(empty_input_le) {
+  std::vector<char> output(8);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      nullptr, 0, output.data());
+  ASSERT_EQUAL(written, size_t(0));
+}
+
+// Test: pure ASCII
+TEST(pure_ascii_le) {
+  std::vector<char16_t> input = {to_utf16le(u'H'), to_utf16le(u'e'),
+                                 to_utf16le(u'l'), to_utf16le(u'l'),
+                                 to_utf16le(u'o')};
+  std::vector<char> output(8);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+  ASSERT_EQUAL(written, size_t(5));
+  ASSERT_TRUE(std::memcmp(output.data(), "Hello", 5) == 0);
+}
+
+// Test: consistency with utf8_length_from_utf16_with_replacement
+TEST_LOOP(length_consistency_le) {
+  const size_t length = 64 + (seed % 128);
+  std::mt19937 gen(seed);
+  std::uniform_int_distribution<uint16_t> dist(0, 0xFFFF);
+
+  std::vector<char16_t> input(length);
+  for (size_t i = 0; i < length; i++) {
+    input[i] = static_cast<char16_t>(dist(gen));
+  }
+
+  simdutf::result len_result =
+      simdutf::utf8_length_from_utf16le_with_replacement(input.data(),
+                                                         input.size());
+
+  std::vector<char> output(length * 3 + 1);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+
+  ASSERT_EQUAL(len_result.count, written);
+}
+
+// Test: output matches to_well_formed_utf16 + convert_utf16_to_utf8 approach
+TEST_LOOP(matches_well_formed_approach_le) {
+  const size_t length = 32 + (seed % 64);
+  std::mt19937 gen(seed);
+  std::uniform_int_distribution<uint16_t> dist(0, 0xFFFF);
+
+  std::vector<char16_t> input(length);
+  for (size_t i = 0; i < length; i++) {
+    input[i] = static_cast<char16_t>(dist(gen));
+  }
+
+  // Approach 1: to_well_formed_utf16 + convert_utf16_to_utf8
+  std::vector<char16_t> well_formed(length);
+  simdutf::to_well_formed_utf16le(input.data(), length, well_formed.data());
+  size_t utf8_len =
+      simdutf::utf8_length_from_utf16le(well_formed.data(), length);
+  std::vector<char> expected(utf8_len + 1);
+  size_t written_expected = simdutf::convert_utf16le_to_utf8(
+      well_formed.data(), length, expected.data());
+
+  // Approach 2: convert_utf16_to_utf8_with_replacement (new function)
+  std::vector<char> actual(utf8_len + 1);
+  size_t written_actual =
+      implementation.convert_utf16le_to_utf8_with_replacement(
+          input.data(), length, actual.data());
+
+  ASSERT_EQUAL(written_expected, written_actual);
+  ASSERT_TRUE(std::memcmp(expected.data(), actual.data(), written_actual) == 0);
+}
+
+// Test: output is always valid UTF-8
+TEST_LOOP(output_is_valid_utf8_le) {
+  const size_t length = 64 + (seed % 256);
+  std::mt19937 gen(seed);
+  std::uniform_int_distribution<uint16_t> dist(0, 0xFFFF);
+
+  std::vector<char16_t> input(length);
+  for (size_t i = 0; i < length; i++) {
+    input[i] = static_cast<char16_t>(dist(gen));
+  }
+
+  std::vector<char> output(length * 3 + 1);
+  size_t written = implementation.convert_utf16le_to_utf8_with_replacement(
+      input.data(), input.size(), output.data());
+
+  ASSERT_TRUE(simdutf::validate_utf8(output.data(), written));
+}
+
+#if SIMDUTF_CPLUSPLUS23
+
+namespace {
+
+// makes a UTF-16 string with an unpaired high surrogate: 'A', 0xD800, 'B'
+template <simdutf::endianness e> constexpr auto make_input_with_unpaired() {
+  simdutf::tests::helpers::CTString<
+      char16_t, 3,
+      e == simdutf::endianness::BIG ? std::endian::big : std::endian::little>
+      data{};
+  data[0] = simdutf::scalar::utf16::swap_if_needed<e>(u'A');
+  data[1] = simdutf::scalar::utf16::swap_if_needed<e>(char16_t(0xD800));
+  data[2] = simdutf::scalar::utf16::swap_if_needed<e>(u'B');
+  return data;
+}
+
+// expected output: 'A' (1 byte) + U+FFFD (3 bytes: EF BF BD) + 'B' (1 byte)
+constexpr auto make_expected_output() {
+  simdutf::tests::helpers::CTString<char, 5> data{};
+  data[0] = 'A';
+  data[1] = char(0xEF);
+  data[2] = char(0xBF);
+  data[3] = char(0xBD);
+  data[4] = 'B';
+  return data;
+}
+
+template <auto input> constexpr auto invoke_convert_with_replacement() {
+  // 'A' = 1 byte, unpaired surrogate = 3 bytes (U+FFFD), 'B' = 1 byte
+  simdutf::tests::helpers::CTString<char, 5> output{};
+  std::size_t written;
+  if constexpr (decltype(input)::endianness == std::endian::little) {
+    written = simdutf::convert_utf16le_to_utf8_with_replacement(input, output);
+  } else {
+    written = simdutf::convert_utf16be_to_utf8_with_replacement(input, output);
+  }
+  if (written != output.size()) {
+    throw "unexpected length";
+  }
+  return output;
+}
+
+} // namespace
+
+TEST(compile_time_convert_utf16le_to_utf8_with_replacement) {
+  using enum simdutf::endianness;
+  constexpr auto input = make_input_with_unpaired<LITTLE>();
+  constexpr auto result = invoke_convert_with_replacement<input>();
+  constexpr auto expected = make_expected_output();
+  static_assert(result == expected);
+}
+
+TEST(compile_time_convert_utf16be_to_utf8_with_replacement) {
+  using enum simdutf::endianness;
+  constexpr auto input = make_input_with_unpaired<BIG>();
+  constexpr auto result = invoke_convert_with_replacement<input>();
+  constexpr auto expected = make_expected_output();
+  static_assert(result == expected);
+}
+
+#endif // SIMDUTF_CPLUSPLUS23
+
+TEST_MAIN