#![allow(dead_code)]
#[path = "../../../os-handles/queue/handles.rs"]
mod handles;

use handles::{BoundedChannel, CloseResult, Error, Rights};

#[test]
fn bounded_channel_fifo_and_boundaries() {
    let mut channel = BoundedChannel::<u64, 3, 2, 4>::new(77);
    let parent = channel.open_kernel(10).unwrap();
    let reader = channel.grant_kernel(10, 20, parent, Rights::READ).unwrap();
    let writer = channel.grant_kernel(10, 30, parent, Rights::WRITE).unwrap();
    assert_eq!(channel.send(30, writer, b"ABCD"), Ok(()));
    assert_eq!(channel.send(10, parent, b""), Ok(()));
    let full = channel.snapshot();
    assert_eq!(channel.send(30, writer, b"Z"), Err(Error::WouldBlock));
    assert_eq!(channel.snapshot(), full);
    assert_eq!(channel.peek(20, reader).unwrap().unwrap().as_slice(), b"ABCD");
    assert_eq!(channel.snapshot(), full);
    let first = channel.receive(20, reader).unwrap().unwrap();
    assert_eq!(first.as_slice(), b"ABCD");
    let second = channel.receive(20, reader).unwrap().unwrap();
    assert!(second.is_empty());
    assert_eq!(channel.receive(20, reader), Ok(None));
    assert_eq!(channel.peek(20, reader), Ok(None));
    assert_eq!(channel.send(10, parent, b"XY"), Ok(()));
    assert_eq!(channel.receive(20, reader).unwrap().unwrap().as_slice(), b"XY");
    assert_eq!(channel.close(30, writer), Ok(CloseResult::Remaining(2)));
    assert_eq!(channel.close(10, parent), Ok(CloseResult::Remaining(1)));
    assert_eq!(channel.close(20, reader), Ok(CloseResult::LastClosed));
    assert_eq!(channel.len(), 0);
    assert!(channel.snapshot().slots.iter().all(Option::is_none));
}

#[test]
fn bounded_channel_denials_leave_snapshot_unchanged() {
    let mut channel = BoundedChannel::<u64, 3, 2, 4>::new(78);
    let parent = channel.open_kernel(10).unwrap();
    let reader = channel.grant_kernel(10, 20, parent, Rights::READ).unwrap();
    let writer = channel.grant_kernel(10, 30, parent, Rights::WRITE).unwrap();
    let before = channel.snapshot();
    assert_eq!(channel.send(99, parent, b"A"), Err(Error::BadFd));
    assert_eq!(channel.send(20, reader, b"A"), Err(Error::Access));
    assert_eq!(channel.receive(30, writer), Err(Error::Access));
    assert_eq!(channel.send(10, parent, b"ABCDE"), Err(Error::MessageTooLarge));
    assert_eq!(channel.snapshot(), before);
    channel.send(10, parent, b"A").unwrap();
    assert_eq!(channel.close(30, writer), Ok(CloseResult::Remaining(2)));
    assert_eq!(channel.close(20, reader), Ok(CloseResult::Remaining(1)));
    assert_eq!(channel.len(), 1);
    assert_eq!(channel.close(10, parent), Ok(CloseResult::LastClosed));
    assert_eq!(channel.len(), 0);
    assert_eq!(channel.send(10, parent, b"A"), Err(Error::BadFd));
    let reopened = channel.open_kernel(10).unwrap();
    assert_ne!(reopened, parent);
    assert_eq!(channel.receive(10, reopened), Ok(None));
}

#[test]
fn copy_fault_does_not_publish() {
    let mut channel = BoundedChannel::<u64, 2, 2, 4>::new(79);
    let owner = channel.open_kernel(10).unwrap();
    let before = channel.snapshot();
    let result = channel.send_from(10, owner, 4, |destination| {
        destination[..2].copy_from_slice(b"AB");
        Err(Error::Fault)
    });
    assert_eq!(result, Err(Error::Fault));
    assert_eq!(channel.snapshot(), before);
    assert_eq!(channel.receive(10, owner), Ok(None));
    channel.send(10, owner, b"GOOD").unwrap();
    assert_eq!(channel.receive(10, owner).unwrap().unwrap().as_slice(), b"GOOD");
}