use super::{EnumPlan, enumerate_dir, nanos, read_one_entry};
use crate::predicate::EntryType;
use std::fs;
use std::time::{Duration, UNIX_EPOCH};
#[test]
fn portable_entry_failure_is_collected_not_fatal() {
let e = read_one_entry(Err(std::io::Error::from_raw_os_error(2)), EnumPlan::FULL);
assert!(e.is_err());
}
#[test]
fn nanos_unavailable_is_zero() {
assert_eq!(nanos(Err(std::io::Error::other("x"))), 0);
}
#[test]
fn nanos_pre_epoch_is_negative() {
let t = UNIX_EPOCH - Duration::from_secs(1);
assert_eq!(nanos(Ok(t)), -1_000_000_000);
}
#[test]
fn nanos_post_epoch_is_positive() {
let t = UNIX_EPOCH + Duration::from_secs(1);
assert_eq!(nanos(Ok(t)), 1_000_000_000);
}
#[test]
fn nanos_far_future_saturates_instead_of_wrapping() {
let t = UNIX_EPOCH + Duration::from_secs(10_000_000_000);
assert_eq!(nanos(Ok(t)), i64::MAX);
}
#[test]
fn enumerate_temp_tree() {
let root = tempfile::tempdir().unwrap();
let mut expected_files = 0usize;
for i in 0..10 {
let d = root.path().join(format!("dir{i}"));
fs::create_dir(&d).unwrap();
for j in 0..20 {
fs::write(d.join(format!("file{j}.txt")), b"x").unwrap();
expected_files += 1;
}
}
let top = enumerate_dir(root.path(), EnumPlan::FULL).unwrap().entries;
let dirs = top
.iter()
.filter(|e| e.entry_type == EntryType::Dir)
.count();
assert_eq!(dirs, 10);
let mut files = 0usize;
for e in &top {
if e.entry_type != EntryType::Dir {
continue;
}
let name: String = e.name.iter().filter_map(|&c| char::from_u32(c)).collect();
let sub = enumerate_dir(&root.path().join(name), EnumPlan::FULL)
.unwrap()
.entries;
for s in &sub {
if s.entry_type == EntryType::File {
files += 1;
assert_eq!(s.size, 1);
assert!(!s.is_reparse);
}
}
}
assert_eq!(files, expected_files);
assert_eq!(files, 200);
}
#[test]
fn meta_view_matches_entry() {
let root = tempfile::tempdir().unwrap();
fs::write(root.path().join("a.txt"), b"hello").unwrap();
let entries = enumerate_dir(root.path(), EnumPlan::FULL).unwrap().entries;
let e = entries
.iter()
.find(|e| e.entry_type == EntryType::File)
.unwrap();
let m = e.meta(2);
assert_eq!(m.depth, 2);
assert_eq!(m.size, 5);
assert_eq!(m.name, e.name.as_slice());
}
#[cfg(windows)]
#[test]
fn native_matches_portable_and_has_file_ids() {
use super::win::enumerate_dir_native;
let root = tempfile::tempdir().unwrap();
for i in 0..5 {
let d = root.path().join(format!("dir{i}"));
fs::create_dir(&d).unwrap();
for j in 0..10 {
fs::write(d.join(format!("f{j}.txt")), b"hello").unwrap();
}
}
let portable = enumerate_dir(root.path(), EnumPlan::FULL).unwrap().entries;
let native = enumerate_dir_native(root.path(), EnumPlan::FULL)
.unwrap()
.entries;
let mut pn: Vec<Vec<u32>> = portable.iter().map(|e| e.name.clone()).collect();
let mut nn: Vec<Vec<u32>> = native.iter().map(|e| e.name.clone()).collect();
pn.sort();
nn.sort();
assert_eq!(pn, nn);
assert_eq!(nn.len(), 5);
assert!(
native
.iter()
.all(|e| e.file_id.volume != 0 || e.file_id.id != 0)
);
let files = enumerate_dir_native(&root.path().join("dir0"), EnumPlan::FULL)
.unwrap()
.entries;
let file_sizes: Vec<u64> = files
.iter()
.filter(|e| e.entry_type == EntryType::File)
.map(|e| e.size)
.collect();
assert_eq!(file_sizes.len(), 10);
assert!(file_sizes.iter().all(|&s| s == 5));
}
#[cfg(target_os = "linux")]
#[test]
fn native_linux_matches_portable_and_has_file_ids() {
use super::linux::enumerate_dir_native;
let root = tempfile::tempdir().unwrap();
for i in 0..5 {
let d = root.path().join(format!("dir{i}"));
fs::create_dir(&d).unwrap();
for j in 0..10 {
fs::write(d.join(format!("f{j}.txt")), b"hello").unwrap();
}
}
let portable = enumerate_dir(root.path(), EnumPlan::FULL).unwrap().entries;
let native = enumerate_dir_native(root.path(), EnumPlan::FULL)
.unwrap()
.entries;
let mut pn: Vec<Vec<u32>> = portable.iter().map(|e| e.name.clone()).collect();
let mut nn: Vec<Vec<u32>> = native.iter().map(|e| e.name.clone()).collect();
pn.sort();
nn.sort();
assert_eq!(pn, nn);
assert_eq!(nn.len(), 5);
assert!(native.iter().all(|e| e.file_id.id != 0));
let mut pids: Vec<_> = portable
.iter()
.map(|e| (e.name.clone(), e.file_id))
.collect();
let mut nids: Vec<_> = native.iter().map(|e| (e.name.clone(), e.file_id)).collect();
pids.sort_by(|a, b| a.0.cmp(&b.0));
nids.sort_by(|a, b| a.0.cmp(&b.0));
assert_eq!(pids, nids);
let files = enumerate_dir_native(&root.path().join("dir0"), EnumPlan::FULL)
.unwrap()
.entries;
let regular: Vec<_> = files
.iter()
.filter(|e| e.entry_type == EntryType::File)
.collect();
assert_eq!(regular.len(), 10);
assert!(regular.iter().all(|e| e.size == 5));
assert!(regular.iter().all(|e| e.mtime > 0));
}
#[cfg(target_os = "linux")]
#[test]
fn native_linux_reports_symlinks_without_following() {
use super::linux::enumerate_dir_native;
let root = tempfile::tempdir().unwrap();
fs::write(root.path().join("target.txt"), b"payload").unwrap();
std::os::unix::fs::symlink("target.txt", root.path().join("link")).unwrap();
let native = enumerate_dir_native(root.path(), EnumPlan::FULL)
.unwrap()
.entries;
let link = native
.iter()
.find(|e| e.name == crate::syntax::decode::decode_bytes(b"link"))
.expect("symlink entry present");
assert!(link.is_reparse);
assert_eq!(link.entry_type, EntryType::Other);
}
#[test]
fn portable_plan_without_stat_skips_metadata() {
let root = tempfile::tempdir().unwrap();
fs::write(root.path().join("a.txt"), b"hello").unwrap();
let plan = EnumPlan {
want_stat: false,
want_file_id: false,
want_reparse_file_id: false,
};
let names_only = enumerate_dir(root.path(), plan).unwrap().entries;
let f = names_only
.iter()
.find(|e| e.entry_type == EntryType::File)
.unwrap();
assert_eq!(f.size, 0);
let full = enumerate_dir(root.path(), EnumPlan::FULL).unwrap().entries;
let f = full
.iter()
.find(|e| e.entry_type == EntryType::File)
.unwrap();
assert_eq!(f.size, 5);
}
#[cfg(target_os = "linux")]
#[test]
fn native_linux_plan_without_stat_uses_dtype_only() {
use super::linux::enumerate_dir_native;
let root = tempfile::tempdir().unwrap();
fs::create_dir(root.path().join("d")).unwrap();
fs::write(root.path().join("f.txt"), b"hello").unwrap();
let plan = EnumPlan {
want_stat: false,
want_file_id: false,
want_reparse_file_id: false,
};
let entries = enumerate_dir_native(root.path(), plan).unwrap().entries;
assert!(entries.iter().any(|e| e.entry_type == EntryType::Dir));
let f = entries
.iter()
.find(|e| e.entry_type == EntryType::File)
.unwrap();
assert_eq!(f.size, 0);
assert_eq!(f.file_id.id, 0);
}
#[cfg(unix)]
#[test]
fn portable_reparse_only_file_id_skips_regular_entries() {
let root = tempfile::tempdir().unwrap();
fs::write(root.path().join("f.txt"), b"x").unwrap();
std::os::unix::fs::symlink("f.txt", root.path().join("link")).unwrap();
let reparse_only = EnumPlan {
want_stat: false,
want_file_id: false,
want_reparse_file_id: true,
};
let e = enumerate_dir(root.path(), reparse_only).unwrap().entries;
let f = e.iter().find(|x| x.entry_type == EntryType::File).unwrap();
let l = e.iter().find(|x| x.is_reparse).unwrap();
assert_eq!(f.file_id.id, 0);
assert!(l.file_id.id != 0);
let all = EnumPlan {
want_stat: false,
want_file_id: true,
want_reparse_file_id: false,
};
let e = enumerate_dir(root.path(), all).unwrap().entries;
let f = e.iter().find(|x| x.entry_type == EntryType::File).unwrap();
assert!(f.file_id.id != 0);
}
#[cfg(target_os = "linux")]
#[test]
fn native_linux_reparse_only_file_id_skips_regular_entries() {
use super::linux::enumerate_dir_native;
let root = tempfile::tempdir().unwrap();
fs::write(root.path().join("f.txt"), b"x").unwrap();
std::os::unix::fs::symlink("f.txt", root.path().join("link")).unwrap();
let reparse_only = EnumPlan {
want_stat: false,
want_file_id: false,
want_reparse_file_id: true,
};
let e = enumerate_dir_native(root.path(), reparse_only)
.unwrap()
.entries;
let f = e.iter().find(|x| x.entry_type == EntryType::File).unwrap();
let l = e.iter().find(|x| x.is_reparse).unwrap();
assert_eq!(f.file_id.id, 0);
assert!(l.file_id.id != 0);
let all = EnumPlan {
want_stat: false,
want_file_id: true,
want_reparse_file_id: false,
};
let e = enumerate_dir_native(root.path(), all).unwrap().entries;
let f = e.iter().find(|x| x.entry_type == EntryType::File).unwrap();
assert!(f.file_id.id != 0);
}