mod support;
use std::fmt::Write as _;
use raf_source::{
LoadError, LoadErrorKind, MemoryTree, Origin, RelPath, ResolveError, TestRole, TreeError,
Workspace,
};
use support::counting::{Counting, Op};
const DEMO: &str = "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n";
fn load(files: &[(&str, &str)]) -> Result<Workspace, LoadError> {
let mut all = vec![("Cargo.toml", DEMO)];
all.extend_from_slice(files);
let tree: MemoryTree = all.into_iter().collect();
Workspace::load(&tree, &["."])
}
fn ok(files: &[(&str, &str)]) -> Workspace {
load(files).unwrap_or_else(|e| panic!("{e}"))
}
fn reached(ws: &Workspace) -> Vec<(String, Vec<String>)> {
ws.files()
.map(|f| {
let mut paths: Vec<String> = f
.reached
.iter()
.map(|r| r.module_path.to_string())
.collect();
paths.sort();
(f.path.to_string(), paths)
})
.collect()
}
fn files(pairs: &[(&str, &[&str])]) -> Vec<(String, Vec<String>)> {
pairs
.iter()
.map(|(path, modules)| {
(
(*path).to_owned(),
modules.iter().map(|m| (*m).to_owned()).collect(),
)
})
.collect()
}
#[test]
fn a_flat_file_and_a_directory_module_are_both_followed_beside_each_other() {
let ws = ok(&[
("src/lib.rs", "mod flat; mod nested;"),
("src/flat.rs", ""),
("src/nested/mod.rs", "mod deeper;"),
("src/nested/deeper.rs", ""),
]);
assert_eq!(
reached(&ws),
files(&[
("src/flat.rs", &["demo::flat"]),
("src/lib.rs", &["demo"]),
("src/nested/deeper.rs", &["demo::nested::deeper"]),
("src/nested/mod.rs", &["demo::nested"]),
])
);
}
#[test]
fn a_non_mod_file_keeps_its_children_in_a_directory_of_its_own_name() {
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "mod b;"),
("src/a/b.rs", "mod c;"),
("src/a/b/c.rs", ""),
]);
let paths: Vec<_> = ws.files().map(|f| f.path.to_string()).collect();
assert_eq!(
paths,
["src/a.rs", "src/a/b.rs", "src/a/b/c.rs", "src/lib.rs"]
);
}
#[test]
fn a_module_with_both_name_rs_and_name_mod_rs_is_an_error_naming_both_files() {
let error = load(&[
("src/lib.rs", "mod both;"),
("src/both.rs", ""),
("src/both/mod.rs", ""),
])
.expect_err("both");
match &error.kind {
LoadErrorKind::BothModFiles {
module,
first,
second,
} => {
assert_eq!(module, "both");
assert_eq!(first.as_str(), "src/both.rs");
assert_eq!(second.as_str(), "src/both/mod.rs");
}
other => panic!("{other:?}"),
}
assert_eq!(error.file.as_str(), "src/lib.rs");
assert_eq!(error.line, Some(1));
let text = error.to_string();
assert!(
text.contains("src/both.rs") && text.contains("src/both/mod.rs"),
"{text}"
);
assert!(load(&[("src/lib.rs", "mod both;"), ("src/both.rs", "")]).is_ok());
assert!(load(&[("src/lib.rs", "mod both;"), ("src/both/mod.rs", "")]).is_ok());
}
#[test]
fn an_unresolved_mod_names_the_declaring_file_and_line() {
let error = load(&[("src/lib.rs", "// one\n// two\nmod missing;\n")]).expect_err("missing");
assert!(matches!(&error.kind, LoadErrorKind::UnresolvedMod { module } if module == "missing"));
assert_eq!(error.file.as_str(), "src/lib.rs");
assert_eq!(error.line, Some(3));
assert!(error.to_string().starts_with("src/lib.rs:3:"), "{error}");
assert!(load(&[("src/lib.rs", "mod present;"), ("src/present.rs", "")]).is_ok());
}
#[test]
fn inline_modules_add_directory_components_for_their_file_children() {
let ws = ok(&[
("src/lib.rs", "mod outer { mod inner { mod leaf; } }"),
("src/outer/inner/leaf.rs", ""),
]);
assert_eq!(
reached(&ws)[0],
("src/lib.rs".to_owned(), vec!["demo".to_owned()])
);
assert_eq!(
reached(&ws)[1],
(
"src/outer/inner/leaf.rs".to_owned(),
vec!["demo::outer::inner::leaf".to_owned()]
)
);
let error = load(&[
("src/lib.rs", "mod outer { mod leaf; }"),
("src/leaf.rs", ""),
])
.expect_err("wrong place");
assert!(matches!(error.kind, LoadErrorKind::UnresolvedMod { .. }));
}
#[test]
fn an_inline_module_inside_a_non_mod_file_nests_below_the_files_own_directory() {
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "mod inline { mod leaf; }"),
("src/a/inline/leaf.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/a/inline/leaf.rs").expect("path"))
.is_some()
);
}
#[test]
fn a_path_attribute_in_a_mod_rs_file_is_relative_to_that_files_directory() {
let ws = ok(&[
("src/lib.rs", "#[path = \"elsewhere/x.rs\"] mod x;"),
("src/elsewhere/x.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/elsewhere/x.rs").expect("path"))
.is_some()
);
}
#[test]
fn a_path_attribute_in_a_non_mod_file_is_relative_to_the_files_directory_not_its_module_directory()
{
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "#[path = \"x.rs\"] mod x;"),
("src/x.rs", ""),
]);
assert_eq!(
reached(&ws)
.into_iter()
.find(|(path, _)| path == "src/x.rs")
.map(|(_, modules)| modules),
Some(vec!["demo::a::x".to_owned()])
);
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "#[path = \"x.rs\"] mod x;"),
("src/a/x.rs", ""),
])
.expect_err("only the file directory counts");
assert!(
matches!(error.kind, LoadErrorKind::UnresolvedMod { .. }),
"{error}"
);
}
#[test]
fn a_path_attribute_inside_an_inline_module_is_relative_to_the_module_directory() {
let ws = ok(&[
("src/lib.rs", "mod inline { #[path = \"x.rs\"] mod x; }"),
("src/inline/x.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/inline/x.rs").expect("path"))
.is_some()
);
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "mod inline { #[path = \"x.rs\"] mod x; }"),
("src/a/inline/x.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/a/inline/x.rs").expect("path"))
.is_some()
);
}
#[test]
fn a_path_attribute_on_an_inline_module_replaces_its_directory_component() {
let ws = ok(&[
(
"src/lib.rs",
"#[path = \"custom\"] mod inline { mod leaf; }",
),
("src/custom/leaf.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/custom/leaf.rs").expect("path"))
.is_some()
);
let error = load(&[
(
"src/lib.rs",
"#[path = \"custom\"] mod inline { mod leaf; }",
),
("src/inline/leaf.rs", ""),
])
.expect_err("the plain name is not used");
assert!(matches!(error.kind, LoadErrorKind::UnresolvedMod { .. }));
}
#[test]
fn a_file_named_by_a_path_attribute_is_a_mod_rs_file_for_its_children() {
let ws = ok(&[
("src/lib.rs", "#[path = \"sub/explicit.rs\"] mod explicit;"),
("src/sub/explicit.rs", "mod child;"),
("src/sub/child.rs", ""),
]);
let paths: Vec<_> = ws.files().map(|f| f.path.to_string()).collect();
assert_eq!(
paths,
["src/lib.rs", "src/sub/child.rs", "src/sub/explicit.rs"]
);
let error = load(&[
("src/lib.rs", "#[path = \"sub/explicit.rs\"] mod explicit;"),
("src/sub/explicit.rs", "mod child;"),
("src/sub/explicit/child.rs", ""),
])
.expect_err("not there");
assert!(matches!(error.kind, LoadErrorKind::UnresolvedMod { .. }));
}
#[test]
fn two_unconditional_path_attributes_are_an_error_beside_one() {
let error = load(&[
(
"src/lib.rs",
"#[path = \"a.rs\"]\n#[path = \"b.rs\"]\nmod x;",
),
("src/a.rs", ""),
("src/b.rs", ""),
])
.expect_err("duplicate");
assert!(matches!(&error.kind, LoadErrorKind::DuplicatePathAttr { module } if module == "x"));
assert!(
matches!(error.origin.as_deref(), Some(Origin::PathAttr { module, .. }) if module == "x")
);
assert!(
load(&[
("src/lib.rs", "#[path = \"a.rs\"] mod x;"),
("src/a.rs", "")
])
.is_ok()
);
}
#[test]
fn every_cfg_attr_path_alternative_is_followed_carrying_its_predicate() {
let ws = ok(&[
(
"src/lib.rs",
"#[cfg_attr(unix, path = \"unix.rs\")]\n#[cfg_attr(windows, path = \"win.rs\")]\nmod sys;",
),
("src/unix.rs", "pub fn go() {}"),
("src/win.rs", "pub fn go() {}"),
]);
let unix = ws
.file(&RelPath::new("src/unix.rs").expect("path"))
.expect("loaded");
assert_eq!(unix.reached[0].predicate.as_deref(), Some("unix"));
assert!(!unix.reached[0].test);
let win = ws
.file(&RelPath::new("src/win.rs").expect("path"))
.expect("loaded");
assert_eq!(win.reached[0].predicate.as_deref(), Some("windows"));
assert_eq!(unix.reached[0].module_path, "demo::sys");
}
#[test]
fn the_default_file_is_also_followed_beside_cfg_attr_alternatives_when_it_exists() {
let ws = ok(&[
(
"src/lib.rs",
"#[cfg_attr(unix, path = \"unix.rs\")] mod sys;",
),
("src/unix.rs", ""),
("src/sys.rs", ""),
]);
let paths: Vec<_> = ws.files().map(|f| f.path.to_string()).collect();
assert_eq!(paths, ["src/lib.rs", "src/sys.rs", "src/unix.rs"]);
let error = load(&[
(
"src/lib.rs",
"#[cfg_attr(unix, path = \"unix.rs\")] mod sys;",
),
("src/sys.rs", ""),
])
.expect_err("alternative missing");
assert!(matches!(error.kind, LoadErrorKind::UnresolvedMod { .. }));
assert!(matches!(
error.origin.as_deref(),
Some(Origin::PathAttr { predicate: Some(p), .. }) if p == "unix"
));
}
#[test]
fn a_cfg_attr_test_path_is_tagged_test_and_nothing_is_dropped() {
let ws = ok(&[
(
"src/lib.rs",
"#[cfg_attr(test, path = \"tests_impl.rs\")] mod m;",
),
("src/m.rs", "pub fn real() {}"),
("src/tests_impl.rs", "pub fn only_in_tests() {}"),
]);
let alternative = ws
.file(&RelPath::new("src/tests_impl.rs").expect("path"))
.expect("loaded");
assert!(alternative.reached[0].test);
assert!(alternative.reached_only_through_tests());
let default = ws
.file(&RelPath::new("src/m.rs").expect("path"))
.expect("loaded");
assert!(!default.reached[0].test);
}
#[test]
fn a_raw_identifier_module_reads_the_plain_file_name() {
let ws = ok(&[("src/lib.rs", "mod r#match;"), ("src/match.rs", "")]);
assert_eq!(
reached(&ws)[1],
("src/match.rs".to_owned(), vec!["demo::match".to_owned()])
);
let ws = ok(&[
("src/lib.rs", "mod r#type { mod r#fn; }"),
("src/type/fn.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/type/fn.rs").expect("path"))
.is_some()
);
assert!(load(&[("src/lib.rs", "mod r#match;"), ("src/r#match.rs", "")]).is_err());
}
#[test]
fn a_module_cycle_is_an_error_naming_both_files() {
let error = load(&[("src/lib.rs", "#[path = \"lib.rs\"]\nmod again;")]).expect_err("cycle");
match &error.kind {
LoadErrorKind::ModuleCycle { module, again } => {
assert_eq!(module, "again");
assert_eq!(again.as_str(), "src/lib.rs");
}
other => panic!("{other:?}"),
}
assert_eq!(error.file.as_str(), "src/lib.rs");
assert_eq!(error.line, Some(2));
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "#[path = \"b.rs\"] mod b;"),
("src/b.rs", "#[path = \"a.rs\"] mod a;"),
])
.expect_err("longer cycle");
match &error.kind {
LoadErrorKind::ModuleCycle { again, .. } => assert_eq!(again.as_str(), "src/a.rs"),
other => panic!("{other:?}"),
}
assert_eq!(error.file.as_str(), "src/b.rs");
}
#[test]
fn a_file_reached_twice_without_a_cycle_is_parsed_once_and_recorded_under_each_path() {
let ws = ok(&[
(
"src/lib.rs",
"#[path = \"shared.rs\"] mod one;\n#[path = \"shared.rs\"] mod two;",
),
("src/shared.rs", "pub fn go() {}"),
]);
let shared = ws
.file(&RelPath::new("src/shared.rs").expect("path"))
.expect("loaded");
let paths: Vec<_> = shared
.reached
.iter()
.map(|r| r.module_path.as_str())
.collect();
assert_eq!(paths, ["demo::one", "demo::two"]);
assert_eq!(
ws.files()
.filter(|f| f.path.as_str() == "src/shared.rs")
.count(),
1
);
}
#[test]
fn module_nesting_beyond_the_depth_budget_is_refused_and_the_budget_itself_loads() {
let nest = |levels: usize| {
format!("{}{}", "mod m { ".repeat(levels), "}".repeat(levels))
};
assert!(load(&[("src/lib.rs", &nest(100))]).is_ok());
let error = load(&[("src/lib.rs", &nest(129))]).err();
let error = error.expect("refused");
assert!(
matches!(error.kind, LoadErrorKind::Budget { .. }),
"{error}"
);
let mut chain: Vec<(String, String)> = vec![("src/lib.rs".into(), "mod m0;".into())];
for index in 0..130 {
chain.push((
format!("src/m{index}.rs"),
format!("#[path = \"m{}.rs\"] mod m{};", index + 1, index + 1),
));
}
chain.push(("src/m130.rs".into(), String::new()));
let pairs: Vec<(&str, &str)> = chain
.iter()
.map(|(a, b)| (a.as_str(), b.as_str()))
.collect();
let error = load(&pairs).expect_err("too deep");
assert!(
matches!(
error.kind,
LoadErrorKind::Budget {
budget: raf_source::Budget::ModuleDepth,
..
}
),
"{error}"
);
chain.truncate(100);
let pairs: Vec<(&str, &str)> = chain
.iter()
.map(|(a, b)| (a.as_str(), b.as_str()))
.collect();
assert!(matches!(
load(&pairs).expect_err("unresolved").kind,
LoadErrorKind::UnresolvedMod { .. }
));
}
#[test]
fn a_path_that_leaves_the_tree_is_refused_naming_module_and_attribute_without_reading_it() {
for escape in ["../../x.rs", "/etc/x.rs", "../../../x.rs"] {
let lib = format!("#[path = \"{escape}\"]\nmod outside;");
let tree = Counting::new(
[
("Cargo.toml", DEMO),
("src/lib.rs", lib.as_str()),
("x.rs", ""),
]
.into_iter()
.collect::<MemoryTree>(),
);
let result = Workspace::load(&tree, &["."]);
let error = result.expect_err(escape);
assert!(
matches!(&error.kind, LoadErrorKind::Tree(e) if matches!(**e, TreeError::OutsideRoot { .. })),
"{error}"
);
assert_eq!(error.file.as_str(), "src/lib.rs");
assert_eq!(error.line, Some(2));
assert!(
matches!(error.origin.as_deref(), Some(Origin::PathAttr { module, .. }) if module == "outside")
);
let text = error.to_string();
assert!(text.contains("outside") && text.contains("path"), "{text}");
let reads = tree.read_log();
assert_eq!(reads, ["Cargo.toml", "src/lib.rs"], "{escape}");
}
let tree = Counting::new(
[
("Cargo.toml", DEMO),
("src/lib.rs", "#[path = \"../inside.rs\"] mod inside;"),
("inside.rs", ""),
]
.into_iter()
.collect::<MemoryTree>(),
);
Workspace::load(&tree, &["."]).expect("inside path loads");
assert!(
tree.read_log()
.iter()
.any(|read| read.as_str() == "inside.rs")
);
}
#[test]
fn a_cfg_test_module_tags_every_item_reached_only_through_it() {
let ws = ok(&[
(
"src/lib.rs",
"pub fn real() {}\n#[cfg(test)] mod t;\nmod live;",
),
("src/t.rs", "fn helper() {}\nmod deeper;"),
("src/t/deeper.rs", "fn more() {}"),
("src/live.rs", "pub fn alive() {}"),
]);
for (path, only_tests) in [
("src/t.rs", true),
("src/t/deeper.rs", true),
("src/live.rs", false),
("src/lib.rs", false),
] {
let file = ws.file(&RelPath::new(path).expect("path")).expect("loaded");
assert_eq!(file.reached_only_through_tests(), only_tests, "{path}");
}
}
#[test]
fn the_cfg_test_matrix_tags_items_and_leaves_their_neighbours_alone() {
let ws = ok(&[(
"src/lib.rs",
"#[cfg(all(test, unix))] fn all_test() {}\n\
#[cfg(any(test, test))] fn any_test() {}\n\
#[cfg(any(test, unix))] fn any_mixed() {}\n\
#[cfg(not(test))] fn not_test() {}\n\
#[cfg(unix)] fn plain_cfg() {}\n\
#[test] fn marked() {}\n\
fn bare() {}\n\
#[cfg(test)] mod tests { fn inside() {} #[test] fn inner_test() {} }\n",
)]);
let file = RelPath::new("src/lib.rs").expect("path");
let role = |name: &str| {
let found: Vec<TestRole> = ws
.items_in(&file)
.filter(|item| &*item.name == name)
.map(|item| item.test)
.collect();
assert_eq!(found.len(), 1, "one item named {name}");
found[0]
};
let roles: Vec<(&str, TestRole)> = [
"all_test",
"any_test",
"any_mixed",
"not_test",
"plain_cfg",
"marked",
"bare",
"tests",
"inside",
"inner_test",
]
.into_iter()
.map(|name| (name, role(name)))
.collect();
assert_eq!(
roles,
[
("all_test", TestRole::CfgTest),
("any_test", TestRole::CfgTest),
("any_mixed", TestRole::None),
("not_test", TestRole::None),
("plain_cfg", TestRole::None),
("marked", TestRole::TestFn),
("bare", TestRole::None),
("tests", TestRole::CfgTest),
("inside", TestRole::CfgTest),
("inner_test", TestRole::TestFn),
]
);
}
#[test]
fn an_unparseable_cfg_is_an_error_naming_file_and_line_beside_a_parseable_one() {
for bad in [
"#[cfg(foo(bar))]",
"#[cfg(not(a, b))]",
"#[cfg(x = 1)]",
"#[cfg()]",
] {
let text = format!("fn ok() {{}}\n{bad}\nfn broken() {{}}\n");
let error = load(&[("src/lib.rs", &text)]).expect_err(bad);
assert!(
matches!(error.kind, LoadErrorKind::CfgParse { .. }),
"{bad}: {error}"
);
assert_eq!(error.file.as_str(), "src/lib.rs");
assert_eq!(error.line, Some(2), "{bad}");
}
assert!(load(&[("src/lib.rs", "#[cfg(all(unix, not(test)))] fn fine() {}")]).is_ok());
}
#[test]
fn one_file_spelled_two_ways_is_one_file_recorded_under_both_module_paths() {
let ws = ok(&[
(
"src/lib.rs",
"mod inner;\n#[path = \"../src/inner.rs\"] mod again;",
),
("src/inner.rs", "pub fn go() {}"),
]);
let inner = ws
.file(&RelPath::new("src/inner.rs").expect("path"))
.expect("loaded");
let paths: Vec<_> = inner
.reached
.iter()
.map(|r| r.module_path.as_str())
.collect();
assert_eq!(paths, ["demo::inner", "demo::again"]);
assert_eq!(ws.files().count(), 2);
}
fn chain(fan: usize, n: usize) -> Vec<(String, String)> {
let mut files = vec![(
"src/lib.rs".to_owned(),
"#[path = \"m0.rs\"] mod m0;".to_owned(),
)];
for index in 0..n {
let mut body = String::new();
for k in 0..fan {
writeln!(body, "#[path = \"m{}.rs\"] mod x{k};", index + 1).expect("write to a string");
}
files.push((format!("src/m{index}.rs"), body));
}
files.push((format!("src/m{n}.rs"), String::new()));
files
}
fn borrowed(files: &[(String, String)]) -> Vec<(&str, &str)> {
files
.iter()
.map(|(a, b)| (a.as_str(), b.as_str()))
.collect()
}
fn load_counted(
files: &[(&str, &str)],
ceiling: usize,
) -> (Counting<MemoryTree>, Result<Workspace, LoadError>) {
let mut all = vec![("Cargo.toml", DEMO)];
all.extend_from_slice(files);
let tree = Counting::new(all.into_iter().collect::<MemoryTree>()).with_ceiling(ceiling);
let result = Workspace::load(&tree, &["."]);
(tree, result)
}
#[test]
fn a_chain_of_files_that_each_declare_the_next_twice_is_refused_by_the_module_path_budget_opening_each_file_once_beside_a_small_diamond()
{
let files = chain(2, 30);
let (tree, result) = load_counted(&borrowed(&files), 200);
let error = result.expect_err("2^30 module paths");
assert!(
matches!(
error.kind,
LoadErrorKind::Budget {
budget: raf_source::Budget::ModulePaths,
limit: 262_144
}
),
"{error}"
);
assert!(error.file.as_str().starts_with("src/m"), "{error}");
assert!(error.line.is_some());
let manifests = 1;
assert!(tree.count(Op::Open) > 0);
assert!(
tree.count(Op::Open) <= files.len() + manifests,
"{} opens for {} files",
tree.count(Op::Open),
files.len()
);
assert!(tree.count(Op::OpenedRead) > 0);
assert!(
tree.count(Op::OpenedRead) <= files.len(),
"{}",
tree.count(Op::OpenedRead)
);
let files = chain(2, 4);
let ws = ok(&borrowed(&files));
let last = ws
.file(&RelPath::new("src/m4.rs").expect("path"))
.expect("loaded");
assert_eq!(last.reached.len(), 16);
let files = chain(2, 16);
assert!(load(&borrowed(&files)).is_ok());
}
#[test]
fn module_depth_of_exactly_the_budget_loads_and_one_more_is_refused() {
let nested = |depth: usize| {
let mut files = vec![(
"src/lib.rs".to_owned(),
"#[path = \"m1.rs\"] mod m1;".to_owned(),
)];
for index in 1..depth {
files.push((
format!("src/m{index}.rs"),
format!("#[path = \"m{}.rs\"] mod m{};", index + 1, index + 1),
));
}
files.push((format!("src/m{depth}.rs"), String::new()));
files
};
let at = nested(128);
assert!(load(&borrowed(&at)).is_ok());
let over = nested(129);
let error = load(&borrowed(&over)).expect_err("129 levels");
assert!(
matches!(
error.kind,
LoadErrorKind::Budget {
budget: raf_source::Budget::ModuleDepth,
limit: 128
}
),
"{error}"
);
assert_eq!(error.file.as_str(), "src/m128.rs");
}
#[test]
fn a_path_attribute_on_an_inline_module_in_a_non_mod_file_replaces_its_directory_component() {
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "#[path = \"custom\"] mod inline { mod leaf; }"),
("src/custom/leaf.rs", ""),
]);
assert!(
ws.file(&RelPath::new("src/custom/leaf.rs").expect("path"))
.is_some()
);
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "#[path = \"custom\"] mod inline { mod leaf; }"),
("src/a/custom/leaf.rs", ""),
])
.expect_err("only the file directory counts");
assert!(matches!(error.kind, LoadErrorKind::UnresolvedMod { .. }));
}
#[test]
fn a_nested_cfg_attr_path_is_flattened_with_the_combined_predicate() {
let ws = ok(&[
(
"src/lib.rs",
"#[cfg_attr(unix, cfg_attr(test, path = \"nested.rs\"))] mod m;",
),
("src/nested.rs", ""),
("src/m.rs", ""),
]);
let nested = ws
.file(&RelPath::new("src/nested.rs").expect("path"))
.expect("loaded");
assert_eq!(
nested.reached[0].predicate.as_deref(),
Some("all(unix, test)")
);
assert!(nested.reached[0].test);
let default = ws
.file(&RelPath::new("src/m.rs").expect("path"))
.expect("loaded");
assert_eq!(default.reached[0].predicate, None);
}
#[test]
fn a_malformed_cfg_path_or_test_attribute_is_an_error_naming_its_line() {
for bad in [
"#[cfg = \"x\"]",
"#[cfg_attr]",
"#[path]",
"#[path(\"x.rs\")]",
"#[test(x)]",
] {
let text = format!("fn ok() {{}}\n{bad}\nmod m;\n");
let error = load(&[("src/lib.rs", &text), ("src/m.rs", "")]).expect_err(bad);
assert!(
matches!(error.kind, LoadErrorKind::CfgParse { .. }),
"{bad}: {error}"
);
assert_eq!(error.line, Some(2), "{bad}");
}
}
fn alternatives(levels: usize) -> String {
let open = "#[cfg_attr(unix, path = \"u\")] #[cfg_attr(windows, path = \"w\")] mod m { ";
format!("{}{}", open.repeat(levels), "}".repeat(levels))
}
#[test]
fn inline_modules_with_path_alternatives_are_bounded_by_the_module_path_budget() {
let (tree, result) = load_counted(&[("src/lib.rs", &alternatives(40))], 200);
let error = result.expect_err("3^40 walks");
assert!(
matches!(
error.kind,
LoadErrorKind::Budget {
budget: raf_source::Budget::ModulePaths,
..
}
),
"{error}"
);
assert_eq!(error.file.as_str(), "src/lib.rs");
let (shallow, loaded) = load_counted(&[("src/lib.rs", &alternatives(5))], 200);
loaded.expect("shallow case loads");
assert_eq!(tree.count(Op::Open), 1);
assert_eq!(tree.count_at(Op::Open, "src/lib.rs"), 1);
assert_eq!(tree.count(Op::OpenedRead), 1, "{:?}", tree.read_log());
assert!(tree.count(Op::Entry) > 0);
for op in [
Op::Read,
Op::Open,
Op::OpenedRead,
Op::Identity,
Op::List,
Op::Entry,
] {
assert_eq!(tree.count(op), shallow.count(op), "{op:?}");
}
}
fn item_paths(ws: &Workspace) -> Vec<(String, Vec<String>)> {
ws.files()
.map(|f| {
let mut paths: Vec<String> = ws.items_in(&f.path).map(|i| i.path.to_string()).collect();
paths.sort();
(f.path.to_string(), paths)
})
.collect()
}
const MOD_RS_CHILD: [(&str, &str); 3] = [
("src/lib.rs", "pub mod a;\npub fn top() {}\n"),
("src/a/mod.rs", "pub mod b;\npub fn in_a() {}\n"),
("src/a/b.rs", "pub fn in_b() {}\n"),
];
#[test]
fn a_child_file_that_sorts_before_its_mod_rs_parent_is_placed_under_its_own_path() {
let ws = ok(&MOD_RS_CHILD);
assert_eq!(
item_paths(&ws),
files(&[
("src/a/b.rs", &["demo::a::b::in_b"]),
("src/a/mod.rs", &["demo::a::b", "demo::a::in_a"]),
("src/lib.rs", &["demo", "demo::a", "demo::top"]),
])
);
}
#[test]
fn a_flat_module_file_and_its_child_below_a_parent_that_sorts_first_keep_their_own_paths() {
let ws = ok(&[
("src/lib.rs", "pub mod d;\n"),
("src/d/mod.rs", "pub mod a;\npub fn in_d() {}\n"),
("src/d/a.rs", "pub mod b;\npub fn in_a() {}\n"),
("src/d/a/b.rs", "pub fn in_b() {}\n"),
]);
assert_eq!(
item_paths(&ws),
files(&[
("src/d/a.rs", &["demo::d::a::b", "demo::d::a::in_a"]),
("src/d/a/b.rs", &["demo::d::a::b::in_b"]),
("src/d/mod.rs", &["demo::d::a", "demo::d::in_d"]),
("src/lib.rs", &["demo", "demo::d"]),
])
);
}
#[test]
fn a_file_module_declared_inside_an_inline_module_is_placed_under_the_inline_module() {
let ws = ok(&[
("src/lib.rs", "pub mod a {\n pub mod b;\n}\n"),
("src/a/b.rs", "pub fn in_b() {}\n"),
]);
assert_eq!(
item_paths(&ws),
files(&[
("src/a/b.rs", &["demo::a::b::in_b"]),
("src/lib.rs", &["demo", "demo::a", "demo::a::b"]),
])
);
}
#[test]
fn the_children_of_a_path_attribute_file_are_placed_under_its_module_whatever_their_names() {
let children = ["a", "ga", "z"];
let mut placed = Vec::new();
let mut expected = Vec::new();
for child in children {
let child_file = format!("src/gen/{child}.rs");
let parent = format!("pub mod {child};\npub fn in_generated() {{}}\n");
let ws = ok(&[
("src/lib.rs", "#[path = \"gen/generated.rs\"]\npub mod g;\n"),
("src/gen/generated.rs", &parent),
(&child_file, "pub struct Thing;\n"),
]);
let file = ws
.file(&RelPath::new(&child_file).expect("path"))
.expect("loaded");
let modules: Vec<String> = file
.reached
.iter()
.map(|r| r.module_path.to_string())
.collect();
let thing = format!("demo::g::{child}::Thing");
placed.push((
child,
item_paths(&ws),
modules,
ws.resolve(&thing).map(|r| r.path),
));
let mut in_generated = vec![
format!("demo::g::{child}"),
"demo::g::in_generated".to_owned(),
];
in_generated.sort();
let mut files = vec![
(child_file.clone(), vec![thing.clone()]),
("src/gen/generated.rs".to_owned(), in_generated),
(
"src/lib.rs".to_owned(),
vec!["demo".to_owned(), "demo::g".to_owned()],
),
];
files.sort();
expected.push((child, files, vec![format!("demo::g::{child}")], Ok(thing)));
}
assert_eq!(placed, expected);
}
#[test]
fn a_shared_test_module_reached_from_a_target_that_sorts_after_it_keeps_its_own_paths() {
let ws = ok(&[
("src/lib.rs", ""),
(
"tests/zz.rs",
"mod common;\n#[test]\nfn case() {\n common::helper();\n common::a::in_common_a();\n}\n",
),
("tests/common/mod.rs", "pub mod a;\npub fn helper() {}\n"),
("tests/common/a.rs", "pub fn in_common_a() {}\n"),
]);
assert_eq!(
item_paths(&ws),
files(&[
("src/lib.rs", &["demo"]),
(
"tests/common/a.rs",
&["demo::test_crate::zz::common::a::in_common_a"]
),
(
"tests/common/mod.rs",
&[
"demo::test_crate::zz::common::a",
"demo::test_crate::zz::common::helper",
]
),
(
"tests/zz.rs",
&[
"demo::test_crate::zz",
"demo::test_crate::zz::case",
"demo::test_crate::zz::common",
]
),
])
);
assert!(matches!(
ws.resolve("demo::test_crate::zz::common::in_common_a"),
Err(ResolveError::NotFound(_))
));
}
#[test]
fn super_super_from_a_child_that_sorts_before_its_parent_climbs_to_the_crate_root() {
let ws = ok(&[
("src/lib.rs", "pub mod a;\npub fn top() {}\n"),
("src/a/mod.rs", "pub mod b;\npub fn in_a() {}\n"),
(
"src/a/b.rs",
"pub use super::super::top as again;\npub use super::in_a as sibling;\npub fn in_b() {\n super::super::top();\n}\n",
),
]);
assert_eq!(
ws.resolve("demo::a::b::again").map(|r| r.path),
Ok("demo::top".to_owned())
);
assert_eq!(
ws.resolve("demo::a::b::sibling").map(|r| r.path),
Ok("demo::a::in_a".to_owned())
);
}
#[test]
fn an_item_is_found_only_under_its_own_module_path() {
let ws = ok(&MOD_RS_CHILD);
assert_eq!(
ws.resolve("demo::a::b::in_b").map(|r| r.path),
Ok("demo::a::b::in_b".to_owned())
);
for missing in ["demo::a::in_b", "demo::a::b::in_a"] {
assert_eq!(
ws.resolve(missing).map(|r| r.path),
Err(ResolveError::NotFound(missing.to_owned())),
"{missing}"
);
}
}
#[test]
fn a_file_reached_under_two_spellings_is_read_once_and_keeps_the_spelling_that_sorts_first() {
let tree = Counting::new(
[
("Cargo.toml", DEMO),
(
"src/lib.rs",
"#[path = \"z/../b.rs\"]\npub mod first;\n#[path = \"b.rs\"]\npub mod second;\n",
),
("src/b.rs", "pub fn f() {}\n"),
]
.into_iter()
.collect::<MemoryTree>(),
);
let ws = Workspace::load(&tree, &["."]).expect("loads");
assert_eq!(
reached(&ws),
files(&[
("src/b.rs", &["demo::first", "demo::second"]),
("src/lib.rs", &["demo"]),
])
);
assert_eq!(
tree.read_log(),
["Cargo.toml", "src/lib.rs", "src/z/../b.rs"]
);
for path in ["demo::first::f", "demo::second::f"] {
let site = ws.resolve(path).expect("resolves").sites[0];
assert_eq!(
ws.item(site).expect("item").file.as_str(),
"src/b.rs",
"{path}"
);
}
}
#[test]
fn a_non_literal_path_attribute_is_reported_as_such_from_the_attribute() {
for (attribute, predicate) in [
(
"#[path = concat!(\"../../../\", \"outside/plain.rs\")]",
None,
),
(
"#[cfg_attr(unix, path = concat!(\"a\", \".rs\"))]",
Some("unix"),
),
] {
let text = format!("pub fn ok() {{}}\n{attribute}\nmod plain;\n");
let error = load(&[("src/lib.rs", &text), ("src/plain.rs", "")]).expect_err(attribute);
assert!(
matches!(&error.kind, LoadErrorKind::CfgParse { message } if message.contains("`path` is not a string literal") && message.contains("concat")),
"{error}"
);
assert_eq!(error.file.as_str(), "src/lib.rs");
assert_eq!(error.line, Some(2), "{attribute}");
assert_eq!(
error.origin.as_deref(),
Some(&Origin::PathAttr {
module: "plain".to_owned(),
predicate: predicate.map(str::to_owned),
}),
"{error}"
);
let shown = error.to_string();
assert!(
!shown.contains("cfg predicate") && !shown.contains("lib.path"),
"{shown}"
);
assert!(
shown.contains("`path` attribute of module `plain`"),
"{shown}"
);
}
assert!(
load(&[
(
"src/lib.rs",
"pub fn ok() {}\n#[path = \"plain.rs\"]\nmod plain;\n"
),
("src/plain.rs", ""),
])
.is_ok()
);
}
#[test]
fn foreign_module_paths_name_only_attributes_that_leave_their_package() {
const SHARED: &str = "#[path = \"../../q/src/shared.rs\"]\nmod shared;";
let tree: MemoryTree = [
(
"Cargo.toml",
"[package]\nname = \"top\"\nversion = \"0.1.0\"\nedition = \"2024\"\n\
[workspace]\nmembers = [\"p\", \"q\"]\n",
),
(
"p/Cargo.toml",
"[package]\nname = \"p\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
),
(
"p/src/lib.rs",
"#[path = \"own.rs\"]\nmod own;\n\
#[path = \"../../q/src/shared.rs\"]\nmod shared;\n\
#[cfg_attr(feature = \"x\", path = \"../../q/src/cond.rs\")]\nmod cond;\n\
#[path = \"../../src/top.rs\"]\nmod up;\n\
#[path = \"../../q/src/dir\"]\nmod moved { mod child; }\n\
#[path = \"../../q/src/raw.rs\"]\nmod r#type;",
),
("p/src/own.rs", ""),
("p/src/main.rs", SHARED),
("p/tests/t.rs", SHARED),
("p/benches/b.rs", SHARED),
("p/examples/e.rs", SHARED),
(
"src/lib.rs",
"// The root package holds the members.\n#[path = \"../p/src/own.rs\"]\nmod member;",
),
("src/top.rs", ""),
(
"q/Cargo.toml",
"[package]\nname = \"q\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
),
("q/src/lib.rs", "#[path = \"shared.rs\"]\nmod mine;"),
("q/src/shared.rs", ""),
("q/src/cond.rs", ""),
("q/src/raw.rs", ""),
("q/src/dir/child.rs", ""),
]
.into_iter()
.collect();
let ws = Workspace::load(&tree, &["."]).unwrap_or_else(|e| panic!("{e}"));
let name = |id| ws.package(id).expect("package").name.clone();
let mut found: Vec<_> = ws
.foreign_module_paths()
.into_iter()
.map(|foreign| {
let kind = ws.target(foreign.reach.target).expect("target").kind;
(
format!("{}:{}", foreign.site.file, foreign.site.line),
foreign.site.resolved.to_string(),
name(foreign.package),
foreign.owner.map(name),
format!("{kind:?}"),
)
})
.collect();
found.sort();
let row = |at: &str, resolved: &str, owner: Option<&str>, kind: &str| {
(
at.to_owned(),
resolved.to_owned(),
"p".to_owned(),
owner.map(str::to_owned),
kind.to_owned(),
)
};
let mut expected = vec![
row("p/benches/b.rs:2", "q/src/shared.rs", Some("q"), "Bench"),
row("p/examples/e.rs:2", "q/src/shared.rs", Some("q"), "Example"),
row("p/src/lib.rs:4", "q/src/shared.rs", Some("q"), "Lib"),
row("p/src/lib.rs:6", "q/src/cond.rs", Some("q"), "Lib"),
row("p/src/lib.rs:8", "src/top.rs", Some("top"), "Lib"),
row("p/src/lib.rs:10", "q/src/dir/child.rs", Some("q"), "Lib"),
row("p/src/lib.rs:12", "q/src/raw.rs", Some("q"), "Lib"),
row("p/src/main.rs:2", "q/src/shared.rs", Some("q"), "Bin"),
row("p/tests/t.rs:2", "q/src/shared.rs", Some("q"), "Test"),
];
expected.push((
"src/lib.rs:3".to_owned(),
"p/src/own.rs".to_owned(),
"top".to_owned(),
Some("p".to_owned()),
"Lib".to_owned(),
));
expected.sort();
assert_eq!(found, expected);
let raw = ws
.foreign_module_paths()
.into_iter()
.find(|foreign| foreign.site.resolved.as_str() == "q/src/raw.rs")
.expect("the raw module is reported");
assert_eq!(raw.reach.module_path.as_str(), "p::type");
}
#[test]
fn a_module_path_outside_every_package_is_reported_without_an_owner() {
let tree: MemoryTree = [
("Cargo.toml", "[workspace]\nmembers = [\"p\"]\n"),
(
"p/Cargo.toml",
"[package]\nname = \"p\"\nversion = \"0.1.0\"\n",
),
("p/src/lib.rs", "#[path = \"../../loose.rs\"]\nmod loose;"),
("loose.rs", ""),
]
.into_iter()
.collect();
let ws = Workspace::load(&tree, &["."]).unwrap_or_else(|e| panic!("{e}"));
let foreign = ws.foreign_module_paths();
assert_eq!(foreign.len(), 1);
assert_eq!(foreign[0].site.resolved.as_str(), "loose.rs");
assert_eq!(foreign[0].owner, None);
}
fn block_path(parent: &str, name: &str, source: &str, marker: &str) -> String {
let start = source.find(marker).expect("the marker is in the source");
let keyword = source[start..]
.find(&format!("mod {name}"))
.expect("the declaration is in the source");
format!("{parent}::{{{name}@{}}}", start + keyword + 4)
}
#[test]
fn a_path_module_declared_in_a_block_is_followed_and_indexed_apart_from_the_module_scope() {
let lib = "fn run() {\n #[path = \"one.rs\"]\n mod shared;\n}\n\
const _: () = {\n #[path = \"two.rs\"]\n mod shared;\n};\n\
struct S;\nimpl S {\n fn method() {\n let _ = || {\n #[path = \"three.rs\"]\n mod shared;\n };\n }\n}\n";
let ws = ok(&[
("src/lib.rs", lib),
("src/one.rs", "pub fn in_one() {}"),
("src/two.rs", "pub fn in_two() {}"),
("src/three.rs", "pub fn in_three() {}"),
]);
let one = block_path("demo", "shared", lib, "#[path = \"one.rs\"]");
let two = block_path("demo", "shared", lib, "#[path = \"two.rs\"]");
let three = block_path("demo", "shared", lib, "#[path = \"three.rs\"]");
assert_eq!(
reached(&ws),
files(&[
("src/lib.rs", &["demo"]),
("src/one.rs", &[one.as_str()]),
("src/three.rs", &[three.as_str()]),
("src/two.rs", &[two.as_str()]),
])
);
assert_eq!(
item_paths(&ws),
files(&[
(
"src/lib.rs",
&["demo", "demo::S", "demo::S::method", "demo::run"]
),
("src/one.rs", &[format!("{one}::in_one").as_str()]),
("src/three.rs", &[format!("{three}::in_three").as_str()]),
("src/two.rs", &[format!("{two}::in_two").as_str()]),
])
);
}
#[test]
fn a_block_local_path_attribute_is_relative_to_the_declaring_files_directory() {
let a = "pub fn f() {\n #[path = \"x.rs\"]\n mod x;\n}\n";
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/x.rs", "pub fn in_x() {}"),
]);
assert_eq!(
reached(&ws)
.into_iter()
.find(|(path, _)| path == "src/x.rs")
.map(|(_, modules)| modules),
Some(vec![block_path("demo::a", "x", a, "#[path")])
);
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/a/x.rs", "pub fn in_x() {}"),
])
.expect_err("only the file directory counts");
assert!(
matches!(&error.kind, LoadErrorKind::UnresolvedMod { module } if module == "x"),
"{error}"
);
assert_eq!(error.file.as_str(), "src/a.rs");
}
#[test]
fn a_plain_block_local_module_is_found_beside_the_declaring_file_not_in_its_module_directory() {
let a = "pub fn f() {\n mod m;\n}\n";
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/m.rs", "pub fn in_m() {}"),
]);
assert_eq!(
reached(&ws)
.into_iter()
.find(|(path, _)| path == "src/m.rs")
.map(|(_, modules)| modules),
Some(vec![block_path("demo::a", "m", a, "mod m")])
);
assert!(
load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", "mod m;"),
("src/a/m.rs", ""),
])
.is_ok()
);
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/a/m.rs", ""),
])
.expect_err("a block owns no module directory");
assert!(
matches!(&error.kind, LoadErrorKind::UnresolvedMod { module } if module == "m"),
"{error}"
);
assert!(load(&[("src/lib.rs", "fn f() { mod m; }"), ("src/m/mod.rs", ""),]).is_ok());
let both = load(&[
("src/lib.rs", "fn f() { mod m; }"),
("src/m.rs", ""),
("src/m/mod.rs", ""),
])
.expect_err("both files exist");
assert!(
matches!(both.kind, LoadErrorKind::BothModFiles { .. }),
"{both}"
);
}
#[test]
fn an_inline_module_in_a_block_resolves_its_children_without_the_files_module_directory() {
let a = "fn f() {\n mod inner {\n mod q;\n #[path = \"p.rs\"]\n mod p;\n }\n}\n";
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/inner/q.rs", ""),
("src/inner/p.rs", ""),
]);
let inner = block_path("demo::a", "inner", a, "mod inner");
assert_eq!(
reached(&ws)
.into_iter()
.filter(|(path, _)| path.starts_with("src/inner/"))
.collect::<Vec<_>>(),
files(&[
("src/inner/p.rs", &[format!("{inner}::p").as_str()]),
("src/inner/q.rs", &[format!("{inner}::q").as_str()]),
])
);
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/a/inner/q.rs", ""),
("src/inner/p.rs", ""),
])
.expect_err("a block owns no module directory");
assert!(
matches!(&error.kind, LoadErrorKind::UnresolvedMod { module } if module == "q"),
"{error}"
);
}
#[test]
fn a_block_local_module_in_a_test_function_or_constant_is_tagged_test_beside_plain_ones() {
let ws = ok(&[
(
"src/lib.rs",
"#[test]\nfn t() {\n #[path = \"fixture.rs\"]\n mod fixture;\n}\n\
fn plain() {\n #[path = \"data.rs\"]\n mod data;\n \
#[cfg(test)]\n const C: () = {\n #[path = \"gated.rs\"]\n mod gated;\n };\n \
const D: () = {\n #[path = \"plain_const.rs\"]\n mod plain_const;\n };\n}\n",
),
("src/fixture.rs", ""),
("src/data.rs", ""),
("src/gated.rs", ""),
("src/plain_const.rs", ""),
]);
let test_of = |file: &str| {
let loaded = ws.files().find(|f| f.path.as_str() == file).expect("file");
loaded.reached.iter().map(|r| r.test).collect::<Vec<_>>()
};
assert_eq!(test_of("src/fixture.rs"), vec![true]);
assert_eq!(test_of("src/data.rs"), vec![false]);
assert_eq!(test_of("src/gated.rs"), vec![true]);
assert_eq!(test_of("src/plain_const.rs"), vec![false]);
}
#[test]
fn a_block_local_path_that_leaves_its_package_is_reported_beside_one_that_stays() {
let tree: MemoryTree = [
(
"Cargo.toml",
"[workspace]\nmembers = [\"p\", \"q\"]\nresolver = \"3\"\n",
),
(
"p/Cargo.toml",
"[package]\nname = \"p\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
),
(
"p/src/lib.rs",
"fn run() {\n #[path = \"own.rs\"]\n mod own;\n \
#[path = \"../../q/src/shared.rs\"]\n mod shared;\n}\n",
),
("p/src/own.rs", ""),
(
"q/Cargo.toml",
"[package]\nname = \"q\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
),
("q/src/lib.rs", ""),
("q/src/shared.rs", ""),
]
.into_iter()
.collect();
let ws = Workspace::load(&tree, &["."]).unwrap_or_else(|e| panic!("{e}"));
let found: Vec<_> = ws
.foreign_module_paths()
.into_iter()
.map(|foreign| {
(
format!("{}:{}", foreign.site.file, foreign.site.line),
foreign.site.resolved.to_string(),
foreign
.owner
.map(|id| ws.package(id).expect("package").name.clone()),
)
})
.collect();
assert_eq!(
found,
vec![(
"p/src/lib.rs:5".to_owned(),
"q/src/shared.rs".to_owned(),
Some("q".to_owned())
)]
);
}
#[test]
fn the_platform_guard_of_an_item_in_a_block_local_module_is_unknown_beside_a_decided_one() {
let ws = ok(&[
(
"src/lib.rs",
"#[cfg(windows)]\npub fn plain() {}\npub fn run() {\n mod inner {\n pub fn g() {}\n }\n #[path = \"out.rs\"]\n mod out;\n}\n",
),
("src/out.rs", "pub fn in_out() {}"),
]);
let platform =
raf_source::CompilerPlatform::parse("target_os=\"linux\"\ntarget_family=\"unix\"\n")
.expect("a platform");
let guard_of = |suffix: &str| {
let item = ws
.items()
.find(|item| item.path.ends_with(suffix))
.unwrap_or_else(|| panic!("{suffix}"));
ws.test_platform_guard(item.id)
.unwrap_or_else(|e| panic!("{suffix}: {e}"))
.evaluate(&platform)
};
assert_eq!(guard_of("demo::plain"), Some(false));
assert_eq!(guard_of("::g"), None);
assert_eq!(guard_of("::in_out"), None);
}
#[test]
fn test_fns_list_a_test_of_the_module_list_and_not_one_inside_a_block() {
let ws = ok(&[(
"src/lib.rs",
"#[test]\nfn listed() {}\nfn run() {\n mod inner {\n #[test]\n fn hidden() {}\n }\n}\n",
)]);
let names: Vec<String> = ws
.test_fns()
.expect("test functions")
.into_iter()
.map(|test| test.name)
.collect();
assert_eq!(names, vec!["listed".to_owned()]);
}
#[test]
fn a_path_on_an_inline_module_in_a_block_names_a_directory_beside_the_declaring_file() {
let a = "fn f() {\n #[path = \"dir\"]\n mod inner {\n mod q;\n }\n}\n";
let ws = ok(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/dir/q.rs", ""),
]);
let inner = block_path("demo::a", "inner", a, "#[path");
assert_eq!(
reached(&ws)
.into_iter()
.find(|(path, _)| path == "src/dir/q.rs")
.map(|(_, modules)| modules),
Some(vec![format!("{inner}::q")])
);
let error = load(&[
("src/lib.rs", "mod a;"),
("src/a.rs", a),
("src/a/dir/q.rs", ""),
])
.expect_err("the directory is not below the module directory");
assert!(
matches!(&error.kind, LoadErrorKind::UnresolvedMod { module } if module == "q"),
"{error}"
);
}
#[test]
fn a_block_module_keeps_its_path_when_its_body_changes_and_moves_with_an_edit_above() {
let path_of_g = |source: &str| {
let ws = ok(&[("src/lib.rs", source)]);
ws.items()
.map(|item| item.path.to_string())
.find(|path| path.ends_with("::g"))
.expect("the function g is indexed")
};
let before = "fn f() {\n mod inner {\n pub fn g() {}\n }\n}\n";
let body = before.replace("pub fn g() {}", "pub fn added() {}\n pub fn g() {}");
let above = format!("// a comment\n{before}");
assert_eq!(path_of_g(before), path_of_g(&body));
assert_ne!(path_of_g(before), path_of_g(&above));
}