multitude 0.1.0

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Consolidated UTF-16 tests (smoke, builder, format, serde, cross-thread,
//! coverage gaps, and mutation-kill cases).

#![cfg(feature = "utf16")]

mod common;

// === merged from tests/utf16_smoke.rs ===
mod utf16_smoke {

    use multitude::Arena;
    use multitude::strings::{ArcUtf16Str, BoxUtf16Str, RcUtf16Str};
    use widestring::utf16str;

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;

    #[test]
    fn alloc_utf16_str_rc() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_rc(utf16str!("hello"));
        assert_eq!(&*s, utf16str!("hello"));
        assert_eq!(s.len(), 5);
        let s2 = s.clone();
        assert_eq!(&*s, &*s2);
    }

    #[test]
    fn alloc_utf16_str_box() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_box(utf16str!("hello"));
        assert_eq!(&*s, utf16str!("hello"));
        assert_eq!(s.len(), 5);
    }

    #[test]
    fn alloc_utf16_str_arc() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_arc(utf16str!("shared"));
        let _: ArcUtf16Str = s;
        assert_eq!(&*s, utf16str!("shared"));
    }

    #[test]
    fn alloc_utf16_str_rc_from_str() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_rc_from_str("hello, world");
        assert_eq!(&*s, utf16str!("hello, world"));
    }

    #[test]
    fn alloc_utf16_str_box_from_str() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_box_from_str("hello");
        assert_eq!(&*s, utf16str!("hello"));
    }

    #[test]
    fn alloc_utf16_str_arc_from_str() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_arc_from_str("hello");
        assert_eq!(&*s, utf16str!("hello"));
    }

    #[test]
    fn empty_string_round_trip() {
        let arena = Arena::new();
        let r: RcUtf16Str = arena.alloc_utf16_str_rc(utf16str!(""));
        assert!(r.is_empty());
        assert_eq!(r.len(), 0);
    }

    #[test]
    fn box_into_rc() {
        let arena = Arena::new();
        let b: BoxUtf16Str = arena.alloc_utf16_str_box(utf16str!("hello"));
        let r: RcUtf16Str = b.into();
        assert_eq!(&*r, utf16str!("hello"));
    }

    #[test]
    fn rc_into_arena_rc_slice() {
        let arena = Arena::new();
        let r = arena.alloc_utf16_str_rc(utf16str!("abc"));
        let bytes: multitude::Rc<[u16]> = r.into();
        assert_eq!(&*bytes, &[u16::from(b'a'), u16::from(b'b'), u16::from(b'c')][..]);
    }

    #[test]
    fn arc_into_arena_arc_slice() {
        let arena = Arena::new();
        let a = arena.alloc_utf16_str_arc(utf16str!("abc"));
        let bytes: multitude::Arc<[u16]> = a.into();
        assert_eq!(&*bytes, &[u16::from(b'a'), u16::from(b'b'), u16::from(b'c')][..]);
    }

    #[test]
    fn surrogate_pair_round_trip() {
        // U+1F496 SPARKLING HEART encodes as a UTF-16 surrogate pair.
        let arena = Arena::new();
        let r = arena.alloc_utf16_str_rc(utf16str!("💖"));
        assert_eq!(r.len(), 2); // 2 u16 units
        assert_eq!(&*r, utf16str!("💖"));
        let s = r.as_utf16_str().to_string();
        assert_eq!(s, "💖");
    }

    #[test]
    fn empty_builder_into_arena_str() {
        let arena = Arena::new();
        let b = arena.alloc_utf16_string();
        let r = b.into_arena_utf16_str();
        assert!(r.is_empty());
    }

    #[test]
    fn comparison_traits() {
        let arena = Arena::new();
        let a = arena.alloc_utf16_str_rc(utf16str!("aaa"));
        let b = arena.alloc_utf16_str_rc(utf16str!("aab"));
        assert!(a < b);
        assert_ne!(a, b);
        assert_eq!(a, a.clone());
        let _ = format!("{a}");
        let _ = format!("{a:?}");
    }
}

// === merged from tests/utf16_string_builder.rs ===
mod utf16_string_builder {

    use multitude::Arena;
    use widestring::utf16str;

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;

    #[test]
    fn push_and_pop() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push('a');
        s.push('b');
        s.push('💖'); // surrogate pair: +2 u16
        assert_eq!(s.len(), 4);
        assert_eq!(s.pop(), Some('💖'));
        assert_eq!(s.len(), 2);
        s.push_str(utf16str!("xyz"));
        assert_eq!(s.as_utf16_str(), utf16str!("abxyz"));
    }

    #[test]
    fn push_from_str_transcodes() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_from_str("hello, 💖");
        assert_eq!(s.as_utf16_str(), utf16str!("hello, 💖"));
        assert_eq!(s.len(), 9); // 7 ascii + 2 surrogate
    }

    #[test]
    fn truncate_and_clear() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));
        s.truncate(3);
        assert_eq!(s.as_utf16_str(), utf16str!("hel"));
        assert_eq!(s.len(), 3);
        s.clear();
        assert!(s.is_empty());
    }

    #[test]
    #[should_panic(expected = "is not on a UTF-16 char boundary")]
    fn truncate_mid_surrogate_panics() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push('💖'); // 2 u16 units
        s.truncate(1);
    }

    #[test]
    fn insert_and_remove() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));
        s.insert(0, 'X');
        assert_eq!(s.as_utf16_str(), utf16str!("Xhello"));
        s.insert_utf16_str(2, utf16str!("YY"));
        assert_eq!(s.as_utf16_str(), utf16str!("XhYYello"));
        let removed = s.remove(0);
        assert_eq!(removed, 'X');
        assert_eq!(s.as_utf16_str(), utf16str!("hYYello"));
    }

    #[test]
    fn replace_range_grows_and_shrinks() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("Hello, world!"));
        s.replace_range(7..12, utf16str!("everyone"));
        assert_eq!(s.as_utf16_str(), utf16str!("Hello, everyone!"));
        s.replace_range(7..15, utf16str!("X"));
        assert_eq!(s.as_utf16_str(), utf16str!("Hello, X!"));
    }

    #[test]
    fn retain_drops_predicate_failures() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_from_str("Hello, World!");
        s.retain(|c| c.is_ascii_alphabetic());
        assert_eq!(s.as_utf16_str(), utf16str!("HelloWorld"));
    }

    #[test]
    fn capacity_growth() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        let n = if cfg!(miri) { 256 } else { 1000 };
        for _ in 0..n {
            s.push('a');
        }
        assert_eq!(s.len(), n);
        assert!(s.capacity() >= n);
    }

    #[test]
    fn shrink_to_fit_at_bump_cursor() {
        let arena = Arena::builder().build();
        let mut s = arena.alloc_utf16_string_with_capacity(64);
        s.push_str(utf16str!("hi"));
        let cap_before = s.capacity();
        assert!(cap_before >= 64);
        s.shrink_to_fit();
        assert_eq!(s.capacity(), 2);
    }

    #[test]
    fn extend_with_chars_str_and_utf16str() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend(['a', 'b', 'c'].iter().copied());
        s.extend(["12", "34"].iter().copied());
        s.extend([utf16str!("XY"), utf16str!("Z")].iter().copied());
        assert_eq!(s.as_utf16_str(), utf16str!("abc1234XYZ"));
    }

    #[test]
    fn from_str_in_and_from_utf16_str_in() {
        let arena = Arena::new();
        let a = multitude::strings::Utf16String::from_str_in("hello", &arena);
        assert_eq!(a.as_utf16_str(), utf16str!("hello"));
        let b = multitude::strings::Utf16String::from_utf16_str_in(utf16str!("world"), &arena);
        assert_eq!(b.as_utf16_str(), utf16str!("world"));
    }

    #[test]
    fn clone_builder() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));
        let c = s.clone();
        assert_eq!(c.as_utf16_str(), s.as_utf16_str());
    }

    #[test]
    fn freeze_tail_reclamation() {
        let arena = Arena::builder().build();
        let stats_before = arena.alloc_utf16_string_with_capacity(64);
        let cap_before = stats_before.capacity();
        drop(stats_before);
        let mut s = arena.alloc_utf16_string_with_capacity(64);
        s.push_str(utf16str!("hi"));
        let r = s.into_arena_utf16_str();
        // Tail reclaim should let a subsequent allocation reuse those bytes.
        let s2 = arena.alloc_utf16_string_with_capacity(50);
        assert!(s2.capacity() >= 50);
        assert_eq!(&*r, utf16str!("hi"));
        assert!(cap_before >= 64);
    }

    #[test]
    fn push_str_accepts_borrowed_utf16str() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        let lit: &widestring::Utf16Str = utf16str!("ab");
        s.push_str(lit);
        assert_eq!(s.as_utf16_str(), utf16str!("ab"));
    }

    #[test]
    fn push_str_accepts_utf16string_via_as_ref() {
        let arena = Arena::new();
        let mut a = arena.alloc_utf16_string();
        a.push_str(utf16str!("hello"));
        let mut b = arena.alloc_utf16_string();
        b.push_str(&a);
        assert_eq!(b.as_utf16_str(), utf16str!("hello"));
    }

    #[test]
    fn push_str_accepts_box_rc_arc_utf16_str() {
        let arena = Arena::new();
        let mut src = arena.alloc_utf16_string();
        src.push_str(utf16str!("xyz"));
        let boxed = arena.alloc_utf16_str_box(utf16str!("xyz"));
        let rc = arena.alloc_utf16_str_rc(utf16str!("xyz"));
        let arc = arena.alloc_utf16_str_arc(utf16str!("xyz"));

        let mut out = arena.alloc_utf16_string();
        out.push_str(&boxed);
        out.push_str(&rc);
        out.push_str(&arc);
        assert_eq!(out.as_utf16_str(), utf16str!("xyzxyzxyz"));
    }

    #[test]
    fn try_push_str_accepts_as_ref_kinds() {
        let arena = Arena::new();
        let lit = utf16str!("lit-");
        let mut owned = arena.alloc_utf16_string();
        owned.push_str(utf16str!("own-"));
        let boxed = arena.alloc_utf16_str_box(utf16str!("box-"));
        let rc = arena.alloc_utf16_str_rc(utf16str!("rc-"));
        let arc = arena.alloc_utf16_str_arc(utf16str!("arc"));

        let mut out = arena.alloc_utf16_string();
        out.try_push_str(lit).unwrap();
        out.try_push_str(&owned).unwrap();
        out.try_push_str(&boxed).unwrap();
        out.try_push_str(&rc).unwrap();
        out.try_push_str(&arc).unwrap();
        assert_eq!(out.as_utf16_str(), utf16str!("lit-own-box-rc-arc"));
    }

    #[test]
    fn push_from_str_accepts_str_like_types() {
        let arena = Arena::new();
        let owned = alloc::string::String::from("own-");
        let boxed: alloc::boxed::Box<str> = alloc::boxed::Box::from("box-");
        let rc: alloc::rc::Rc<str> = alloc::rc::Rc::from("rc-");
        let arc: alloc::sync::Arc<str> = alloc::sync::Arc::from("arc");

        let mut out = arena.alloc_utf16_string();
        out.push_from_str("lit-");
        out.push_from_str(&owned);
        out.push_from_str(&boxed);
        out.push_from_str(&rc);
        out.push_from_str(&arc);
        assert_eq!(out.as_utf16_str(), utf16str!("lit-own-box-rc-arc"));
    }

    #[test]
    fn try_push_from_str_accepts_str_like_types() {
        let arena = Arena::new();
        let owned = alloc::string::String::from("hello, 💖");
        let mut out = arena.alloc_utf16_string();
        out.try_push_from_str(&owned).unwrap();
        out.try_push_from_str("!").unwrap();
        assert_eq!(out.as_utf16_str(), utf16str!("hello, 💖!"));
    }

    // === Fast, direct tests targeting Utf16String::len and ===
    // === Utf16String::try_with_capacity_in mutants.          ===
    //
    // These mutants survive when the only coverage runs through heavy
    // integration paths. Keep these tests minimal so cargo-mutants can
    // kill them quickly (a `len -> 0` replacement should fail in
    // milliseconds, not minutes).

    #[test]
    fn len_is_zero_for_fresh_string() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_string();
        assert_eq!(s.len(), 0);
        assert!(s.is_empty());
    }

    #[test]
    fn len_tracks_number_of_u16_code_units_after_push_str() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        assert_eq!(s.len(), 3);
        s.push_str(utf16str!("de"));
        assert_eq!(s.len(), 5);
    }

    #[test]
    fn len_handles_non_bmp_chars_as_two_code_units() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push('🦀'); // U+1F980, one scalar => two UTF-16 code units
        assert_eq!(s.len(), 2);
        s.push('a');
        assert_eq!(s.len(), 3);
    }

    #[test]
    fn len_returns_zero_after_clear() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("nonempty"));
        assert!(!s.is_empty());
        s.clear();
        assert_eq!(s.len(), 0);
    }

    #[test]
    fn try_with_capacity_in_zero_does_not_allocate_but_is_usable() {
        let arena = Arena::new();
        let s = multitude::strings::Utf16String::try_with_capacity_in(0, &arena).unwrap();
        assert_eq!(s.len(), 0);
        assert_eq!(s.capacity(), 0);
        assert!(s.is_empty());
    }

    #[test]
    fn try_with_capacity_in_respects_requested_capacity() {
        let arena = Arena::new();
        let s = multitude::strings::Utf16String::try_with_capacity_in(8, &arena).unwrap();
        assert!(s.capacity() >= 8);
        assert_eq!(s.len(), 0);
    }

    #[test]
    fn try_with_capacity_in_one_allocates_at_least_one_unit() {
        let arena = Arena::new();
        let s = multitude::strings::Utf16String::try_with_capacity_in(1, &arena).unwrap();
        assert!(s.capacity() >= 1);
        assert_eq!(s.len(), 0);
    }

    #[test]
    fn reserve_grows_capacity_and_preserves_contents() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        let cap_before = s.capacity();
        s.reserve(cap_before + 32);
        assert!(s.capacity() >= s.len() + cap_before + 32);
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
        assert_eq!(s.len(), 3);
    }

    #[test]
    fn reserve_grows_from_zero_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        assert_eq!(s.capacity(), 0);
        s.reserve(64);
        assert!(s.capacity() >= 64);
        assert_eq!(s.len(), 0);
    }

    #[test]
    fn try_reserve_zero_additional_is_noop() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("xy"));
        let cap_before = s.capacity();
        s.try_reserve(0).unwrap();
        assert_eq!(s.capacity(), cap_before);
        assert_eq!(s.as_utf16_str(), utf16str!("xy"));
    }

    #[test]
    fn extend_chars_appends_in_order() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend(['a', 'b', 'c'].iter().copied());
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
        assert_eq!(s.len(), 3);
        s.extend(std::iter::once(&'d').copied());
        assert_eq!(s.as_utf16_str(), utf16str!("abcd"));
        assert_eq!(s.len(), 4);
    }

    #[test]
    fn extend_chars_handles_surrogate_pairs() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend(['a', '🦀', 'b'].iter().copied());
        assert_eq!(s.as_utf16_str(), utf16str!("a🦀b"));
        assert_eq!(s.len(), 4); // 1 + 2 + 1
    }

    #[test]
    fn extend_str_slices_appends_in_order() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend(["ab", "cd"].iter().copied());
        assert_eq!(s.as_utf16_str(), utf16str!("abcd"));
        assert_eq!(s.len(), 4);
    }

    #[test]
    fn extend_utf16_str_slices_appends_in_order() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend([utf16str!("ab"), utf16str!("cd")].iter().copied());
        assert_eq!(s.as_utf16_str(), utf16str!("abcd"));
        assert_eq!(s.len(), 4);
    }

    extern crate alloc;
}

// === merged from tests/utf16_format.rs ===
mod utf16_format {

    use core::fmt;

    use multitude::Arena;
    use multitude::strings::format_utf16;
    use widestring::utf16str;

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;

    #[test]
    fn format_utf16_basic() {
        let arena = Arena::new();
        let n = 42_i32;
        let s = format_utf16!(in &arena, "n = {n}");
        assert_eq!(s.as_utf16_str(), utf16str!("n = 42"));
    }

    #[test]
    fn format_utf16_with_unicode() {
        let arena = Arena::new();
        let s = format_utf16!(in &arena, "love {}", '💖');
        assert_eq!(s.as_utf16_str(), utf16str!("love 💖"));
    }

