photocraft/crates/raster/tests/scratch.rs

//! The scratch pool is process-wide, so these tests live in their own binary (nothing else
//! allocates tiles here) and take a lock to run one at a time.

use photocraft_raster::scratch::*;
use std::sync::{Mutex, PoisonError};

static SERIAL: Mutex<()> = Mutex::new(());

/// Lets a miss evict every pooled byte for the test's lifetime, so sizes can be counted.
struct NoFloor;
impl NoFloor {
    /// Sets the miss floor to zero for this guard's lifetime.
    fn new() -> Self {
        set_miss_floor(0);
        NoFloor
    }
}
impl Drop for NoFloor {
    fn drop(&mut self) {
        set_miss_floor(DEFAULT_MISS_FLOOR);
    }
}
/// Locks the process-wide pool tests against concurrent access.
fn lock_serial() -> std::sync::MutexGuard<'static, ()> {
    SERIAL.lock().unwrap_or_else(PoisonError::into_inner)
}

/// Runs a test alone with idle release off, so the idle thread can't empty the pool between a
/// `give` and the checks after it; idle release comes back on when dropped.
struct Serial {
    _lock: std::sync::MutexGuard<'static, ()>,
}
impl Drop for Serial {
    fn drop(&mut self) {
        set_idle_release(true);
    }
}
/// Serializes a test and disables idle release until the guard is dropped.
fn serial() -> Serial {
    let _lock = lock_serial();
    set_idle_release(false);
    Serial { _lock }
}

#[test]
/// Verifies pooled buffers are reused by pointer, retain capacity, and are refilled to the requested length.
fn reuse_returns_same_capacity_and_refills() {
    let _g = serial();
    release();
    let mut v = take(100_000, 0.0f32);
    v.iter_mut().for_each(|x| *x = 7.0);
    let ptr = v.as_ptr();
    give(v);
    assert_eq!(retained_bytes(), 400_000);
    let w = take(100_000, 1.5f32);
    assert_eq!(w.as_ptr(), ptr);
    assert_eq!(w.len(), 100_000);
    assert!(w.iter().all(|&x| x == 1.5));
    assert_eq!(retained_bytes(), 0);
    // A smaller request within 2x reuses it too, and is sized exactly.
    give(w);
    let s = take(60_000, 0.0f32);
    assert_eq!(s.as_ptr(), ptr);
    assert_eq!(s.len(), 60_000);
    release();
}

#[test]
/// Verifies oversized or non-exact buffers are discarded instead of reused.
fn too_big_a_buffer_is_not_reused() {
    let _g = serial();
    release();
    let _floor = NoFloor::new();
    give(vec![0u8; 1_000_000]);
    assert_eq!(take_exact(1_000_000, 0u8).len(), 1_000_000);
    assert_eq!(retained_bytes(), 0);
    give(vec![0u8; 1_000_000]);
    // More than 2x (or not exact): allocated fresh, and the miss drops the unusable buffer.
    assert_eq!(take(100_000, 0u8).capacity(), 100_000);
    assert_eq!(retained_bytes(), 0);
    give(vec![0u8; 1_000_000]);
    assert_eq!(take_exact(999_999, 0u8).capacity(), 999_999);
    assert_eq!(retained_bytes(), 0);
    release();
}

#[test]
/// Verifies exact try-takes reuse a matching buffer and succeed on a miss.
fn try_take_exact_reuses_and_allocates() {
    let _g = serial();
    release();
    let buf = vec![0u8; 200_000];
    let ptr = buf.as_ptr();
    give(buf);
    let v = try_take_exact(200_000, 9u8);
    assert!(v.as_ref().is_some_and(|v| v.len() == 200_000 && v.iter().all(|&b| b == 9)));
    assert_eq!(v.as_ref().map(|v| v.as_ptr()), Some(ptr));
    assert_eq!(retained_bytes(), 0);
    assert!(try_take_exact(300_000, 0u8).is_some());
    release();
}

#[test]
/// Verifies buffers below the pooling threshold are not retained.
fn small_buffers_are_not_retained() {
    let _g = serial();
    release();
    give(vec![0u8; MIN_POOLED_BYTES - 1]);
    give(vec![0.0f32; 100]);
    assert_eq!(retained_bytes(), 0);
    assert_eq!(take(10, 3u8), vec![3u8; 10]);
}

#[test]
/// Verifies zero-length take and give operations remain empty.
fn zero_length() {
    let _g = serial();
    assert!(take(0, 0u8).is_empty());
    give(Vec::<u8>::new());
    assert!(take_exact(0, [0.0f32; 4]).is_empty());
}

