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

use waitset::{Error, Interest, Kind, ObjectKey, RegistrationId, Waitset};

#[test]
fn typed_registration_reuse_and_stale_denial() {
    let mut set = Waitset::<u64, 2>::new(10);
    let file = ObjectKey {kind: Kind::File, id: 7};
    let channel = ObjectKey {kind: Kind::Channel, id: 7};
    let a = set.register(10, file, Interest::READ).unwrap();
    let b = set.register(10, channel, Interest::WRITE).unwrap();
    assert_eq!(a.raw(), (1u64 << 32) | 1);
    assert_eq!(b.raw(), (1u64 << 32) | 2);
    assert_eq!(set.len(), 2);
    assert_eq!(set.query(10, a), Ok((file, Interest::READ)));
    assert_eq!(set.query(10, b), Ok((channel, Interest::WRITE)));
    assert_eq!(set.unregister(10, a), Ok(()));
    assert_eq!(set.query(10, a), Err(Error::BadFd));
    let c = set.register(10, ObjectKey {kind: Kind::Task, id: 8},
        Interest::CLOSED).unwrap();
    assert_eq!(c.raw(), (2u64 << 32) | 1);
    assert_eq!(set.query(10, RegistrationId::from_raw(a.raw())),
        Err(Error::BadFd));
    assert_eq!(set.len(), 2);
}

#[test]
fn waitset_denials_leave_snapshot_unchanged() {
    let mut set = Waitset::<u64, 2>::new(10);
    let key = ObjectKey {kind: Kind::Channel, id: 52};
    let id = set.register(10, key, Interest::READ_CLOSED).unwrap();
    let before = set.snapshot();
    assert_eq!(set.register(10, key, Interest::WRITE), Err(Error::Exists));
    assert_eq!(set.register(20, ObjectKey {kind: Kind::Task, id: 3},
        Interest::READ), Err(Error::Access));
    assert_eq!(set.register(10, ObjectKey {kind: Kind::File, id: 0},
        Interest::READ), Err(Error::Invalid));
    assert_eq!(set.register(10, ObjectKey {kind: Kind::File, id: 1},
        Interest::from_bits(8)), Err(Error::Invalid));
    assert_eq!(set.unregister(20, id), Err(Error::Access));
    assert_eq!(set.unregister(10, RegistrationId::from_raw(1)),
        Err(Error::BadFd));
    assert_eq!(set.snapshot(), before);
}

#[test]
fn waitset_capacity_and_generation_overflow() {
    let mut set = Waitset::<u64, 1>::new(10);
    let first = set.register(10, ObjectKey {kind: Kind::File, id: 1},
        Interest::READ).unwrap();
    let before = set.snapshot();
    assert_eq!(set.register(10, ObjectKey {kind: Kind::File, id: 2},
        Interest::WRITE), Err(Error::Full));
    assert_eq!(set.snapshot(), before);
    set.unregister(10, first).unwrap();
    let mut exhausted = Waitset::<u64, 1>::with_generation_seed(10,
        [u32::MAX]);
    let before = exhausted.snapshot();
    assert_eq!(exhausted.register(10, ObjectKey {kind: Kind::File, id: 3},
        Interest::READ), Err(Error::Overflow));
    assert_eq!(exhausted.snapshot(), before);
}