#[path = "../../../os-pci-resources/src/lib.rs"]
mod pci_resources;

use pci_resources::{Error, MemoryBar, MemoryBarSize, RangeTable, Width,
    decode_memory_bar, decode_memory_bar_sizing};

#[test]
fn os_pci_resources_bar_size_positive() {
    assert_eq!(decode_memory_bar_sizing(0, 0xffff_f000, 0),
        Ok(MemoryBarSize {size: 0x1000, width: Width::Bits32,
            prefetchable: false}));
    assert_eq!(decode_memory_bar_sizing(0x4, 0xffff_c004, 0xffff_ffff),
        Ok(MemoryBarSize {size: 0x4000, width: Width::Bits64,
            prefetchable: false}));
    let bar32 = decode_memory_bar(0x1000_0000, 0, 0xffff_f000, 0).unwrap();
    assert_eq!(bar32, MemoryBar {base: 0x1000_0000, size: 0x1000,
        width: Width::Bits32, prefetchable: false});
    let bar64 = decode_memory_bar(0x0000_0004, 0x80, 0xffff_c004, 0xffff_ffff).unwrap();
    assert_eq!(bar64, MemoryBar {base: 0x80_0000_0000, size: 0x4000,
        width: Width::Bits64, prefetchable: false});
    let mut ranges = RangeTable::<2>::new();
    assert_eq!(ranges.claim(0x1000_0000, 0, 0xffff_f000, 0), Ok(bar32));
    assert_eq!(ranges.claim(0x0000_0004, 0x80, 0xffff_c004, 0xffff_ffff), Ok(bar64));
    assert_eq!(ranges.snapshot().entries, [Some(bar32), Some(bar64)]);
    assert_eq!(ranges.count(), 2);
    ranges.release(bar64).unwrap();
    ranges.release(bar32).unwrap();
    assert_eq!(ranges.snapshot().entries, [None, None]);
    assert_eq!(ranges.count(), 0);
}

#[test]
fn os_pci_resources_bar_size_negative() {
    let mut ranges = RangeTable::<2>::new();
    let healthy = ranges.claim(0x1000_0000, 0, 0xffff_f000, 0).unwrap();
    let before = ranges.snapshot();
    assert_eq!(ranges.claim(0x2000_0000, 0, 0xffff_e800, 0), Err(Error::MalformedMask));
    assert_eq!(ranges.claim(0x2000_0001, 0, 0xffff_ff01, 0), Err(Error::IoBar));
    assert_eq!(ranges.claim(0, 0, 0xffff_f000, 0), Err(Error::Unassigned));
    assert_eq!(decode_memory_bar_sizing(0, 0xffff_e800, 0),
        Err(Error::MalformedMask));
    assert_eq!(ranges.claim(0x2000_0800, 0, 0xffff_f000, 0), Err(Error::UnalignedBase));
    assert_eq!(ranges.claim(0xffff_f004, 0xffff_ffff, 0xffff_f004, 0xffff_ffff),
        Err(Error::AddressOverflow));
    assert_eq!(ranges.snapshot(), before);
    assert_eq!(ranges.claim(0x1000_0000, 0, 0xffff_f000, 0), Err(Error::Overlap));
    assert_eq!(ranges.snapshot(), before);
    assert_eq!(ranges.snapshot().entries[0], Some(healthy));
    ranges.release(healthy).unwrap();
    assert_eq!(ranges.count(), 0);
}