mumu-test 0.1.2

Test suite plugin for the Lava 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
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

use mumu::{
    parser::interpreter::Interpreter,
    parser::types::{FunctionValue, Value},
};
use std::sync::{Arc, Mutex};
use crate::describe_it::{describe_bridge_fn, it_bridge_fn};
use crate::asserts::{expect_equal_bridge_fn, expect_not_equal_bridge_fn, has_key_bridge_fn, prop_equals_bridge_fn};
use crate::expect_error::expect_error_bridge_fn;
use crate::file_asserts::register_file_asserts;
use crate::lorem_file::register_lorem_file;
use crate::unique_filename::register_unique_filename;
use crate::runner::run_all::runner_all_bridge;

#[export_name = "Cargo_lock"]
pub unsafe extern "C" fn cargo_lock(
    interp_ptr: *mut std::ffi::c_void,
    extra_str: *const std::ffi::c_void,
) -> i32 {
    if interp_ptr.is_null() {
        return 1;
    }
    let interp = &mut *(interp_ptr as *mut Interpreter);

    if interp.is_verbose() {
        eprintln!("[test:Cargo.lock] => dynamic plugin init => bridging...");
        if !extra_str.is_null() {
            use std::ffi::CStr;
            let c_str = CStr::from_ptr(extra_str as *const i8);
            eprintln!("[test:Cargo.lock] => extra arg='{}'", c_str.to_string_lossy());
        }
    }

    // Register describe
    let dfn = Arc::new(Mutex::new(describe_bridge_fn));
    interp.register_dynamic_function("describe", dfn);
    interp.set_variable(
        "describe",
        Value::Function(Box::new(FunctionValue::Named("describe".into())))
    );

    // Register it
    let ifn = Arc::new(Mutex::new(it_bridge_fn));
    interp.register_dynamic_function("it", ifn);
    interp.set_variable(
        "it",
        Value::Function(Box::new(FunctionValue::Named("it".into())))
    );

    // Register expect_equal
    let efn = Arc::new(Mutex::new(expect_equal_bridge_fn));
    interp.register_dynamic_function("expect_equal", efn);
    interp.set_variable(
        "expect_equal",
        Value::Function(Box::new(FunctionValue::Named("expect_equal".into())))
    );

    // Register expect_not_equal
    let nefn = Arc::new(Mutex::new(expect_not_equal_bridge_fn));
    interp.register_dynamic_function("expect_not_equal", nefn);
    interp.set_variable(
        "expect_not_equal",
        Value::Function(Box::new(FunctionValue::Named("expect_not_equal".into())))
    );

    // Register has_key
    let has_key_fn = Arc::new(Mutex::new(has_key_bridge_fn));
    interp.register_dynamic_function("has_key", has_key_fn);
    interp.set_variable(
        "has_key",
        Value::Function(Box::new(FunctionValue::Named("has_key".into())))
    );

    // Register prop_equals
    let prop_eq_fn = Arc::new(Mutex::new(prop_equals_bridge_fn));
    interp.register_dynamic_function("prop_equals", prop_eq_fn);
    interp.set_variable(
        "prop_equals",
        Value::Function(Box::new(FunctionValue::Named("prop_equals".into())))
    );

    // Register expect_error
    let ee_fn = Arc::new(Mutex::new(expect_error_bridge_fn));
    interp.register_dynamic_function("test:expect_error", ee_fn);
    interp.set_variable(
        "test:expect_error",
        Value::Function(Box::new(FunctionValue::Named("test:expect_error".into())))
    );

    // Register test:all
    let afn = Arc::new(Mutex::new(runner_all_bridge));
    interp.register_dynamic_function("test:all", afn.clone());
    interp.set_variable(
        "test:all",
        Value::Function(Box::new(FunctionValue::Named("test:all".into())))
    );

    // Register file asserts
    register_file_asserts(interp);

    // Register lorem file
    register_lorem_file(interp);

    // Register unique filename
    register_unique_filename(interp);

    if interp.is_verbose() {
        eprintln!("[test:Cargo.lock] => dynamic plugin init => success");
    }
    0
}