koto_test_utils 0.16.1

Testing utilities for the Koto programming language
Documentation 
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

use crate::script_instructions;
use koto_bytecode::{CompilerSettings, ModuleLoader};
use koto_runtime::{Result, prelude::*};

/// Runs a script using the provided Vm, optionally checking its output
pub fn run_test_script(
    mut vm: KotoVm,
    script: &str,
    script_path: Option<KString>,
    expected_output: Option<KValue>,
) -> Result<()> {
    let mut loader = ModuleLoader::default();
    let chunk = match loader.compile_script(script, script_path, CompilerSettings::default()) {
        Ok(chunk) => chunk,
        Err(error) => {
            println!("{script}\n");
            return Err(format!("Error while compiling script: {error}").into());
        }
    };

    match vm.run(chunk) {
        Ok(result) => {
            if let Some(expected_output) = expected_output {
                match vm.run_binary_op(BinaryOp::Equal, result.clone(), expected_output.clone()) {
                    Ok(KValue::Bool(true)) => {}
                    Ok(KValue::Bool(false)) => {
                        return Err(format!(
                            "{}\nUnexpected result - expected: {}, result: {}",
                            script_instructions(script, vm.chunk()),
                            vm.value_to_string(&expected_output).unwrap(),
                            vm.value_to_string(&result).unwrap(),
                        )
                        .into());
                    }
                    Ok(other) => {
                        return Err(format!(
                            "{}\nExpected bool from equality comparison, found '{}'",
                            script_instructions(script, vm.chunk()),
                            vm.value_to_string(&other).unwrap()
                        )
                        .into());
                    }
                    Err(e) => {
                        return Err(format!(
                            "{}\nError while comparing output value: ({e})",
                            script_instructions(script, vm.chunk()),
                        )
                        .into());
                    }
                }
            }

            match vm.run_tests(vm.exports().clone()) {
                Ok(_) => Ok(()),
                Err(e) => Err(format!("{}\n {e}", script_instructions(script, vm.chunk())).into()),
            }
        }

        Err(e) => Err(format!(
            "{}\nError while running script: {e}",
            script_instructions(script, vm.chunk())
        )
        .into()),
    }
}