just/src/testing.rs

135 lines
3.1 KiB
Rust
Raw Normal View History

use super::*;
2017-11-16 23:30:08 -08:00
2021-06-08 01:01:27 -07:00
use crate::compiler::Compiler;
use pretty_assertions::assert_eq;
pub(crate) fn compile(text: &str) -> Justfile {
match Compiler::compile(text) {
2017-11-16 23:30:08 -08:00
Ok(justfile) => justfile,
Err(error) => panic!("Expected successful compilation but got error:\n {}", error),
2017-11-16 23:30:08 -08:00
}
}
pub(crate) fn config(args: &[&str]) -> Config {
let mut args = Vec::from(args);
args.insert(0, "just");
let app = Config::app();
let matches = app.get_matches_from_safe(args).unwrap();
Config::from_matches(&matches).unwrap()
}
pub(crate) fn search(config: &Config) -> Search {
let working_directory = config.invocation_directory.clone();
let justfile = working_directory.join("justfile");
Search {
justfile,
working_directory,
}
}
2021-07-03 14:26:59 -07:00
pub(crate) fn tempdir() -> tempfile::TempDir {
tempfile::Builder::new()
.prefix("just-test-tempdir")
.tempdir()
.expect("failed to create temporary directory")
}
macro_rules! analysis_error {
(
name: $name:ident,
input: $input:expr,
offset: $offset:expr,
line: $line:expr,
column: $column:expr,
width: $width:expr,
kind: $kind:expr,
) => {
#[test]
fn $name() {
$crate::testing::analysis_error($input, $offset, $line, $column, $width, $kind);
}
};
2017-11-16 23:30:08 -08:00
}
pub(crate) fn analysis_error(
src: &str,
offset: usize,
line: usize,
column: usize,
length: usize,
kind: CompileErrorKind,
) {
let tokens = Lexer::lex(src).expect("Lexing failed in parse test...");
2021-07-23 20:26:27 -07:00
let ast = Parser::parse(&tokens).expect("Parsing failed in analysis test...");
2021-07-23 20:26:27 -07:00
match Analyzer::analyze(ast) {
Ok(_) => panic!("Analysis unexpectedly succeeded"),
Err(have) => {
let want = CompileError {
token: Token {
kind: have.token.kind,
src,
offset,
line,
column,
length,
},
kind,
};
assert_eq!(have, want);
}
}
}
macro_rules! run_error {
{
name: $name:ident,
src: $src:expr,
args: $args:expr,
error: $error:pat,
check: $check:block $(,)?
} => {
#[test]
fn $name() {
let config = $crate::testing::config(&$args);
let search = $crate::testing::search(&config);
if let Subcommand::Run{ overrides, arguments } = &config.subcommand {
match $crate::compiler::Compiler::compile(&$crate::unindent::unindent($src))
.expect("Expected successful compilation")
.run(
&config,
&search,
&overrides,
&arguments,
).expect_err("Expected runtime error") {
$error => $check
other => {
panic!("Unexpected run error: {:?}", other);
}
}
} else {
panic!("Unexpected subcommand: {:?}", config.subcommand);
}
}
};
}
macro_rules! assert_matches {
($expression:expr, $( $pattern:pat_param )|+ $( if $guard:expr )?) => {
match $expression {
$( $pattern )|+ $( if $guard )? => {}
left => panic!(
"assertion failed: (left ~= right)\n left: `{:?}`\n right: `{}`",
left,
stringify!($($pattern)|+ $(if $guard)?)
),
}
}
}