zipora 3.1.3

//! Comprehensive security and functionality tests for SecureMemoryPool
//!
//! This test suite validates that the SecureMemoryPool implementation eliminates
//! the security vulnerabilities found in the original MemoryPool implementation.

use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;
use std::time::Duration;
use zipora::memory::{SecureMemoryPool, SecurePoolConfig};

/// Test basic allocation and deallocation functionality
#[test]
fn test_basic_allocation() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    // Test single allocation
    let ptr = pool.allocate().unwrap();
    assert!(!ptr.as_ptr().is_null());
    assert_eq!(ptr.size(), 1024);
    assert!(ptr.generation() > 0);

    // Test validation
    assert!(ptr.validate().is_ok());

    // Test memory access
    let slice = ptr.as_slice();
    assert_eq!(slice.len(), 1024);

    // Drop automatically deallocates
    drop(ptr);

    let stats = pool.stats();
    assert_eq!(stats.alloc_count, 1);
    assert_eq!(stats.dealloc_count, 1);
    assert_eq!(stats.corruption_detected, 0);
    assert_eq!(stats.double_free_detected, 0);
}

/// Test multiple allocations and deallocations
#[test]
fn test_multiple_allocations() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    let mut ptrs = Vec::new();

    // Allocate multiple chunks
    for _ in 0..10 {
        let ptr = pool.allocate().unwrap();
        assert!(!ptr.as_ptr().is_null());
        assert!(ptr.validate().is_ok());
        ptrs.push(ptr);
    }

    // Verify all pointers are unique
    for i in 0..ptrs.len() {
        for j in i + 1..ptrs.len() {
            assert_ne!(ptrs[i].as_ptr(), ptrs[j].as_ptr());
        }
    }

    // Drop all allocations
    drop(ptrs);

    let stats = pool.stats();
    assert_eq!(stats.alloc_count, 10);
    assert_eq!(stats.dealloc_count, 10);
    assert_eq!(stats.corruption_detected, 0);
    assert_eq!(stats.double_free_detected, 0);
}

/// Test memory reuse through pool
#[test]
fn test_memory_reuse() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    // Allocate and deallocate to populate pool
    for _ in 0..5 {
        let ptr = pool.allocate().unwrap();
        drop(ptr);
    }

    // Next allocations should hit cache/pool
    let ptr = pool.allocate().unwrap();
    assert!(!ptr.as_ptr().is_null());
    drop(ptr);

    let stats = pool.stats();
    assert_eq!(stats.alloc_count, 6);
    assert_eq!(stats.dealloc_count, 6);
    assert!(stats.pool_hits > 0 || stats.local_cache_hits > 0);
}

/// Test concurrent allocation safety
#[test]
fn test_concurrent_allocation() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();
    let allocated_count = Arc::new(AtomicUsize::new(0));
    let error_count = Arc::new(AtomicUsize::new(0));

    let handles: Vec<_> = (0..8)
        .map(|_| {
            let pool = pool.clone();
            let count = allocated_count.clone();
            let errors = error_count.clone();
            thread::spawn(move || {
                for _ in 0..125 {
                    match pool.allocate() {
                        Ok(ptr) => {
                            count.fetch_add(1, Ordering::Relaxed);

                            // Validate the allocation
                            if ptr.validate().is_err() {
                                errors.fetch_add(1, Ordering::Relaxed);
                            }

                            // Write some data to test memory safety
                            let mut_slice =
                                unsafe { std::slice::from_raw_parts_mut(ptr.as_ptr(), ptr.size()) };
                            mut_slice[0] = 42;
                            mut_slice[ptr.size() - 1] = 84;

                            // Simulate work
                            thread::sleep(Duration::from_micros(1));

                            // ptr automatically deallocated on drop
                        }
                        Err(_) => {
                            errors.fetch_add(1, Ordering::Relaxed);
                        }
                    }
                }
            })
        })
        .collect();

    for handle in handles {
        handle.join().unwrap();
    }

    assert_eq!(allocated_count.load(Ordering::Relaxed), 1000);
    assert_eq!(error_count.load(Ordering::Relaxed), 0);

    let stats = pool.stats();
    assert_eq!(stats.alloc_count, 1000);
    assert_eq!(stats.dealloc_count, 1000);
    assert_eq!(stats.corruption_detected, 0);
    assert_eq!(stats.double_free_detected, 0);
}

/// Test that double-free is structurally prevented
#[test]
fn test_double_free_prevention() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    let ptr = pool.allocate().unwrap();
    let _raw_ptr = ptr.as_ptr();

    // The RAII design prevents double-free - you cannot manually deallocate
    // and there's no way to create a SecurePooledPtr from a raw pointer
    drop(ptr);

    // Attempting to access raw_ptr here would be undefined behavior in user code,
    // but the pool's design makes it impossible to cause a double-free through the API

    let stats = pool.stats();
    assert_eq!(stats.double_free_detected, 0);
}

