- Bit operators & | ^ ~ << >> and their op= forms (Go precedence),
plus hex, binary and octal literals (0xff, 0b1010, 0o755)
- defer stmt / defer { ... }: runs when the block ends, last first,
also on return, ?, break and continue
- List methods insert, remove, clear, contains, index_of, reverse,
sort and sort_by (stable merge sort)
- rand module: int(a, b), float(), seed(n)
- assert(cond[, msg]) and `rex test`, which runs each test_ function
in its own process
- rex.toml marks a project's top folder: imports count from there
- Docs, formatter, LSP completions and editor grammars updated
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
129 lines
5.3 KiB
Rust
129 lines
5.3 KiB
Rust
//! Tests of `rex fmt`.
|
|
|
|
use rex::fmt::format;
|
|
|
|
fn fmt(src: &str) -> String {
|
|
format(src).unwrap_or_else(|d| panic!("{}", d.render("test.rex", src)))
|
|
}
|
|
|
|
#[test]
|
|
fn fixes_indentation_and_spaces() {
|
|
let messy = "func add( a:int,b :int ):int{\nreturn a+b\n}\n\n\n\nfunc main(){\nvar x=add(1,2)*3 -1\nif x>3{print( \"big\" )}else{print(-x)}\nfor i in 0..10 step 2{ print(i)}\n}\n";
|
|
// line breaks stay where they are: a block written on one line stays on one line
|
|
let want = "func add(a: int, b: int): int {\n return a + b\n}\n\nfunc main() {\n var x = add(1, 2) * 3 - 1\n if x > 3 { print(\"big\") } else { print(-x) }\n for i in 0..10 step 2 { print(i) }\n}\n";
|
|
assert_eq!(fmt(messy), want);
|
|
}
|
|
|
|
#[test]
|
|
fn literals_and_types_stay_tight() {
|
|
let src = "struct P{x,y:float}\nfunc main(){\nvar p=P{x:1.0,y:2.0}\nvar m=map[string,int]{}\nvar n={\"a\":1,\"b\":2}\nvar xs:[]int=[1,2,3]\nvar o:int?=nil\nvar s=Stack[int]{}\nprint(p,m,n,xs,o,s)\n}\n";
|
|
let out = fmt(src);
|
|
// struct bodies are blocks; literals have no inner spaces
|
|
assert!(out.contains("var p = P{x: 1.0, y: 2.0}"), "{out}");
|
|
assert!(out.contains("var m = map[string, int]{}"), "{out}");
|
|
assert!(out.contains("var n = {\"a\": 1, \"b\": 2}"), "{out}");
|
|
assert!(out.contains("var xs: []int = [1, 2, 3]"), "{out}");
|
|
assert!(out.contains("var o: int? = nil"), "{out}");
|
|
assert!(out.contains("var s = Stack[int]{}"), "{out}");
|
|
}
|
|
|
|
#[test]
|
|
fn comments_and_blank_lines_survive() {
|
|
let src = "// top\nfunc main() {\n\n\n var a = 1 // one\n var bbb = 2 // two\n\n // standalone\n print(a, bbb)\n\n}\n";
|
|
let want = "// top\nfunc main() {\n var a = 1 // one\n var bbb = 2 // two\n\n // standalone\n print(a, bbb)\n}\n";
|
|
assert_eq!(fmt(src), want);
|
|
}
|
|
|
|
#[test]
|
|
fn closures_and_continuation_lines() {
|
|
let src = "func main() {\nrun(func() {\nprint(1)\n})\nvar total = 1 +\n2 +\n3\nvar xs = [\n1,\n2,\n]\n}\n";
|
|
let want = "func main() {\n run(func() {\n print(1)\n })\n var total = 1 +\n 2 +\n 3\n var xs = [\n 1,\n 2,\n ]\n}\n";
|
|
assert_eq!(fmt(src), want);
|
|
}
|
|
|
|
#[test]
|
|
fn strings_are_left_alone() {
|
|
let src = "func main() {\nprint(\"a {x+1} b\", 'x', '\\n')\n}\n";
|
|
let out = fmt(src);
|
|
assert!(out.contains("\"a {x+1} b\""), "{out}");
|
|
}
|
|
|
|
#[test]
|
|
fn already_formatted_code_does_not_change() {
|
|
let src = "func main() {\n var s = \"é\"\n for i, c in s {\n match c {\n 'a' => print(i)\n _ => {\n print(-i)\n }\n }\n }\n}\n";
|
|
assert_eq!(fmt(src), src);
|
|
}
|
|
|
|
#[test]
|
|
fn broken_code_is_refused() {
|
|
assert!(format("func main( {").is_err());
|
|
}
|
|
|
|
fn rex_files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
|
|
for e in std::fs::read_dir(dir).unwrap() {
|
|
let p = e.unwrap().path();
|
|
if p.is_dir() {
|
|
rex_files(&p, out);
|
|
} else if p.extension().map_or(false, |x| x == "rex") {
|
|
out.push(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn examples_are_formatted_and_formatting_is_stable() {
|
|
let mut files = Vec::new();
|
|
rex_files(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("examples"), &mut files);
|
|
assert!(files.len() > 30);
|
|
for f in files {
|
|
let src = std::fs::read_to_string(&f).unwrap();
|
|
let once = fmt(&src);
|
|
assert_eq!(once, src, "{} is not formatted (run `rex fmt examples`)", f.display());
|
|
assert_eq!(fmt(&once), once, "formatting {} twice differs", f.display());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn doc_examples_are_stable() {
|
|
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("docs");
|
|
let mut n = 0;
|
|
for e in std::fs::read_dir(dir).unwrap() {
|
|
let p = e.unwrap().path();
|
|
let text = std::fs::read_to_string(&p).unwrap();
|
|
let mut rest = text.as_str();
|
|
while let Some(start) = rest.find("```rex\n") {
|
|
let after = &rest[start + "```rex\n".len()..];
|
|
let end = after.find("```").unwrap();
|
|
let code = &after[..end];
|
|
rest = &after[end + 3..];
|
|
if let Ok(once) = format(code) {
|
|
assert_eq!(once, code, "doc example in {} is not formatted:\n{code}", p.display());
|
|
n += 1;
|
|
}
|
|
}
|
|
}
|
|
assert!(n > 20, "only {n} doc examples were formattable");
|
|
}
|
|
|
|
#[test]
|
|
fn step_as_a_name_and_c_imports() {
|
|
let src = "import \"raylib.h\" { Color,RED }\nimport \"zlib.h\" link \"z\"\n\nfunc step(dt: f32) {}\n\nfunc main() {\n step(1.0)\n for i in 0..10 step 2 { print(i) }\n}\n";
|
|
assert_eq!(
|
|
fmt(src),
|
|
"import \"raylib.h\" { Color, RED }\nimport \"zlib.h\" link \"z\"\n\nfunc step(dt: f32) {}\n\nfunc main() {\n step(1.0)\n for i in 0..10 step 2 { print(i) }\n}\n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn import_paths_going_up_keep_their_dots() {
|
|
let src = "import ...engine.engine\nimport ..side\nimport a.b\n\nfunc main() {\n for i in 0..3 { print(i) }\n}\n";
|
|
assert_eq!(fmt(src), src);
|
|
}
|
|
|
|
#[test]
|
|
fn bit_operators_and_defer() {
|
|
let src = "func main() {\nvar a=0xff&~0b1|1<<4>>2^3\na<<=1\na>>=1\na&=3\na|=4\na^=5\ndefer print(a)\ndefer{\nprint(-a)\n}\n}\n";
|
|
let want = "func main() {\n var a = 0xff & ~0b1 | 1 << 4 >> 2 ^ 3\n a <<= 1\n a >>= 1\n a &= 3\n a |= 4\n a ^= 5\n defer print(a)\n defer {\n print(-a)\n }\n}\n";
|
|
assert_eq!(fmt(src), want);
|
|
}
|