#[test]
/// Verifies the byte budget evicts oldest buffers and rejects buffers larger than the budget.
fn budget_evicts_oldest() {
    let _g = serial();
    release();
    set_budget(250_000);
    let (a, b) = (vec![0u8; 100_000], vec![0u8; 100_000]);
    let pb = b.as_ptr();
    give(a);
    give(b);
    give(vec![0u8; 100_000]);
    assert_eq!(retained_bytes(), 200_000);
    // The oldest was evicted; the survivors include b.
    let first = take_exact(100_000, 0u8);
    let second = take_exact(100_000, 0u8);
    assert!(first.as_ptr() == pb || second.as_ptr() == pb);
    // Larger than the whole budget: dropped.
    give(vec![0u8; 300_000]);
    assert_eq!(retained_bytes(), 0);
    set_budget(DEFAULT_BUDGET);
    release();
}

#[test]
/// Verifies release empties pooled buffers of several element types.
fn release_empties() {
    let _g = serial();
    give(vec![0u8; 200_000]);
    give(vec![0.0f32; 200_000]);
    give(vec![[0.0f32; 4]; 100_000]);
    assert!(retained_bytes() > 0);
    release();
    assert_eq!(retained_bytes(), 0);
}

#[test]
/// Verifies the usage counter advances for both take and give.
fn uses_counts_calls() {
    let _g = serial();
    let before = uses();
    give(take(10, 0u8));
    assert_eq!(uses(), before + 2);
}

#[test]
/// Verifies dropping a `Buf` returns its storage to the pool.
fn buf_returns_on_drop() {
    let _g = serial();
    release();
    {
        let mut b = Buf::new(150_000, 0.0f32);
        b[3] = 1.0;
        assert_eq!(b.len(), 150_000);
    }
    assert_eq!(retained_bytes(), 600_000);
    release();
}

#[test]
/// Verifies concurrent take and give operations preserve initialized values and finish cleanly.
fn concurrent_smoke() {
    let _g = serial();
    release();
    let handles: Vec<_> = (0..8u8)
        .map(|t| {
            std::thread::spawn(move || {
                for i in 0..200 {
                    let v = take(70_000 + i % 5, t);
                    assert!(v.iter().all(|&x| x == t));
                    give(v);
                }
            })
        })
        .collect();
    for h in handles {
        assert!(h.join().is_ok());
    }
    release();
    assert_eq!(retained_bytes(), 0);
}

#[test]
/// Verifies budget eviction uses insertion age across different element types.
fn eviction_is_oldest_first_across_types() {
    let _g = serial();
    release();
    set_budget(500_000);
    give(vec![0u8; 300_000]);
    give(vec![0.0f32; 50_000]);
    assert_eq!(retained_bytes(), 500_000);
    // Needs 200 000 more: the older u8 buffer goes, the f32 one stays.
    give(vec![[0.0f32; 4]; 12_500]);
    assert_eq!(retained_bytes(), 400_000);
    assert_eq!(take_exact(50_000, 1.0f32).len(), 50_000);
    assert_eq!(retained_bytes(), 200_000);
    set_budget(DEFAULT_BUDGET);
    release();
}

#[test]
/// Verifies reuse chooses the smallest eligible capacity and exact takes require an exact match.
fn best_fit_picks_the_smallest_fitting_capacity() {
    let _g = serial();
    release();
    let _floor = NoFloor::new();
    for n in [180_000usize, 120_000, 150_000, 300_000] {
        give(vec![0u8; n]);
    }
    // Within 2x of 100 000: 120 000 is the tightest fit, then 150 000, then 180 000.
    assert_eq!(take(100_000, 0u8).capacity(), 120_000);
    assert_eq!(take(100_000, 0u8).capacity(), 150_000);
    assert_eq!(take(100_000, 0u8).capacity(), 180_000);
    // 300 000 is more than 2x: allocated fresh, and the miss drops the pooled one.
    assert_eq!(take(100_000, 0u8).capacity(), 100_000);
    assert_eq!(retained_bytes(), 0);
    // An exact capacity beats a smaller-slack scan.
    give(vec![0u8; 100_000]);
    assert_eq!(take_exact(100_000, 0u8).capacity(), 100_000);
    assert_eq!(take_exact(250_000, 0u8).capacity(), 250_000);
    release();
}

