blind_pool/

pooled_mut.rs

use std::fmt;
use std::ops::{Deref, DerefMut};
use std::pin::Pin;

use crate::{BlindPool, Pooled, RawPooled};

/// A mutable reference to a value stored in a [`BlindPool`].
///
/// This type provides automatic lifetime management for values in the pool with exclusive access.
/// When the [`PooledMut`] instance is dropped, the value is automatically removed from the pool.
///
/// Unlike [`Pooled<T>`], this type does not implement [`Clone`] and provides exclusive access
/// through [`DerefMut`], making it suitable for scenarios where mutable access is required
/// and shared ownership is not needed.
///
/// # Thread Safety
///
/// [`PooledMut<T>`] implements thread safety traits conditionally based on the stored type `T`:
///
/// - **Send**: [`PooledMut<T>`] is [`Send`] if and only if `T` is [`Send`]. This allows moving
///   pooled mutable references between threads when the referenced type can be moved between threads.
///
/// - **Sync**: [`PooledMut<T>`] does NOT implement [`Sync`] because it provides exclusive mutable
///   access via [`DerefMut`]. Allowing multiple threads to share references to the same
///   [`PooledMut<T>`] instance would violate Rust's borrowing rules and lead to data races.
///
/// # Example
///
/// ```rust
/// use blind_pool::BlindPool;
///
/// let pool = BlindPool::new();
/// let mut value_handle = pool.insert_mut("Test".to_string());
///
/// // Mutably access the value.
/// value_handle.push_str(" - Modified");
/// assert_eq!(*value_handle, "Test - Modified");
///
/// // Value is automatically cleaned up when handle is dropped.
/// ```
pub struct PooledMut<T: ?Sized> {
    /// The inner data containing the actual pooled item and pool handle.
    inner: PooledMutInner<T>,
}

/// Internal data structure that manages the lifetime of a mutably pooled item.
struct PooledMutInner<T: ?Sized> {
    /// The typed handle to the actual item in the pool.
    pooled: RawPooled<T>,

    /// A handle to the pool that keeps it alive as long as this item exists.
    pool: BlindPool,
}

impl<T: ?Sized> PooledMut<T> {
    /// Creates a new [`PooledMut<T>`] from a pooled item and pool handle.
    ///
    /// This is an internal constructor used by [`BlindPool::insert_mut`] and
    /// [`BlindPool::insert_with_mut`].
    #[must_use]
    pub(crate) fn new(pooled: RawPooled<T>, pool: BlindPool) -> Self {
        let inner = PooledMutInner { pooled, pool };
        Self { inner }
    }

    /// Provides access to the internal raw pooled handle for type casting operations.
    ///
    /// This method is used internally by the casting macro system and should not be
    /// used directly by user code.
    #[doc(hidden)]
    pub fn __private_cast_dyn_with_fn<U: ?Sized, F>(self, cast_fn: F) -> PooledMut<U>
    where
        F: FnOnce(&mut T) -> &mut U,
    {
        // We need to prevent the Drop from running on the original handle while still
        // extracting its fields. This is safe because we're transferring ownership
        // to the new handle.
        let this = std::mem::ManuallyDrop::new(self);
        // SAFETY: We are reading from ManuallyDrop wrapped value to transfer ownership.
        // The field is guaranteed to be initialized and we prevent Drop from running.
        let pooled = unsafe { std::ptr::read(&raw const this.inner.pooled) };
        // SAFETY: We are reading from ManuallyDrop wrapped value to transfer ownership.
        // The field is guaranteed to be initialized and we prevent Drop from running.
        let pool = unsafe { std::ptr::read(&raw const this.inner.pool) };

        // Cast the RawPooled to the trait object using the provided function
        // SAFETY: The lifetime management logic of this pool guarantees that the target item is
        // still alive in the pool for as long as any handle exists, which it clearly does.
        let cast_pooled = unsafe { pooled.__private_cast_dyn_with_fn_mut(cast_fn) };

        // Create the new PooledMut with the cast handle and the same pool
        PooledMut {
            inner: PooledMutInner {
                pooled: cast_pooled,
                pool,
            },
        }
    }

