#[path = "../../../os-block-requests/src/lib.rs"]
mod block_io;

use block_io::{Error, Requests, State, Token};

#[test]
fn os_block_io_requests_positive() {
    let mut requests = Requests::<4>::new(4, 7).unwrap();
    let first = requests.prepare(0, 0x4000_1000, 0, 200, 100, 7).unwrap();
    let second = requests.prepare(1, 0x4000_2000, 2047, 220, 100, 7).unwrap();
    assert_ne!(first.id, second.id);
    assert_eq!(requests.snapshot().live, 2);
    assert_eq!(requests.request(first).unwrap().buffer, 0x4000_1000);
    assert_eq!(requests.request(second).unwrap().lba, 2047);
    requests.publish(first, 110).unwrap();
    requests.publish(second, 110).unwrap();
    assert_eq!(requests.request(first).unwrap().state, State::Published);
    assert_eq!(requests.snapshot().live, 2);
    assert_eq!(requests.complete(second, 1, 513, 0).unwrap().buffer, 0x4000_2000);
    assert_eq!(requests.complete(first, 0, 513, 0).unwrap().buffer, 0x4000_1000);
    assert_eq!(requests.snapshot().live, 0);
    let reused = requests.prepare(0, 0x4000_1000, 5, 300, 250, 7).unwrap();
    assert!(reused.id > second.id);
    assert_eq!(requests.abort_prepared(reused).unwrap().lba, 5);
    assert_eq!(requests.snapshot().live, 0);
}

#[test]
fn os_block_io_requests_negative() {
    let mut requests = Requests::<4>::new(4, 7).unwrap();
    let initial = requests.snapshot();
    assert_eq!(requests.prepare(0, 0x4000_1000, 0, 200, 100, 6), Err(Error::StaleDevice));
    assert_eq!(requests.prepare(0, 0x4000_1001, 0, 200, 100, 7), Err(Error::InvalidBuffer));
    assert_eq!(requests.prepare(0, 0x4000_1000, 0, 100, 100, 7), Err(Error::InvalidDeadline));
    assert_eq!(requests.snapshot(), initial);
    let token = requests.prepare(0, 0x4000_1000, 0, 200, 100, 7).unwrap();
    assert_eq!(requests.prepare(0, 0x4000_2000, 1, 200, 100, 7), Err(Error::Busy));
    let before = requests.snapshot();
    assert_eq!(requests.publish(token, 200), Err(Error::InvalidDeadline));
    assert_eq!(requests.snapshot(), before);
    requests.publish(token, 101).unwrap();
    let published = requests.snapshot();
    let foreign = Token {id: token.id + 1, ..token};
    assert_eq!(requests.complete(foreign, 0, 513, 0), Err(Error::WrongCompletion));
    assert_eq!(requests.complete(token, 1, 513, 0), Err(Error::WrongCompletion));
    assert_eq!(requests.complete(token, 0, 512, 0), Err(Error::ShortRead));
    assert_eq!(requests.complete(token, 0, 513, 1), Err(Error::IoError));
    assert_eq!(requests.abort_prepared(token), Err(Error::WrongState));
    assert_eq!(requests.expired(token, 200), Ok(true));
    assert_eq!(requests.snapshot(), published);
    assert_eq!(requests.observe_reset(1, 0, 8), Err(Error::NotReset));
    assert_eq!(requests.snapshot(), published);
    requests.observe_reset(0, 0, 8).unwrap();
    assert_eq!(requests.snapshot().live, 0);
    assert_eq!(requests.complete(token, 0, 513, 0), Err(Error::StaleDevice));
    let fresh = requests.prepare(0, 0x4000_1000, 1, 300, 201, 8).unwrap();
    assert!(fresh.id > token.id);
    assert_eq!(requests.abort_prepared(fresh).unwrap().lba, 1);
}

