#[path = "../../../os-shared-memory/src/ring.rs"]
mod ring;
use ring::{Error, Ring, CAPACITY};

#[test]
fn os_shared_memory_ring_positive() {
    let mut ring = Ring::new();
    for base in (0..1000u64).step_by(CAPACITY) {
        let amount = (1000 - base).min(CAPACITY as u64);
        for offset in 0..amount {
            ring.produce(base + offset).unwrap();
        }
        for offset in 0..amount {
            assert_eq!(ring.consume(), Ok(base + offset));
        }
    }
    let snapshot = ring.snapshot();
    assert_eq!(snapshot.produced, 1000);
    assert_eq!(snapshot.consumed, 1000);
    assert_eq!(snapshot.producer, snapshot.consumer);
    assert_eq!(snapshot.slots, [0; CAPACITY]);
    assert_eq!(snapshot.kernel_canary, *b"RING-KERNEL-SAFE");
}

#[test]
fn os_shared_memory_ring_negative() {
    let mut ring = Ring::new();
    ring.produce(0x71).unwrap();
    let before = ring.snapshot();
    assert_eq!(ring.validate_untrusted_producer(100_000), Err(Error::Invalid));
    assert_eq!(ring.validate_untrusted_producer(u64::MAX), Err(Error::Invalid));
    assert_eq!(ring.validate_untrusted_producer(0), Err(Error::Stale));
    assert_eq!(ring.snapshot(), before);
    assert_eq!(ring.consume(), Ok(0x71));
}

#[test]
fn ring_full_and_empty_boundaries_are_atomic() {
    let mut ring = Ring::new();
    assert_eq!(ring.consume(), Err(Error::Empty));
    for value in 0..CAPACITY as u64 { ring.produce(value).unwrap(); }
    let before = ring.snapshot();
    assert_eq!(ring.produce(0xffff), Err(Error::Full));
    assert_eq!(ring.snapshot(), before);
    for value in 0..CAPACITY as u64 {
        assert_eq!(ring.consume(), Ok(value));
    }
    assert_eq!(ring.consume(), Err(Error::Empty));
}