    /// Returns a pinned reference to the value stored in the pool.
    ///
    /// Since values in the pool are always pinned (they never move once inserted),
    /// this method provides safe access to `Pin<&T>` without requiring unsafe code.
    ///
    /// # Example
    ///
    /// ```rust
    /// use std::pin::Pin;
    ///
    /// use blind_pool::BlindPool;
    ///
    /// let pool = BlindPool::new();
    /// let handle = pool.insert_mut("hello".to_string());
    ///
    /// let pinned: Pin<&String> = handle.as_pin();
    /// assert_eq!(pinned.len(), 5);
    /// ```
    #[must_use]
    #[inline]
    pub fn as_pin(&self) -> Pin<&T> {
        // Delegate to the underlying opaque_pool Pooled<T> as_pin implementation.
        // This is safe and efficient since opaque_pool now provides safe as_pin.
        self.inner.pooled.opaque_handle().as_pin()
    }

    /// Returns a pinned mutable reference to the value stored in the pool.
    ///
    /// Since values in the pool are always pinned (they never move once inserted),
    /// this method provides safe access to `Pin<&mut T>` without requiring unsafe code.
    ///
    /// # Example
    ///
    /// ```rust
    /// use std::pin::Pin;
    ///
    /// use blind_pool::BlindPool;
    ///
    /// let pool = BlindPool::new();
    /// let mut handle = pool.insert_mut("hello".to_string());
    ///
    /// let mut pinned: Pin<&mut String> = handle.as_pin_mut();
    /// // Can use Pin methods or deref to &mut String
    /// ```
    #[must_use]
    #[inline]
    pub fn as_pin_mut(&mut self) -> Pin<&mut T> {
        // SAFETY: We have exclusive access through PooledMut and the pooled handle contains
        // a valid value. We can safely create a mutable reference to convert the shared
        // RawPooled to provide mutable access for our exclusive PooledMut.
        let mutable_ref = unsafe { self.inner.pooled.ptr().as_mut() };
        // SAFETY: Values in the pool are always pinned - they never move once inserted.
        unsafe { Pin::new_unchecked(mutable_ref) }
    }

    /// Converts this exclusive [`PooledMut<T>`] handle into a shared [`Pooled<T>`] handle.
    ///
    /// This operation consumes the [`PooledMut<T>`] and returns a [`Pooled<T>`] that allows
    /// multiple shared references to the same pooled value. Once converted, you can no longer
    /// obtain exclusive (mutable) references to the value, but you can create multiple
    /// shared references through cloning.
    ///
    /// The returned [`Pooled<T>`] maintains the same lifetime management semantics -
    /// the value will be automatically removed from the pool when all references
    /// (including the returned [`Pooled<T>`]) are dropped.
    ///
    /// # Example
    ///
    /// ```rust
    /// use blind_pool::BlindPool;
    ///
    /// let pool = BlindPool::new();
    /// let mut exclusive_handle = pool.insert_mut("Test".to_string());
    ///
    /// // Modify the value while we have exclusive access.
    /// exclusive_handle.push_str(" - Modified");
    /// assert_eq!(*exclusive_handle, "Test - Modified");
    ///
    /// // Convert to shared access.
    /// let shared_handle = exclusive_handle.into_shared();
    ///
    /// // Now we can create multiple shared references.
    /// let cloned_handle = shared_handle.clone();
    /// assert_eq!(*shared_handle, "Test - Modified");
    /// assert_eq!(*cloned_handle, "Test - Modified");
    ///
    /// // Value is automatically cleaned up when all handles are dropped.
    /// ```
    #[must_use]
    #[inline]
    pub fn into_shared(self) -> Pooled<T> {
        // We need to prevent the Drop from running on the original handle while still
        // extracting its fields. This is safe because we're transferring ownership
        // to the new shared handle.
        let this = std::mem::ManuallyDrop::new(self);
        // SAFETY: We are reading from ManuallyDrop wrapped value to transfer ownership.
        // The fields are guaranteed to be initialized and we prevent Drop from running.
        let pooled = unsafe { std::ptr::read(&raw const this.inner.pooled) };
        // SAFETY: We are reading from ManuallyDrop wrapped value to transfer ownership.
        // The field is guaranteed to be initialized and we prevent Drop from running.
        let pool = unsafe { std::ptr::read(&raw const this.inner.pool) };

        // Create the new shared handle with the same pooled item and pool
        Pooled::new(pooled, pool)
    }
}