    /// A `Display` impl that fragments output across multiple `write_str`
    /// calls — verifies that fragmenting a sequence of code points across
    /// `write_str` boundaries produces correct UTF-16 output. Each `&str`
    /// passed to `write_str` is itself a complete UTF-8 fragment so no
    /// cross-call surrogate state is needed; this test exercises that
    /// invariant.
    struct Fragmented<'a>(&'a [&'a str]);

    impl fmt::Display for Fragmented<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            for piece in self.0 {
                f.write_str(piece)?;
            }
            Ok(())
        }
    }

    #[test]
    fn format_utf16_fragmented_writes() {
        let arena = Arena::new();
        let pieces = ["he", "llo, ", "💖", " bye"];
        let f = Fragmented(&pieces);
        let s = format_utf16!(in &arena, "{f}");
        assert_eq!(s.as_utf16_str(), utf16str!("hello, 💖 bye"));
    }

    #[test]
    fn format_utf16_freeze() {
        let arena = Arena::new();
        let s = format_utf16!(in &arena, "x={}", 7);
        let frozen: multitude::strings::RcUtf16Str = s.into_arena_utf16_str();
        assert_eq!(&*frozen, utf16str!("x=7"));
    }
}

// === merged from tests/utf16_serde.rs ===
mod utf16_serde {

    use multitude::Arena;
    use widestring::utf16str;

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;

    #[test]
    fn rc_serializes_as_utf8_string() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_rc(utf16str!("hello, 💖"));
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(json, r#""hello, 💖""#);
    }

    #[test]
    fn arc_serializes_as_utf8_string() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_arc(utf16str!("shared"));
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(json, r#""shared""#);
    }

    #[test]
    fn box_serializes_as_utf8_string() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_box(utf16str!("boxed"));
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(json, r#""boxed""#);
    }

    #[test]
    fn string_serializes_as_utf8_string() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("growable"));
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(json, r#""growable""#);
    }
}

// === merged from tests/utf16_cross_thread.rs ===
mod utf16_cross_thread {

    use core::sync::atomic::{AtomicUsize, Ordering};
    use std::thread;

    use multitude::Arena;
    use widestring::utf16str;

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;

    #[test]
    fn arc_send_across_threads() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_arc(utf16str!("shared utf16"));
        let s2 = s.clone();
        let h = thread::spawn(move || s2.len());
        assert_eq!(h.join().unwrap(), 12);
        assert_eq!(&*s, utf16str!("shared utf16"));
    }

    #[test]
    fn arc_concurrent_clone_drop() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_str_arc(utf16str!("concurrent"));
        let counter = std::sync::Arc::new(AtomicUsize::new(0));
        let mut handles = std::vec::Vec::new();
        for _ in 0..8 {
            let s = s.clone();
            let c = std::sync::Arc::clone(&counter);
            handles.push(thread::spawn(move || {
                for _ in 0..100 {
                    let copy = s.clone();
                    let _ = c.fetch_add(copy.len(), Ordering::Relaxed);
                }
            }));
        }
        for h in handles {
            h.join().unwrap();
        }
        assert_eq!(counter.load(Ordering::Relaxed), 8 * 100 * 10);
        assert_eq!(&*s, utf16str!("concurrent"));
    }
}

// === merged from tests/utf16_coverage.rs ===
mod utf16_coverage {
    #![allow(clippy::std_instead_of_core, reason = "tests use std")]
    #![allow(clippy::unwrap_used, reason = "test code")]
    #![allow(unused_results, reason = "test code")]
    use std::collections::hash_map::DefaultHasher;
    use std::hash::{Hash, Hasher};
    use std::panic::AssertUnwindSafe;

    use multitude::Arena;
    use multitude::strings::{ArcStr, BoxStr, RcStr, RcUtf16Str, String, Utf16String};
    use widestring::{Utf16Str, utf16str};

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;
    use crate::common::{FailingAllocator, SendFailingAllocator};

    fn expect_panic<F: FnOnce()>(f: F) {
        let r = std::panic::catch_unwind(AssertUnwindSafe(f));
        assert!(r.is_err(), "expected panic but call returned");
    }

    fn fail_arena() -> Arena<FailingAllocator> {
        Arena::new_in(FailingAllocator::new(0))
    }
    fn send_fail_arena() -> Arena<SendFailingAllocator> {
        Arena::new_in(SendFailingAllocator::new(0))
    }

    #[test]
    fn panic_alloc_utf16_str_rc() {
        expect_panic(|| {
            let a = fail_arena();
            let _ = a.alloc_utf16_str_rc(utf16str!("x"));
        });
    }

    #[test]
    fn panic_alloc_utf16_str_arc() {
        expect_panic(|| {
            let a = send_fail_arena();
            let _ = a.alloc_utf16_str_arc(utf16str!("x"));
        });
    }

    #[test]
    fn panic_alloc_utf16_str_box() {
        expect_panic(|| {
            let a = fail_arena();
            let _ = a.alloc_utf16_str_box(utf16str!("x"));
        });
    }

    #[test]
    fn panic_alloc_utf16_str_rc_from_str() {
        expect_panic(|| {
            let a = fail_arena();
            let _ = a.alloc_utf16_str_rc_from_str("x");
        });
    }

    #[test]
    fn panic_alloc_utf16_str_arc_from_str() {
        expect_panic(|| {
            let a = send_fail_arena();
            let _ = a.alloc_utf16_str_arc_from_str("x");
        });
    }

    #[test]
    fn panic_alloc_utf16_str_box_from_str() {
        expect_panic(|| {
            let a = fail_arena();
            let _ = a.alloc_utf16_str_box_from_str("x");
        });
    }

    #[test]
    fn panic_alloc_utf16_string_with_capacity() {
        expect_panic(|| {
            let a = fail_arena();
            let _ = a.alloc_utf16_string_with_capacity(64);
        });
    }

    #[test]
    fn try_alloc_utf16_str_rc_err() {
        let a = fail_arena();
        a.try_alloc_utf16_str_rc(utf16str!("x")).unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_str_arc_err() {
        let a = send_fail_arena();
        a.try_alloc_utf16_str_arc(utf16str!("x")).unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_str_box_err() {
        let a = fail_arena();
        a.try_alloc_utf16_str_box(utf16str!("x")).unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_str_rc_from_str_err() {
        let a = fail_arena();
        a.try_alloc_utf16_str_rc_from_str("x").unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_str_arc_from_str_err() {
        let a = send_fail_arena();
        a.try_alloc_utf16_str_arc_from_str("x").unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_str_box_from_str_err() {
        let a = fail_arena();
        a.try_alloc_utf16_str_box_from_str("x").unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_string_with_capacity_err() {
        let a = fail_arena();
        a.try_alloc_utf16_string_with_capacity(64).unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_string_with_capacity_zero_no_alloc() {
        // cap == 0 — no allocation, no failure.
        let a = fail_arena();
        let s = a.try_alloc_utf16_string_with_capacity(0).unwrap();
        assert_eq!(s.capacity(), 0);
    }

    #[test]
    fn empty_builder_accessors() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_string();
        assert_eq!(s.len(), 0);
        assert!(s.is_empty());
        assert_eq!(s.capacity(), 0);
        assert_eq!(s.as_utf16_str(), utf16str!(""));
        let empty: &[u16] = &[];
        assert_eq!(s.as_slice(), empty);
        let p: *const u16 = s.as_ptr();
        assert!(!p.is_null());
    }

    #[test]
    fn empty_builder_as_mut() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        let m: &mut Utf16Str = s.as_mut_utf16_str();
        assert_eq!(m, utf16str!(""));
        let p: *mut u16 = s.as_mut_ptr();
        assert!(!p.is_null());
    }

    #[test]
    fn pop_on_empty_returns_none() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        assert_eq!(s.pop(), None);
    }

    #[test]
    fn truncate_noop_when_new_len_ge_len() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.truncate(10);
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
        // Folded from_mutants_extras_utf16_scattered::utf16_truncate_to_current_length_is_noop.
        s.truncate(3);
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
        assert_eq!(s.len(), 3);
    }

    #[test]
    fn shrink_to_fit_noop_when_full() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(0, &arena);
        // cap==0 path
        s.shrink_to_fit();
        assert_eq!(s.capacity(), 0);

        // Folded from_mutants_extras_utf16_scattered::utf16_shrink_to_fit_already_tight_is_noop.
        let mut tight = arena.alloc_utf16_string_with_capacity(3);
        tight.push_from_str("abc");
        tight.shrink_to_fit();
        assert_eq!(tight.len(), 3);

        // cap == len path
        s.push_str(utf16str!("hi"));
        let cap = s.capacity();
        let len = s.len();
        if cap == len {
            s.shrink_to_fit(); // still no-op
            assert_eq!(s.capacity(), cap);
        }
        let mut s2 = Utf16String::with_capacity_in(8, &arena);
        s2.push_str(utf16str!("ab"));
        drop(s); // ensure s2 is no longer at the bump cursor
        let _other = arena.alloc_utf16_str_rc(utf16str!("xx"));
        let cap_before = s2.capacity();
        s2.shrink_to_fit(); // not at bump cursor → no-op
        assert_eq!(s2.capacity(), cap_before);
    }

    #[test]
    fn insert_str_empty_is_noop() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.insert_utf16_str(1, utf16str!(""));
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
    }

    #[test]
    fn insert_at_end() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.insert_utf16_str(3, utf16str!("XY"));
        assert_eq!(s.as_utf16_str(), utf16str!("abcXY"));
    }

