140 lines
3.9 KiB
Rust
140 lines
3.9 KiB
Rust
use std::fs;
|
|
use std::fs::File;
|
|
use std::io::Write;
|
|
use std::path::Path;
|
|
|
|
fn main() {
|
|
let paths = fs::read_dir("src/integration_tests/test_cases/").unwrap();
|
|
let mod_file_path = Path::new("src/integration_tests/mod.rs");
|
|
let mut mod_file = File::create(mod_file_path).unwrap();
|
|
|
|
write!(
|
|
mod_file,
|
|
r#"////////////////////////////
|
|
// Automatically Generated//
|
|
////////////////////////////"#
|
|
)
|
|
.unwrap();
|
|
|
|
for path_opt in paths {
|
|
if let Err(..) = path_opt {
|
|
continue;
|
|
}
|
|
let path = path_opt.unwrap();
|
|
if !path.file_type().unwrap().is_dir() {
|
|
continue;
|
|
}
|
|
|
|
let p = path.path();
|
|
let mut script_path = p.clone();
|
|
script_path.push("script.ses");
|
|
|
|
if !script_path.exists() {
|
|
continue;
|
|
}
|
|
|
|
let script = fs::read_to_string(script_path).unwrap();
|
|
let test_name = p.file_stem().unwrap().to_str().unwrap();
|
|
|
|
writeln!(mod_file, "mod {name};", name = test_name).unwrap();
|
|
|
|
let testfile_path = format!("src/integration_tests/{}.rs", test_name);
|
|
let mut testfile = File::create(Path::new(&testfile_path)).unwrap();
|
|
|
|
write!(
|
|
testfile,
|
|
r#"////////////////////////////
|
|
// Automatically Generated//
|
|
////////////////////////////
|
|
use crate::logger::messages::Message;
|
|
use crate::parsing::lexer::lex;
|
|
use crate::parsing::lexer::lex_tokens::LexToken;
|
|
use crate::parsing::parser::parse;
|
|
use crate::parsing::parser::parsed_statement::ParsedStatement;
|
|
use crate::span::Span;
|
|
|
|
fn ignore_error(_msg: Message, _: Span) {{
|
|
}}
|
|
|
|
fn panic_on_error(msg: Message, _: Span) {{
|
|
std::panic::panic_any(msg.stringify());
|
|
}}"#
|
|
)
|
|
.unwrap();
|
|
write!(
|
|
testfile,
|
|
r#"
|
|
#[test]
|
|
fn integration_{name}() {{
|
|
let script = "{script}";
|
|
let lexed_tokens = lex(script, &mut panic_on_error);
|
|
println!("{{}}", serde_json::to_string(&lexed_tokens).unwrap());
|
|
"#,
|
|
name = test_name,
|
|
script = script.as_str()
|
|
)
|
|
.unwrap();
|
|
|
|
let mut tokens_file_path = p.clone();
|
|
tokens_file_path.push("lex_tokens.json");
|
|
if tokens_file_path.exists() {
|
|
let tokens_json = fs::read_to_string(tokens_file_path).unwrap();
|
|
write!(
|
|
testfile,
|
|
r##" let expected_tokens: Vec<LexToken> =
|
|
serde_json::from_str(r#"{tokens}"#).unwrap();
|
|
assert_eq!(lexed_tokens, expected_tokens);
|
|
"##,
|
|
tokens = tokens_json.as_str()
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
write!(
|
|
testfile,
|
|
r##"
|
|
let parsed_tree = parse(lexed_tokens, &mut panic_on_error);
|
|
println!("{{}}", serde_json::to_string(&parsed_tree).unwrap());
|
|
"##
|
|
)
|
|
.unwrap();
|
|
|
|
let mut parsed_tree_path = p.clone();
|
|
parsed_tree_path.push("parsed_tree.json");
|
|
if parsed_tree_path.exists() {
|
|
let parsed_tree_json = fs::read_to_string(parsed_tree_path).unwrap();
|
|
write!(
|
|
testfile,
|
|
r##" let expected_tree: Box<ParsedStatement> =
|
|
serde_json::from_str(r#"{expected_tree}"#).unwrap();
|
|
assert_eq!(parsed_tree, expected_tree);
|
|
"##,
|
|
expected_tree = parsed_tree_json.as_str()
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
write!(testfile, "}}").unwrap();
|
|
|
|
write!(
|
|
testfile,
|
|
r##"
|
|
// A substring of a script should never panic, even though it might be completely invalid.
|
|
#[test]
|
|
fn integration_{name}_substring() {{
|
|
let mut script = "{script}".to_string();
|
|
for _ in 0..script.len() {{
|
|
script.pop();
|
|
let lexed_tokens = lex(script.as_str(), &mut ignore_error);
|
|
let _parsed_tree = parse(lexed_tokens, &mut ignore_error);
|
|
}}
|
|
|
|
}}
|
|
"##,
|
|
name = test_name,
|
|
script = script
|
|
)
|
|
.unwrap();
|
|
}
|
|
}
|