impl<T: Unpin> PooledMut<T> {
    /// Moves the value out of the pool, returning it to the caller and consuming the [`PooledMut<T>`].
    ///
    /// This method extracts the value from the pool and transfers ownership to the caller.
    /// The item is removed from the pool, but the value is not dropped - instead, it is
    /// returned to the caller who becomes responsible for its lifetime management.
    ///
    /// This method is only available for types that implement [`Unpin`], as moving a value
    /// out of the pool would break the pinning guarantee for `!Unpin` types.
    ///
    /// # Example
    ///
    /// ```rust
    /// use blind_pool::BlindPool;
    ///
    /// let pool = BlindPool::new();
    /// let mut pooled_string = pool.insert_mut("Hello".to_string());
    ///
    /// // Modify the value while it is in the pool.
    /// pooled_string.push_str(" World");
    /// assert_eq!(*pooled_string, "Hello World");
    /// assert_eq!(pool.len(), 1);
    ///
    /// // Extract the value from the pool.
    /// let extracted_string = pooled_string.into_inner();
    /// assert_eq!(extracted_string, "Hello World");
    /// assert_eq!(pool.len(), 0); // Pool is now empty.
    ///
    /// // The caller now owns the value and is responsible for its lifetime.
    /// println!("Extracted: {}", extracted_string);
    /// ```
    #[must_use]
    #[inline]
    pub fn into_inner(self) -> T {
        // We need to prevent the Drop from running on the original handle while still
        // extracting the pooled item information to remove it from the pool.
        let this = std::mem::ManuallyDrop::new(self);

        // SAFETY: We are reading from ManuallyDrop wrapped value to access fields.
        // The fields are guaranteed to be initialized and we prevent Drop from running.
        let pooled = unsafe { std::ptr::read(&raw const this.inner.pooled) };
        // SAFETY: We are reading from ManuallyDrop wrapped value to access fields.
        // The field is guaranteed to be initialized and we prevent Drop from running.
        let pool = unsafe { std::ptr::read(&raw const this.inner.pool) };

        // Remove the item from the pool and move the value out.
        // SAFETY: T: Unpin is guaranteed by the impl constraint, and this pooled handle
        // is consumed by this operation, ensuring it cannot be used again.
        unsafe { pool.remove_unpin(&pooled) }
    }
}

impl<T: ?Sized> Deref for PooledMut<T> {
    type Target = T;

    /// Provides direct access to the value stored in the pool.
    ///
    /// This allows the handle to be used as if it were a reference to the stored value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use blind_pool::BlindPool;
    ///
    /// let pool = BlindPool::new();
    /// let string_handle = pool.insert_mut("hello".to_string());
    ///
    /// // Access string methods directly.
    /// assert_eq!(string_handle.len(), 5);
    /// assert!(string_handle.starts_with("he"));
    /// ```
    #[inline]
    fn deref(&self) -> &Self::Target {
        // Delegate to the underlying opaque_pool Pooled<T> Deref implementation.
        // This is safe and efficient since opaque_pool now provides safe Deref.
        self.inner.pooled.opaque_handle()
    }
}

impl<T: ?Sized> DerefMut for PooledMut<T> {
    /// Provides direct mutable access to the value stored in the pool.
    ///
    /// This allows the handle to be used as if it were a mutable reference to the stored value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use blind_pool::BlindPool;
    ///
    /// let pool = BlindPool::new();
    /// let mut string_handle = pool.insert_mut("hello".to_string());
    ///
    /// // Mutate the string directly.
    /// string_handle.push_str(" world");
    /// assert_eq!(*string_handle, "hello world");
    /// ```
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        // We cannot delegate to opaque_pool's DerefMut because our pooled handle is shared,
        // but we provide exclusive access through PooledMut's ownership semantics.
        // SAFETY: The pooled handle is valid and contains initialized memory of type T.
        // We have exclusive ownership through PooledMut, so no other references can exist.
        unsafe { self.inner.pooled.ptr().as_mut() }
    }
}

