use super::{guard_nesting, parse_faces};
const PAST_THE_STACK: usize = 60_000;
fn refused(case: &str, source: &str) {
match parse_faces(source) {
Ok(faces) => panic!(
"{case}: expected a syntax error, but parsed {} faces",
faces.len()
),
Err(error) => assert!(
error.to_string().contains("nest"),
"{case}: the refusal must explain itself: {error}"
),
}
}
#[test]
fn deeply_nested_parentheses_are_refused() {
let source = format!(
"const X: u8 = {}1{};",
"(".repeat(PAST_THE_STACK),
")".repeat(PAST_THE_STACK)
);
refused("balanced parentheses", &source);
}
#[test]
fn an_unclosed_run_of_parentheses_is_refused() {
let source = "(".repeat(PAST_THE_STACK);
assert!(
parse_faces(&source).is_err(),
"an unterminated group must be an error, not a parse"
);
}
#[test]
fn deeply_nested_braces_are_refused() {
let source = format!(
"fn f() {}{}",
"{".repeat(PAST_THE_STACK / 3),
"}".repeat(PAST_THE_STACK / 3)
);
refused("nested blocks", &source);
}
#[test]
fn deeply_nested_angle_brackets_are_refused() {
let source = format!(
"pub struct S(pub {}u8{});",
"Vec<".repeat(PAST_THE_STACK / 2),
">".repeat(PAST_THE_STACK / 2)
);
refused("nested generic arguments", &source);
}
#[test]
fn a_long_unary_reference_chain_is_refused() {
let source = format!("pub struct S(pub {}u8);", "&".repeat(PAST_THE_STACK));
refused("unary references", &source);
}
#[test]
fn a_long_mutable_reference_chain_is_refused() {
let source = format!("pub struct S(pub {}u8);", "&mut ".repeat(PAST_THE_STACK));
refused("mutable references", &source);
}
#[test]
fn a_long_lifetime_reference_chain_is_refused() {
let source = format!("pub struct S<'a>(pub {}u8);", "&'a ".repeat(PAST_THE_STACK));
refused("lifetime references", &source);
}
#[test]
fn a_long_dereference_chain_is_refused() {
let source = format!("pub const X: () = {}&true;", "*".repeat(PAST_THE_STACK));
refused("dereferences", &source);
}
#[test]
fn a_long_negation_chain_is_refused() {
let source = format!("pub const X: i32 = {}1;", "-".repeat(PAST_THE_STACK));
refused("negations", &source);
}
#[test]
fn a_long_not_chain_is_refused() {
let source = format!("pub const X: bool = {}true;", "!".repeat(PAST_THE_STACK));
refused("not-operators", &source);
}
#[test]
fn a_long_closure_chain_is_refused() {
let source = format!("pub const X: () = {}1;", "|| ".repeat(PAST_THE_STACK / 2));
refused("closures", &source);
}
#[test]
fn a_long_binary_addition_chain_is_refused() {
let source = format!("pub const X: u32 = {}1;", "1 + ".repeat(PAST_THE_STACK));
refused("binary chains", &source);
}
#[test]
fn the_refusal_names_the_limit_that_applies() {
let delimiters = format!("const X: u8 = {}1{};", "(".repeat(300), ")".repeat(300));
let error = parse_faces(&delimiters)
.expect_err("nesting is refused")
.to_string();
assert!(error.contains("limit of 128"), "{error}");
let run = format!("pub const X: u8 = {}1;", "&".repeat(2000));
let error = parse_faces(&run)
.expect_err("nesting is refused")
.to_string();
assert!(
error.contains("limit of 1024"),
"a linear run is measured against its own limit: {error}"
);
let arguments = format!(
"pub struct S(pub X{}u8{});",
"<u8, X".repeat(200),
">".repeat(200)
);
let error = guard_nesting(&arguments)
.expect_err("nesting is refused")
.to_string();
assert!(
error.contains("limit of 128") && error.contains("generic arguments"),
"a comma-separated generic chain is measured on its brackets: {error}"
);
}
#[test]
fn an_arrow_cancelled_chain_is_refused() {
let source = format!("type T = {}T{};", "X<fn() -> ".repeat(95), ">".repeat(95));
let error = guard_nesting(&source)
.expect_err("an arrow's `>` must not cancel the depth it sits inside")
.to_string();
assert!(error.contains("generic arguments"), "{error}");
}
#[test]
fn an_arrow_dense_chain_is_refused() {
let source = format!(
"type T = {}T{};",
"X<fn() -> fn() -> fn() -> fn() -> ".repeat(45),
">".repeat(45)
);
let error = guard_nesting(&source)
.expect_err("a `fn`-heavy level weighs more than one")
.to_string();
assert!(error.contains("generic arguments"), "{error}");
}
#[test]
fn comparisons_are_not_generic_nesting() {
let source: String = (0..129)
.map(|index| format!("fn f{index}() {{ let _ = 1 < 2; }}\n"))
.collect();
guard_nesting(&source).expect("a `<` comparison opens no generic level");
}
#[test]
fn a_documentation_block_is_not_a_run() {
let source: String = (0..3000)
.map(|index| format!("//! line {index} of a module header\n"))
.collect();
guard_nesting(&source).expect("a doc block is metadata, not a linear run");
}
#[test]
fn an_attribute_does_not_hide_a_real_run() {
let source = format!("#[allow(unused)]\n{};\n", "1 + ".repeat(2000) + "1");
let error = guard_nesting(&source)
.expect_err("2000 operators are still a run")
.to_string();
assert!(error.contains("above the limit of"), "{error}");
}