#[test]
/// Verifies repeated budget overflow evicts oldest entries across mixed types and capacities.
fn eviction_walks_oldest_first_through_mixed_types_and_capacities() {
    let _g = serial();
    release();
    let _floor = NoFloor::new();
    set_budget(700_000);
    // Oldest to newest, 100 000 bytes each, interleaved types and two u8 capacities.
    give(vec![0u8; 100_000]);
    let f = vec![0.0f32; 25_000];
    give(f);
    give(vec![0u8; 100_000]);
    give(vec![0u16; 50_000]);
    let newest = vec![0u8; 150_000];
    let np = newest.as_ptr();
    give(newest);
    assert_eq!(retained_bytes(), 550_000);
    // 200 000 more overflows by 50 000: the oldest (u8) goes.
    give(vec![[0.0f32; 4]; 12_500]);
    assert_eq!(retained_bytes(), 650_000);
    // 100 000 more: the next oldest (the f32 buffer) goes.
    give(vec![0u8; 100_000]);
    assert_eq!(retained_bytes(), 650_000);
    // 200 000 more: the u8 then the u16 buffer go.
    give(vec![0u8; 200_000]);
    assert_eq!(retained_bytes(), 650_000);
    // The newest u8 buffer of the old batch is still pooled; the f32 one was evicted.
    let again = take_exact(150_000, 0u8);
    assert_eq!(again.as_ptr(), np);
    assert_eq!(retained_bytes(), 500_000);
    // The evicted f32 buffer is a miss: the oldest buffers, at least its 100 000 bytes, leave
    // (the 200 000-byte [f32; 4] one).
    assert_eq!(take_exact(25_000, 0.0f32).len(), 25_000);
    assert_eq!(retained_bytes(), 300_000);
    set_budget(DEFAULT_BUDGET);
    release();
}

#[test]
/// Verifies the idle-release worker clears an unused pooled buffer.
fn idle_pool_is_released_by_the_background_thread() {
    // Idle release stays on here: it is what this test checks.
    let _g = lock_serial();
    release();
    give(vec![0u8; MIN_POOLED_BYTES]);
    assert_eq!(retained_bytes(), MIN_POOLED_BYTES);
    // Released after one full idle interval without use (at most two from the give).
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3 * IDLE_RELEASE_SECS + 1);
    while retained_bytes() > 0 && std::time::Instant::now() < deadline {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    assert_eq!(retained_bytes(), 0);
}

#[test]
/// Verifies a miss discards pooled bytes in proportion to its allocation and a hit preserves the pool.
fn a_miss_drops_as_many_pooled_bytes_as_it_allocates() {
    let _g = serial();
    release();
    let _floor = NoFloor::new();
    // Three 64 KiB f32 buffers a byte request can't use.
    for _ in 0..3 {
        give(vec![0.0f32; MIN_POOLED_BYTES / 4]);
    }
    assert_eq!(retained_bytes(), 3 * MIN_POOLED_BYTES);
    // A 128 KiB miss drops the two oldest, so pool plus live buffers stay at 192 KiB.
    let v = take(2 * MIN_POOLED_BYTES, 0u8);
    assert_eq!(retained_bytes(), MIN_POOLED_BYTES);
    give(v);
    // A hit drops nothing.
    let w = take(MIN_POOLED_BYTES / 4, 0.0f32);
    assert_eq!(retained_bytes(), 2 * MIN_POOLED_BYTES);
    drop(w);
    release();
}

#[test]
/// Verifies miss eviction stops when the configured retained-byte floor is reached.
fn a_miss_keeps_the_floor() {
    let _g = serial();
    release();
    set_miss_floor(2 * MIN_POOLED_BYTES);
    for _ in 0..3 {
        give(vec![0.0f32; MIN_POOLED_BYTES / 4]);
    }
    // A 192 KiB miss would drop all three; only one goes, down to the floor.
    assert_eq!(take(3 * MIN_POOLED_BYTES, 0u8).len(), 3 * MIN_POOLED_BYTES);
    assert_eq!(retained_bytes(), 2 * MIN_POOLED_BYTES);
    set_miss_floor(DEFAULT_MISS_FLOOR);
    release();
}

#[test]
/// Verifies a failed oversized reservation leaves the pool empty.
fn a_failed_reservation_releases_the_pool() {
    let _g = serial();
    release();
    // Unmatched buffers under the miss floor stay pooled on a miss.
    give(vec![0u8; 4 * MIN_POOLED_BYTES]);
    assert!(retained_bytes() > 0);
    // No allocator can reserve this: the call fails, but not before the pool was emptied. (The
    // retry after the release isn't observable here: it needs an allocator that fails once.)
    assert!(try_take_exact(isize::MAX as usize, 0u8).is_none());
    assert_eq!(retained_bytes(), 0);
}

#[test]
/// Verifies a successful miss preserves unmatched buffers within the miss floor.
fn a_successful_miss_keeps_unmatched_pooled_buffers() {
    let _g = serial();
    release();
    give(vec![0u8; 4 * MIN_POOLED_BYTES]);
    let v = try_take_exact(2 * MIN_POOLED_BYTES, 0u8);
    assert!(v.as_ref().is_some_and(|v| v.len() == 2 * MIN_POOLED_BYTES && v.iter().all(|&b| b == 0)));
    assert_eq!(retained_bytes(), 4 * MIN_POOLED_BYTES, "within the miss floor, nothing is dropped");
    release();
}