use super::shapes::{MANIFEST, holder_scan, lookups, prelude};
use crate::meter::charges;
use crate::work::{Tally, Work, measure};
use crate::{
Budget, ExportError, LoadError, LoadErrorKind, LoadOptions, MemoryTree, RelPath, ResolveError,
Workspace,
};
fn tree(lib: &str) -> MemoryTree {
[("Cargo.toml", MANIFEST), ("src/lib.rs", lib)]
.into_iter()
.collect()
}
fn load_with(lib: &str, options: &LoadOptions) -> Result<Workspace, LoadError> {
Workspace::load_with(&tree(lib), &["."], options)
}
fn load(lib: &str, max_work: usize) -> Result<Workspace, LoadError> {
load_with(
lib,
&LoadOptions {
max_work,
..LoadOptions::default()
},
)
}
fn queried(lib: &str, max_query_work: usize) -> Workspace {
load_with(
lib,
&LoadOptions {
max_query_work,
..LoadOptions::default()
},
)
.unwrap_or_else(|error| panic!("loads: {error}"))
}
const ANY: &str = "pub mod g { pub struct A; }\n\
pub mod m { use crate::missing::A; pub use crate::g::*; }\n\
pub mod u { use crate::m::*; use A as B; }\n";
const SURFACE: &str = "pub mod g { pub struct A; }\n\
pub mod x { use other::A; pub use crate::g::*; }\n\
pub mod m { pub use crate::x::*; pub use another::A; }\n\
pub mod a { pub use crate::b::*; }\n\
pub mod b { pub mod c { pub struct X; } }\n\
pub mod u { pub use crate::a::c::*; }\n";
fn checked(ws: &Workspace) -> Tally {
#[cfg(debug_assertions)]
{
let index = ws.index();
let ((), tally) = measure(usize::MAX, || {
index.lookups.built(false);
index.check_settled();
index.lookups.take();
index.lookups.built(true);
});
tally
}
#[cfg(not(debug_assertions))]
{
let _ = ws;
Tally::default()
}
}
fn made(tally: &Tally) -> usize {
tally.get(Work::LookupReads) + tally.get(Work::LookupScans)
}
fn refused_at(error: &LoadError, limit: usize) {
assert!(
matches!(
error.kind,
LoadErrorKind::Budget { budget: Budget::Work, limit: refused } if refused == limit
),
"at {limit}: {error}"
);
}
#[test]
fn the_lookups_of_many_named_imports_through_many_globs_are_charged_and_refused_by_a_small_limit_at_the_first_checkpoint_past_it()
{
for n in [8, 16] {
let lib = lookups(n);
charges::take();
let ws = load(&lib, Budget::Work.limit()).unwrap_or_else(|error| panic!("{n}: {error}"));
let all = charges::take();
let total = ws.usage().work;
assert!(total > 0);
assert_eq!(all.iter().sum::<usize>(), total, "{n}");
assert_eq!(
load(&lib, total).map(|ws| ws.usage().work).ok(),
Some(total)
);
let error = load(&lib, total - 1).expect_err("one step below its work");
refused_at(&error, total - 1);
let limit = total / 10;
charges::take();
let error = load(&lib, limit).expect_err("a small work budget");
refused_at(&error, limit);
assert_eq!(error.file.as_str(), "src/lib.rs");
assert!(
lib.lines()
.nth(error.line.expect("responsible import") - 1)
.is_some_and(|text| text.contains("use ")),
"{error}"
);
let made = charges::take();
let passing = all
.iter()
.scan(0, |sum, charge| {
*sum += charge;
Some(*sum)
})
.position(|sum| sum > limit)
.expect("a charge passes the limit");
assert_eq!(made, all[..=passing], "{n}");
assert!(made.iter().sum::<usize>() < total, "{n}");
}
}
#[test]
fn every_limit_below_the_work_of_the_lookups_shape_is_refused_by_the_work_budget_and_by_nothing_else()
{
let lib = lookups(4);
let total = load(&lib, Budget::Work.limit())
.expect("loads")
.usage()
.work;
for limit in 0..total {
match load(&lib, limit) {
Err(error) => refused_at(&error, limit),
Ok(ws) => panic!("accepted at {limit}, below {}", ws.usage().work),
}
}
assert_eq!(
load(&lib, total).map(|ws| ws.usage().work).ok(),
Some(total)
);
}
#[test]
fn every_glob_read_a_lookup_of_the_load_looks_at_is_charged_once() {
for (shape, lib) in [
("lookups", lookups(8)),
("whether globs bring in", ANY.to_owned()),
] {
let (ws, tally) = measure(usize::MAX, || {
Workspace::load(&tree(&lib), &["."]).unwrap_or_else(|error| panic!("{error}"))
});
let check = checked(&ws);
assert!(
made(&tally) > made(&check),
"{shape}: the load looks names up"
);
assert_eq!(
tally.get(Work::LookupCharges),
made(&tally) - made(&check),
"{shape}"
);
if shape != "lookups" {
assert!(tally.get(Work::AnyLookups) > 0, "{shape}");
}
assert_eq!(ws.index().lookups.get(), 0, "{shape}");
}
}
const QUERIED: &str = "demo::t::X";
const fn query_steps(n: usize) -> usize {
2 * n + 1
}
#[test]
fn a_query_after_the_load_is_charged_its_own_lookup_steps_against_the_limit_of_one_query() {
for n in [8, 16] {
let lib = lookups(n);
let steps = query_steps(n);
let ws = queried(&lib, Budget::Work.limit());
let (answer, tally) = measure(usize::MAX, || ws.resolve(QUERIED));
assert_eq!(
answer.map(|found| found.path).ok(),
Some("demo::d::X".to_owned())
);
assert_eq!(made(&tally), steps, "{n}");
assert_eq!(tally.get(Work::LookupCharges), steps, "{n}");
let ws = queried(&lib, steps);
assert!(ws.usage().work > steps);
for turn in ["first", "second"] {
assert_eq!(
ws.resolve(QUERIED).map(|found| found.path).ok(),
Some("demo::d::X".to_owned()),
"{n}, the {turn} time"
);
}
let ws = queried(&lib, steps - 1);
for turn in ["first", "second"] {
assert_eq!(
ws.resolve(QUERIED),
Err(ResolveError::Budget {
budget: Budget::Work,
limit: steps - 1,
file: RelPath::new("src/lib.rs").expect("a relative path"),
line: Some(3),
}),
"{n}, the {turn} time"
);
}
}
}
#[test]
fn every_limit_below_the_steps_of_a_query_refuses_it_and_the_refusal_comes_before_any_answer() {
let lib = lookups(8);
let steps = query_steps(8);
for limit in 0..steps {
let answer = queried(&lib, limit).resolve(QUERIED);
assert!(
matches!(
answer,
Err(ResolveError::Budget { budget: Budget::Work, limit: refused, .. })
if refused == limit
),
"at {limit}: {answer:?}"
);
}
}
#[test]
fn every_query_counts_the_lookups_of_its_walks_and_of_the_views_it_looks_at_to_find_them() {
let mut scanned = 0;
let mut any = 0;
for (lib, module, path) in [
(holder_scan(8), None, "demo::u0::X0"),
(prelude(8), None, "demo::T0"),
(prelude(8), None, "demo::c1::T0"),
(ANY.to_owned(), Some("demo::u"), "A"),
] {
let ws = queried(&lib, Budget::Work.limit());
let (_, tally) = measure(usize::MAX, || match module {
Some(module) => ws.resolve_from(module, path).map(|_| ()),
None => ws.resolve(path).map(|_| ()),
});
assert!(made(&tally) > 0, "{path}");
assert_eq!(tally.get(Work::LookupCharges), made(&tally), "{path}");
scanned += tally.get(Work::LookupScans);
any += tally.get(Work::AnyLookups);
let ws = queried(&lib, made(&tally) - 1);
let answer = match module {
Some(module) => ws.resolve_from(module, path),
None => ws.resolve(path),
};
assert!(
matches!(answer, Err(ResolveError::Budget { .. })),
"{path}: {answer:?}"
);
}
assert!(scanned > 0 && any > 0, "views {scanned}, whether {any}");
}
#[test]
fn every_way_of_resolving_a_path_is_a_query_with_its_own_limit() {
let ws = queried(&lookups(8), 0);
let package = ws.packages().first().expect("one package").name.clone();
let lib = ws.target_ids().next().expect("the library");
for (way, answer) in [
("resolve", ws.resolve(QUERIED)),
("resolve_in", ws.resolve_in(QUERIED, crate::Namespace::Type)),
(
"resolve_in_package",
ws.resolve_in_package(&package, QUERIED),
),
("resolve_from", ws.resolve_from("demo::t", "self::X")),
(
"resolve_from_in",
ws.resolve_from_in("demo::t", "self::X", crate::Namespace::Type),
),
] {
assert!(
matches!(answer, Err(ResolveError::Budget { limit: 0, .. })),
"{way}: {answer:?}"
);
}
assert!(ws.resolve("demo::d::X").is_ok());
match ws.exported_items(lib) {
Err(ExportError::Budget(error)) => refused_at(&error, 0),
other => panic!("the glob surface must consume query work: {other:?}"),
}
let definitions = queried("pub mod d { pub struct X {} }", 0);
let lib = definitions.target_ids().next().expect("the library");
assert!(definitions.exported_items(lib).is_ok());
}
#[test]
fn the_public_surface_is_one_query_whose_lookups_and_those_of_the_paths_it_resolves_share_its_limit()
{
let steps = 4 + 2 * 3;
let ws = queried(SURFACE, Budget::Work.limit());
let lib = ws.target_ids().next().expect("the library");
let (listed, tally) = measure(usize::MAX, || ws.exported_items(lib).map(|_| ()));
assert!(listed.is_ok());
assert_eq!(tally.get(Work::LookupCharges), steps);
assert_eq!(made(&tally), steps);
assert!(queried(SURFACE, steps).exported_items(lib).is_ok());
match queried(SURFACE, steps - 1).exported_items(lib) {
Err(ExportError::Budget(error)) => refused_at(&error, steps - 1),
other => panic!("{other:?}"),
}
}
#[test]
fn queries_on_other_threads_each_count_from_zero() {
let lib = lookups(8);
let steps = query_steps(8);
let ws = queried(&lib, steps);
let answers: Vec<Result<String, ResolveError>> = std::thread::scope(|scope| {
let ws = &ws;
let workers: Vec<_> = (0..4)
.map(|_| scope.spawn(move || ws.resolve(QUERIED).map(|found| found.path)))
.collect();
workers
.into_iter()
.map(|worker| worker.join().expect("the query runs"))
.collect()
});
assert_eq!(answers, vec![Ok("demo::d::X".to_owned()); 4]);
}