    #[test]
    fn replace_range_unbounded() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));
        s.replace_range(.., utf16str!("world"));
        assert_eq!(s.as_utf16_str(), utf16str!("world"));
    }

    #[test]
    fn replace_range_inclusive_excluded_bounds() {
        use core::ops::Bound;
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abcdef"));
        // (Excluded(0), Included(2)) ≡ 1..=2
        s.replace_range((Bound::Excluded(0), Bound::Included(2)), utf16str!("X"));
        assert_eq!(s.as_utf16_str(), utf16str!("aXdef"));
    }

    #[test]
    fn replace_range_equal_size() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abcdef"));
        s.replace_range(2..4, utf16str!("XY")); // same length
        assert_eq!(s.as_utf16_str(), utf16str!("abXYef"));
    }

    #[test]
    fn try_push_err() {
        let a = fail_arena();
        let mut s = Utf16String::new_in(&a);
        assert!(s.try_push('a').is_err());
    }

    #[test]
    fn try_push_str_err() {
        let a = fail_arena();
        let mut s = Utf16String::new_in(&a);
        assert!(s.try_push_str(utf16str!("abc")).is_err());
    }

    #[test]
    fn try_push_from_str_err() {
        let a = fail_arena();
        let mut s = Utf16String::new_in(&a);
        assert!(s.try_push_from_str("abc").is_err());
    }

    #[test]
    fn try_reserve_zero_is_noop() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.try_reserve(0).unwrap();
        assert_eq!(s.capacity(), 0);
    }

    #[test]
    fn reserve_panics_when_alloc_fails() {
        expect_panic(|| {
            let a = fail_arena();
            let mut s = Utf16String::new_in(&a);
            s.reserve(64);
        });
    }

    #[test]
    fn try_reserve_err() {
        let a = fail_arena();
        let mut s = Utf16String::new_in(&a);
        assert!(s.try_reserve(64).is_err());
    }

    #[test]
    fn push_empty_str_is_noop() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!(""));
        assert!(s.is_empty());
        s.push_from_str("");
        assert!(s.is_empty());
    }

    #[test]
    fn try_push_from_str_with_surrogate_pair() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.try_push_from_str("a💖b").unwrap();
        assert_eq!(s.as_utf16_str(), utf16str!("a💖b"));
    }

    #[test]
    fn arena_utf16_string_traits() {
        use core::borrow::{Borrow, BorrowMut};
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));

        // Deref / DerefMut
        let _: &Utf16Str = &s;
        let _: &mut Utf16Str = &mut s;
        // AsRef / AsMut
        let _: &Utf16Str = AsRef::as_ref(&s);
        let _: &mut Utf16Str = AsMut::as_mut(&mut s);
        // Borrow / BorrowMut
        let _: &Utf16Str = Borrow::borrow(&s);
        let _: &mut Utf16Str = BorrowMut::borrow_mut(&mut s);

        // Clone
        let c = s.clone();
        assert_eq!(c, s);
        assert_eq!(c.as_utf16_str(), s.as_utf16_str());

        // Ord / PartialOrd
        let mut other = arena.alloc_utf16_string();
        other.push_str(utf16str!("hellp"));
        assert!(s < other);
        assert!(s.partial_cmp(&other).is_some());
        assert_eq!(s.cmp(&s.clone()), core::cmp::Ordering::Equal);

        // PartialEq vs Self / Utf16Str / &Utf16Str
        let lit = utf16str!("hello");
        assert_eq!(s, lit);
        assert!(s == lit);

        // Hash
        let mut h = DefaultHasher::new();
        s.hash(&mut h);
        let _ = h.finish();

        // Display / Debug
        let _ = format!("{s}");
        let _ = format!("{s:?}");
    }

    #[test]
    fn rc_utf16_traits_and_pointer() {
        use core::borrow::Borrow;
        let arena = Arena::new();
        let r = arena.alloc_utf16_str_rc(utf16str!("hello"));
        let _: &Utf16Str = &r;
        let _: &Utf16Str = AsRef::as_ref(&r);
        let _: &Utf16Str = Borrow::borrow(&r);

        // PartialEq vs Utf16Str / &Utf16Str
        assert!(r == *utf16str!("hello"));
        assert!(r == utf16str!("hello"));

        // Display / Debug / Pointer formatters
        let _ = format!("{r}");
        let _ = format!("{r:?}");
        let _ = format!("{r:p}");

        // Hash
        let mut h = DefaultHasher::new();
        r.hash(&mut h);
        let _ = h.finish();

        // Ord / PartialOrd via clones
        let r2 = r.clone();
        assert_eq!(r.cmp(&r2), core::cmp::Ordering::Equal);
        assert_eq!(r.partial_cmp(&r2), Some(core::cmp::Ordering::Equal));

        // From<ArenaRcUtf16Str> for ArenaRc<[u16]>
        let bytes: multitude::Rc<[u16]> = r.into();
        assert_eq!(
            &*bytes,
            &[u16::from(b'h'), u16::from(b'e'), u16::from(b'l'), u16::from(b'l'), u16::from(b'o')][..]
        );
    }

    #[test]
    fn arc_utf16_traits_and_pointer() {
        use core::borrow::Borrow;
        let arena = Arena::new();
        let a = arena.alloc_utf16_str_arc(utf16str!("hello"));
        let _: &Utf16Str = &a;
        let _: &Utf16Str = AsRef::as_ref(&a);
        let _: &Utf16Str = Borrow::borrow(&a);

        assert!(a == *utf16str!("hello"));
        assert!(a == utf16str!("hello"));

        let _ = format!("{a}");
        let _ = format!("{a:?}");
        let _ = format!("{a:p}");

        let mut h = DefaultHasher::new();
        a.hash(&mut h);
        let _ = h.finish();

        let a2 = a.clone();
        assert_eq!(a.cmp(&a2), core::cmp::Ordering::Equal);
        assert_eq!(a.partial_cmp(&a2), Some(core::cmp::Ordering::Equal));

        let bytes: multitude::Arc<[u16]> = a.into();
        assert_eq!(
            &*bytes,
            &[u16::from(b'h'), u16::from(b'e'), u16::from(b'l'), u16::from(b'l'), u16::from(b'o')][..]
        );
    }

    #[test]
    fn box_utf16_traits_pointer_and_mutators() {
        use core::borrow::{Borrow, BorrowMut};
        let arena = Arena::new();
        let mut b = arena.alloc_utf16_str_box(utf16str!("hello"));

        // Deref / DerefMut / AsRef / AsMut / Borrow / BorrowMut
        let _: &Utf16Str = &b;
        let _: &mut Utf16Str = &mut b;
        let _: &Utf16Str = AsRef::as_ref(&b);
        let _: &mut Utf16Str = AsMut::as_mut(&mut b);
        let _: &Utf16Str = Borrow::borrow(&b);
        let _: &mut Utf16Str = BorrowMut::borrow_mut(&mut b);

        // PartialEq variants
        assert!(b == *utf16str!("hello"));
        assert!(b == utf16str!("hello"));

        // Display / Debug / Pointer
        let _ = format!("{b}");
        let _ = format!("{b:?}");
        let _ = format!("{b:p}");

        // Hash
        let mut h = DefaultHasher::new();
        b.hash(&mut h);
        let _ = h.finish();

        // Ord / PartialOrd against another box
        let b2 = arena.alloc_utf16_str_box(utf16str!("hello"));
        assert_eq!(b.cmp(&b2), core::cmp::Ordering::Equal);
        assert_eq!(b.partial_cmp(&b2), Some(core::cmp::Ordering::Equal));

        // From<ArenaBoxUtf16Str> for ArenaRcUtf16Str
        let r: RcUtf16Str = b.into();
        assert_eq!(&*r, utf16str!("hello"));
    }

    #[test]
    fn utf8_smart_pointer_partial_eq_str() {
        let arena = Arena::new();

        let r: RcStr = arena.alloc_str_rc("hi");
        assert!(r == *"hi");
        assert!(r == "hi");

        let a: ArcStr = arena.alloc_str_arc("hi");
        assert!(a == *"hi");
        assert!(a == "hi");

        let b: BoxStr = arena.alloc_str_box("hi");
        assert!(b == *"hi");
        assert!(b == "hi");

        let mut g: String = arena.alloc_string();
        g.push_str("hi");
        assert!(g == *"hi");
        assert!(g == "hi");
    }

    #[test]
    fn from_utf16_str_in_and_from_str_in() {
        let arena = Arena::new();
        let a = Utf16String::from_str_in("hello, 💖", &arena);
        assert_eq!(a.as_utf16_str(), utf16str!("hello, 💖"));
        let b = Utf16String::from_utf16_str_in(utf16str!("world"), &arena);
        assert_eq!(b.as_utf16_str(), utf16str!("world"));
    }

    #[test]
    fn extend_chars_with_size_hint() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        let chars = ['a', 'b', 'c', '💖'];
        s.extend(chars.iter().copied()); // size_hint > 0 → reserve path
        assert_eq!(s.as_utf16_str(), utf16str!("abc💖"));
    }

    #[test]
    fn extend_chars_zero_lower_bound() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend(core::iter::empty::<char>()); // lower == 0 → skip reserve branch
        assert!(s.is_empty());
    }

    #[test]
    fn extend_str_slices() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend(["ab", "cd"]);
        assert_eq!(s.as_utf16_str(), utf16str!("abcd"));
    }

    #[test]
    fn extend_utf16_str_slices() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.extend([utf16str!("ab"), utf16str!("cd")]);
        assert_eq!(s.as_utf16_str(), utf16str!("abcd"));
    }

    #[test]
    #[should_panic(expected = "not on a UTF-16 char boundary")]
    fn insert_at_mid_surrogate_panics() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push('💖');
        s.insert(1, 'X');
    }

    #[test]
    #[should_panic(expected = "not on a UTF-16 char boundary")]
    fn remove_at_mid_surrogate_panics() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push('💖');
        s.remove(1);
    }

    #[test]
    #[should_panic(expected = "not on a UTF-16 char boundary")]
    fn replace_range_start_mid_surrogate_panics() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("a💖b"));
        s.replace_range(2..3, utf16str!(""));
    }

    #[test]
    #[should_panic(expected = "Utf16String::replace_range")]
    fn replace_range_end_oob_panics() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.replace_range(0..10, utf16str!(""));
    }

    #[test]
    #[should_panic(expected = "Utf16String::replace_range")]
    fn replace_range_start_greater_than_end_panics() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        #[expect(clippy::reversed_empty_ranges, reason = "intentionally inverted to trigger panic")]
        s.replace_range(2..1, utf16str!(""));
    }

    #[test]
    fn grow_doubling_path() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(4, &arena);
        s.push_str(utf16str!("abcd"));
        s.push('e'); // forces grow; doubling 4*2 = 8 covers needed 5
        assert!(s.capacity() >= 8);
        assert_eq!(s.as_utf16_str(), utf16str!("abcde"));
    }

    #[test]
    fn grow_uses_min_cap_when_doubling_too_small() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(4, &arena);
        s.push_str(utf16str!("abcd"));
        let big = "x".repeat(100);
        s.push_from_str(&big); // forces grow; min_cap > 2*old_cap
        assert!(s.capacity() >= 104);
    }

    #[test]
    fn arena_utf16_string_drop_releases_chunk() {
        let arena = Arena::new();
        {
            let mut s = arena.alloc_utf16_string();
            s.push_str(utf16str!("data"));
            // explicit drop covers the cap > 0 branch in Drop
        }
        // arena drop later covers the cap == 0 branch via the empty builder used elsewhere
    }

    #[test]
    fn retain_keep_all() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.retain(|_| true);
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
    }

    #[test]
    fn retain_drop_all() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.retain(|_| false);
        assert!(s.is_empty());
    }

    #[test]
    fn retain_with_surrogate() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("a💖b"));
        s.retain(|c| c.is_ascii());
        assert_eq!(s.as_utf16_str(), utf16str!("ab"));
    }

    #[test]
    fn clear_resets_len_only() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));
        let cap = s.capacity();
        s.clear();
        assert_eq!(s.len(), 0);
        assert_eq!(s.capacity(), cap);
    }

    #[test]
    fn into_arena_utf16_str_zero_cap() {
        let arena = Arena::new();
        let s = arena.alloc_utf16_string();
        let r = s.into_arena_utf16_str();
        assert!(r.is_empty());
    }

    #[test]
    fn into_arena_utf16_str_with_data_reclaims_tail() {
        let arena = Arena::builder().build();
        let mut s = arena.alloc_utf16_string_with_capacity(64);
        s.push_str(utf16str!("hi"));
        let r = s.into_arena_utf16_str();
        assert_eq!(&*r, utf16str!("hi"));
        let _follow = arena.alloc_utf16_string_with_capacity(50);
    }

    // From<ArenaUtf16String> for ArenaRcUtf16Str (exercises the
    // `into` arrow that the From impl wraps).

    #[test]
    fn from_arena_utf16_string_for_rc() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("frozen"));
        let r: RcUtf16Str = s.into();
        assert_eq!(&*r, utf16str!("frozen"));
    }

    // Display impl chain: ArenaArcUtf16Str / ArenaBoxUtf16Str / ArenaRcUtf16Str
    // pass through to Utf16Str's Display.

    #[test]
    fn display_passes_through() {
        let arena = Arena::new();
        let r = arena.alloc_utf16_str_rc(utf16str!("hi💖"));
        assert_eq!(format!("{r}"), "hi💖");
        let a = arena.alloc_utf16_str_arc(utf16str!("hi💖"));
        assert_eq!(format!("{a}"), "hi💖");
        let b = arena.alloc_utf16_str_box(utf16str!("hi💖"));
        assert_eq!(format!("{b}"), "hi💖");

        // Folded from_coverage_extras_utf16::utf16_string_display_renders_content.
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hello"));
        assert_eq!(std::format!("{s}"), "hello");
    }

    #[test]
    fn insert_grows_capacity() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(4, &arena);
        s.push_str(utf16str!("abcd"));
        s.insert_utf16_str(2, utf16str!("XYZW"));
        assert_eq!(s.as_utf16_str(), utf16str!("abXYZWcd"));
        assert!(s.capacity() >= 8);
    }

    #[test]
    fn replace_range_grows_capacity() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(4, &arena);
        s.push_str(utf16str!("abcd"));
        s.replace_range(0..1, utf16str!("XXXXX")); // adds 4 → needs cap 8
        assert_eq!(s.as_utf16_str(), utf16str!("XXXXXbcd"));
        assert!(s.capacity() >= 8);
    }

    #[test]
    fn as_slice_non_empty() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("ab"));
        let slice: &[u16] = s.as_slice();
        assert_eq!(slice, &[u16::from(b'a'), u16::from(b'b')][..]);
    }

    // PartialEq<Utf16Str> (by-value rhs) on the ArenaUtf16String — explicitly
    // invoke the impl so its body is hit.

    #[test]
    fn arena_utf16_string_eq_utf16str_value() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("hi"));
        let lit: &Utf16Str = utf16str!("hi");
        // Both PartialEq<&Utf16Str> (s == lit) and PartialEq<Utf16Str> (s == *lit)
        // are reachable through method-call form; using the bare op resolves to
        // whichever impl rustc prefers, so call eq directly to nail the by-value one.
        assert!(<Utf16String<'_, _> as PartialEq<Utf16Str>>::eq(&s, lit));
        assert!(<Utf16String<'_, _> as PartialEq<&Utf16Str>>::eq(&s, &lit));
    }

    // from_str helpers: allocator-failure paths. The from-str variants now
    // transcode directly into the target-flavor chunk in a single allocation,
    // so the only failure point is that one allocation.

    #[test]
    fn try_alloc_utf16_str_arc_from_str_err_on_alloc_failure() {
        // FailingAllocator(0): the very first alloc fails. With the
        // single-allocation transcode path, that's the only path to Err.
        let arena = Arena::new_in(SendFailingAllocator::new(0));
        arena.try_alloc_utf16_str_arc_from_str("xyz").unwrap_err();
    }

    #[test]
    fn try_alloc_utf16_str_rc_from_str_success() {
        let arena = Arena::new();
        let r = arena.try_alloc_utf16_str_rc_from_str("hello, 💖").unwrap();
        assert_eq!(&*r, utf16str!("hello, 💖"));
    }

    #[test]
    fn try_alloc_utf16_str_arc_from_str_success() {
        let arena = Arena::new();
        let a = arena.try_alloc_utf16_str_arc_from_str("hello").unwrap();
        assert_eq!(&*a, utf16str!("hello"));
    }

    #[test]
    fn try_alloc_utf16_str_box_from_str_success() {
        let arena = Arena::new();
        let b = arena.try_alloc_utf16_str_box_from_str("hello").unwrap();
        assert_eq!(&*b, utf16str!("hello"));
    }

    #[test]
    fn try_alloc_utf16_str_box_from_str_err_on_alloc_failure() {
        // Single-allocation transcode path: the chunk alloc is the only failure point.
        let arena = Arena::new_in(FailingAllocator::new(0));
        arena.try_alloc_utf16_str_box_from_str("xyz").unwrap_err();
    }

    // Panic-driving variants of the same path (drive the `panic_alloc` lambda
    // in `alloc_utf16_str_*_from_str`).

    #[test]
    fn panic_alloc_utf16_str_arc_from_str_when_alloc_fails() {
        expect_panic(|| {
            let arena = Arena::new_in(SendFailingAllocator::new(0));
            let _ = arena.alloc_utf16_str_arc_from_str("xyz");
        });
    }

    #[test]
    fn panic_alloc_utf16_str_box_from_str_when_alloc_fails() {
        expect_panic(|| {
            let arena = Arena::new_in(FailingAllocator::new(0));
            let _ = arena.alloc_utf16_str_box_from_str("xyz");
        });
    }

    // grow_for_string err inside try_grow_to_at_least: cap > 0 path that
    // re-allocates and the allocator fails on the relocation.

    #[test]
    fn grow_for_string_err_on_relocation() {
        // FailingAllocator(1): builder gets initial chunk (cap=4), then a huge
        // try_reserve would need a fresh oversized chunk → second alloc fails.
        let arena = Arena::builder().allocator_in(FailingAllocator::new(1)).build();
        let mut s = Utf16String::try_with_capacity_in(4, &arena).unwrap();
        s.try_push_str(utf16str!("abcd")).unwrap();
        assert!(s.try_reserve(64 * 1024).is_err());
    }

    #[test]
    fn panic_grow_to_at_least() {
        expect_panic(|| {
            let arena = Arena::builder().allocator_in(FailingAllocator::new(1)).build();
            let mut s = Utf16String::try_with_capacity_in(4, &arena).unwrap();
            s.try_push_str(utf16str!("abcd")).unwrap();
            // grow_to_at_least's panic_alloc lambda fires here.
            s.push_from_str("x".repeat(64 * 1024));
        });
    }

    // Panic paths through push / push_str / push_from_str when the allocator
    // fails — drives the `unwrap_or_else(panic_alloc)` lambdas inside push_slice
    // and push_from_str, plus the `reserve` path with no growth needed.

    #[test]
    fn panic_push_when_alloc_fails() {
        expect_panic(|| {
            let a = fail_arena();
            let mut s = Utf16String::new_in(&a);
            s.push('a');
        });
    }

    #[test]
    fn panic_push_str_when_alloc_fails() {
        expect_panic(|| {
            let a = fail_arena();
            let mut s = Utf16String::new_in(&a);
            s.push_str(utf16str!("abc"));
        });
    }

    #[test]
    fn panic_push_from_str_when_alloc_fails() {
        expect_panic(|| {
            let a = fail_arena();
            let mut s = Utf16String::new_in(&a);
            s.push_from_str("abc");
        });
    }

    #[test]
    fn reserve_no_growth_path() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(16, &arena);
        s.reserve(4); // already have cap >= len + 4; no-op branch
        assert_eq!(s.capacity(), 16);
        assert_eq!(s.len(), 0);
    }

    // `total > isize::MAX` guard: cap whose payload byte count overflows isize
    // (but not usize) — we never allocate; the function returns AllocError
    // before reaching the allocator.

    #[test]
    fn try_with_capacity_isize_overflow_guard() {
        let arena = Arena::new();
        // cap*2 > isize::MAX but ≤ usize::MAX on 64-bit. checked_mul succeeds,
        // checked_add succeeds, isize::try_from fails → AllocError.
        let cap = (isize::MAX.unsigned_abs() / 2) + 1000;
        let r = Utf16String::try_with_capacity_in(cap, &arena);
        r.unwrap_err();
    }

    #[test]
    fn try_grow_isize_overflow_guard() {
        let arena = Arena::new();
        let mut s = Utf16String::try_with_capacity_in(4, &arena).unwrap();
        // Force try_grow_to_at_least → new_cap such that new_cap*2 > isize::MAX
        // but ≤ usize::MAX. The isize::try_from check on new_total returns Err.
        let huge = (isize::MAX.unsigned_abs() / 2) + 1000;
        let r = s.try_reserve(huge);
        assert!(r.is_err());
    }
}

// === merged from tests/mutants_utf16_strings.rs ===
mod mutants_for_utf16_strings {
    #![allow(clippy::std_instead_of_core, reason = "test code")]
    #![allow(clippy::unwrap_used, reason = "test code")]
    #![allow(clippy::doc_markdown, reason = "doc comments cite raw identifier names")]
    #![allow(clippy::cast_possible_truncation, reason = "bounded indices fit in u16")]
    #![allow(clippy::unnecessary_cast, reason = "explicit width clarifies intent")]
    #![allow(clippy::cast_lossless, reason = "test code")]
    use multitude::Arena;
    use multitude::strings::Utf16String;
    use widestring::utf16str;

    #[expect(unused_imports, reason = "merged test module re-exports common helpers")]
    use crate::common;

