use super::*;
use crate::syntax::CaseSensitivity;
const CS: CaseSensitivity = CaseSensitivity::Sensitive;
const CI: CaseSensitivity = CaseSensitivity::Insensitive;
fn cps(s: &str) -> Vec<u32> {
s.chars().map(|c| c as u32).collect()
}
fn meta(name: &[u32]) -> EntryMeta<'_> {
EntryMeta {
name,
depth: 0,
entry_type: EntryType::File,
is_reparse: false,
reparse_tag: 0,
attributes: 0,
size: 0,
btime: 0,
mtime: 0,
atime: 0,
ctime: 0,
}
}
#[test]
fn name_exact_and_negate() {
let n = cps("main.rs");
let m = meta(&n);
assert!(eval_leaf(&Leaf::name_exact("main.rs", CS), &m));
assert!(!eval_leaf(&Leaf::name_exact("other.rs", CS), &m));
let not = Leaf::Name {
seg: super::literals("main.rs"),
case: CS,
negate: true,
};
assert!(!eval_leaf(¬, &m));
}
#[test]
fn name_extension_and_contains() {
let n = cps("archive.tar.gz");
let m = meta(&n);
assert!(eval_leaf(&Leaf::name_extension("gz", CS), &m));
assert!(!eval_leaf(&Leaf::name_extension("tar", CS), &m));
assert!(eval_leaf(&Leaf::name_contains("tar", CS), &m));
assert!(!eval_leaf(&Leaf::name_contains("zip", CS), &m));
}
#[test]
fn name_in_set() {
let n = cps("Makefile");
let m = meta(&n);
assert!(eval_leaf(
&Leaf::name_in_set(&["Makefile", "BUILD"], CS),
&m
));
assert!(!eval_leaf(&Leaf::name_in_set(&["a", "b"], CS), &m));
}
#[test]
fn name_case_insensitive() {
let n = cps("readme.md");
let m = meta(&n);
assert!(eval_leaf(&Leaf::name_exact("README.MD", CI), &m));
assert!(!eval_leaf(&Leaf::name_exact("README.MD", CS), &m));
}
#[test]
fn entry_type() {
let n = cps("dir");
let m = EntryMeta {
entry_type: EntryType::Dir,
..meta(&n)
};
assert!(eval_leaf(
&Leaf::IsType {
ty: EntryType::Dir,
negate: false
},
&m
));
assert!(eval_leaf(
&Leaf::IsType {
ty: EntryType::File,
negate: true
},
&m
));
}
#[test]
fn reparse_bool_and_tag() {
const IO_REPARSE_TAG_SYMLINK: u32 = 0xA000_000C;
let n = cps("link");
let m = EntryMeta {
is_reparse: true,
reparse_tag: IO_REPARSE_TAG_SYMLINK,
..meta(&n)
};
assert!(eval_leaf(&Leaf::IsReparse { negate: false }, &m));
assert!(!eval_leaf(&Leaf::IsReparse { negate: true }, &m));
assert!(eval_leaf(
&Leaf::ReparseTag {
tag: IO_REPARSE_TAG_SYMLINK,
negate: false
},
&m
));
}
#[test]
fn attribute_masks() {
let hidden = 0x2;
let system = 0x4;
let n = cps("f");
let m = EntryMeta {
attributes: hidden,
..meta(&n)
};
assert!(eval_leaf(&Leaf::AttrsAllSet(hidden), &m));
assert!(!eval_leaf(&Leaf::AttrsAllSet(hidden | system), &m));
assert!(eval_leaf(&Leaf::AttrsAllClear(system), &m));
assert!(!eval_leaf(&Leaf::AttrsAllClear(hidden), &m));
}
#[test]
fn size_time_depth_comparisons() {
let n = cps("f");
let m = EntryMeta {
size: 1000,
mtime: 500,
depth: 3,
..meta(&n)
};
assert!(eval_leaf(
&Leaf::Size {
op: Cmp::Gt,
value: 999
},
&m
));
assert!(!eval_leaf(
&Leaf::Size {
op: Cmp::Lt,
value: 1000
},
&m
));
assert!(eval_leaf(
&Leaf::Time {
field: TimeField::Mtime,
op: Cmp::Ge,
value: 500
},
&m
));
assert!(eval_leaf(
&Leaf::Depth {
op: Cmp::Eq,
value: 3
},
&m
));
}
#[test]
fn conjunction_and_empty() {
let n = cps("app.log");
let m = EntryMeta {
size: 2000,
..meta(&n)
};
let pass = vec![
Leaf::name_extension("log", CS),
Leaf::Size {
op: Cmp::Gt,
value: 1000,
},
];
let fail = vec![
Leaf::name_extension("log", CS),
Leaf::Size {
op: Cmp::Gt,
value: 5000,
},
];
assert!(eval_all(&pass, &m));
assert!(!eval_all(&fail, &m));
assert!(eval_all(&[], &m)); }
#[test]
fn fetch_mask_union() {
let leaves = vec![
Leaf::Size {
op: Cmp::Gt,
value: 0,
},
Leaf::Time {
field: TimeField::Mtime,
op: Cmp::Gt,
value: 0,
},
Leaf::IsType {
ty: EntryType::File,
negate: false,
},
];
assert_eq!(
required_fields(&leaves),
MetaMask::SIZE | MetaMask::MTIME | MetaMask::TYPE
);
let cheap = vec![
Leaf::name_exact("x", CS),
Leaf::Depth {
op: Cmp::Lt,
value: 5,
},
];
assert_eq!(required_fields(&cheap), MetaMask::empty());
}
#[test]
fn d66_per_pattern_emit_example() {
let ten_mib = 10 * 1024 * 1024;
let emit_log = vec![
Leaf::name_extension("log", CS),
Leaf::Size {
op: Cmp::Gt,
value: ten_mib,
},
];
let emit_conf = vec![Leaf::name_extension("conf", CS)];
let conf_name = cps("app.conf");
let log_name = cps("app.log");
let small_conf = EntryMeta {
size: 2000,
..meta(&conf_name)
};
let small_log = EntryMeta {
size: 2000,
..meta(&log_name)
};
let big_log = EntryMeta {
size: 20 * 1024 * 1024,
..meta(&log_name)
};
assert!(eval_all(&emit_conf, &small_conf)); assert!(!eval_all(&emit_log, &small_log)); assert!(eval_all(&emit_log, &big_log)); assert!(!eval_all(&emit_conf, &small_log)); }