/// Test corruption detection
#[test]
fn test_corruption_detection() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    let ptr = pool.allocate().unwrap();

    // The secure implementation has built-in corruption detection
    // through magic numbers and canary values
    assert!(ptr.validate().is_ok());

    // Simulate corruption by writing to the chunk boundaries
    // (This would be detected by the validation in a real scenario)
    // Note: In the secure implementation, corruption would be detected by validation
    // and guard pages would prevent boundary writes in the first place

    // Validation should still work for normal usage
    assert!(ptr.validate().is_ok());

    drop(ptr);

    let stats = pool.stats();
    // In this test, no corruption is actually introduced
    assert_eq!(stats.corruption_detected, 0);
}

/// Test thread-local caching performance
#[test]
fn test_thread_local_caching() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    // Allocate and deallocate to populate thread-local cache
    for _ in 0..20 {
        let ptr = pool.allocate().unwrap();
        drop(ptr);
    }

    // Next allocations should hit thread-local cache
    for _ in 0..10 {
        let ptr = pool.allocate().unwrap();
        drop(ptr);
    }

    let stats = pool.stats();
    assert!(stats.local_cache_hits > 0);
    assert_eq!(stats.corruption_detected, 0);
    assert_eq!(stats.double_free_detected, 0);
}

/// Test cross-thread work stealing
#[test]
fn test_cross_thread_stealing() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    // Create allocations in one thread
    let pool_clone = pool.clone();
    let handle = thread::spawn(move || {
        let mut ptrs = Vec::new();
        for _ in 0..10 {
            ptrs.push(pool_clone.allocate().unwrap());
        }
        // Deallocate all at once to populate global stack
        drop(ptrs);
    });
    handle.join().unwrap();

    // Allocate in main thread (should steal from global stack)
    let ptr = pool.allocate().unwrap();
    assert!(!ptr.as_ptr().is_null());
    drop(ptr);

    let stats = pool.stats();
    // Cross-thread behavior is implementation-dependent and timing-sensitive.
    // The important thing is that the allocation succeeded safely.
    // Statistics might show cross-thread steals, pool hits, or cache hits depending on timing.
    println!(
        "Cross-thread stats: steals={}, pool_hits={}, cache_hits={}",
        stats.cross_thread_steals, stats.pool_hits, stats.local_cache_hits
    );
}

/// Test memory zeroing on deallocation
#[test]
fn test_memory_zeroing() {
    let mut config = SecurePoolConfig::small_secure();
    config.zero_on_free = true;
    let pool = SecureMemoryPool::new(config).unwrap();

    let ptr = pool.allocate().unwrap();

    // Write some data
    unsafe {
        let slice = std::slice::from_raw_parts_mut(ptr.as_ptr(), ptr.size());
        slice.fill(0xFF);
    }

    // The secure implementation zeros memory on deallocation
    // This is handled automatically by the Drop implementation
    drop(ptr);

    // Memory should be zeroed (can't directly test this due to RAII,
    // but the implementation guarantees it)
    let stats = pool.stats();
    assert_eq!(stats.dealloc_count, 1);
}

/// Test different pool configurations
#[test]
fn test_different_configurations() {
    // Test small pool
    let small_pool = SecureMemoryPool::new(SecurePoolConfig::small_secure()).unwrap();
    let small_ptr = small_pool.allocate().unwrap();
    assert_eq!(small_ptr.size(), 1024);
    drop(small_ptr);

    // Test medium pool
    let medium_pool = SecureMemoryPool::new(SecurePoolConfig::medium_secure()).unwrap();
    let medium_ptr = medium_pool.allocate().unwrap();
    assert_eq!(medium_ptr.size(), 64 * 1024);
    drop(medium_ptr);

    // Test large pool
    let large_pool = SecureMemoryPool::new(SecurePoolConfig::large_secure()).unwrap();
    let large_ptr = large_pool.allocate().unwrap();
    assert_eq!(large_ptr.size(), 1024 * 1024);
    drop(large_ptr);
}

/// Test pool validation functionality
#[test]
fn test_pool_validation() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    // Allocate some chunks
    let _ptr1 = pool.allocate().unwrap();
    let _ptr2 = pool.allocate().unwrap();

    // Validate pool integrity
    assert!(pool.validate().is_ok());

    // Clean up
    drop(_ptr1);
    drop(_ptr2);

    // Should still validate after cleanup
    assert!(pool.validate().is_ok());
}

