#![cfg(all(feature = "python", feature = "rhai"))]
use std::collections::HashMap;
use std::fs;
use std::io::{self, Result};
use std::path::{Path, PathBuf};
use postscriptum::{EngineType, ScriptEngine, get_engine};
fn cases_dir() -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/cases")
}
struct TestSuite {
rhai_engine: Box<dyn ScriptEngine>,
python_engine: Box<dyn ScriptEngine>,
}
impl TestSuite {
fn new() -> Self {
TestSuite {
rhai_engine: get_engine(EngineType::Rhai),
python_engine: get_engine(EngineType::Python),
}
}
fn test_both_engines(&mut self, code: &str, expected_result: &str) -> bool {
let rhai_result = self.rhai_engine.eval(code);
let python_result = self.python_engine.eval(code);
match (rhai_result, python_result) {
(Ok(rhai_val), Ok(python_val)) => {
let rhai_trimmed = rhai_val.trim();
let python_trimmed = python_val.trim();
let expected_trimmed = expected_result.trim();
if rhai_trimmed == expected_trimmed && python_trimmed == expected_trimmed {
println!(
"✓ PASS: '{}' - Rhai: '{}', Python: '{}'",
code.replace('\n', " "),
rhai_trimmed,
python_trimmed
);
true
} else {
println!(
"✗ FAIL: '{}' - Expected: '{}', Rhai: '{}', Python: '{}'",
code.replace('\n', " "),
expected_trimmed,
rhai_trimmed,
python_trimmed
);
false
}
}
(Err(rhai_err), Err(python_err)) => {
println!(
"✓ PASS (both failed): '{}' - Rhai: '{}', Python: '{}'",
code.replace('\n', " "),
rhai_err,
python_err
);
true }
(Ok(rhai_val), Err(python_err)) => {
println!(
"✗ FAIL: '{}' - Rhai: '{}', Python: '{}'",
code.replace('\n', " "),
rhai_val,
python_err
);
false
}
(Err(rhai_err), Ok(python_val)) => {
println!(
"✗ FAIL: '{}' - Rhai: '{}', Python: '{}'",
code.replace('\n', " "),
rhai_err,
python_val
);
false
}
}
}
fn test_both_engines_error(&mut self, code: &str) -> bool {
let rhai_result = self.rhai_engine.eval(code);
let python_result = self.python_engine.eval(code);
match (rhai_result, python_result) {
(Err(_), Err(_)) => {
println!("✓ PASS (both engines error): '{}'", code.replace('\n', " "));
true
}
(Ok(rhai_val), Err(_)) => {
println!(
"✗ FAIL: '{}' - Rhai: '{}', Python: error",
code.replace('\n', " "),
rhai_val
);
false
}
(Err(_), Ok(python_val)) => {
println!(
"✗ FAIL: '{}' - Rhai: error, Python: '{}'",
code.replace('\n', " "),
python_val
);
false
}
(Ok(rhai_val), Ok(python_val)) => {
println!(
"✗ FAIL: '{}' - Expected both to error, but Rhai: '{}', Python: '{}'",
code.replace('\n', " "),
rhai_val,
python_val
);
false
}
}
}
fn check_single(
engine: &mut Box<dyn ScriptEngine>,
lang_name: &str,
code: &str,
expected: &str,
) -> bool {
match engine.eval(code) {
Ok(val) => {
if val.trim() == expected.trim() {
println!(
"✓ PASS ({}): '{}' - Got: '{}'",
lang_name,
code.replace('\n', " "),
val.trim()
);
true
} else {
println!(
"✗ FAIL ({}): '{}' - Expected: '{}', Got: '{}'",
lang_name,
code.replace('\n', " "),
expected.trim(),
val.trim()
);
false
}
}
Err(err) => {
println!(
"✗ FAIL ({}): '{}' - Error: '{}'",
lang_name,
code.replace('\n', " "),
err
);
false
}
}
}
}
pub struct TestRunner {
pub engines: HashMap<EngineType, Box<dyn ScriptEngine>>,
}
impl TestRunner {
pub fn new() -> Self {
let mut engines: HashMap<EngineType, Box<dyn ScriptEngine>> = HashMap::new();
engines.insert(EngineType::Rhai, get_engine(EngineType::Rhai));
engines.insert(EngineType::Python, get_engine(EngineType::Python));
TestRunner { engines }
}
}
impl Default for TestRunner {
fn default() -> Self {
Self::new()
}
}
impl TestRunner {
pub fn run_all_tests(&mut self) -> Result<bool> {
println!("Running comprehensive test suite...");
let mut suite = TestSuite::new();
let mut total_passed = 0;
let mut total_tests = 0;
for (passed, count) in [
self.run_basic_arithmetic_tests(&mut suite),
self.run_variables_and_assignments_tests(&mut suite),
self.run_conditionals_tests(&mut suite),
self.run_loops_tests(&mut suite),
self.run_functions_tests(&mut suite),
self.run_string_operations_tests(&mut suite),
self.run_error_handling_tests(&mut suite),
self.run_python_specific_syntax_tests(&mut suite),
self.run_rhai_specific_syntax_tests(&mut suite),
] {
total_passed += passed;
total_tests += count;
}
println!("\n=== INTEGRATED TEST SUITE SUMMARY ===");
println!("Total integrated tests: {}", total_tests);
println!("Passed: {}", total_passed);
println!("Failed: {}", total_tests - total_passed);
println!(
"Success rate: {:.1}%",
(total_passed as f64 / total_tests as f64) * 100.0
);
let integrated_all_passed = total_passed == total_tests;
let file_dirs = fs::read_dir(cases_dir())?;
let mut total_file_tests = 0;
let mut passed_file_tests = 0;
for dir in file_dirs {
let dir = dir?;
if dir.file_type()?.is_dir() {
println!(
"\nRunning file-based tests in: {}",
dir.file_name().to_string_lossy()
);
let (dir_passed, dir_total) = self.run_test_directory(&dir.path())?;
total_file_tests += dir_total;
passed_file_tests += dir_passed;
}
}
println!("\n=== FILE-BASED TEST SUITE SUMMARY ===");
println!("Total file-based tests: {}", total_file_tests);
println!("Passed: {}", passed_file_tests);
println!("Failed: {}", total_file_tests - passed_file_tests);
if total_file_tests > 0 {
println!(
"Success rate: {:.1}%",
(passed_file_tests as f64 / total_file_tests as f64) * 100.0
);
}
let file_all_passed = total_file_tests == 0 || passed_file_tests == total_file_tests;
let overall_total_tests = total_tests + total_file_tests;
let overall_passed_tests = total_passed + passed_file_tests;
println!("\n=== OVERALL SUMMARY ===");
println!("Total tests: {}", overall_total_tests);
println!("Passed: {}", overall_passed_tests);
println!("Failed: {}", overall_total_tests - overall_passed_tests);
if overall_total_tests > 0 {
println!(
"Success rate: {:.1}%",
(overall_passed_tests as f64 / overall_total_tests as f64) * 100.0
);
}
Ok(integrated_all_passed && file_all_passed)
}
fn run_basic_arithmetic_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let tests = vec![
("2 + 2", "4"),
("5 - 3", "2"),
("4 * 5", "20"),
("10 % 3", "1"),
("2 + 3 * 4", "14"), ("(2 + 3) * 4", "20"), ];
for (code, expected) in tests {
total += 1;
if suite.test_both_engines(code, expected) {
passed += 1;
}
}
println!("\nBasic Arithmetic Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_variables_and_assignments_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let rhai_tests = vec![
("let x = 5; x", "5"),
("let a = 10; let b = 20; a + b", "30"),
("let z = 42; z * 2", "84"),
];
for (code, expected) in rhai_tests {
total += 1;
if TestSuite::check_single(&mut suite.rhai_engine, "Rhai", code, expected) {
passed += 1;
}
}
let python_tests = vec![
("x = 5\nx", "5"),
("a = 10\nb = 20\na + b", "30"),
("z = 42\nz * 2", "84"),
];
for (code, expected) in python_tests {
total += 1;
if TestSuite::check_single(&mut suite.python_engine, "Python", code, expected) {
passed += 1;
}
}
println!(
"\nVariables and Assignments Tests: {}/{} passed",
passed, total
);
(passed, total)
}
fn run_conditionals_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let rhai_tests = vec![
("if true { 1 } else { 0 }", "1"),
("if false { 1 } else { 0 }", "0"),
("let x = 5; if x > 3 { 10 } else { 20 }", "10"),
("let y = 2; if y > 3 { 10 } else { 20 }", "20"),
];
for (code, expected) in rhai_tests {
total += 1;
if TestSuite::check_single(&mut suite.rhai_engine, "Rhai", code, expected) {
passed += 1;
}
}
let python_tests = vec![
("1 if True else 0", "1"),
("0 if False else 1", "1"),
("10 if 5 > 3 else 20", "10"),
("10 if 2 > 3 else 20", "20"),
];
for (code, expected) in python_tests {
total += 1;
if TestSuite::check_single(&mut suite.python_engine, "Python", code, expected) {
passed += 1;
}
}
println!("\nConditionals Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_loops_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let rhai_tests = vec![(
"let sum = 0; let i = 0; while i < 3 { sum = sum + 1; i = i + 1; } sum",
"3",
)];
for (code, expected) in rhai_tests {
total += 1;
if TestSuite::check_single(&mut suite.rhai_engine, "Rhai", code, expected) {
passed += 1;
}
}
let python_tests = vec![("total = 0\nfor i in range(3):\n total += 1\ntotal", "3")];
for (code, expected) in python_tests {
total += 1;
if TestSuite::check_single(&mut suite.python_engine, "Python", code, expected) {
passed += 1;
}
}
println!("\nLoops Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_functions_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let rhai_tests = vec![
("fn add(x, y) { x + y } add(3, 4)", "7"),
("fn square(x) { x * x } square(5)", "25"),
];
for (code, expected) in rhai_tests {
total += 1;
if TestSuite::check_single(&mut suite.rhai_engine, "Rhai", code, expected) {
passed += 1;
}
}
let python_tests = vec![
("(lambda x, y: x + y)(3, 4)", "7"),
("def square(n):\n return n * n\nsquare(5)", "25"),
];
for (code, expected) in python_tests {
total += 1;
if TestSuite::check_single(&mut suite.python_engine, "Python", code, expected) {
passed += 1;
}
}
println!("\nFunctions Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_string_operations_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let rhai_tests = vec![
("\"Hello\" + \" \" + \"World\"", "Hello World"),
("\"Test\" + \"123\"", "Test123"),
];
for (code, expected) in rhai_tests {
total += 1;
if suite.test_both_engines(code, expected) {
passed += 1;
}
}
println!("\nString Operations Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_error_handling_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let error_tests = vec![
"undefined_variable", ];
for code in error_tests {
total += 1;
if suite.test_both_engines_error(code) {
passed += 1;
}
}
println!("\nError Handling Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_python_specific_syntax_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let python_tests = vec![
("2 + 2", "4"),
("5 - 3", "2"),
("4 * 5", "20"),
("15 // 3", "5"), ("10 % 3", "1"), ("2 ** 3", "8"), ("\"Hello\" + \" \" + \"World\"", "Hello World"),
("len([1, 2, 3])", "3"),
("[1, 2, 3][0]", "1"),
];
for (code, expected) in python_tests {
total += 1;
let python_result = suite.python_engine.eval(code);
match python_result {
Ok(python_val) => {
if python_val.trim() == expected.trim() {
println!(
"✓ PASS (Python): '{}' - Python: '{}'",
code.replace('\n', " "),
python_val.trim()
);
passed += 1;
} else {
println!(
"✗ FAIL (Python): '{}' - Expected: '{}', Python: '{}'",
code.replace('\n', " "),
expected.trim(),
python_val.trim()
);
}
}
Err(err) => {
println!(
"✗ FAIL (Python): '{}' - Error: '{}'",
code.replace('\n', " "),
err
);
}
}
}
println!(
"\nPython-Specific Syntax Tests: {}/{} passed",
passed, total
);
(passed, total)
}
fn run_rhai_specific_syntax_tests(&mut self, suite: &mut TestSuite) -> (usize, usize) {
let mut passed = 0;
let mut total = 0;
let rhai_tests = vec![
("2 + 2", "4"),
("5 - 3", "2"),
("4 * 5", "20"),
("15 / 3", "5"),
("10 % 3", "1"),
("2 ** 3", "8"), ("\"Hello\" + \" \" + \"World\"", "Hello World"),
("let arr = [1, 2, 3]; arr.len()", "3"), ("let arr = [1, 2, 3]; arr[0]", "1"),
("fn add(x, y) { x + y } add(3, 4)", "7"),
("let x = 5; if x > 3 { 10 } else { 20 }", "10"),
(
"let sum = 0; let i = 0; while i < 3 { sum = sum + 1; i = i + 1; } sum",
"3",
),
("let s = \"test\"; s.len()", "4"), ];
for (code, expected) in rhai_tests {
total += 1;
let rhai_result = suite.rhai_engine.eval(code);
match rhai_result {
Ok(rhai_val) => {
if rhai_val.trim() == expected.trim() {
println!(
"✓ PASS (Rhai): '{}' - Rhai: '{}'",
code.replace('\n', " "),
rhai_val.trim()
);
passed += 1;
} else {
println!(
"✗ FAIL (Rhai): '{}' - Expected: '{}', Rhai: '{}'",
code.replace('\n', " "),
expected.trim(),
rhai_val.trim()
);
}
}
Err(err) => {
println!(
"✗ FAIL (Rhai): '{}' - Error: '{}'",
code.replace('\n', " "),
err
);
}
}
}
println!("\nRhai-Specific Syntax Tests: {}/{} passed", passed, total);
(passed, total)
}
fn run_test_directory(&mut self, dir_path: &Path) -> Result<(usize, usize)> {
let mut total_tests = 0;
let mut passed_tests = 0;
let mut test_files: HashMap<String, HashMap<EngineType, String>> = HashMap::new();
for entry in fs::read_dir(dir_path)? {
let entry = entry?;
let file_path = entry.path();
if file_path.is_file() {
if let Some(file_name) = file_path.file_name().and_then(|n| n.to_str()) {
if let Some((test_name, ext)) = file_name.rsplit_once('.') {
let lang = match ext {
"rhai" => EngineType::Rhai,
"py" | "python" => EngineType::Python,
_ => continue, };
test_files
.entry(test_name.to_string())
.or_default()
.insert(lang, file_path.to_string_lossy().to_string());
}
}
}
}
for (test_name, file_paths) in test_files {
let test_result = self.run_single_test(&test_name, &file_paths)?;
total_tests += 1;
if test_result {
passed_tests += 1;
}
}
Ok((passed_tests, total_tests))
}
fn run_single_test(
&mut self,
test_name: &str,
file_paths: &HashMap<EngineType, String>,
) -> Result<bool> {
let mut all_passed = true;
for (language, file_path) in file_paths {
let lang_name = match language {
EngineType::Rhai => "Rhai",
EngineType::Python => "Python",
};
let expected_path = Path::new(file_path).with_extension("expected");
let expected = match fs::read_to_string(&expected_path) {
Ok(contents) => contents,
Err(e) => {
println!(
"✗ FAIL ({}): {} - Missing expectation file {} ({})",
lang_name,
test_name,
expected_path.display(),
e
);
all_passed = false;
continue;
}
};
match fs::read_to_string(file_path) {
Ok(code) => match self.engines.get_mut(language) {
Some(engine) => match engine.as_mut().eval(&code) {
Ok(result) => {
if result.trim() == expected.trim() {
println!(
"✓ PASS ({}): {} - Result: {}",
lang_name,
test_name,
result.trim()
);
} else {
println!(
"✗ FAIL ({}): {} - Expected: '{}', Got: '{}'",
lang_name,
test_name,
expected.trim(),
result.trim()
);
all_passed = false;
}
}
Err(e) => {
println!("✗ FAIL ({}): {} - Error: {}", lang_name, test_name, e);
all_passed = false;
}
},
None => {
println!("⚠ SKIP: {} - No engine for {:?}", test_name, language);
}
},
Err(e) => {
println!("✗ ERROR: Could not read test file {} - {}", file_path, e);
all_passed = false;
}
}
}
Ok(all_passed)
}
pub fn run_specific_test(&mut self, test_category: &str, test_name: &str) -> Result<bool> {
let dir_path = cases_dir().join(test_category);
if !dir_path.exists() {
println!("Test directory {} does not exist", test_category);
return Ok(false);
}
let mut test_files: HashMap<EngineType, String> = HashMap::new();
for entry in fs::read_dir(&dir_path)? {
let entry = entry?;
let file_path = entry.path();
if !file_path.is_file() {
return Ok(false);
}
let file_name = match file_path.file_name() {
Some(name) => name
.to_str()
.ok_or(io::Error::other("can't convert file path to file name"))?,
None => return Ok(false),
};
if !file_name.starts_with(test_name) {
return Ok(false);
}
if let Some((name, ext)) = file_name.rsplit_once('.') {
if name == test_name {
let lang = match ext {
"rhai" => EngineType::Rhai,
"py" | "python" => EngineType::Python,
_ => {
return Err(io::Error::other("unsupported test file extension"));
}
};
test_files.insert(lang, file_path.to_string_lossy().to_string());
}
}
}
self.run_single_test(test_name, &test_files)
}
}
#[test]
fn test_complete_file_based_suite() {
let mut runner = TestRunner::new();
assert!(
runner.run_all_tests().expect("test suite should run"),
"not all engine tests passed"
);
}
#[cfg(test)]
mod function_bundle_tests {
use postscriptum::{FunctionBundle, ScriptEngine, python::PythonEngine, rhai::RhaiEngine};
struct FunctionBundleTestSuite;
impl FunctionBundleTestSuite {
fn new() -> Self {
FunctionBundleTestSuite
}
fn test_python_function_bundle(&mut self) -> bool {
let mut python_bundle = FunctionBundle::new_python();
python_bundle.add_python_fn0::<fn() -> f64, f64>("get_pi", || std::f64::consts::PI);
python_bundle.add_python_fn1::<fn(i64) -> i64, i64, i64>("add_one", |x: i64| x + 1);
python_bundle
.add_python_fn2::<fn(i64, i64) -> i64, i64, i64, i64>("add", |a: i64, b: i64| {
a + b
});
let mut engine = match PythonEngine::with_bundle(&python_bundle) {
Ok(engine) => engine,
Err(_) => {
println!("✗ FAIL: Could not create Python engine with bundle");
return false;
}
};
let result1 = engine.eval("get_pi()");
match result1 {
Ok(val) => {
println!("raw value returned from Python: {val}");
let pi_val = val.trim().parse::<f64>().unwrap_or(0.0);
if (pi_val - std::f64::consts::PI).abs() < 0.0001 {
println!("✓ PASS: Python get_pi() returned correct value");
} else {
println!("✗ FAIL: Python get_pi() returned {}, expected PI", val);
return false;
}
}
Err(e) => {
println!("✗ FAIL: Python get_pi() evaluation failed: {}", e);
return false;
}
}
let result2 = engine.eval("add_one(5)");
match result2 {
Ok(val) => {
if val.trim() == "6" {
println!("✓ PASS: Python add_one(5) returned correct value");
} else {
println!("✗ FAIL: Python add_one(5) returned {}, expected 6", val);
return false;
}
}
Err(e) => {
println!("✗ FAIL: Python add_one(5) evaluation failed: {}", e);
return false;
}
}
let result3 = engine.eval("add(3, 4)");
match result3 {
Ok(val) => {
if val.trim() == "7" {
println!("✓ PASS: Python add(3, 4) returned correct value");
} else {
println!("✗ FAIL: Python add(3, 4) returned {}, expected 7", val);
return false;
}
}
Err(e) => {
println!("✗ FAIL: Python add(3, 4) evaluation failed: {}", e);
return false;
}
}
true
}
fn test_rhai_function_bundle(&mut self) -> bool {
let mut rhai_bundle = FunctionBundle::new_rhai();
rhai_bundle.add_rhai_fn0::<fn() -> f64, f64>("get_e", || std::f64::consts::E);
rhai_bundle.add_rhai_fn1::<fn(i64) -> i64, i64, i64>("double", |x: i64| x * 2);
rhai_bundle.add_rhai_fn2::<fn(i64, i64) -> i64, i64, i64, i64>(
"multiply",
|a: i64, b: i64| a * b,
);
let mut engine = RhaiEngine::with_bundle(&rhai_bundle);
let result1 = engine.eval("get_e()");
match result1 {
Ok(val) => {
let e_val = val.trim().parse::<f64>().unwrap_or(0.0);
if (e_val - std::f64::consts::E).abs() < 0.0001 {
println!("✓ PASS: Rhai get_e() returned correct value");
} else {
println!("✗ FAIL: Rhai get_e() returned {}, expected E", val);
return false;
}
}
Err(e) => {
println!("✗ FAIL: Rhai get_e() evaluation failed: {}", e);
return false;
}
}
let result2 = engine.eval("double(7)");
match result2 {
Ok(val) => {
if val.trim() == "14" {
println!("✓ PASS: Rhai double(7) returned correct value");
} else {
println!("✗ FAIL: Rhai double(7) returned {}, expected 14", val);
return false;
}
}
Err(e) => {
println!("✗ FAIL: Rhai double(7) evaluation failed: {}", e);
return false;
}
}
let result3 = engine.eval("multiply(3, 5)");
match result3 {
Ok(val) => {
if val.trim() == "15" {
println!("✓ PASS: Rhai multiply(3, 5) returned correct value");
} else {
println!("✗ FAIL: Rhai multiply(3, 5) returned {}, expected 15", val);
return false;
}
}
Err(e) => {
println!("✗ FAIL: Rhai multiply(3, 5) evaluation failed: {}", e);
return false;
}
}
true
}
fn run_tests(&mut self) -> bool {
println!("\nRunning Function Bundle Tests...");
let mut all_passed = true;
let mut total = 0;
let mut passed = 0;
total += 1;
if self.test_python_function_bundle() {
passed += 1;
} else {
all_passed = false;
}
total += 1;
if self.test_rhai_function_bundle() {
passed += 1;
} else {
all_passed = false;
}
println!("\nFunction Bundle Tests: {}/{} passed", passed, total);
println!(
"Success rate: {:.1}%",
(passed as f64 / total as f64) * 100.0
);
all_passed
}
}
#[test]
fn test_function_bundles_comprehensive() {
let mut suite = FunctionBundleTestSuite::new();
assert!(suite.run_tests(), "Not all function bundle tests passed");
}
#[test]
fn test_simple_python_functions() {
let mut python_bundle = FunctionBundle::new_python();
python_bundle.add_python_fn0::<fn() -> i32, i32>("get_number", || 42);
python_bundle.add_python_fn1::<fn(i64) -> i64, i64, i64>("square", |x: i64| x * x);
python_bundle.add_python_fn2::<fn(f64, f64) -> f64, f64, f64, f64>(
"power",
|base: f64, exp: f64| base.powf(exp),
);
let mut engine = PythonEngine::with_bundle(&python_bundle).unwrap();
match engine.eval("get_number()") {
Ok(result) => assert_eq!(result.trim(), "42"),
Err(e) => panic!("Failed to evaluate get_number(): {}", e),
}
match engine.eval("square(5)") {
Ok(result) => assert_eq!(result.trim(), "25"),
Err(e) => panic!("Failed to evaluate square(5): {}", e),
}
match engine.eval("power(2.0, 3.0)") {
Ok(result) => {
let power_result = result.trim().parse::<f64>().unwrap_or(0.0);
assert!((power_result - 8.0).abs() < 0.0001);
}
Err(e) => panic!("Failed to evaluate power(2.0, 3.0): {}", e),
}
}
#[test]
fn test_simple_rhai_functions() {
let mut rhai_bundle = FunctionBundle::new_rhai();
rhai_bundle.add_rhai_fn0::<fn() -> i64, i64>("get_answer", || 42);
rhai_bundle.add_rhai_fn1::<fn(i64) -> i64, i64, i64>("increment", |x: i64| x + 1);
rhai_bundle
.add_rhai_fn2::<fn(i64, i64) -> i64, i64, i64, i64>("modulo", |a: i64, b: i64| a % b);
let mut engine = RhaiEngine::with_bundle(&rhai_bundle);
assert_eq!(engine.eval("get_answer()").unwrap().trim(), "42");
assert_eq!(engine.eval("increment(99)").unwrap().trim(), "100");
assert_eq!(engine.eval("modulo(10, 3)").unwrap().trim(), "1");
}
}
#[cfg(test)]
mod tests {
use super::*;
use postscriptum::EngineType;
#[test]
fn test_runner_basic_functionality() {
let runner = TestRunner::new();
assert!(runner.engines.contains_key(&EngineType::Rhai));
assert!(runner.engines.contains_key(&EngineType::Python));
}
#[test]
fn test_run_arithmetic_tests() {
let runner = TestRunner::new();
assert!(runner.engines.contains_key(&EngineType::Rhai));
assert!(runner.engines.contains_key(&EngineType::Python));
}
#[test]
fn test_counter_repro() {
use postscriptum::{FunctionBundle, python::PythonEngine};
let mut python_bundle = FunctionBundle::new_python();
python_bundle.add_python_fn0::<fn() -> f64, f64>("get_pi", || std::f64::consts::PI);
python_bundle.add_python_fn1::<fn(i64) -> i64, i64, i64>("plusone", |x: i64| x + 1);
let mut python_engine = PythonEngine::with_bundle(&python_bundle).unwrap();
assert_eq!(
python_engine.eval("counter = 1\ncounter").unwrap().trim(),
"1"
);
for (i, expected) in ["2", "3", "4", "5", "6", "7"].iter().enumerate() {
let got = python_engine.eval("counter += 1\ncounter").unwrap();
assert_eq!(got.trim(), *expected, "incr {i} should be {expected}");
}
}
#[test]
fn test_context_preservation_rhai() {
use postscriptum::rhai::RhaiEngine;
let mut rhai_engine = RhaiEngine::new();
let result1 = rhai_engine.eval("let a = 5; a").unwrap();
assert_eq!(result1, "5");
let result2 = rhai_engine.eval("a = a + 1; a").unwrap();
assert_eq!(result2, "6");
let result3 = rhai_engine.eval("a * 2").unwrap();
assert_eq!(result3, "12");
}
#[test]
fn test_context_preservation_python() {
use postscriptum::python::PythonEngine;
let mut python_engine = PythonEngine::new();
let result1 = python_engine.eval("a = 5\na").unwrap();
assert_eq!(result1, "5");
let result2 = python_engine.eval("a = a + 1\na").unwrap();
assert_eq!(result2, "6");
let result3 = python_engine.eval("a * 2").unwrap();
assert_eq!(result3, "12");
}
#[test]
fn test_python_globals_identity() {
use postscriptum::python::PythonEngine;
let mut engine = PythonEngine::new();
let result = engine.eval("globals() is locals()").unwrap();
assert_eq!(
result.trim(),
"True",
"globals() and locals() should be identical"
);
}
#[test]
fn test_python_variable_visible_in_later_function() {
use postscriptum::python::PythonEngine;
let mut engine = PythonEngine::new();
let r1 = engine.eval("x = 42\nx").unwrap();
assert_eq!(r1.trim(), "42");
let r2 = engine.eval("def get_x():\n return x\n").unwrap();
assert_eq!(r2.trim(), "Executed successfully");
let r3 = engine.eval("get_x()").unwrap();
assert_eq!(
r3.trim(),
"42",
"function defined in a later eval must see variables from prior evals"
);
}
#[test]
fn test_python_function_modifies_global_variable() {
use postscriptum::python::PythonEngine;
let mut engine = PythonEngine::new();
engine.eval("counter = 0\ncounter").unwrap();
engine
.eval("def bump():\n global counter\n counter += 1\n return counter\n")
.unwrap();
for expected in 1..=5 {
let r = engine.eval("bump()").unwrap();
assert_eq!(r.trim(), expected.to_string(), "bump() call #{expected}");
}
}
#[test]
fn test_python_globals_dict_persists_across_evals() {
use postscriptum::python::PythonEngine;
let mut engine = PythonEngine::new();
engine.eval("globals()['g'] = 99").unwrap();
let r = engine.eval("globals()['g']").unwrap();
assert_eq!(r.trim(), "99", "value stored in globals() must persist");
}
#[test]
fn test_python_class_sees_module_variables() {
use postscriptum::python::PythonEngine;
let mut engine = PythonEngine::new();
engine.eval("MAX_SIZE = 100").unwrap();
engine
.eval("class Container:\n def capacity(self):\n return MAX_SIZE\n")
.unwrap();
let r = engine.eval("Container().capacity()").unwrap();
assert_eq!(
r.trim(),
"100",
"class method must see module-level variables"
);
}
#[test]
fn test_python_nested_function_scope_chain() {
use postscriptum::python::PythonEngine;
let mut engine = PythonEngine::new();
engine.eval("outer = 'hello'").unwrap();
engine
.eval("def make_closure():\n def inner():\n return outer\n return inner\n")
.unwrap();
let r = engine.eval("make_closure()()").unwrap();
assert_eq!(
r.trim(),
"hello",
"nested closure must resolve enclosing module variable"
);
}
}