    /// Kills `utf16_string.rs:191:20 > → >=` in `truncate`.
    ///
    /// `truncate(new_len)` performs a boundary check `new_len > 0` to
    /// guard a surrogate-pair assert. With `>=`, the assert path is
    /// taken for `new_len == 0` and reads `self.as_slice()[0]` — which
    /// is safe (empty slice indexing panics deterministically when
    /// `len == 0`, but in our scenario `len > 0`). We instead rely on
    /// the *post-truncate length* invariant: truncating to 0 must leave
    /// the string empty. With `>=` (mutant), the function panics on
    /// surrogate check before assigning `self.len = 0`. Either way
    /// `len == 0` after a successful truncate(0).
    #[test]
    fn truncate_to_zero_clears_string() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abc"), &arena);
        s.truncate(0);
        assert_eq!(s.len(), 0);
        assert_eq!(s.as_utf16_str(), utf16str!(""));
    }

    /// Kills `utf16_string.rs:203:26 || → &&` and `206:38 - → /` and
    /// `207:43 * → +//` in `shrink_to_fit`.
    ///
    /// Pre-conditions:
    /// - `cap == 0 || len == cap` returns early; otherwise shrink.
    /// - With `&&`: early-return only when both, so otherwise-shrink path
    ///   runs even when `cap == 0` → UB-ish pointer math on dangling.
    /// - With `- → /`: `cap - len → cap / len` (wrong reclaim units).
    /// - With `* → + | /`: byte-count math wrong → wrong reclaim_bytes.
    ///
    /// To exercise: build a Utf16String with known cap > len, shrink_to_fit,
    /// assert capacity drops to `len`.
    #[test]
    fn shrink_to_fit_reduces_capacity_to_len() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(64, &arena);
        s.push_str(utf16str!("abc"));
        assert_eq!(s.len(), 3);
        let cap_before = s.capacity();
        assert!(cap_before >= 64);
        s.shrink_to_fit();
        assert_eq!(s.len(), 3);
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
        // Cap must drop to len when the buffer ends at the chunk's bump
        // cursor (it does, because no intervening allocation happened).
        assert_eq!(s.capacity(), 3);
    }

    /// Kills `utf16_string.rs:260:19 > → >=` (`try_push_from_str`),
    /// `277:19 > → >=` (`try_push_slice`), `298:19 > → >=` (`try_reserve`):
    /// the `if needed > self.cap { try_grow }` boundary. With `>=`, the
    /// grow path runs even when capacity already suffices.
    ///
    /// Detection: call try_reserve with a value that produces `needed
    /// == cap` exactly. With `>` the grow is skipped (no observable
    /// change); with `>=` the buffer is reallocated → observable via
    /// the change in pointer identity (`as_ptr()` differs).
    #[test]
    fn reserve_exact_capacity_does_not_regrow() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(8, &arena);
        assert!(s.capacity() >= 8);
        let cap = s.capacity();
        let ptr_before = s.as_ptr();
        // Reserve `additional` such that `needed == self.cap`. self.len ==
        // 0, so additional == cap.
        s.reserve(cap);
        let ptr_after = s.as_ptr();
        assert_eq!(s.capacity(), cap, "no regrow when cap already suffices");
        assert_eq!(
            ptr_before, ptr_after,
            "reserve at exact-fit boundary must not reallocate (kills `> → >=`)"
        );
    }

    /// Same as above for `try_push_slice` boundary.
    #[test]
    fn push_slice_at_exact_fit_does_not_regrow() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(8, &arena);
        let cap = s.capacity();
        let ptr_before = s.as_ptr();
        // Push exactly `cap` u16s.
        let payload: Vec<u16> = (0..cap as u16).collect();
        let payload_str = widestring::Utf16Str::from_slice(&payload).expect("valid utf16");
        s.push_str(payload_str);
        let ptr_after = s.as_ptr();
        assert_eq!(s.len(), cap);
        assert_eq!(s.capacity(), cap);
        assert_eq!(ptr_before, ptr_after, "push at exact-fit must not reallocate");
    }

    /// Kills `utf16_string.rs:318:16 > → >=` and `330:19 > → >=` and
    /// `337:76 - → +` in `insert_slice`.
    ///
    /// 318:16 is `if idx > 0 && idx < self.len` (surrogate check guard).
    /// 330:19 is `if needed > self.cap { grow }` (same shape as above).
    /// 337:76 is `self.len - idx` (memmove count). `- → +` produces
    /// `self.len + idx` → reads past the buffer → corruption or panic.
    ///
    /// Test by inserting a slice that fits exactly and asserting both
    /// content and length post-insert.
    #[test]
    fn insert_slice_preserves_content() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        // Insert at idx = 1 (boundary > 0 && < len)
        s.insert_utf16_str(1, utf16str!("XX"));
        assert_eq!(s.as_utf16_str(), utf16str!("hXXello"));
        assert_eq!(s.len(), 7);

        // Insert at the boundary idx == len (append).
        s.insert_utf16_str(s.len(), utf16str!("!"));
        assert_eq!(s.as_utf16_str(), utf16str!("hXXello!"));

        // Folded from_coverage_extras_utf16::utf16_string_insert_str_at_end_of_string.
        let mut appended = arena.alloc_utf16_string();
        appended.push_str(utf16str!("hi"));
        appended.insert_utf16_str(appended.len(), utf16str!("!"));
        assert_eq!(appended.as_utf16_str(), utf16str!("hi!"));

        // Insert at idx == 0 (head).
        s.insert_utf16_str(0, utf16str!(">"));
        assert_eq!(s.as_utf16_str(), utf16str!(">hXXello!"));

        // Insert exactly at the grow boundary: build a String at known
        // cap, then insert enough to hit needed == cap.
        let mut t = Utf16String::with_capacity_in(8, &arena);
        t.push_str(utf16str!("abcd"));
        let ptr_before = t.as_ptr();
        let cap = t.capacity();
        let extra = vec![b'x' as u16; cap - t.len()];
        let extra_str = widestring::Utf16Str::from_slice(&extra).expect("valid utf16");
        t.insert_utf16_str(t.len(), extra_str);
        assert_eq!(t.len(), cap);
        assert_eq!(t.as_ptr(), ptr_before, "insert at exact-fit must not reallocate");
    }

    /// Kills `utf16_string.rs:356:72 - → +`, `356:78 - → +/*` in `remove`.
    ///
    /// `self.len - idx - n` is the memmove byte count after extracting
    /// the char at `idx` (`n` code units wide). The two `-` operators
    /// are: `(len - idx) - n` (binding `len - idx` first). Wrong arithmetic
    /// reads past the buffer or produces a giant count.
    ///
    /// Test: build a string with content, remove from the middle, and
    /// verify the result and length.
    #[test]
    fn remove_middle_preserves_content() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        let removed = s.remove(1); // 'e'
        assert_eq!(removed, 'e');
        assert_eq!(s.as_utf16_str(), utf16str!("hllo"));
        assert_eq!(s.len(), 4);

        // Remove last char (idx == len - 1).
        let removed = s.remove(s.len() - 1);
        assert_eq!(removed, 'o');
        assert_eq!(s.as_utf16_str(), utf16str!("hll"));

        // Remove first char (idx == 0).
        let removed = s.remove(0);
        assert_eq!(removed, 'h');
        assert_eq!(s.as_utf16_str(), utf16str!("ll"));

        // Folded from_mutants_extras_utf16_scattered::utf16_remove_shifts_correct_byte_count.
        let mut s = Utf16String::new_in(&arena);
        s.push_from_str("abcdefghij");
        assert_eq!(s.remove(4), 'e');
        assert_eq!(s.as_slice().to_vec(), widestring::Utf16String::from_str("abcdfghij").into_vec());
        assert_eq!(s.remove(0), 'a');
        assert_eq!(s.as_slice().to_vec(), widestring::Utf16String::from_str("bcdfghij").into_vec());
        assert_eq!(s.remove(s.len() - 1), 'j');
        assert_eq!(s.as_slice().to_vec(), widestring::Utf16String::from_str("bcdfghi").into_vec());
    }

    /// Kills `utf16_string.rs:396:22 && → ||`, `396:18 > → >=`,
    /// `396:31 < → <=` (the surrogate-guard `start > 0 && start <
    /// self.len`), `403:16/27` (same for end), `418:20 > → >=`
    /// (`new_len > self.cap`), and `424:81 - → +` (`self.len - end`
    /// memmove count) in `replace_range`.
    ///
    /// The test exercises replace_range with several boundary positions
    /// and verifies output content and length.
    #[test]
    fn replace_range_at_boundaries() {
        let arena = Arena::new();

        // Full-range replace.
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.replace_range(.., utf16str!("WORLD"));
        assert_eq!(s.as_utf16_str(), utf16str!("WORLD"));

        // Folded from_coverage_extras_utf16::utf16_string_replace_range_full_with_longer.
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        s.replace_range(0..3, utf16str!("xyzw"));
        assert_eq!(s.as_utf16_str(), utf16str!("xyzw"));

        // Folded from_coverage_extras_utf16::utf16_string_replace_range_full_with_shorter.
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abcdef"));
        s.replace_range(0..6, utf16str!("xy"));
        assert_eq!(s.as_utf16_str(), utf16str!("xy"));

        // Middle replace, different lengths (longer).
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.replace_range(1..4, utf16str!("XXXX"));
        assert_eq!(s.as_utf16_str(), utf16str!("hXXXXo"));

        // Middle replace, shorter.
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.replace_range(1..4, utf16str!("X"));
        assert_eq!(s.as_utf16_str(), utf16str!("hXo"));

        // Head replace (start == 0).
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.replace_range(..2, utf16str!("HE"));
        assert_eq!(s.as_utf16_str(), utf16str!("HEllo"));

        // Tail replace (end == len).
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.replace_range(3.., utf16str!("LO"));
        assert_eq!(s.as_utf16_str(), utf16str!("helLO"));

        // Empty range insert (start == end).
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.replace_range(2..2, utf16str!("--"));
        assert_eq!(s.as_utf16_str(), utf16str!("he--llo"));

        // Folded from_coverage_extras_utf16::utf16_string_replace_range_empty_at_end.
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("abc"));
        let n = s.len();
        s.replace_range(n..n, utf16str!("xyz"));
        assert_eq!(s.as_utf16_str(), utf16str!("abcxyz"));

        // Replace into an empty string.
        let mut s = Utf16String::new_in(&arena);
        s.replace_range(0..0, utf16str!("abc"));
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
    }

    /// Kills `utf16_string.rs:466:21 == → !=` in `into_arena_box_utf16_str`.
    ///
    /// The branch is `if self.cap == 0 { … return empty … }`. With `!=`,
    /// the empty fast-path runs for non-empty strings (UB / wrong data)
    /// and the data path runs for empty strings (reads from dangling).
    /// We test both branches by freezing an empty and a non-empty
    /// string into a `BoxUtf16Str`.
    #[test]
    fn into_arena_box_utf16_str_handles_empty_and_non_empty() {
        let arena = Arena::new();
        // Empty case.
        let s = Utf16String::new_in(&arena);
        let b = s.into_arena_box_utf16_str();
        assert_eq!(&*b, utf16str!(""));
        assert_eq!(b.len(), 0);

        // Non-empty case.
        let s = Utf16String::from_utf16_str_in(utf16str!("hello, world"), &arena);
        let b = s.into_arena_box_utf16_str();
        assert_eq!(&*b, utf16str!("hello, world"));
        assert_eq!(b.len(), 12);
    }

    /// Kills `utf16_string.rs:491:29 - → /` in `try_reclaim_tail`.
    ///
    /// `total - used` (= unused trailing bytes). With `/` produces a tiny
    /// reclaim amount → buffer cursor moves slightly back. The chunk
    /// invariant is violated subtly but the next allocation may overlap
    /// the still-live frozen string. Exercise:
    /// 1. Build a Utf16String with extra capacity.
    /// 2. Freeze into box (triggers try_reclaim_tail).
    /// 3. Allocate more in the same arena.
    /// 4. Read back the frozen string — it must still equal the original.
    ///
    /// With wrong reclaim arithmetic, the second allocation would
    /// overlap the frozen string's tail (or the data pointer), corrupting
    /// the readback.
    #[test]
    fn reclaim_tail_does_not_corrupt_frozen_string() {
        let arena = Arena::new();
        let mut s = Utf16String::with_capacity_in(256, &arena);
        s.push_str(utf16str!("frozen"));
        let frozen = s.into_arena_box_utf16_str();
        // Allocate something in the same arena to potentially overlap with
        // the reclaimed tail bytes.
        let _filler: multitude::vec::Vec<'_, u64> = {
            let mut v = arena.alloc_vec_with_capacity::<u64>(64);
            for i in 0..64 {
                v.push(i);
            }
            v
        };
        assert_eq!(&*frozen, utf16str!("frozen"));
    }
}

// === merged from tests/mutation_coverage.rs ===
mod mutation_coverage {
    #![allow(clippy::std_instead_of_core, reason = "tests use std")]
    #![allow(clippy::unwrap_used, reason = "test code")]
    #![allow(clippy::large_stack_arrays, reason = "boundary-focused tests use large values")]
    #![allow(clippy::undocumented_unsafe_blocks, reason = "test code")]
    #![allow(unused_results, reason = "test code")]
    #![allow(clippy::needless_pass_by_value, reason = "test code")]
    use std::collections::hash_map::DefaultHasher;
    use std::hash::{Hash, Hasher};
    use std::panic::catch_unwind;
    use std::sync::Arc as StdArc;
    use std::sync::atomic::{AtomicUsize, Ordering};

    use multitude::strings::{BoxStr, BoxUtf16Str, String as ArenaString, Utf16String};
    use multitude::vec::Vec as ArenaVec;
    use multitude::{Arena, ArenaBuilder};
    use widestring::{Utf16Str, utf16str};

    use crate::common;

    fn hash_value<T: Hash>(value: &T) -> u64 {
        let mut hasher = DefaultHasher::new();
        value.hash(&mut hasher);
        hasher.finish()
    }

    struct DropCounter(StdArc<AtomicUsize>);

    impl Drop for DropCounter {
        fn drop(&mut self) {
            self.0.fetch_add(1, Ordering::Relaxed);
        }
    }

    #[test]
    fn test_string_is_empty_false_when_nonempty() {
        let arena = Arena::new();
        let s = ArenaString::from_str_in("alpha", &arena);
        assert!(!s.is_empty());
    }

    #[test]
    fn test_string_partial_eq_distinguishes_different_values() {
        let arena = Arena::new();
        let a = ArenaString::from_str_in("alpha", &arena);
        let b = ArenaString::from_str_in("beta", &arena);
        let beta = "beta";

        assert_ne!(a, b);
        assert!(a != "beta");
        assert!(a != beta);
    }

    #[test]
    fn test_string_hash_depends_on_contents() {
        let arena = Arena::new();
        let a = ArenaString::from_str_in("alpha", &arena);
        let b = ArenaString::from_str_in("beta", &arena);

        assert_ne!(hash_value(&a), hash_value(&b));
    }

    #[test]
    fn test_string_as_ref_returns_expected_contents() {
        let arena = Arena::new();
        let s = ArenaString::from_str_in("expected", &arena);
        let r: &str = s.as_ref();

        assert_eq!(r, "expected");
        assert_ne!(r, "");
    }

    #[test]
    fn test_string_insert_str_grows_at_full_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(5);
        s.push_str("hello");

        s.insert_str(5, "!!");

