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

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

#[test]
fn owned_message_survives_source_mutation_and_sender_close() {
    let mut channel = OwnedChannel::<u64, 2, 2, 4>::new(91);
    let parent = channel.open_kernel(10).unwrap();
    let child = channel.grant_kernel(10, 20, parent, Rights::READ_WRITE).unwrap();
    let mut source = *b"ABCD";
    channel.send(20, child, &source).unwrap();
    source.copy_from_slice(b"ZZZZ");
    assert_eq!(channel.close(20, child), Ok(CloseResult::Remaining(1)));
    let before = channel.snapshot();
    let peek = channel.peek(10, parent).unwrap().unwrap();
    assert_eq!(peek.sender, 20);
    assert_eq!(peek.payload.as_slice(), b"ABCD");
    assert_eq!(channel.snapshot(), before);
    let received = channel.receive(10, parent).unwrap().unwrap();
    assert_eq!(received, peek);
    assert_eq!(channel.len(), 0);
    assert_eq!(channel.snapshot().senders, [None; 2]);
    assert_eq!(channel.close(10, parent), Ok(CloseResult::LastClosed));
}

#[test]
fn owned_message_boundaries_and_last_close_cleanup() {
    let mut channel = OwnedChannel::<u64, 3, 2, 4>::new(92);
    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, writer, b"A"), Err(Error::BadFd));
    assert_eq!(channel.send(20, reader, b"A"), Err(Error::Access));
    assert_eq!(channel.send(30, writer, b"ABCDE"), Err(Error::MessageTooLarge));
    assert_eq!(channel.snapshot(), before);
    channel.send(30, writer, b"ABCD").unwrap();
    channel.send(10, parent, b"XY").unwrap();
    let full = channel.snapshot();
    assert_eq!(channel.send(30, writer, b"Z"), Err(Error::WouldBlock));
    assert_eq!(channel.snapshot(), full);
    assert_eq!(channel.receive(20, reader).unwrap().unwrap().sender, 30);
    assert_eq!(channel.receive(20, reader).unwrap().unwrap().sender, 10);
    assert_eq!(channel.receive(20, reader), Ok(None));
    channel.send(30, writer, b"Q").unwrap();
    assert_eq!(channel.close(30, writer), Ok(CloseResult::Remaining(2)));
    assert_eq!(channel.close(20, reader), Ok(CloseResult::Remaining(1)));
    assert_eq!(channel.close(10, parent), Ok(CloseResult::LastClosed));
    assert_eq!(channel.len(), 0);
    assert_eq!(channel.snapshot().senders, [None; 2]);
}

#[test]
fn copy_fault_does_not_publish_sender() {
    let mut channel = OwnedChannel::<u64, 2, 2, 4>::new(93);
    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.peek(10, owner), Ok(None));
    channel.send(10, owner, b"GOOD").unwrap();
    let message = channel.receive(10, owner).unwrap().unwrap();
    assert_eq!(message.sender, 10);
    assert_eq!(message.payload.as_slice(), b"GOOD");
}