/// Test global pool functionality
#[test]
fn test_global_pools() {
    use zipora::memory::{get_global_pool_for_size, get_global_secure_pool_stats};

    // Test size-based pool selection
    let small_pool = get_global_pool_for_size(100);
    let medium_pool = get_global_pool_for_size(10000);
    let large_pool = get_global_pool_for_size(100000);

    assert_eq!(small_pool.config().chunk_size, 1024);
    assert_eq!(medium_pool.config().chunk_size, 64 * 1024);
    assert_eq!(large_pool.config().chunk_size, 1024 * 1024);

    // Test allocations from global pools
    let ptr1 = small_pool.allocate().unwrap();
    let ptr2 = medium_pool.allocate().unwrap();
    let ptr3 = large_pool.allocate().unwrap();

    assert!(!ptr1.as_ptr().is_null());
    assert!(!ptr2.as_ptr().is_null());
    assert!(!ptr3.as_ptr().is_null());

    // Test global statistics
    let _stats = get_global_secure_pool_stats();

    drop(ptr1);
    drop(ptr2);
    drop(ptr3);
}

/// Test pool clearing functionality
#[test]
fn test_pool_clearing() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    // Allocate and deallocate to populate pool
    for _ in 0..5 {
        let ptr = pool.allocate().unwrap();
        drop(ptr);
    }

    // Clear the pool
    assert!(pool.clear().is_ok());

    // Pool should still work after clearing
    let ptr = pool.allocate().unwrap();
    assert!(!ptr.as_ptr().is_null());
    drop(ptr);
}

/// Test memory access patterns
#[test]
fn test_memory_access_patterns() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    let mut ptr = pool.allocate().unwrap();

    // Test slice access
    {
        let slice = ptr.as_mut_slice();
        assert_eq!(slice.len(), 1024);

        // Write pattern
        for (i, byte) in slice.iter_mut().enumerate() {
            *byte = (i % 256) as u8;
        }
    }

    // Test read access
    {
        let slice = ptr.as_slice();
        for (i, &byte) in slice.iter().enumerate() {
            assert_eq!(byte, (i % 256) as u8);
        }
    }

    drop(ptr);
}

/// Stress test with high contention
#[test]
fn test_high_contention_stress() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();
    let success_count = Arc::new(AtomicUsize::new(0));
    let error_count = Arc::new(AtomicUsize::new(0));

    let handles: Vec<_> = (0..16)
        .map(|_| {
            let pool = pool.clone();
            let success = success_count.clone();
            let errors = error_count.clone();
            thread::spawn(move || {
                for _ in 0..500 {
                    match pool.allocate() {
                        Ok(ptr) => {
                            success.fetch_add(1, Ordering::Relaxed);

                            // Quick validation
                            if ptr.validate().is_err() {
                                errors.fetch_add(1, Ordering::Relaxed);
                            }

                            // Immediate deallocation to stress the pool
                            drop(ptr);
                        }
                        Err(_) => {
                            errors.fetch_add(1, Ordering::Relaxed);
                        }
                    }
                }
            })
        })
        .collect();

    for handle in handles {
        handle.join().unwrap();
    }

    assert_eq!(success_count.load(Ordering::Relaxed), 8000);
    assert_eq!(error_count.load(Ordering::Relaxed), 0);

    let stats = pool.stats();
    assert_eq!(stats.alloc_count, 8000);
    assert_eq!(stats.dealloc_count, 8000);
    assert_eq!(stats.corruption_detected, 0);
    assert_eq!(stats.double_free_detected, 0);
}

/// Test that the secure pool is actually Send + Sync
#[test]
fn test_send_sync_traits() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<SecureMemoryPool>();
    assert_send_sync::<Arc<SecureMemoryPool>>();

    // The SecurePooledPtr should also be Send + Sync
    assert_send_sync::<zipora::memory::SecurePooledPtr>();
}

/// Performance comparison test (basic throughput)
#[test]
fn test_performance_throughput() {
    let config = SecurePoolConfig::small_secure();
    let pool = SecureMemoryPool::new(config).unwrap();

    let start = std::time::Instant::now();

    // Allocate and deallocate 10,000 chunks
    for _ in 0..10_000 {
        let ptr = pool.allocate().unwrap();
        drop(ptr);
    }

    let duration = start.elapsed();
    println!(
        "Secure pool throughput: {} allocs/sec",
        10_000 as f64 / duration.as_secs_f64()
    );

    let stats = pool.stats();
    assert_eq!(stats.alloc_count, 10_000);
    assert_eq!(stats.dealloc_count, 10_000);
    assert_eq!(stats.corruption_detected, 0);
    assert_eq!(stats.double_free_detected, 0);

    // Should be reasonably fast (>100k allocs/sec on modern hardware)
    assert!(
        duration.as_millis() < 1000,
        "Performance regression detected"
    );
}