#[path = "../../../os-turkfs-reader/src/lib.rs"]
mod reader;

struct Fixture { reads: Vec<u64>, fail_on: Option<u64> }

impl reader::BlockReader for Fixture {
    fn read_block(&mut self, lba: u64, out: &mut [u8; reader::BLOCK_BYTES])
        -> Result<(), ()> {
        self.reads.push(lba);
        if self.fail_on == Some(lba) { return Err(()); }
        out.fill(lba as u8);
        Ok(())
    }
}

fn extents() -> [reader::Extent; 3] {
    [reader::Extent { first_block: 100, block_count: 1 },
     reader::Extent { first_block: 104, block_count: 1 },
     reader::Extent { first_block: 108, block_count: 1 }]
}

#[test]
fn os_turkfs_reader_extents_positive() {
    let file = reader::File::validate(extents(), 1300, 2048).unwrap();
    assert_eq!(file.size(), 1300);
    assert_eq!(file.extents(), extents());
    let mut disk = Fixture { reads: Vec::new(), fail_on: None };
    let mut output = [0xA5; 1301];
    assert_eq!(file.read_all(&mut disk, &mut output), Ok(1300));
    assert_eq!(disk.reads, [100, 104, 108]);
    assert!(output[..512].iter().all(|byte| *byte == 100));
    assert!(output[512..1024].iter().all(|byte| *byte == 104));
    assert!(output[1024..1300].iter().all(|byte| *byte == 108));
    assert_eq!(output[1300], 0xA5);
}

#[test]
fn os_turkfs_reader_extents_negative() {
    let mut overlap = extents();
    overlap[1].first_block = 100;
    assert_eq!(reader::File::validate(overlap, 1300, 2048),
        Err(reader::Error::Overlap));
    let mut reversed = extents();
    reversed[1].first_block = 99;
    assert_eq!(reader::File::validate(reversed, 1300, 2048),
        Err(reader::Error::OutOfOrder));
    let mut beyond = extents();
    beyond[2].first_block = 2048;
    assert_eq!(reader::File::validate(beyond, 1300, 2048),
        Err(reader::Error::OutOfBounds));
    assert_eq!(reader::File::validate(extents(), 1537, 2048),
        Err(reader::Error::FileTooLarge));
    let file = reader::File::validate(extents(), 1300, 2048).unwrap();
    let mut disk = Fixture { reads: Vec::new(), fail_on: None };
    let mut too_small = [0xA5; 1299];
    assert_eq!(file.read_all(&mut disk, &mut too_small),
        Err(reader::Error::OutputTooSmall));
    assert!(disk.reads.is_empty());
    assert!(too_small.iter().all(|byte| *byte == 0xA5));
    let mut disk = Fixture { reads: Vec::new(), fail_on: Some(104) };
    let mut output = [0xA5; 1300];
    assert_eq!(file.read_all(&mut disk, &mut output),
        Err(reader::Error::ReadFailed));
    assert_eq!(disk.reads, [100, 104]);
    assert!(output[..512].iter().all(|byte| *byte == 0));
    assert!(output[512..].iter().all(|byte| *byte == 0xA5));
}