hush 0.1.0

Hush is a unix shell scripting language based on the Lua programming language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::{
	io,
	path::Path,
	os::unix::ffi::OsStrExt,
};

use serial_test::serial;

use crate::{
	fmt,
	semantic::{self, ErrorsDisplayContext},
	symbol,
	syntax::{self, AnalysisDisplayContext},
	tests,
};
use super::{Runtime, Value, Panic};


fn test_dir<P, F>(path: P, mut check: F) -> io::Result<()>
where
	P: AsRef<Path>,
	F: FnMut(&Result<Value, Panic>) -> bool,
{
	let interner = symbol::Interner::new();
	let args = std::iter::empty::<&str>();
	let mut runtime = Runtime::new(args, interner);

	tests::util::test_dir(
		path,
		move |path, file| {
			let path_symbol = runtime
				.interner_mut()
				.get_or_intern(path.as_os_str().as_bytes());
			let source = syntax::Source::from_reader(path_symbol, file)?;
			let syntactic_analysis = syntax::Analysis::analyze(
				&source,
				runtime.interner_mut()
			);

			if !syntactic_analysis.errors.is_empty() {
				panic!(
					"{}",
					fmt::Show(
						syntactic_analysis,
						AnalysisDisplayContext {
							max_errors: None,
							interner: runtime.interner(),
						}
					)
				);
			}

			let semantic_analysis = semantic::Analyzer::analyze(
				syntactic_analysis.ast,
				runtime.interner_mut()
			);
			let program = match semantic_analysis {
				Ok(program) => program,
				Err(errors) => panic!(
					"{}",
					fmt::Show(
						errors,
						ErrorsDisplayContext {
							max_errors: None,
							interner: runtime.interner(),
						}
					)
				),
			};

			let program = Box::leak(Box::new(program));

			let result = runtime.eval(program);

			if !check(&result) {
				match result {
					Ok(value) => panic!(
						"File {}: expected panic, got {}",
						path.display(),
						fmt::Show(value, runtime.interner())
					),
					Err(panic) => panic!("{}", fmt::Show(panic, runtime.interner())),
				}
			}

			Ok(())
		}
	)
}


// As our garbage collector is not thread safe, we must *not* run the following tests in
// parallel.


#[test]
#[serial]
fn test_positive() -> io::Result<()> {
	test_dir(
		"src/runtime/tests/data/positive",
		Result::is_ok
	)
}


#[test]
#[serial]
fn test_negative() -> io::Result<()> {
	test_dir(
		"src/runtime/tests/data/negative",
		Result::is_err
	)
}


#[test]
#[serial]
fn test_asserts() -> io::Result<()> {
	test_dir(
		"src/runtime/tests/data/negative/asserts",
		|result| matches!(result, Err(Panic::AssertionFailed { .. }))
	)
}