#[path = "../../../os-vfs-paths/src/lib.rs"]
mod paths;

fn namespace() -> paths::MountNamespace {
    let resolver = paths::PathState::new();
    let root = resolver.resolve(b"/sandbox").unwrap();
    let first = paths::Mount::new(resolver.resolve(b"/sandbox/veri").unwrap(), 1).unwrap();
    let second = paths::Mount::new(resolver.resolve(b"/sandbox/ara").unwrap(), 2).unwrap();
    paths::MountNamespace::new(root, first, second).unwrap()
}

#[test]
fn os_vfs_paths_mount_cross_positive() {
    let mut namespace = namespace();
    let first = namespace.chdir(b"/veri/alt").unwrap();
    assert_eq!((first.volume, first.relative_depth), (1, 1));
    assert_eq!(first.path.component(0), Some("sandbox"));
    assert_eq!(first.path.component(2), Some("alt"));
    let second = namespace.chdir(b"../../ara/alt").unwrap();
    assert_eq!((second.volume, second.relative_depth), (2, 1));
    assert_eq!(second.path.component(1), Some("ara"));
    assert_eq!(second.path.component(2), Some("alt"));
    assert_eq!(namespace.cwd, second.path);
    assert_eq!(namespace.generation, 2);

    let resolver = paths::PathState::new();
    let root = resolver.resolve(b"/sandbox").unwrap();
    let outer = paths::Mount::new(resolver.resolve(b"/sandbox/veri").unwrap(), 3).unwrap();
    let inner = paths::Mount::new(resolver.resolve(b"/sandbox/veri/alt").unwrap(), 4).unwrap();
    let nested = paths::MountNamespace::new(root, outer, inner).unwrap();
    let route = nested.resolve(b"/veri/alt/dosya").unwrap();
    assert_eq!((route.volume, route.relative_depth), (4, 1));
}

#[test]
fn os_vfs_paths_mount_cross_negative() {
    let mut namespace = namespace();
    namespace.chdir(b"/ara/alt").unwrap();
    let baseline = namespace;
    assert_eq!(namespace.chdir(b"../../../gizli"), Err(paths::Error::AboveRoot));
    assert_eq!(namespace, baseline);
    assert_eq!(namespace.chdir(&[b'/', 0xff]), Err(paths::Error::InvalidUtf8));
    assert_eq!(namespace, baseline);
    assert_eq!(namespace.chdir(b"/bilinmeyen"), Err(paths::Error::NoMount));
    assert_eq!(namespace, baseline);

    let resolver = paths::PathState::new();
    let root = resolver.resolve(b"/sandbox").unwrap();
    let inside = paths::Mount::new(resolver.resolve(b"/sandbox/veri").unwrap(), 1).unwrap();
    let outside = paths::Mount::new(resolver.resolve(b"/disari").unwrap(), 2).unwrap();
    assert_eq!(paths::MountNamespace::new(root, inside, outside),
        Err(paths::Error::InvalidMount));
    let duplicate = paths::Mount::new(inside.at, 3).unwrap();
    assert_eq!(paths::MountNamespace::new(root, inside, duplicate),
        Err(paths::Error::InvalidMount));
}