use turkos_os_syscall_abi::syscall_abi::{DecodeError, Errno};
use turkos_os_user_runtime_compat::{self as compat, Fault, VersionProbe};

struct Probe { answer: Result<u64, Fault>, queries: usize, acquisitions: usize }
impl VersionProbe for Probe {
    fn version(&mut self) -> Result<u64, Fault> {
        self.queries += 1;
        self.answer
    }
}

fn start_image(probe: &mut Probe, required: u64) -> Result<(), Fault> {
    let _session = compat::negotiate(probe, required)?;
    probe.acquisitions += 1;
    Ok(())
}

#[test]
fn os_user_api_compatibility_positive() {
    let mut probe = Probe {answer: Ok(1), queries: 0, acquisitions: 0};
    let session = compat::negotiate(&mut probe, 1).unwrap();
    assert_eq!((session.required(), session.available()), (1, 1));
    assert!(session.supports(1));
    assert!(!session.supports(2));
    assert_eq!((probe.queries, probe.acquisitions), (1, 0));
    assert_eq!(start_image(&mut probe, 1), Ok(()));
    assert_eq!((probe.queries, probe.acquisitions), (2, 1));
}

#[test]
fn os_user_api_compatibility_negative() {
    let mut probe = Probe {answer: Ok(1), queries: 0, acquisitions: 0};
    assert_eq!(start_image(&mut probe, 2),
        Err(Fault::Unsupported {required: 2, available: 1}));
    assert_eq!((probe.queries, probe.acquisitions), (1, 0));
}

#[test]
fn invalid_version_and_kernel_failure_never_start_image() {
    let mut invalid = Probe {answer: Ok(0), queries: 0, acquisitions: 0};
    assert_eq!(start_image(&mut invalid, 1),
        Err(Fault::Unsupported {required: 1, available: 0}));
    assert_eq!((invalid.queries, invalid.acquisitions), (1, 0));
    let mut failed = Probe {answer: Err(Fault::Kernel(Errno::NoSys)),
        queries: 0, acquisitions: 0};
    assert_eq!(start_image(&mut failed, 1),
        Err(Fault::Kernel(Errno::NoSys)));
    assert_eq!((failed.queries, failed.acquisitions), (1, 0));
    let mut malformed = Probe {answer: Err(Fault::Wire(DecodeError::UnknownError)),
        queries: 0, acquisitions: 0};
    assert_eq!(start_image(&mut malformed, 1),
        Err(Fault::Wire(DecodeError::UnknownError)));
    assert_eq!((malformed.queries, malformed.acquisitions), (1, 0));
}