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

fn node(inode: u64, parent: u64, kind: directory::Kind, name: &[u8])
    -> directory::Node {
    let mut bytes = [0; directory::NAME_BYTES];
    bytes[..name.len()].copy_from_slice(name);
    directory::Node {inode, parent, kind, name_len: name.len() as u8, name: bytes}
}

fn tree() -> [directory::Node; 4] {
    [node(1, 0, directory::Kind::Directory, b""),
     node(2, 1, directory::Kind::Directory, b"a"),
     node(3, 2, directory::Kind::Directory, b"b"),
     node(4, 3, directory::Kind::Regular, b"file")]
}

#[test]
fn os_turkfs_reader_directories_positive() {
    let validated = directory::Directory::validate(tree()).unwrap();
    assert_eq!(validated.node_count(), 4);
    assert_eq!(validated.lookup(b"/").unwrap().inode, 1);
    assert_eq!(validated.lookup(b"/a").unwrap().inode, 2);
    assert_eq!(validated.lookup(b"/a/b").unwrap().inode, 3);
    assert_eq!(validated.lookup(b"/a/b/file").unwrap().inode, 4);
    assert_eq!(validated.lookup(b"/a/b/absent"), Err(directory::Error::NoEntry));
    assert_eq!(validated.lookup(b"/a/b/file/child"),
        Err(directory::Error::NotDirectory));
}

#[test]
fn os_turkfs_reader_directories_negative() {
    let mut self_loop = tree();
    self_loop[2].parent = 3;
    assert_eq!(directory::Directory::validate(self_loop),
        Err(directory::Error::Loop));
    let mut mutual_loop = tree();
    mutual_loop[1].parent = 3;
    assert_eq!(directory::Directory::validate(mutual_loop),
        Err(directory::Error::Loop));
    let mut bad_parent = tree();
    bad_parent[1].kind = directory::Kind::Regular;
    assert_eq!(directory::Directory::validate(bad_parent),
        Err(directory::Error::NotDirectory));
    let mut duplicate = tree();
    duplicate[3].inode = 3;
    assert_eq!(directory::Directory::validate(duplicate),
        Err(directory::Error::DuplicateInode));
    let mut duplicate_name = tree();
    duplicate_name[3].parent = 2;
    duplicate_name[3].name = [0; directory::NAME_BYTES];
    duplicate_name[3].name[0] = b'b';
    duplicate_name[3].name_len = 1;
    assert_eq!(directory::Directory::validate(duplicate_name),
        Err(directory::Error::DuplicateName));
    let mut invalid_name = tree();
    invalid_name[3].name[0] = b'/';
    assert_eq!(directory::Directory::validate(invalid_name),
        Err(directory::Error::InvalidName));
    let validated = directory::Directory::validate(tree()).unwrap();
    assert_eq!(validated.lookup(b"a/b/file"), Err(directory::Error::InvalidPath));
    assert_eq!(validated.lookup(b"/a//file"), Err(directory::Error::InvalidPath));
}