#[test]
fn os_block_io_timeouts_positive() {
    let mut requests = Requests::<4>::new(4, 11).unwrap();
    let request = requests.prepare(0, 0x4000_1000, 9, 200, 100, 11).unwrap();
    requests.publish(request, 101).unwrap();
    let before = requests.snapshot();
    assert_eq!(requests.timeout(request, 199), Err(Error::InvalidDeadline));
    assert_eq!(requests.snapshot(), before);
    requests.timeout(request, 200).unwrap();
    assert_eq!(requests.request(request).unwrap().state, State::TimedOut);
    assert_eq!(requests.request(request).unwrap().buffer, 0x4000_1000);
    assert_eq!(requests.snapshot().live, 1);
    assert_eq!(requests.complete(request, 0, 513, 0), Err(Error::LateCompletion));
    assert_eq!(requests.snapshot().live, 1);
    assert_eq!(requests.observe_reset(0, 1, 12), Err(Error::NotReset));
    assert_eq!(requests.snapshot().live, 1);
    requests.observe_reset(0, 0, 12).unwrap();
    assert_eq!(requests.snapshot().live, 0);
    assert_eq!(requests.request(request), Err(Error::StaleDevice));
}

#[test]
fn os_block_io_timeouts_negative() {
    let mut requests = Requests::<4>::new(4, 11).unwrap();
    let token = requests.prepare(0, 0x4000_1000, 3, 200, 100, 11).unwrap();
    requests.publish(token, 101).unwrap();
    requests.cancel(token).unwrap();
    assert_eq!(requests.request(token).unwrap().state, State::CancelRequested);
    let cancelled = requests.snapshot();
    assert_eq!(cancelled.live, 1);
    assert_eq!(requests.complete(token, 0, 513, 0), Err(Error::LateCompletion));
    assert_eq!(requests.snapshot(), cancelled);
    assert_eq!(requests.cancel(token), Err(Error::WrongState));
    assert_eq!(requests.observe_reset(0, 1, 12), Err(Error::NotReset));
    assert_eq!(requests.snapshot(), cancelled);
    requests.observe_reset(0, 0, 12).unwrap();
    assert_eq!(requests.snapshot().live, 0);
    assert_eq!(requests.complete(token, 0, 513, 0), Err(Error::StaleDevice));
    let healthy = requests.prepare(0, 0x4000_2000, 4, 400, 300, 12).unwrap();
    requests.publish(healthy, 301).unwrap();
    assert_eq!(requests.complete(healthy, 0, 513, 0).unwrap().lba, 4);
    assert_eq!(requests.snapshot().live, 0);
}

#[test]
fn os_block_io_errors_positive() {
    let mut requests = Requests::<4>::new(4, 21).unwrap();
    let token = requests.prepare(0, 0x4000_1000, 42, 200, 100, 21).unwrap();
    requests.publish(token, 101).unwrap();
    let finished = requests.complete(token, 0, 513, 0).unwrap();
    assert_eq!((finished.lba, finished.buffer), (42, 0x4000_1000));
    assert_eq!(requests.snapshot().live, 0);
    assert_eq!(requests.complete(token, 0, 513, 0), Err(Error::UnknownRequest));
}

#[test]
fn os_block_io_errors_negative() {
    let mut requests = Requests::<4>::new(4, 21).unwrap();
    let token = requests.prepare(0, 0x4000_1000, 42, 200, 100, 21).unwrap();
    requests.publish(token, 101).unwrap();
    let before = requests.snapshot();
    assert_eq!(requests.complete(token, 0, 257, 0), Err(Error::ShortRead));
    assert_eq!(requests.snapshot(), before);
    assert_eq!(requests.complete(token, 0, 513, 1), Err(Error::IoError));
    assert_eq!(requests.snapshot(), before);
    assert_eq!(requests.complete(token, 0, 513, 2), Err(Error::Unsupported));
    assert_eq!(requests.snapshot(), before);
    assert_eq!(requests.complete(token, 0, 514, 0), Err(Error::ShortRead));
    assert_eq!(requests.snapshot(), before);
    assert_eq!(requests.observe_reset(0, 1, 22), Err(Error::NotReset));
    assert_eq!(requests.snapshot(), before);
    requests.observe_reset(0, 0, 22).unwrap();
    assert_eq!(requests.snapshot().live, 0);
    let healthy = requests.prepare(0, 0x4000_2000, 43, 300, 201, 22).unwrap();
    requests.publish(healthy, 202).unwrap();
    assert_eq!(requests.complete(healthy, 0, 513, 0).unwrap().lba, 43);
    assert_eq!(requests.snapshot().live, 0);
}