        assert_eq!(s.as_str(), "hello!!");
        assert!(s.capacity() >= s.len());
    }

    #[test]
    fn test_string_insert_str_middle_preserves_surrounding_bytes() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(8);
        s.push_str("abef");

        s.insert_str(2, "cd");

        assert_eq!(s.as_str(), "abcdef");
    }

    #[test]
    fn test_string_remove_from_middle_preserves_tail() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcde", &arena);

        assert_eq!(s.remove(2), 'c');
        assert_eq!(s.as_str(), "abde");
    }

    #[test]
    fn test_string_retain_keeps_only_requested_chars() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abracadabra", &arena);

        s.retain(|ch| ch == 'a');

        assert_eq!(s.as_str(), "aaaaa");
    }

    #[test]
    fn test_string_replace_range_longer_grows_and_shifts_tail() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(5);
        s.push_str("abYZ");

        s.replace_range(2..2, "1234");

        assert_eq!(s.as_str(), "ab1234YZ");
    }

    #[test]
    fn test_string_replace_range_shorter_shifts_tail_left() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcXYZdef", &arena);

        s.replace_range(3..6, "Q");

        assert_eq!(s.as_str(), "abcQdef");
    }

    #[test]
    fn test_string_shrink_to_fit_reclaims_capacity_and_preserves_contents() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(16);
        s.push_str("hello");

        s.shrink_to_fit();
        let _follow_on = arena.alloc_str("zzzz");

        assert_eq!(s.capacity(), s.len());
        assert_eq!(s.as_str(), "hello");
    }

    #[test]
    fn test_string_drop_releases_retired_chunk() {
        let alloc = common::TrackingAllocator::new();
        {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            let mut s = arena.alloc_string_with_capacity(3500);
            s.push_str("hello");
            let filler = arena.alloc_slice_copy_rc(std::vec![1_u8; 4000]);
            drop(filler);
            drop(s);
        }

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[test]
    fn test_utf16_string_is_empty_false_when_nonempty() {
        let arena = Arena::new();
        let s = Utf16String::from_utf16_str_in(utf16str!("alpha"), &arena);
        assert!(!s.is_empty());
    }

    #[test]
    fn test_utf16_string_partial_eq_distinguishes_different_values() {
        let arena = Arena::new();
        let a = Utf16String::from_utf16_str_in(utf16str!("alpha"), &arena);
        let b = Utf16String::from_utf16_str_in(utf16str!("beta"), &arena);
        let beta = utf16str!("beta");

        assert_ne!(a, b);
        assert!(a != utf16str!("beta"));
        assert!(a != beta);
    }

    #[test]
    fn test_utf16_string_hash_depends_on_contents() {
        let arena = Arena::new();
        let a = Utf16String::from_utf16_str_in(utf16str!("alpha"), &arena);
        let b = Utf16String::from_utf16_str_in(utf16str!("beta"), &arena);

        assert_ne!(hash_value(&a), hash_value(&b));
    }

    #[test]
    fn test_utf16_string_as_mut_utf16_str_returns_live_contents() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("ab"), &arena);
        let view: &mut Utf16Str = s.as_mut_utf16_str();

        assert_eq!(view, utf16str!("ab"));

        unsafe {
            *s.as_mut_ptr() = 'z' as u16;
        }
        assert_eq!(s.as_utf16_str(), utf16str!("zb"));
    }

    #[test]
    fn test_utf16_string_pop_reduces_length() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("ab"), &arena);

        assert_eq!(s.pop(), Some('b'));
        assert_eq!(s.as_utf16_str(), utf16str!("a"));
    }

    #[test]
    fn test_utf16_string_shrink_to_fit_reclaims_capacity_and_preserves_contents() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push_str(utf16str!("hello"));

        s.shrink_to_fit();
        let _follow_on = arena.alloc_utf16_str_rc(utf16str!("zzzz"));

        assert_eq!(s.capacity(), s.len());
        assert_eq!(s.as_utf16_str(), utf16str!("hello"));

        #[cfg(all(feature = "stats", feature = "utf16"))]
        {
            // Folded from_mutants_extras_utf16_scattered::utf16_shrink_to_fit_reclaims_tail.
            let mut s = arena.alloc_utf16_string_with_capacity(128);
            s.push_from_str("hi");
            let before_chunks = arena.stats().normal_local_chunks_allocated;
            s.shrink_to_fit();
            let _r: multitude::Rc<u8> = arena.alloc_rc(0);
            assert_eq!(arena.stats().normal_local_chunks_allocated, before_chunks);
        }
    }

    #[test]
    fn test_utf16_string_insert_middle_preserves_tail() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(8);
        s.push_str(utf16str!("abef"));

        s.insert_utf16_str(2, utf16str!("cd"));

        assert_eq!(s.as_utf16_str(), utf16str!("abcdef"));
    }

    #[test]
    fn test_utf16_string_remove_from_middle_preserves_tail() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcde"), &arena);

        assert_eq!(s.remove(2), 'c');
        assert_eq!(s.as_utf16_str(), utf16str!("abde"));
    }

    #[test]
    fn test_utf16_string_retain_keeps_only_requested_chars() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abracadabra"), &arena);

        s.retain(|ch| ch == 'a');

        assert_eq!(s.as_utf16_str(), utf16str!("aaaaa"));
    }

    #[test]
    fn test_utf16_string_replace_range_longer_grows_and_shifts_tail() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(4);
        s.push_str(utf16str!("abYZ"));

        s.replace_range(2..2, utf16str!("1234"));

        assert_eq!(s.as_utf16_str(), utf16str!("ab1234YZ"));
    }

    #[test]
    fn test_utf16_string_replace_range_shorter_shifts_tail_left() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcXYZdef"), &arena);

        s.replace_range(3..6, utf16str!("Q"));

        assert_eq!(s.as_utf16_str(), utf16str!("abcQdef"));
    }

    #[test]
    fn test_utf16_into_arena_utf16_str_preserves_contents_after_tail_reclaim() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push_str(utf16str!("hello"));

        let frozen = s.into_arena_utf16_str();
        let _follow_on = arena.alloc_utf16_str_rc(utf16str!("zzzz"));

        assert_eq!(&*frozen, utf16str!("hello"));

        // Folded from_coverage_extras_utf16::utf16_into_arena_str_reclaims_tail.
        let mut s = arena.alloc_utf16_string_with_capacity(64);
        s.push_str(utf16str!("abcd"));
        let frozen = s.into_arena_utf16_str();
        let frozen_end_addr = frozen.as_ptr() as usize + frozen.len() * core::mem::size_of::<u16>();
        let next: multitude::Rc<u32> = arena.alloc_rc(0_u32);
        let next_addr = multitude::Rc::as_ptr(&next) as usize;
        let gap = next_addr.saturating_sub(frozen_end_addr);
        assert!(gap < 120, "gap was {gap} bytes");
    }

    #[test]
    fn test_utf16_string_drop_releases_retired_chunk() {
        let alloc = common::TrackingAllocator::new();
        {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            let mut s = arena.alloc_utf16_string_with_capacity(1800);
            s.push_str(utf16str!("hello"));
            let filler = arena.alloc_slice_copy_rc(std::vec![1_u8; 4000]);
            drop(filler);
            drop(s);
        }

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[test]
    fn test_box_str_partial_eq_distinguishes_different_values() {
        let arena = Arena::new();
        let boxed: BoxStr = arena.alloc_str_box("alpha");
        let beta = "beta";

        assert!(boxed != "beta");
        assert!(boxed != beta);
    }

    #[test]
    fn test_box_utf16_str_partial_eq_distinguishes_different_values() {
        let arena = Arena::new();
        let boxed: BoxUtf16Str = arena.alloc_utf16_str_box(utf16str!("alpha"));
        let beta = utf16str!("beta");

        assert!(boxed != utf16str!("beta"));
        assert!(boxed != beta);
    }

    #[test]
    fn test_box_utf16_str_drop_releases_chunk_after_arena_drop() {
        let alloc = common::TrackingAllocator::new();
        let boxed: BoxUtf16Str<_> = {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            arena.alloc_utf16_str_box(utf16str!("hello"))
        };

        assert_eq!(&*boxed, utf16str!("hello"));
        drop(boxed);

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[test]
    fn test_vec_is_empty_false_when_nonempty() {
        let arena = Arena::new();
        let mut v: ArenaVec<u32, _> = ArenaVec::new_in(&arena);
        v.push(1);
        assert!(!v.is_empty());
    }

    #[test]
    fn test_vec_from_iter_in_uses_nonzero_size_hint() {
        let arena = Arena::new_in(common::FailingAllocator::new(1));
        let v = ArenaVec::from_iter_in([1_u32, 2, 3], &arena);

        assert_eq!(v.as_slice(), &[1, 2, 3]);
    }

    #[test]
    fn test_vec_insert_middle_preserves_positions() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 4, 5]);

        v.insert(2, 3);

        assert_eq!(v.as_slice(), &[1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_vec_remove_middle_preserves_positions() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3, 4, 5]);

        assert_eq!(v.remove(2), 3);
        assert_eq!(v.as_slice(), &[1, 2, 4, 5]);
    }

    #[test]
    fn test_vec_truncate_drops_removed_elements() {
        let arena = Arena::new();
        let drops = StdArc::new(AtomicUsize::new(0));
        let mut v = arena.alloc_vec();
        for _ in 0..4 {
            v.push(DropCounter(StdArc::clone(&drops)));
        }

        v.truncate(2);

        assert_eq!(drops.load(Ordering::Relaxed), 2);
        assert_eq!(v.len(), 2);
    }

    #[test]
    fn test_vec_shrink_to_fit_reduces_capacity_and_preserves_values() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec_with_capacity::<u32>(16);
        v.extend(0_u32..5);

        v.shrink_to_fit();
        let _follow_on = arena.alloc_str("tail");

        assert_eq!(v.capacity(), v.len());
        assert_eq!(v.as_slice(), &[0, 1, 2, 3, 4]);
    }

    #[test]
    fn test_vec_resize_with_adds_expected_elements() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2]);
        let mut next = 10_u32;

        v.resize_with(5, || {
            let value = next;
            next += 1;
            value
        });

        assert_eq!(v.as_slice(), &[1, 2, 10, 11, 12]);
    }

    #[test]
    fn test_vec_into_arena_rc_preserves_values_after_tail_reclaim() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec_with_capacity::<u32>(16);
        v.extend(0_u32..5);

        let frozen = v.into_arena_rc();
        let _follow_on = arena.alloc_str("tail");

        assert_eq!(&*frozen, &[0, 1, 2, 3, 4]);
    }

    #[test]
    fn test_vec_hash_depends_on_contents() {
        let arena = Arena::new();
        let mut a = arena.alloc_vec();
        a.extend([1_u32, 2, 3]);
        let mut b = arena.alloc_vec();
        b.extend([1_u32, 2, 4]);

        assert_ne!(hash_value(&a), hash_value(&b));
    }

    #[test]
    fn test_vec_drop_runs_element_drops() {
        let drops = StdArc::new(AtomicUsize::new(0));
        {
            let arena = Arena::new();
            let mut v = arena.alloc_vec();
            for _ in 0..3 {
                v.push(DropCounter(StdArc::clone(&drops)));
            }
        }

        assert_eq!(drops.load(Ordering::Relaxed), 3);
    }

    #[test]
    fn test_vec_drop_deallocates_retired_buffer() {
        let alloc = common::TrackingAllocator::new();
        {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            let mut v = arena.alloc_vec_with_capacity::<u64>(512);
            v.extend(0_u64..4);
            let filler = arena.alloc_slice_copy_rc(std::vec![1_u8; 4000]);
            drop(filler);
            drop(v);
        }

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[test]
    fn test_vec_drain_size_hint_tracks_remaining_items() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend(0_u32..6);

        {
            let mut drain = v.drain(1..5);
            assert_eq!(drain.size_hint(), (4, Some(4)));
            assert_eq!(drain.len(), 4);
            assert_eq!(drain.next(), Some(1));
            assert_eq!(drain.size_hint(), (3, Some(3)));
            assert_eq!(drain.next_back(), Some(4));
            assert_eq!(drain.size_hint(), (2, Some(2)));
        }

        assert_eq!(v.as_slice(), &[0, 5]);
    }

    #[test]
    fn test_vec_drain_drop_moves_tail_after_partial_iteration() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend(0_u32..6);

        {
            let mut drain = v.drain(1..4);
            assert_eq!(drain.next(), Some(1));
        }

        assert_eq!(v.as_slice(), &[0, 4, 5]);
    }

    #[test]
    fn test_arena_alloc_str_keeps_pinned_chunk_alive_across_rotation() {
        let arena = ArenaBuilder::new().build();
        let s: &mut str = arena.alloc_str("hello");

        let a = arena.alloc_slice_copy(std::vec![1_u8; 4000]);
        let b = arena.alloc_slice_copy(std::vec![2_u8; 4000]);
        assert_eq!(a.len(), 4000);
        assert_eq!(b.len(), 4000);

        s.make_ascii_uppercase();
        assert_eq!(s, "HELLO");
    }

    #[cfg(feature = "stats")]
    #[test]
    fn test_arena_slice_fill_with_rc_initializes_items_and_charges_stats() {
        let arena = Arena::new();
        let before = arena.stats().total_bytes_allocated;

        let slice = arena.alloc_slice_fill_with_rc(5, |i| u32::try_from(i).unwrap() * 2);

        assert_eq!(&*slice, &[0, 2, 4, 6, 8]);
        assert_eq!(arena.stats().total_bytes_allocated, before + (5 * size_of::<u32>()) as u64);
    }

    #[cfg(feature = "stats")]
    #[test]
    fn test_oversized_slice_copy_rc_survives_arena_drop() {
        let rc = {
            let arena = Arena::new();
            let rc = arena.alloc_slice_copy_rc(std::vec![7_u8; 32 * 1024]);
            assert!(arena.stats().oversized_local_chunks_allocated >= 1);
            rc
        };

        assert_eq!(rc.len(), 32 * 1024);
        assert_eq!(rc[0], 7);
        assert_eq!(rc[rc.len() - 1], 7);
    }

    #[cfg(feature = "stats")]
    #[test]
    fn test_vec_into_arena_rc_slow_path_oversized_survives_arena_drop() {
        struct NeedsDrop(u16);
        impl Drop for NeedsDrop {
            fn drop(&mut self) {
                let _ = self.0;
            }
        }

        let rc = {
            let arena = Arena::new();
            let mut v = arena.alloc_vec_with_capacity::<NeedsDrop>(20_000);
            for i in 0..17_000_u16 {
                v.push(NeedsDrop(i % 251));
            }
            let before = arena.stats().oversized_local_chunks_allocated;
            let rc = v.into_arena_rc();
            assert!(arena.stats().oversized_local_chunks_allocated > before);
            rc
        };

        assert_eq!(rc.len(), 17_000);
        assert_eq!(rc[123].0, 123);
        assert_eq!(rc[16_000].0, (16_000 % 251) as u16);
    }

    #[cfg(feature = "stats")]
    #[test]
    fn test_arena_builder_default_max_normal_alloc_is_chunk_size_div_4() {
        let arena = ArenaBuilder::new().build();

        let _ = arena.alloc_slice_copy_rc(std::vec![0_u8; 5 * 1024]);

        assert_eq!(arena.stats().oversized_local_chunks_allocated, 0);
    }

    // `chunk_size` builder method and `BuildError::ChunkSizeOutOfRange` are
    // gone with the adaptive-sizing change.

    #[test]
    fn test_rc_drop_after_arena_drop_frees_chunk_instead_of_caching_it() {
        let alloc = common::TrackingAllocator::new();
        let rc = {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            arena.alloc_rc(std::string::String::from("persist"))
        };

        assert_eq!(&*rc, "persist");
        drop(rc);

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[cfg(feature = "stats")]
    #[test]
    fn test_aligned_drop_allocation_is_correctly_aligned_and_not_oversized() {
        #[repr(align(256))]
        struct HighAlignDrop(u8);
        impl Drop for HighAlignDrop {
            fn drop(&mut self) {
                let _ = self.0;
            }
        }

        let arena = Arena::builder().build();
        let value = arena.alloc_rc(HighAlignDrop(1));
        let ptr = (&raw const *value) as usize;

        assert_eq!(ptr % 256, 0);
        assert_eq!(arena.stats().oversized_local_chunks_allocated, 0);
    }

    #[cfg(feature = "stats")]
    #[test]
    fn test_vec_reserve_grows_in_place_without_relocation() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec_with_capacity::<u32>(4);
        v.extend([1_u32, 2, 3, 4]);
        let before = arena.stats().relocations;

        v.reserve(8);

        assert_eq!(arena.stats().relocations, before);
        assert_eq!(v.as_slice(), &[1, 2, 3, 4]);
    }

    #[test]
    fn test_cache_overflow_rejected_chunk_is_freed() {
        let alloc = common::TrackingAllocator::new();
        {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            let a = arena.alloc_slice_copy_rc(std::vec![1_u8; 4000]);
            let b = arena.alloc_slice_copy_rc(std::vec![2_u8; 4000]);
            let c = arena.alloc_slice_copy_rc(std::vec![3_u8; 4000]);
            drop(a);
            drop(b);
            drop(c);
        }

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[test]
    fn test_arena_drop_clears_current_chunk_slots() {
        let alloc = common::TrackingAllocator::new();
        {
            let arena = Arena::builder().allocator_in(alloc.clone()).build();
            let value = arena.alloc(123_u64);
            assert_eq!(*value, 123);
        }

        assert_eq!(alloc.live_chunks(), 0);
        assert_eq!(alloc.live_bytes(), 0);
    }

    #[test]
    fn test_box_str_partial_eq_str_returns_false_for_mismatch() {
        let arena = Arena::new();
        let boxed: BoxStr = arena.alloc_str_box("alpha");
        // Force PartialEq<str> (not PartialEq<&str>)
        assert!(!<BoxStr as PartialEq<str>>::eq(&boxed, "beta"));
    }

    #[test]
    fn test_box_utf16_str_partial_eq_utf16str_returns_false_for_mismatch() {
        let arena = Arena::new();
        let boxed: BoxUtf16Str = arena.alloc_utf16_str_box(utf16str!("alpha"));
        assert!(!<BoxUtf16Str as PartialEq<Utf16Str>>::eq(&boxed, utf16str!("beta")));
    }

    #[test]
    fn test_string_partial_eq_str_returns_false_for_mismatch() {
        let arena = Arena::new();
        let s = ArenaString::from_str_in("alpha", &arena);
        assert!(!<ArenaString as PartialEq<str>>::eq(&s, "beta"));
    }

    #[test]
    fn test_utf16_string_partial_eq_utf16str_returns_false_for_mismatch() {
        let arena = Arena::new();
        let s = Utf16String::from_utf16_str_in(utf16str!("alpha"), &arena);
        assert!(!<Utf16String as PartialEq<Utf16Str>>::eq(&s, utf16str!("beta")));
    }

    #[test]
    fn test_vec_try_with_capacity_in_zero_does_not_allocate() {
        let arena = Arena::new();
        let v = ArenaVec::<u32>::try_with_capacity_in(0, &arena).unwrap();
        assert_eq!(v.capacity(), 0);
        assert_eq!(v.len(), 0);
    }

    #[test]
    fn test_vec_try_reserve_at_exact_boundary_does_not_grow() {
        let arena = Arena::new();
        let mut v = ArenaVec::<u32>::try_with_capacity_in(8, &arena).unwrap();
        v.push(1);
        v.push(2);
        // cap=8, len=2, spare = cap - len = 6
        let cap_before = v.capacity();
        v.try_reserve(6).unwrap(); // additional == spare, should NOT grow
        assert_eq!(v.capacity(), cap_before);
    }

    #[test]
    fn test_vec_from_iter_in_with_zero_size_hint() {
        let arena = Arena::new();
        // An iterator with size_hint == (0, None)
        let iter = std::iter::from_fn({
            let mut i = 0_u32;
            move || {
                (i < 3).then(|| {
                    i += 1;
                    i
                })
            }
        });
        let v = ArenaVec::from_iter_in(iter, &arena);
        assert_eq!(v.as_slice(), &[1, 2, 3]);
    }

    #[test]
    fn test_vec_insert_at_start_shifts_all() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([2_u32, 3, 4, 5]);
        v.insert(0, 1);
        assert_eq!(v.as_slice(), &[1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_vec_remove_at_start_shifts_all() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3, 4, 5]);
        assert_eq!(v.remove(0), 1);
        assert_eq!(v.as_slice(), &[2, 3, 4, 5]);
    }

    #[test]
    fn test_vec_remove_second_to_last_shifts_one() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3]);
        assert_eq!(v.remove(1), 2);
        assert_eq!(v.as_slice(), &[1, 3]);
    }

    #[test]
    fn test_vec_truncate_to_zero_drops_all() {
        let arena = Arena::new();
        let drops = StdArc::new(AtomicUsize::new(0));
        let mut v = arena.alloc_vec();
        for _ in 0..5 {
            v.push(DropCounter(StdArc::clone(&drops)));
        }
        v.truncate(0);
        assert_eq!(drops.load(Ordering::Relaxed), 5);
        assert_eq!(v.len(), 0);
    }

    #[test]
    fn test_vec_truncate_to_one_drops_rest() {
        let arena = Arena::new();
        let drops = StdArc::new(AtomicUsize::new(0));
        let mut v = arena.alloc_vec();
        for _ in 0..3 {
            v.push(DropCounter(StdArc::clone(&drops)));
        }
        v.truncate(1);
        assert_eq!(drops.load(Ordering::Relaxed), 2);
        assert_eq!(v.len(), 1);
    }

    #[test]
    fn test_vec_shrink_to_fit_zst_is_noop() {
        let arena = Arena::new();
        let mut v: ArenaVec<()> = arena.alloc_vec();
        v.push(());
        v.push(());
        let cap_before = v.capacity();
        v.shrink_to_fit();
        // ZST: shrink_to_fit should be a no-op (capacity is meaningless for ZSTs)
        assert_eq!(v.capacity(), cap_before);
        assert_eq!(v.len(), 2);
    }

    #[test]
    fn test_vec_try_reserve_exact_at_boundary_does_not_grow() {
        let arena = Arena::new();
        let mut v = ArenaVec::<u32>::try_with_capacity_in(8, &arena).unwrap();
        v.push(1);
        v.push(2);
        let cap_before = v.capacity();
        // needed = len(2) + additional(6) = 8 = cap, should NOT grow
        v.try_reserve_exact(6).unwrap();
        assert_eq!(v.capacity(), cap_before);
    }

    #[test]
    fn test_vec_resize_with_same_len_is_noop() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3]);
        let cap_before = v.capacity();
        v.resize_with(3, || panic!("should not be called"));
        assert_eq!(v.as_slice(), &[1, 2, 3]);
        assert_eq!(v.capacity(), cap_before);
    }

    #[test]
    fn test_vec_into_arena_rc_empty_with_capacity() {
        let arena = Arena::new();
        let v = arena.alloc_vec_with_capacity::<u32>(16);
        let frozen = v.into_arena_rc();
        assert!(frozen.is_empty());
    }

    #[test]
    fn test_vec_extend_empty_iterator() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3]);
        let cap_before = v.capacity();
        v.extend(std::iter::empty::<u32>());
        assert_eq!(v.as_slice(), &[1, 2, 3]);
        assert_eq!(v.capacity(), cap_before);
    }

    #[test]
    fn test_vec_extend_ref_empty_iterator() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3]);
        let cap_before = v.capacity();
        let empty: &[u32] = &[];
        v.extend(empty.iter());
        assert_eq!(v.as_slice(), &[1, 2, 3]);
        assert_eq!(v.capacity(), cap_before);
    }

    #[test]
    fn test_vec_drain_all_elements_no_tail() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3]);
        {
            let drained: std::vec::Vec<_> = v.drain(0..3).collect();
            assert_eq!(drained, vec![1, 2, 3]);
        }
        assert!(v.is_empty());
    }

    #[test]
    fn test_vec_drain_suffix_no_tail() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec();
        v.extend([1_u32, 2, 3, 4]);
        {
            let drained: std::vec::Vec<_> = v.drain(2..4).collect();
            assert_eq!(drained, vec![3, 4]);
        }
        assert_eq!(v.as_slice(), &[1, 2]);
    }

    #[test]
    fn test_string_shrink_to_fit_cap_equals_len_is_noop() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("hello", &arena);
        // Force a shrink_to_fit so cap == len
        s.shrink_to_fit();
        let cap_after_first = s.capacity();
        // Calling again should be a no-op since cap == len
        s.shrink_to_fit();
        assert_eq!(s.capacity(), cap_after_first);
        assert_eq!(s.as_str(), "hello");
    }

    #[test]
    fn test_string_shrink_to_fit_cap_zero_is_noop() {
        let arena = Arena::new();
        let s = arena.alloc_string_with_capacity(0);
        assert_eq!(s.capacity(), 0);
        // Can't mutably borrow to call shrink_to_fit on a zero-capacity string
        // through the arena API, but we can create one fresh
        let mut s2: ArenaString = ArenaString::new_in(&arena);
        s2.shrink_to_fit(); // cap == 0 path
        assert_eq!(s2.len(), 0);
    }

    #[test]
    fn test_string_insert_str_at_start_shifts_all() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("world", &arena);
        s.insert_str(0, "hello ");
        assert_eq!(s.as_str(), "hello world");
    }

    #[test]
    fn test_string_insert_str_at_exact_capacity_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(5);
        s.push_str("hello");
        assert_eq!(s.capacity(), 5);
        s.insert_str(5, "!");
        assert_eq!(s.as_str(), "hello!");
        assert!(s.capacity() >= 6);
    }

    #[test]
    fn test_string_remove_first_char_shifts_all() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcde", &arena);
        assert_eq!(s.remove(0), 'a');
        assert_eq!(s.as_str(), "bcde");
    }

    #[test]
    fn test_string_remove_multibyte_char() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("aéc", &arena);
        assert_eq!(s.remove(1), 'é');
        assert_eq!(s.as_str(), "ac");
    }

    #[test]
    fn test_string_retain_removes_alternating() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcdef", &arena);
        let mut toggle = false;
        s.retain(|_| {
            toggle = !toggle;
            toggle
        });
        assert_eq!(s.as_str(), "ace");
    }

    #[test]
    fn test_string_retain_removes_none() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abc", &arena);
        s.retain(|_| true);
        assert_eq!(s.as_str(), "abc");
    }

    #[test]
    fn test_string_retain_removes_all() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abc", &arena);
        s.retain(|_| false);
        assert_eq!(s.as_str(), "");
    }

    #[test]
    fn test_string_replace_range_grow_at_exact_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(6);
        s.push_str("abcdef");
        // Replace "cd" (2 bytes) with "1234" (4 bytes), growth of 2
        s.replace_range(2..4, "1234");
        assert_eq!(s.as_str(), "ab1234ef");
    }

    #[test]
    fn test_string_replace_range_shrink_by_exact_amount() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcdef", &arena);
        // Replace "bcde" (4 bytes) with "X" (1 byte), shrink of 3
        s.replace_range(1..5, "X");
        assert_eq!(s.as_str(), "aXf");
    }

    #[test]
    fn test_string_replace_range_same_size() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcdef", &arena);
        s.replace_range(2..4, "CD");
        assert_eq!(s.as_str(), "abCDef");
    }

    #[test]
    fn test_string_replace_range_shrink_at_end() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("abcdef", &arena);
        // Replace "ef" with "" — shrink == removed, no tail shift needed
        s.replace_range(4..6, "");
        assert_eq!(s.as_str(), "abcd");
    }

    #[test]
    fn test_string_try_push_str_at_exact_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(5);
        s.push_str("hello");
        let cap_before = s.capacity();
        // Push more, forcing growth
        s.try_push_str("!").unwrap();
        assert_eq!(s.as_str(), "hello!");
        assert!(s.capacity() > cap_before);
    }

    #[test]
    fn test_string_try_push_str_within_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(10);
        s.push_str("hello");
        let cap_before = s.capacity();
        s.try_push_str("!").unwrap();
        assert_eq!(s.as_str(), "hello!");
        assert_eq!(s.capacity(), cap_before); // no growth needed
    }

    #[test]
    fn test_string_reserve_at_exact_boundary_does_not_grow() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(10);
        s.push_str("hello"); // len=5, cap=10
        let cap_before = s.capacity();
        s.reserve(5); // needed = 5+5 = 10 = cap, should NOT grow
        assert_eq!(s.capacity(), cap_before);
    }

    #[test]
    fn test_string_try_reserve_at_exact_boundary_does_not_grow() {
        let arena = Arena::new();
        let mut s = arena.alloc_string_with_capacity(10);
        s.push_str("hello"); // len=5, cap=10
        let cap_before = s.capacity();
        s.try_reserve(5).unwrap(); // needed = 5+5 = 10 = cap, should NOT grow
        assert_eq!(s.capacity(), cap_before);
    }

    #[test]
    fn test_string_extend_empty_chars() {
        let arena = Arena::new();
        let mut s = ArenaString::from_str_in("hello", &arena);
        let cap_before = s.capacity();
        s.extend(std::iter::empty::<char>());
        assert_eq!(s.as_str(), "hello");
        assert_eq!(s.capacity(), cap_before);
    }

    #[test]
    fn test_utf16_string_shrink_to_fit_cap_equals_len_is_noop() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        s.shrink_to_fit();
        let cap_after_first = s.capacity();
        s.shrink_to_fit();
        assert_eq!(s.capacity(), cap_after_first);
        assert_eq!(s.as_utf16_str(), utf16str!("hello"));
    }

    #[test]
    fn test_utf16_string_shrink_to_fit_cap_zero_is_noop() {
        let arena = Arena::new();
        let mut s = Utf16String::new_in(&arena);
        s.shrink_to_fit();
        assert_eq!(s.len(), 0);
    }

    #[test]
    fn test_utf16_string_insert_at_start_shifts_all() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("world"), &arena);
        s.insert_utf16_str(0, utf16str!("hello "));
        assert_eq!(s.as_utf16_str(), utf16str!("hello world"));
    }

    #[test]
    fn test_utf16_string_insert_at_exact_capacity_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        s.push_str(utf16str!("hello"));
        assert_eq!(s.capacity(), 5);
        s.insert_utf16_str(5, utf16str!("!"));
        assert_eq!(s.as_utf16_str(), utf16str!("hello!"));
    }

    #[test]
    fn test_utf16_string_remove_first_shifts_all() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcde"), &arena);
        assert_eq!(s.remove(0), 'a');
        assert_eq!(s.as_utf16_str(), utf16str!("bcde"));
    }

    #[test]
    fn test_utf16_string_retain_removes_alternating() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcdef"), &arena);
        let mut toggle = false;
        s.retain(|_| {
            toggle = !toggle;
            toggle
        });
        assert_eq!(s.as_utf16_str(), utf16str!("ace"));
    }

    #[test]
    fn test_utf16_string_retain_removes_all() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abc"), &arena);
        s.retain(|_| false);
        assert!(s.is_empty());
    }

    #[test]
    fn test_utf16_string_retain_removes_none() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abc"), &arena);
        s.retain(|_| true);
        assert_eq!(s.as_utf16_str(), utf16str!("abc"));
    }

    #[test]
    fn test_utf16_string_replace_range_grow_at_exact_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(6);
        s.push_str(utf16str!("abcdef"));
        s.replace_range(2..4, utf16str!("1234"));
        assert_eq!(s.as_utf16_str(), utf16str!("ab1234ef"));
    }

    #[test]
    fn test_utf16_string_replace_range_shrink_exact() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcdef"), &arena);
        s.replace_range(1..5, utf16str!("X"));
        assert_eq!(s.as_utf16_str(), utf16str!("aXf"));
    }

    #[test]
    fn test_utf16_string_replace_range_same_size() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcdef"), &arena);
        s.replace_range(2..4, utf16str!("CD"));
        assert_eq!(s.as_utf16_str(), utf16str!("abCDef"));
    }

    #[test]
    fn test_utf16_string_replace_range_shrink_at_end() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("abcdef"), &arena);
        s.replace_range(4..6, utf16str!(""));
        assert_eq!(s.as_utf16_str(), utf16str!("abcd"));
    }

    #[test]
    fn test_utf16_string_try_push_from_str_at_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        s.push_str(utf16str!("hello"));
        let cap_before = s.capacity();
        s.try_push_from_str("!").unwrap();
        assert!(s.capacity() > cap_before);
    }

    #[test]
    fn test_utf16_string_try_push_slice_at_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        s.push_str(utf16str!("hello"));
        let cap_before = s.capacity();
        s.try_push_str(utf16str!("!")).unwrap();
        assert!(s.capacity() > cap_before);
    }

    #[test]
    fn test_utf16_string_try_push_slice_within_capacity() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push_str(utf16str!("hello"));
        let cap_before = s.capacity();
        s.try_push_str(utf16str!("!")).unwrap();
        assert_eq!(s.capacity(), cap_before);
    }

    #[test]
    fn test_utf16_string_reserve_at_exact_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push_str(utf16str!("hello")); // len=5, cap=10
        let cap_before = s.capacity();
        s.reserve(5); // needed = 10 = cap, should NOT grow
        assert_eq!(s.capacity(), cap_before);
    }

    #[test]
    fn test_utf16_string_extend_empty_chars() {
        let arena = Arena::new();
        let mut s = Utf16String::from_utf16_str_in(utf16str!("hello"), &arena);
        let cap_before = s.capacity();
        s.extend(std::iter::empty::<char>());
        assert_eq!(s.as_utf16_str(), utf16str!("hello"));
        assert_eq!(s.capacity(), cap_before);
    }

    #[test]
    fn test_arena_builder_max_normal_alloc_at_exact_min_succeeds() {
        // MIN_MAX_NORMAL_ALLOC = 4096
        let result = ArenaBuilder::new().max_normal_alloc(4096).try_build();
        result.unwrap();
    }

    #[test]
    #[should_panic(expected = "max_normal_alloc must be in")]
    fn test_arena_builder_max_normal_alloc_below_min_fails() {
        let _ = ArenaBuilder::new().max_normal_alloc(4095).try_build();
    }

    #[test]
    fn test_slice_fill_with_panic_drops_initialized_elements() {
        let drops = StdArc::new(AtomicUsize::new(0));
        let arena = Arena::new();

        let result = catch_unwind(std::panic::AssertUnwindSafe(|| {
            let drops_clone = StdArc::clone(&drops);
            let _ = arena.alloc_slice_fill_with(5, |i| {
                assert!(i != 3, "intentional panic at index 3");
                DropCounter(StdArc::clone(&drops_clone))
            });
        }));

        assert!(result.is_err());
        // Elements 0, 1, 2 were initialized and should be dropped
        assert_eq!(drops.load(Ordering::Relaxed), 3);
    }
}

