Skip to main content

mumutest/
plugin_entry.rs

1use mumu::{
2    parser::interpreter::Interpreter,
3    parser::types::{FunctionValue, Value},
4};
5use std::sync::{Arc, Mutex};
6use crate::describe_it::{describe_bridge_fn, it_bridge_fn};
7use crate::asserts::{expect_equal_bridge_fn, expect_not_equal_bridge_fn, has_key_bridge_fn, prop_equals_bridge_fn};
8use crate::expect_error::expect_error_bridge_fn;
9use crate::file_asserts::register_file_asserts;
10use crate::lorem_file::register_lorem_file;
11use crate::unique_filename::register_unique_filename;
12use crate::runner::run_all::runner_all_bridge;
13
14#[export_name = "Cargo_lock"]
15pub unsafe extern "C" fn cargo_lock(
16    interp_ptr: *mut std::ffi::c_void,
17    extra_str: *const std::ffi::c_void,
18) -> i32 {
19    if interp_ptr.is_null() {
20        return 1;
21    }
22    let interp = &mut *(interp_ptr as *mut Interpreter);
23
24    if interp.is_verbose() {
25        eprintln!("[test:Cargo.lock] => dynamic plugin init => bridging...");
26        if !extra_str.is_null() {
27            use std::ffi::CStr;
28            let c_str = CStr::from_ptr(extra_str as *const i8);
29            eprintln!("[test:Cargo.lock] => extra arg='{}'", c_str.to_string_lossy());
30        }
31    }
32
33    // Register describe
34    let dfn = Arc::new(Mutex::new(describe_bridge_fn));
35    interp.register_dynamic_function("describe", dfn);
36    interp.set_variable(
37        "describe",
38        Value::Function(Box::new(FunctionValue::Named("describe".into())))
39    );
40
41    // Register it
42    let ifn = Arc::new(Mutex::new(it_bridge_fn));
43    interp.register_dynamic_function("it", ifn);
44    interp.set_variable(
45        "it",
46        Value::Function(Box::new(FunctionValue::Named("it".into())))
47    );
48
49    // Register expect_equal
50    let efn = Arc::new(Mutex::new(expect_equal_bridge_fn));
51    interp.register_dynamic_function("expect_equal", efn);
52    interp.set_variable(
53        "expect_equal",
54        Value::Function(Box::new(FunctionValue::Named("expect_equal".into())))
55    );
56
57    // Register expect_not_equal
58    let nefn = Arc::new(Mutex::new(expect_not_equal_bridge_fn));
59    interp.register_dynamic_function("expect_not_equal", nefn);
60    interp.set_variable(
61        "expect_not_equal",
62        Value::Function(Box::new(FunctionValue::Named("expect_not_equal".into())))
63    );
64
65    // Register has_key
66    let has_key_fn = Arc::new(Mutex::new(has_key_bridge_fn));
67    interp.register_dynamic_function("has_key", has_key_fn);
68    interp.set_variable(
69        "has_key",
70        Value::Function(Box::new(FunctionValue::Named("has_key".into())))
71    );
72
73    // Register prop_equals
74    let prop_eq_fn = Arc::new(Mutex::new(prop_equals_bridge_fn));
75    interp.register_dynamic_function("prop_equals", prop_eq_fn);
76    interp.set_variable(
77        "prop_equals",
78        Value::Function(Box::new(FunctionValue::Named("prop_equals".into())))
79    );
80
81    // Register expect_error
82    let ee_fn = Arc::new(Mutex::new(expect_error_bridge_fn));
83    interp.register_dynamic_function("test:expect_error", ee_fn);
84    interp.set_variable(
85        "test:expect_error",
86        Value::Function(Box::new(FunctionValue::Named("test:expect_error".into())))
87    );
88
89    // Register test:all
90    let afn = Arc::new(Mutex::new(runner_all_bridge));
91    interp.register_dynamic_function("test:all", afn.clone());
92    interp.set_variable(
93        "test:all",
94        Value::Function(Box::new(FunctionValue::Named("test:all".into())))
95    );
96
97    // Register file asserts
98    register_file_asserts(interp);
99
100    // Register lorem file
101    register_lorem_file(interp);
102
103    // Register unique filename
104    register_unique_filename(interp);
105
106    if interp.is_verbose() {
107        eprintln!("[test:Cargo.lock] => dynamic plugin init => success");
108    }
109    0
110}