impl<T: ?Sized> Drop for PooledMut<T> {
    /// Automatically removes the item from the pool when the handle is dropped.
    ///
    /// This ensures that resources are properly cleaned up without requiring manual intervention.
    #[inline]
    fn drop(&mut self) {
        // We have exclusive ownership, so we can safely remove the item from the pool.
        // SAFETY: This pooled handle is being consumed by Drop, ensuring it cannot be used again.
        unsafe {
            self.inner.pool.remove(&self.inner.pooled.erase());
        }
    }
}

// SAFETY: PooledMut<T> can be Send if T is Send, because we can move the exclusive
// mutable access between threads when T can be moved between threads.
unsafe impl<T: ?Sized + Send> Send for PooledMut<T> {}

// Note: PooledMut<T> does NOT implement Sync because it provides mutable access
// via DerefMut. Allowing multiple threads to share references to the same
// PooledMut<T> instance would violate Rust's borrowing rules and lead to data races.

impl<T: ?Sized> fmt::Debug for PooledMut<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PooledMut")
            .field("type_name", &std::any::type_name::<T>())
            .field("ptr", &self.inner.pooled.ptr())
            .finish()
    }
}

impl<T: ?Sized> fmt::Debug for PooledMutInner<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PooledMutInner")
            .field("type_name", &std::any::type_name::<T>())
            .field("ptr", &self.pooled.ptr())
            .field("pool", &self.pool)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use static_assertions::{assert_impl_all, assert_not_impl_any};

    use super::PooledMut;
    use crate::BlindPool;

    #[test]
    fn thread_safety_assertions() {
        // PooledMut<T> should be Send if T is Send, but never Sync
        assert_impl_all!(PooledMut<u32>: Send);
        assert_impl_all!(PooledMut<String>: Send);
        assert_impl_all!(PooledMut<Vec<u8>>: Send);

        // PooledMut should NOT be Clone
        assert_not_impl_any!(PooledMut<u32>: Clone);
        assert_not_impl_any!(PooledMut<String>: Clone);
        assert_not_impl_any!(PooledMut<Vec<u8>>: Clone);

        // PooledMut should NOT be Sync (regardless of T's Sync status)
        // We only test with types that are known to not be Sync to avoid type inference issues
        use std::cell::RefCell;
        use std::rc::Rc;
        assert_not_impl_any!(PooledMut<RefCell<u32>>: Sync); // RefCell is not Sync
        assert_not_impl_any!(PooledMut<Rc<u32>>: Sync); // Rc is not Sync

        // With non-Send types, PooledMut should also not be Send
        assert_not_impl_any!(PooledMut<Rc<u32>>: Send); // Rc is not Send

        // RefCell<T> is Send if T is Send
        assert_impl_all!(PooledMut<RefCell<u32>>: Send); // RefCell<u32> is Send

        // PooledMut should implement Unpin
        assert_impl_all!(PooledMut<u32>: Unpin);
        assert_impl_all!(PooledMut<String>: Unpin);
        assert_impl_all!(PooledMut<Vec<u8>>: Unpin);
    }

    #[test]
    fn automatic_cleanup() {
        let pool = BlindPool::new();

        {
            let _handle = pool.insert_mut(42_u32);
            assert_eq!(pool.len(), 1);
        }

        // Item should be automatically removed after drop
        assert_eq!(pool.len(), 0);
        assert!(pool.is_empty());
    }

    #[test]
    fn mutable_access() {
        let pool = BlindPool::new();
        let mut handle = pool.insert_mut("hello".to_string());

        // Test mutable access
        handle.push_str(" world");
        assert_eq!(*handle, "hello world");

        // Test that the modification persists
        assert_eq!(handle.len(), 11);
    }

    #[test]
    fn deref_and_deref_mut_work() {
        let pool = BlindPool::new();
        let mut handle = pool.insert_mut(vec![1, 2, 3]);

        // Test Deref
        assert_eq!(handle.len(), 3);
        assert_eq!(*handle.first().expect("vec should not be empty"), 1);

        // Test DerefMut
        handle.push(4);
        *handle.get_mut(0).expect("index 0 should exist") = 10;

        assert_eq!(*handle, vec![10, 2, 3, 4]);
    }

    #[test]
    fn works_with_drop_types() {
        use std::sync::Arc;
        use std::sync::atomic::{AtomicBool, Ordering};

        struct DropTracker {
            dropped: Arc<AtomicBool>,
        }

        impl Drop for DropTracker {
            fn drop(&mut self) {
                self.dropped.store(true, Ordering::Relaxed);
            }
        }

        let pool = BlindPool::new();
        let dropped = Arc::new(AtomicBool::new(false));

        {
            let _handle = pool.insert_mut(DropTracker {
                dropped: Arc::clone(&dropped),
            });
            assert!(!dropped.load(Ordering::Relaxed));
        }

        // Item's Drop should have been called when pool handle was dropped
        assert!(dropped.load(Ordering::Relaxed));
    }

    #[test]
    fn double_remove_bug_reproduction() {
        use std::task::{Context, Poll, Waker};

        #[allow(
            clippy::unused_async,
            reason = "Need async fn to create Future for testing"
        )]
        async fn echo(val: u32) -> u32 {
            val
        }

        let pool = BlindPool::new();
        let mut future_handle = pool.insert_mut(echo(10));

        // Create a context for polling
        let waker = Waker::noop();
        let mut context = Context::from_waker(waker);

        // Poll the future
        let pinned_future = future_handle.as_pin_mut();
        match pinned_future.poll(&mut context) {
            Poll::Ready(result) => {
                assert_eq!(result, 10);
            }
            Poll::Pending => {
                // Should not happen for this simple future
                panic!("Future should complete immediately");
            }
        }

        // The handle should be dropped normally here without panicking
    }

    #[test]
    fn detailed_future_test() {
        use std::task::{Context, Poll, Waker};

        // A simple async function that should complete immediately
        #[allow(
            clippy::unused_async,
            reason = "Need async fn to create Future for testing"
        )]
        async fn echo(val: u32) -> u32 {
            val
        }

        let pool = BlindPool::new();

        // Insert the future into the pool
        let mut future_handle = pool.insert_mut(echo(42));
        assert_eq!(pool.len(), 1);

        // Create a context for polling
        let waker = Waker::noop();
        let mut context = Context::from_waker(waker);

        // Poll the future through the pinned reference
        let pinned_future = future_handle.as_pin_mut();
        let result = match pinned_future.poll(&mut context) {
            Poll::Ready(value) => value,
            Poll::Pending => panic!("Simple future should complete immediately"),
        };

        assert_eq!(result, 42);
        assert_eq!(pool.len(), 1); // Future should still be in pool

        // Drop the handle - this should cleanly remove the future from pool
        drop(future_handle);
        assert_eq!(pool.len(), 0); // Should be removed now
    }

    #[test]
    fn unpin_with_non_unpin_type() {
        use std::marker::PhantomPinned;

        // Create a type that is !Unpin
        struct NotUnpin {
            _pinned: PhantomPinned,
            value: u32,
        }

        // Verify that NotUnpin is indeed !Unpin
        assert_not_impl_any!(NotUnpin: Unpin);

        // PooledMut<NotUnpin> should still be Unpin because the wrapper implements Unpin
        // regardless of T's Unpin status - the pooled data is always pinned in place
        assert_impl_all!(PooledMut<NotUnpin>: Unpin);

        let pool = BlindPool::new();
        let handle = pool.insert_mut(NotUnpin {
            _pinned: PhantomPinned,
            value: 42,
        });

        // Can access the value normally
        assert_eq!(handle.value, 42);
    }

    #[test]
    #[allow(
        dead_code,
        reason = "Macro-generated trait only used for casting in this test"
    )]
    fn casting_with_futures() {
        use std::future::Future;
        use std::task::{Context, Poll, Waker};

        /// Custom trait for futures returning u32.
        pub(crate) trait MyFuture: Future<Output = u32> {}

        /// Blanket implementation for any Future<Output = u32>.
        impl<T> MyFuture for T where T: Future<Output = u32> {}

        // Generate casting methods for MyFuture.
        crate::define_pooled_dyn_cast!(MyFuture);

        #[allow(
            clippy::unused_async,
            reason = "Need async fn to create Future for testing"
        )]
        async fn echo(val: u32) -> u32 {
            val
        }

        let pool = BlindPool::new();

        // Create the future handle first, then cast it (separate operations)
        let original_handle = pool.insert_mut(echo(10));
        let mut future_handle = original_handle.cast_my_future();

        // After casting, the pool should still have the item
        assert_eq!(pool.len(), 1);

        // Poll the future using the safe pinning method from PooledMut
        let waker = Waker::noop();
        let mut context = Context::from_waker(waker);

        // Use the as_pin_mut method to get a properly pinned reference
        let pinned_future = future_handle.as_pin_mut();
        match pinned_future.poll(&mut context) {
            Poll::Ready(result) => {
                assert_eq!(result, 10);
            }
            Poll::Pending => {
                panic!("Simple future should complete immediately");
            }
        }

        assert_eq!(pool.len(), 1); // Should still be 1 after polling

        // Drop should work fine
        drop(future_handle);
        assert_eq!(pool.len(), 0);
    }

    #[test]
    fn explicit_double_drop_test() {
        // Try to create a scenario where something might be dropped twice
        let pool = BlindPool::new();
        let handle = pool.insert_mut(42_u32);

        // Ensure the pool has the item
        assert_eq!(pool.len(), 1);
        assert_eq!(*handle, 42);

        // Normal drop should work
        drop(handle);
        assert_eq!(pool.len(), 0);
    }

    #[test]
    fn into_shared_conversion() {
        let pool = BlindPool::new();
        let mut exclusive_handle = pool.insert_mut("Test".to_string());

        // Modify the value while we have exclusive access
        exclusive_handle.push_str(" - Modified");
        assert_eq!(*exclusive_handle, "Test - Modified");
        assert_eq!(pool.len(), 1);

        // Convert to shared access
        let shared_handle = exclusive_handle.into_shared();
        assert_eq!(*shared_handle, "Test - Modified");
        assert_eq!(pool.len(), 1); // Should still be 1 item

        // Now we can create multiple shared references
        let cloned_handle = shared_handle.clone();
        assert_eq!(*shared_handle, "Test - Modified");
        assert_eq!(*cloned_handle, "Test - Modified");
        assert_eq!(pool.len(), 1); // Still 1 item

        // Value is automatically cleaned up when all handles are dropped
        drop(shared_handle);
        assert_eq!(pool.len(), 1); // Still alive due to cloned_handle
        assert_eq!(*cloned_handle, "Test - Modified"); // Still accessible

        drop(cloned_handle);
        assert_eq!(pool.len(), 0); // Now cleaned up
    }

    #[test]
    fn into_shared_with_different_types() {
        let pool = BlindPool::new();

        // Test with a Vec
        let mut vec_handle = pool.insert_mut(vec![1, 2, 3]);
        vec_handle.push(4);
        let shared_vec = vec_handle.into_shared();
        assert_eq!(*shared_vec, vec![1, 2, 3, 4]);

        // Test with a u64
        let mut_handle = pool.insert_mut(42_u64);
        let shared_u64 = mut_handle.into_shared();
        assert_eq!(*shared_u64, 42);

        assert_eq!(pool.len(), 2);
        drop(shared_vec);
        drop(shared_u64);
        assert_eq!(pool.len(), 0);
    }

    #[test]
    fn into_inner_basic() {
        let pool = BlindPool::new();
        let mut handle = pool.insert_mut("Test".to_string());

        // Modify the value while it is in the pool
        handle.push_str(" - Modified");
        assert_eq!(*handle, "Test - Modified");
        assert_eq!(pool.len(), 1);

        // Extract the value from the pool
        let extracted = handle.into_inner();
        assert_eq!(extracted, "Test - Modified");
        assert_eq!(pool.len(), 0); // Pool should be empty now
    }

    #[test]
    fn into_inner_with_different_types() {
        #[derive(Debug, Eq, PartialEq)]
        struct TestStruct {
            value: i32,
            text: String,
        }

        let pool = BlindPool::new();

        // Test with a Vec (which is Unpin)
        let mut vec_handle = pool.insert_mut(vec![1, 2, 3]);
        vec_handle.push(4);
        let extracted_vec = vec_handle.into_inner();
        assert_eq!(extracted_vec, vec![1, 2, 3, 4]);

        // Test with a u64 (which is Unpin)
        let u64_handle = pool.insert_mut(42_u64);
        let extracted_u64 = u64_handle.into_inner();
        assert_eq!(extracted_u64, 42);

        // Test with a custom struct (which is Unpin by default)
        let struct_handle = pool.insert_mut(TestStruct {
            value: 100,
            text: "hello".to_string(),
        });
        let extracted_struct = struct_handle.into_inner();
        assert_eq!(
            extracted_struct,
            TestStruct {
                value: 100,
                text: "hello".to_string(),
            }
        );

        assert_eq!(pool.len(), 0); // All items should be extracted
    }

    #[test]
    fn into_inner_preserves_value_ownership() {
        let pool = BlindPool::new();
        let handle = pool.insert_mut("Hello World".to_string());

        // Extract the value
        let extracted = handle.into_inner();

        // Verify the extracted value is fully owned and can be modified
        let mut owned_string = extracted;
        owned_string.push_str(" - Owned");
        assert_eq!(owned_string, "Hello World - Owned");

        assert_eq!(pool.len(), 0);
    }

    #[test]
    fn into_inner_with_drop_types() {
        use std::sync::Arc;
        use std::sync::atomic::{AtomicBool, Ordering};

        struct DropTracker {
            dropped: Arc<AtomicBool>,
        }

        impl Drop for DropTracker {
            fn drop(&mut self) {
                self.dropped.store(true, Ordering::Relaxed);
            }
        }

        let pool = BlindPool::new();
        let dropped = Arc::new(AtomicBool::new(false));

        let handle = pool.insert_mut(DropTracker {
            dropped: Arc::clone(&dropped),
        });

        // Value should not be dropped yet
        assert!(!dropped.load(Ordering::Relaxed));

        // Extract the value - this should not drop it
        let extracted = handle.into_inner();
        assert!(!dropped.load(Ordering::Relaxed));

        assert_eq!(pool.len(), 0); // Pool should be empty

        // Value should only be dropped when we drop the extracted value
        drop(extracted);
        assert!(dropped.load(Ordering::Relaxed));
    }

    #[test]
    fn into_inner_with_copy_types() {
        let pool = BlindPool::new();

        // Test with a Copy type
        let handle = pool.insert_mut(42_i32);
        let extracted = handle.into_inner();
        assert_eq!(extracted, 42);

        // Test with arrays (which are Copy if elements are Copy)
        let array_handle = pool.insert_mut([1, 2, 3, 4]);
        let extracted_array = array_handle.into_inner();
        assert_eq!(extracted_array, [1, 2, 3, 4]);

        assert_eq!(pool.len(), 0);
    }

    #[test]
    fn into_inner_pool_count_updates() {
        let pool = BlindPool::new();

        // Insert multiple items
        let handle1 = pool.insert_mut("First".to_string());
        let handle2 = pool.insert_mut("Second".to_string());
        let handle3 = pool.insert_mut("Third".to_string());

        assert_eq!(pool.len(), 3);

        // Extract one item
        let extracted1 = handle1.into_inner();
        assert_eq!(extracted1, "First");
        assert_eq!(pool.len(), 2);

        // Extract another item
        let extracted2 = handle2.into_inner();
        assert_eq!(extracted2, "Second");
        assert_eq!(pool.len(), 1);

        // Extract the last item
        let extracted3 = handle3.into_inner();
        assert_eq!(extracted3, "Third");
        assert_eq!(pool.len(), 0);
        assert!(pool.is_empty());
    }
}