// === relocated from mutants_extras.rs (was mutants_for_kill3::utf16_*) ===
mod utf16_tests {
    use multitude::Arena;

    /// Kills: `utf16_string.rs:191:20` `> -> >=` in truncate
    /// `if new_len > 0 { check boundary }`
    /// If `>` becomes `>=`, truncate(0) would try to check
    /// `self.as_slice()[0]` for surrogate boundary, but `new_len==0`
    /// means we're clearing — no boundary check needed.
    #[test]
    fn utf16_191_truncate_to_zero() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push('A');
        s.push('B');
        s.truncate(0);
        assert_eq!(s.len(), 0);
    }

    /// Also kills: `utf16_string.rs:191:20` by testing truncation to len-1
    /// where len-1 lands on a valid boundary.
    #[test]
    fn utf16_191_truncate_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push('A'); // 1 u16
        s.push('B'); // 1 u16
        s.push('C'); // 1 u16
        assert_eq!(s.len(), 3);
        s.truncate(1); // Should keep just 'A'
        assert_eq!(s.len(), 1);
    }

    /// Kills: `utf16_string.rs:203:26` `|| -> &&` in `shrink_to_fit`
    /// `if self.cap == 0 || self.len == self.cap { return; }`
    /// If `||` becomes `&&`, both conditions must be true to skip,
    /// but cap==0 && len==cap is always cap==0 && len==0.
    /// When cap > 0 && len == cap, `shrink_to_fit` would incorrectly
    /// try to reclaim 0 bytes.
    #[test]
    fn utf16_203_shrink_to_fit_or_to_and() {
        let arena = Arena::new();
        // Case: cap > 0 && len == cap → should be no-op
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        s.push('A');
        s.push('B');
        s.push('C');
        s.push('D');
        s.push('E');
        assert_eq!(s.len(), 5);
        // Now len == cap, shrink should be no-op
        s.shrink_to_fit();
        assert_eq!(s.len(), 5);

        // Case: cap == 0 → should be no-op
        let s2 = arena.alloc_utf16_string_with_capacity(0);
        assert_eq!(s2.len(), 0);
    }

    /// Kills: `utf16_string.rs:206:38` `- -> /` in `shrink_to_fit`
    /// `let reclaim_units = self.cap - self.len;`
    #[test]
    fn utf16_206_shrink_reclaim_units() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        // len=2, cap=20, reclaim_units should be 18
        // If / instead of -, reclaim_units = 20/2 = 10 (wrong)
        s.shrink_to_fit();
        // After shrink, cap should equal len if reclaim succeeded
        // (best-effort, so we just verify no crash)
    }

    /// Kills: `utf16_string.rs:207:43` `* -> +` / `* -> /` in `shrink_to_fit`
    /// `let reclaim_bytes = reclaim_units * core::mem::size_of::<u16>();`
    #[test]
    fn utf16_207_shrink_reclaim_bytes() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(50);
        for _ in 0..5 {
            s.push('X');
        }
        // reclaim_units = 45, reclaim_bytes should be 90
        // If * becomes +, reclaim_bytes = 45 + 2 = 47 (wrong)
        // If * becomes /, reclaim_bytes = 45 / 2 = 22 (wrong)
        s.shrink_to_fit();
        // Verify string is still valid
        assert_eq!(s.len(), 5);
    }

    /// Kills: `utf16_string.rs:260:19` `> -> >=` in `try_push_from_str`
    /// `if needed > self.cap { self.try_grow_to_at_least(needed)?; }`
    #[test]
    fn utf16_260_push_from_str_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        // Push exactly 5 ASCII chars (each is 1 u16)
        // needed = 0 + 5*2 = 10 (worst case), but actual is 5
        s.try_push_from_str("A").unwrap();
        s.try_push_from_str("B").unwrap();
        s.try_push_from_str("C").unwrap();
        s.try_push_from_str("D").unwrap();
        s.try_push_from_str("E").unwrap();
        assert_eq!(s.len(), 5);
        // Now cap == len, pushing one more should trigger grow
        s.try_push_from_str("F").unwrap();
        assert_eq!(s.len(), 6);
    }

    /// Kills: `utf16_string.rs:277:19` `> -> >=` in `try_push_slice`
    /// `if needed > self.cap { self.try_grow_to_at_least(needed)?; }`
    #[test]
    fn utf16_277_push_slice_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(3);
        // Push 3 chars to fill capacity exactly
        s.push('A');
        s.push('B');
        s.push('C');
        assert_eq!(s.len(), 3); // needed == cap, no grow
        // Push one more to trigger grow
        s.push('D');
        assert_eq!(s.len(), 4);
    }

    /// Kills: `utf16_string.rs:298:19` `> -> >=` in `try_reserve`
    #[test]
    fn utf16_298_try_reserve_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push('A'); // len=1
        let cap_before = s.capacity();
        // Folded mutant-kill: exact-fit reserve must short-circuit before the grow path.
        s.try_reserve(9).unwrap(); // needed=10==cap, no grow
        assert_eq!(s.capacity(), cap_before);
        s.try_reserve(10).unwrap(); // needed=11>cap, must grow
    }

    /// Kills: `utf16_string.rs:318:16` `> -> >=` in `insert_slice` (idx <= self.len)
    /// `utf16_string.rs:330:19` `> -> >=` in `insert_slice` (needed > self.cap)
    #[test]
    fn utf16_318_330_insert_slice() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        s.push('A');
        s.push('B');
        s.push('C');
        // Insert at end (idx == len)
        s.insert(3, 'D');
        assert_eq!(s.len(), 4);
        // Insert at beginning
        s.insert(0, 'Z');
        assert_eq!(s.len(), 5);
        // Now len==cap==5, insert one more to trigger grow
        s.insert(2, 'X');
        assert_eq!(s.len(), 6);
    }

    /// Kills: `utf16_string.rs:337:76` `- -> +` in `insert_slice`
    /// `core::ptr::copy(base.add(idx), base.add(idx + s_len), self.len - idx);`
    /// If `-` becomes `+`, the copy length is self.len + idx (too much),
    /// reading/writing out of bounds.
    #[test]
    fn utf16_337_insert_copy_length() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        s.push('C');
        s.push('D');
        s.push('E');
        // Insert at idx=2 — must shift 3 elements (len-idx = 5-2 = 3)
        s.insert(2, 'X');
        let slice = s.as_slice();
        assert_eq!(slice[0], 'A' as u16);
        assert_eq!(slice[1], 'B' as u16);
        assert_eq!(slice[2], 'X' as u16);
        assert_eq!(slice[3], 'C' as u16);
        assert_eq!(slice[4], 'D' as u16);
        assert_eq!(slice[5], 'E' as u16);
    }

    /// Kills: `utf16_string.rs:356:72` `- -> +` and 356:78 `- -> +` / `- -> /`
    /// In remove: `self.len - idx - n` — shift length after removal.
    #[test]
    fn utf16_356_remove_shift() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        s.push('C');
        s.push('D');
        s.push('E');
        // Remove 'C' at idx=2 (n=1)
        let ch = s.remove(2);
        assert_eq!(ch, 'C');
        assert_eq!(s.len(), 4);
        let slice = s.as_slice();
        assert_eq!(slice[0], 'A' as u16);
        assert_eq!(slice[1], 'B' as u16);
        assert_eq!(slice[2], 'D' as u16);
        assert_eq!(slice[3], 'E' as u16);
    }

    /// Kills: `utf16_string.rs:396:18` `> -> >=` and 396:22 `&& -> ||` and 396:31 `< -> <=`
    /// These are the boundary checks in `replace_range`:
    /// `if start > 0 && start < self.len { check boundary }`
    #[test]
    fn utf16_396_replace_range_start_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        s.push('C');
        s.push('D');
        // Replace at start=0 — should skip boundary check (start > 0 is false)
        let replacement = widestring::utf16str!("XY");
        s.replace_range(0..1, replacement);
        assert_eq!(s.len(), 5); // removed 1, added 2
        // Replace at start==len — should skip check (start < self.len is false)
        let empty = widestring::utf16str!("");
        s.replace_range(5..5, empty);
        assert_eq!(s.len(), 5);
    }

    /// Kills: `utf16_string.rs:403:16` `> -> ==` / `> -> <` / `> -> >=`
    /// and 403:27 `< -> >`
    /// `if end > 0 && end < self.len { check boundary }`
    #[test]
    fn utf16_403_replace_range_end_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        s.push('C');
        // Replace with end=0 — should skip check (end > 0 is false)
        let empty = widestring::utf16str!("");
        s.replace_range(0..0, empty);
        assert_eq!(s.len(), 3);
        // Replace with end==len — should skip check (end < self.len is false)
        let x = widestring::utf16str!("Z");
        s.replace_range(2..3, x);
        assert_eq!(s.len(), 3);
    }

    /// Kills: `utf16_string.rs:418:20` `> -> >=` in `replace_range`
    /// `if new_len > self.cap { self.grow_to_at_least(new_len); }`
    #[test]
    fn utf16_418_replace_range_grow_boundary() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(5);
        s.push('A');
        s.push('B');
        s.push('C');
        s.push('D');
        s.push('E');
        // Replace 1 element with 1 element — new_len == old_len == cap, no grow
        let x = widestring::utf16str!("X");
        s.replace_range(2..3, x);
        assert_eq!(s.len(), 5);
        assert_eq!(s.as_slice()[2], 'X' as u16);
    }

    /// Kills: `utf16_string.rs:424:81` `- -> +` in `replace_range`
    /// `core::ptr::copy(base.add(end), base.add(start + inserted), self.len - end);`
    #[test]
    fn utf16_424_replace_range_copy() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        s.push('C');
        s.push('D');
        s.push('E');
        // Replace B,C (indices 1..3) with "XYZ" (3 elements)
        let xyz = widestring::utf16str!("XYZ");
        s.replace_range(1..3, xyz);
        assert_eq!(s.len(), 6); // 5 - 2 + 3 = 6
        let slice = s.as_slice();
        assert_eq!(slice[0], 'A' as u16);
        assert_eq!(slice[1], 'X' as u16);
        assert_eq!(slice[2], 'Y' as u16);
        assert_eq!(slice[3], 'Z' as u16);
        assert_eq!(slice[4], 'D' as u16);
        assert_eq!(slice[5], 'E' as u16);
    }

    /// Kills: `utf16_string.rs:491:29` `- -> /` in `try_reclaim_tail`
    /// `let reclaim = total - used;`
    #[test]
    fn utf16_491_reclaim_tail() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(100);
        s.push('A');
        s.push('B');
        // len=2, cap=100. Reclaim should free ~196 bytes.
        // If / instead of -, reclaim is wrong.
        let _frozen = s.into_arena_utf16_str();
        // Verify arena still works
        let _v = arena.alloc(42u64);
    }
}

mod utf16_round2 {
    use multitude::Arena;

    /// Kills: `utf16_string.rs:337:76` `- -> +` in `insert_slice` copy
    /// `core::ptr::copy(base.add(idx), base.add(idx + s_len), self.len - idx)`
    /// If `- -> +`: copy count is `self.len + idx` instead of `self.len - idx`.
    /// For a string "ABCDE" (len=5) inserting at idx=2:
    ///   Correct count = 5 - 2 = 3 (shift C,D,E right)
    ///   Mutated count = 5 + 2 = 7 (reads 7 u16s starting at idx, goes OOB)
    #[test]
    fn utf16_337_insert_copy_oob() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        // Build "ABCDEFGHIJ" (10 chars)
        for ch in "ABCDEFGHIJ".chars() {
            s.push(ch);
        }
        assert_eq!(s.len(), 10);
        // Insert "XY" at idx=3 — must shift 7 elements right
        // With mutation: copies 10+3=13 elements (OOB!)
        s.insert(3, 'X');
        assert_eq!(s.len(), 11);
        let slice = s.as_slice();
        assert_eq!(slice[0], 'A' as u16);
        assert_eq!(slice[1], 'B' as u16);
        assert_eq!(slice[2], 'C' as u16);
        assert_eq!(slice[3], 'X' as u16);
        assert_eq!(slice[4], 'D' as u16);
        assert_eq!(slice[5], 'E' as u16);
        assert_eq!(slice[6], 'F' as u16);
        assert_eq!(slice[7], 'G' as u16);
        assert_eq!(slice[8], 'H' as u16);
        assert_eq!(slice[9], 'I' as u16);
        assert_eq!(slice[10], 'J' as u16);
    }

    /// Kills: `utf16_string.rs:356:72` `- -> +` and 356:78 `- -> +` / `- -> /`
    /// In remove: copy(base.add(idx + n), base.add(idx), self.len - idx - n)
    /// 356:72 is the outer `-`: `self.len - idx` becomes `self.len + idx`
    /// 356:78 is the inner `-`: `(self.len - idx) - n` or `(self.len + idx) - n`
    /// For "ABCDEFGHIJ" (len=10), remove at idx=2 (n=1):
    ///   Correct: copy 7 elements from idx=3 to idx=2
    ///   356:72 `+ -> +`: copy `10 + 2 - 1 = 11` elements (OOB)
    ///   356:78 `- -> +`: copy `10 - 2 + 1 = 9` elements (reads past end)
    ///   356:78 `- -> /`: copy `10 - 2 / 1 = 8` elements (wrong count)
    #[test]
    fn utf16_356_remove_long_string() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        for ch in "ABCDEFGHIJ".chars() {
            s.push(ch);
        }
        assert_eq!(s.len(), 10);
        // Remove 'C' at idx=2 (n=1 since 'C' is 1 u16)
        let removed = s.remove(2);
        assert_eq!(removed, 'C');
        assert_eq!(s.len(), 9);
        // Verify entire remaining string
        let expected = [
            'A' as u16, 'B' as u16, 'D' as u16, 'E' as u16, 'F' as u16, 'G' as u16, 'H' as u16, 'I' as u16, 'J' as u16,
        ];
        assert_eq!(s.as_slice(), &expected);
    }

    /// Kills: `utf16_string.rs:403:16` `> -> ==` — end boundary check
    /// `if end > 0 && end < self.len { check boundary }`
    /// With ==: `if end == 0 && end < self.len` — only checks boundary
    /// when end==0, which is never valid (end==0 && end < len means
    /// end is 0 but we check character at index 0, which is always valid).
    /// Need to test: end > 0 && end < len where end is at a valid boundary.
    #[test]
    fn utf16_403_end_boundary_mid_string() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        // Push "A😀B" — 'A' (1 u16), '😀' (2 u16s: D83D DE00), 'B' (1 u16)
        s.push('A');
        s.push('😀');
        s.push('B');
        assert_eq!(s.len(), 4); // 1 + 2 + 1 = 4 u16s

        // Replace range ending at index 3 (between high and low surrogate is at 2)
        // end=3 is valid (after the emoji, start of 'B')
        let replacement = widestring::utf16str!("X");
        s.replace_range(3..4, replacement); // replace 'B' with 'X'
        assert_eq!(s.len(), 4);
        assert_eq!(s.as_slice()[3], 'X' as u16);
    }

    /// Kills: `utf16_string.rs:403:16` `> -> >=` — end boundary
    /// If `>= 0` is always true for usize, the boundary check always runs.
    /// This means end==0 (which is valid) would try to check character boundary.
    #[test]
    fn utf16_403_end_zero() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(10);
        s.push('A');
        s.push('B');
        // Replace range 0..0 with nothing (end=0)
        let empty = widestring::utf16str!("");
        s.replace_range(0..0, empty);
        assert_eq!(s.len(), 2);
    }

    /// Kills: `utf16_string.rs:403:27` `< -> >` — end boundary
    /// `if end > 0 && end < self.len` becomes `end > 0 && end > self.len`
    /// Would check boundary when end > len, which is already rejected by
    /// the `assert!(start <= end && end <= self.len)` above. So this should
    /// be equivalent — the `end > len` case never reaches this check.
    /// But wait: `end == self.len` skips the check with `<`. With `>`,
    /// `end > self.len` also skips it. So the only difference is `end < self.len`
    /// vs `end > self.len`. When end < len, we need to check boundary.
    /// With `>`, we skip the check when end is in the middle, allowing
    /// `replace_range` to split a surrogate pair at the end boundary.
    #[test]
    fn utf16_403_27_end_surrogate_check() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        // "A😀B" = A [D83D DE00] B
        s.push('A');
        s.push('😀');
        s.push('B');
        // end=2 points at DE00 (low surrogate) — must panic
        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
            let x = widestring::utf16str!("");
            s.replace_range(0..2, x);
        }));
        assert!(result.is_err(), "replace_range ending at low surrogate must panic");
    }

    /// Kills: `utf16_string.rs:418:20` `> -> >=` in `replace_range` grow
    /// `if new_len > self.cap { grow }`
    /// With >=: `new_len` == cap triggers unnecessary grow.
    /// The grow is a no-op since `grow_to_at_least` returns early for `min_cap` <= cap.
    /// So this is EQUIVALENT.
    // ---
    /// Kills: `utf16_string.rs:424:81` `- -> +` in `replace_range` copy
    /// `copy(base.add(end), base.add(start + inserted), self.len - end)`
    /// With +: `self.len + end` (huge copy, OOB)
    #[test]
    fn utf16_424_replace_range_tail_copy() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        for ch in "ABCDEFGHIJ".chars() {
            s.push(ch);
        }
        // Replace "CDE" (indices 2..5) with "XY"
        let xy = widestring::utf16str!("XY");
        s.replace_range(2..5, xy);
        assert_eq!(s.len(), 9); // 10 - 3 + 2
        let expected = [
            'A' as u16, 'B' as u16, 'X' as u16, 'Y' as u16, 'F' as u16, 'G' as u16, 'H' as u16, 'I' as u16, 'J' as u16,
        ];
        assert_eq!(s.as_slice(), &expected);
    }

    /// Kills: `utf16_string.rs:491:29` `- -> /` in `try_reclaim_tail`
    /// `let reclaim = total - used` becomes `total / used`.
    /// For cap=100, len=2: total = 8 + 200 = 208, used = 8 + 4 = 12
    /// Correct: reclaim = 196. Mutated: reclaim = 208/12 = 17.
    /// Wrong reclaim moves cursor by wrong amount.
    #[test]
    fn utf16_491_reclaim_tail_v2() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(100);
        s.push('A');
        s.push('B');
        let _frozen = s.into_arena_utf16_str();
        // Subsequent allocation should be able to use reclaimed space
        let mut s2 = arena.alloc_utf16_string_with_capacity(50);
        s2.push('X');
        let _frozen2 = s2.into_arena_utf16_str();
    }

    /// Kills: `utf16_string.rs:206:38` `- -> /` in `shrink_to_fit`
    /// `reclaim_units = self.cap - self.len` becomes `self.cap / self.len`
    /// For cap=20, len=2: correct=18, mutated=10. Wrong reclaim.
    #[test]
    fn utf16_206_shrink_reclaim_v2() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(20);
        s.push('A');
        s.push('B');
        s.shrink_to_fit();
        // After successful shrink, capacity should equal len
        // (if try_shrink_at_cursor succeeded)
        // Just verify string is still valid
        assert_eq!(s.len(), 2);
        assert_eq!(s.as_slice()[0], 'A' as u16);
    }

    /// Kills: `utf16_string.rs:207:43` `* -> +` and `* -> /` in `shrink_to_fit`
    /// `reclaim_bytes = reclaim_units * size_of::<u16>()` (= `reclaim_units` * 2)
    /// With +: `reclaim_bytes` = `reclaim_units` + 2 (wrong)
    /// With /: `reclaim_bytes` = `reclaim_units` / 2 (wrong)
    #[test]
    fn utf16_207_shrink_bytes_v2() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(100);
        for _ in 0..10 {
            s.push('X');
        }
        // reclaim_units = 90, reclaim_bytes should be 180
        // With +: 92 (wrong), with /: 45 (wrong)
        s.shrink_to_fit();
        assert_eq!(s.len(), 10);
    }

    // utf16:260/277/298/330 `> -> >=`: try_grow_to_at_least returns early
    // when min_cap <= cap, so the extra grow call is a no-op. EQUIVALENT.

    // utf16:203 `|| -> &&`: When cap > 0 && len == cap, reclaim_units = 0,
    // reclaim_bytes = 0, try_shrink_at_cursor(end, 0) is a no-op. EQUIVALENT.
}

// === relocated from coverage_extras.rs (utf16-gated tests) ===
mod from_coverage_extras_utf16 {
    #![allow(clippy::items_after_statements, reason = "relocated tests put inner types near use")]
    #![allow(clippy::clone_on_ref_ptr, reason = "relocated tests use .clone() on Arc/Rc")]
    #![allow(dead_code, reason = "relocated helpers retain fields for layout")]
    #![allow(
        unfulfilled_lint_expectations,
        reason = "relocated #[expect] may be fulfilled at file or feature level"
    )]
    #![allow(
        clippy::undocumented_unsafe_blocks,
        reason = "relocated test bodies preserve original safety reasoning"
    )]
    #![allow(clippy::multiple_unsafe_ops_per_block, reason = "relocated tests group related unsafe ops")]
    #![allow(clippy::cast_possible_truncation, reason = "relocated tests use bounded values")]
    #![allow(clippy::cast_sign_loss, reason = "relocated tests use non-negative values")]
    #![allow(clippy::empty_drop, reason = "relocated tests use empty Drop impls to mark dropability")]
    #![allow(clippy::assertions_on_result_states, reason = "relocated tests deliberately assert error returns")]
    #![allow(clippy::empty_line_after_doc_comments, reason = "relocated test doc-comments")]
    use multitude::strings::Utf16String;
    use multitude::vec::FromIteratorIn;
    use multitude::{Arena, ArenaBuilder};
    use widestring::utf16str;

    #[expect(unused_imports, reason = "relocated tests may reference common helpers")]
    use crate::common::{self, FailingAllocator};

    #[test]
    #[should_panic(expected = "allocator returned AllocError")]
    fn utf16_string_push_panics_on_allocator_error() {
        let arena = ArenaBuilder::new_in(FailingAllocator::new(0)).build();
        let mut s = arena.alloc_utf16_string();
        s.push('x');
    }

    #[test]
    #[should_panic(expected = "allocator returned AllocError")]
    fn utf16_string_insert_panics_from_grow_to_at_least() {
        let arena = ArenaBuilder::new_in(FailingAllocator::new(1)).build();
        let mut s = Utf16String::from_str_in("a", &arena);
        let replacement = widestring::Utf16String::from_str(&"x".repeat(70_000));
        s.insert_utf16_str(0, replacement.as_utfstr());
    }

    #[test]
    fn utf16_string_reserve_zero_on_nonempty_string_is_noop() {
        let arena = Arena::new();
        let mut s = Utf16String::from_str_in("already allocated", &arena);
        let cap = s.capacity();
        s.reserve(0);
        assert_eq!(s.capacity(), cap);
        assert_eq!(s.as_utf16_str().to_string(), "already allocated");
    }

    #[test]
    fn utf16_string_from_iterator_in_impls() {
        let arena = Arena::new();

        let chars = Utf16String::from_iter_in(['a', 'β', '🦀'], &arena);
        assert_eq!(chars.as_utf16_str().to_string(), "aβ🦀");

        let parts = [utf16str!("hi"), utf16str!("!")];
        let from_utf16 = Utf16String::from_iter_in(parts, &arena);
        assert_eq!(from_utf16.as_utf16_str().to_string(), "hi!");

        let from_strs = Utf16String::from_iter_in(["wide", " ", "string"], &arena);
        assert_eq!(from_strs.as_utf16_str().to_string(), "wide string");
    }

    #[cfg(all(feature = "utf16", feature = "serde"))]
    #[test]
    fn utf16_string_serialize_impl_body() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_str(utf16str!("serde 🦀"));
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(json, r#""serde 🦀""#);
    }

    #[test]
    fn alloc_utf16_str_rc_oversized_routes_via_oversized_local() {
        let arena = Arena::new();
        let len_u16 = 16 * 1024;
        let buf: Vec<u16> = (0..len_u16).map(|i: usize| u16::try_from(i & 0xFFFF).unwrap()).collect();
        let src = widestring::Utf16Str::from_slice(&buf).unwrap();
        let rc = arena.alloc_utf16_str_rc(src);
        assert_eq!(rc.len(), len_u16);
    }

    #[test]
    fn alloc_utf16_str_box_oversized_routes_via_oversized_local() {
        let arena = Arena::new();
        let len_u16 = 16 * 1024;
        let buf: Vec<u16> = (0..len_u16).map(|i: usize| u16::try_from(i & 0xFFFF).unwrap()).collect();
        let src = widestring::Utf16Str::from_slice(&buf).unwrap();
        let b = arena.alloc_utf16_str_box(src);
        assert_eq!(b.len(), len_u16);
    }

    #[test]
    fn alloc_utf16_str_arc_oversized_routes_via_oversized_shared() {
        let arena = Arena::new();
        let len_u16 = 16 * 1024;
        let buf: Vec<u16> = (0..len_u16).map(|i: usize| u16::try_from(i & 0xFFFF).unwrap()).collect();
        let src = widestring::Utf16Str::from_slice(&buf).unwrap();
        let arc = arena.alloc_utf16_str_arc(src);
        assert_eq!(arc.len(), len_u16);
    }
}

// === relocated from mutants_extras.rs (utf16-gated tests) ===
mod from_mutants_extras_utf16_scattered {
    #![allow(clippy::items_after_statements, reason = "relocated tests put inner types near use")]
    #![allow(clippy::clone_on_ref_ptr, reason = "relocated tests use .clone() on Arc/Rc")]
    #![allow(dead_code, reason = "relocated helpers retain fields for layout")]
    #![allow(
        unfulfilled_lint_expectations,
        reason = "relocated #[expect] may be fulfilled at file or feature level"
    )]
    #![allow(
        clippy::undocumented_unsafe_blocks,
        reason = "relocated test bodies preserve original safety reasoning"
    )]
    #![allow(clippy::multiple_unsafe_ops_per_block, reason = "relocated tests group related unsafe ops")]
    #![allow(clippy::cast_possible_truncation, reason = "relocated tests use bounded values")]
    #![allow(clippy::cast_sign_loss, reason = "relocated tests use non-negative values")]
    #![allow(clippy::empty_drop, reason = "relocated tests use empty Drop impls to mark dropability")]
    #![allow(clippy::assertions_on_result_states, reason = "relocated tests deliberately assert error returns")]
    #![allow(clippy::empty_line_after_doc_comments, reason = "relocated test doc-comments")]
    extern crate alloc;
    use multitude::{Arena, Rc};

    #[expect(unused_imports, reason = "relocated tests may reference common helpers")]
    use crate::common::{self, FailingAllocator, SendFailingAllocator};

    // =====================================================================
    // vec/vec.rs mutants
    // =====================================================================

    /// Kills: vec.rs:362:21 `< -> <=` in `shrink_to_fit`
    /// `if self.len < self.cap && self.realloc(self.len).is_err() { ... }`
    /// If `<` becomes `<=`, len == cap would trigger a realloc to same
    /// size, which is a no-op but shouldn't happen.
    #[test]
    fn vec_362_shrink_to_fit_boundary() {
        let arena = Arena::new();
        let mut v = arena.alloc_vec_with_capacity::<u64>(10);
        v.push(1);
        v.push(2);
        v.push(3);
        assert_eq!(v.len(), 3);
        assert!(v.capacity() >= 10);
        v.shrink_to_fit();
        // After shrink, capacity should equal len
        assert_eq!(v.capacity(), v.len());

        // When len == cap, shrink should be no-op
        v.shrink_to_fit(); // should not panic or reallocate
        assert_eq!(v.len(), 3);
    }

    // =====================================================================
    // Vec stronger tests
    // =====================================================================

    /// Kills: vec.rs:451:34 `- -> +` in resize
    /// `self.reserve(new_len - self.len)` becomes `self.reserve(new_len + self.len)`
    /// For len=2, `new_len=5`: correct reserve=3, mutated=7.
    /// Extra reservation succeeds but wastes space.
    /// With tight budget, the extra reservation might fail.
    #[test]
    fn vec_451_resize_tight_budget() {
        let arena = Arena::builder().byte_budget(128 * 1024).build();
        let mut v = arena.alloc_vec_with_capacity::<u64>(5);
        v.push(1);
        v.push(2);
        v.resize(5, 42);
        assert_eq!(v.len(), 5);
        assert_eq!(v[0], 1);
        assert_eq!(v[1], 2);
        assert_eq!(v[2], 42);
        assert_eq!(v[3], 42);
        assert_eq!(v[4], 42);
    }

    /// Kills `utf16_string.rs:207:43 * → +` in `Utf16String::shrink_to_fit`.
    ///
    /// `reclaim_bytes = reclaim_units * sizeof::<u16>()`:
    /// * Original `*`: with `reclaim_units = 8, sizeof(u16) = 2`,
    ///   `reclaim_bytes = 16`.
    /// * Mutated `+`: `reclaim_bytes = 10`.
    ///
    /// We observe through the arena cursor: after a `shrink_to_fit`, the
    /// next allocation should re-use the freed tail. With the wrong
    /// `reclaim_bytes`, the cursor moves back by a different amount and
    /// the next allocation lands at a different offset.
    #[test]
    fn utf16_shrink_to_fit_uses_multiplication() {
        use multitude::strings::Utf16String;
        let arena = Arena::new();
        let mut s: Utf16String<'_> = Utf16String::new_in(&arena);
        s.reserve(32);
        for _ in 0..8_u16 {
            s.push('a');
        }
        let cap_before = s.capacity();
        let len = s.len();
        assert!(cap_before >= len + 8, "test prerequisites: cap={cap_before}, len={len}");

        // Original `*`: shrink reclaims (cap_before - 8) * 2 bytes.
        // Mutated `+`:  reclaims (cap_before - 8) + 2 bytes.
        // In both, the shrink either succeeds (cap → 8) or fails (no-op),
        // so cap alone may not distinguish. We instead allocate a probe
        // immediately afterward and check whether it could fit in the
        // *expected* reclaimed range.
        s.shrink_to_fit();
        // If the shrink succeeded, cap == len. If it failed, cap unchanged.
        // The mutation does NOT cause `try_shrink_at_cursor` to fail
        // outright (smaller reclaim is accepted), so the observable here is
        // the post-shrink allocation cursor — exercised indirectly by
        // pushing more data and confirming content integrity.
        s.push('z');
        assert_eq!(s.len(), len + 1);
        // Content integrity is the strongest assertion we can make without
        // exposing internal arena cursors.
        let units: alloc::vec::Vec<u16> = s.as_slice().to_vec();
        let last = units.last().copied().expect("non-empty");
        assert_eq!(last, u16::from(b'z'));
    }

    /// Kills `utf16_string.rs:356:72 - → +` and `356:78 - → +` in `Utf16String::remove`.
    ///
    /// `core::ptr::copy(base.add(idx + n), base.add(idx), self.len - idx - n)`:
    /// * Original: shifts the tail left by `n`, copying `len - idx - n` units.
    /// * Mutated col 72 `- → +`: shifts `len + idx - n` units → wildly large
    ///   and writes out-of-bounds garbage into the buffer.
    /// * Mutated col 78 `- → +`: shifts `len - idx + n` units → off-by-`2n`
    ///   into the tail, leaving the wrong content.
    ///
    /// We assert exact post-remove content over many calls.
    /// Kills `utf16_string.rs:260:19`, `277:19`, `298:19`, `318:16`, `396:18`,
    /// `418:20` — all `> → >=` boundary mutations on
    /// `if needed > self.cap { grow }`.
    ///
    /// At `needed == self.cap` (exactly fits): original skips the grow
    /// (no-op). Mutated `>=` invokes `try_grow_to_at_least(cap)` which is
    /// itself a no-op (returns Ok immediately when `min_cap` <= cap).
    ///
    /// These mutations are therefore **equivalent**. We document this in
    /// `MUTANTS_EQUIVALENT.md` and verify the observable: after the push
    /// that lands exactly at cap, the content and cap are identical to
    /// what they would be under either operator.
    #[test]
    fn utf16_exact_fit_push_is_observably_identical() {
        use multitude::strings::Utf16String;
        let arena = Arena::new();
        let mut s: Utf16String<'_> = Utf16String::new_in(&arena);
        s.reserve(4);
        let cap = s.capacity();
        // Push exactly `cap` ASCII chars (each 1 u16). After the last push,
        // len == cap. The branch `needed > cap` is false; mutated `needed >= cap`
        // would attempt `try_grow_to_at_least(cap)` → also no-op.
        for _ in 0..cap {
            s.push('x');
        }
        assert_eq!(s.len(), cap);
        assert!(s.capacity() >= cap);
    }

    #[test]
    fn utf16_insert_at_start_preserves_tail() {
        use widestring::utf16str;
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_from_str("World");
        s.insert_utf16_str(0, utf16str!("Hello, "));
        let actual: std::string::String = std::char::decode_utf16(s.as_slice().iter().copied()).map(|r| r.unwrap()).collect();
        assert_eq!(actual, "Hello, World");
    }

    #[test]
    fn utf16_insert_in_middle_preserves_surrounding() {
        use widestring::utf16str;
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_from_str("HelloWorld");
        s.insert_utf16_str(5, utf16str!(", "));
        let actual: std::string::String = std::char::decode_utf16(s.as_slice().iter().copied()).map(|r| r.unwrap()).collect();
        assert_eq!(actual, "Hello, World");
    }

    #[test]
    fn utf16_remove_first_preserves_rest() {
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_from_str("hello");
        let removed = s.remove(0);
        assert_eq!(removed, 'h');
        assert_eq!(s.len(), 4);
    }

    #[test]
    fn utf16_replace_range_replaces_exact_range() {
        use widestring::utf16str;
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string();
        s.push_from_str("Hello, World!");
        s.replace_range(7..12, utf16str!("Rust"));
        let actual: std::string::String = std::char::decode_utf16(s.as_slice().iter().copied()).map(|r| r.unwrap()).collect();
        assert_eq!(actual, "Hello, Rust!");
    }

    #[cfg(feature = "stats")]
    #[test]
    fn utf16_string_into_arena_str_reclaim_lets_followup_fit_in_chunk() {
        // Capacity 1800 u16 = 3600 bytes; only "hi" pushed.
        let arena = Arena::new();
        let mut s = arena.alloc_utf16_string_with_capacity(1800);
        s.push_from_str("hi");
        let chunks_before = arena.stats().normal_local_chunks_allocated;
        let _rs = s.into_arena_utf16_str();
        let big: Rc<[u8; 2000]> = arena.alloc_rc([3_u8; 2000]);
        assert_eq!(big[0], 3);
        assert_eq!(big[1999], 3);
        assert_eq!(arena.stats().normal_local_chunks_allocated, chunks_before);
    }

    #[cfg(feature = "stats")]
    #[test]
    fn utf16_string_shrink_to_fit_reclaim_lets_followup_fit_in_chunk() {
        let arena = Arena::new();
        // cap=1800 u16 = 3600 bytes.
        let mut s = arena.alloc_utf16_string_with_capacity(1800);
        s.push_from_str("hi");
        s.shrink_to_fit();
        let chunks_before = arena.stats().normal_local_chunks_allocated;
        let big: Rc<[u8; 2000]> = arena.alloc_rc([4_u8; 2000]);
        assert_eq!(big[0], 4);
        assert_eq!(big[1999], 4);
        assert_eq!(s.len(), 2);
        assert_eq!(arena.stats().normal_local_chunks_allocated, chunks_before);
    }
}