fixed some test

src/facades.rs

@@ -944,8 +944,14 @@ impl QuickJsRuntimeFacade {
     }
 }
 
+#[cfg(test)]
+lazy_static! {
+    static ref INITTED: std::sync::Mutex<bool> = std::sync::Mutex::new(false);
+}
+
 #[cfg(test)]
 pub mod tests {
+
     use crate::facades::QuickJsRuntimeFacade;
     use crate::jsutils::modules::{NativeModuleLoader, ScriptModuleLoader};
     use crate::jsutils::JsError;
@@ -1057,15 +1063,25 @@ pub mod tests {
     }
 
     pub fn init_test_rt() -> QuickJsRuntimeFacade {
-        panic::set_hook(Box::new(|panic_info| {
-            let backtrace = Backtrace::new();
-            println!("thread panic occurred: {panic_info}\nbacktrace: {backtrace:?}");
-            log::error!(
-                "thread panic occurred: {}\nbacktrace: {:?}",
-                panic_info,
-                backtrace
-            );
-        }));
+        {
+            let i_lock = &mut *crate::facades::INITTED.lock().unwrap();
+            if !*i_lock {
+                panic::set_hook(Box::new(|panic_info| {
+                    let backtrace = Backtrace::new();
+                    println!("thread panic occurred: {panic_info}\nbacktrace: {backtrace:?}");
+                    log::error!(
+                        "thread panic occurred: {}\nbacktrace: {:?}",
+                        panic_info,
+                        backtrace
+                    );
+                }));
+
+                simple_logging::log_to_file("./quickjs_runtime.log", log::LevelFilter::max())
+                    .expect("could not init logger");
+
+                *i_lock = true;
+            }
+        }
 
         QuickJsRuntimeFacade::builder()
             .gc_interval(Duration::from_secs(1))

src/quickjs_utils/compile.rs

@@ -192,7 +192,7 @@ pub mod tests {
     use crate::quickjs_utils::primitives;
     use crate::quickjsrealmadapter::QuickJsRealmAdapter;
     use crate::values::JsValueFacade;
-    use backtrace::Backtrace;
+    //use backtrace::Backtrace;
     use futures::executor::block_on;
     use std::panic;
     use std::sync::Arc;
@@ -361,15 +361,15 @@ pub mod tests {
 
     #[test]
     fn test_bytecode_module() {
-        panic::set_hook(Box::new(|panic_info| {
+        /*panic::set_hook(Box::new(|panic_info| {
             let backtrace = Backtrace::new();
             println!("thread panic occurred: {panic_info}\nbacktrace: {backtrace:?}");
             log::error!(
                 "thread panic occurred: {}\nbacktrace: {:?}",
                 panic_info,
                 backtrace
             );
-        }));
+        }));*/
 
         //simple_logging::log_to_file("quickjs_runtime.log", LevelFilter::max())
         //            .expect("could not init logger");

src/quickjs_utils/errors.rs

@@ -144,6 +144,7 @@ pub mod tests {
     use crate::jsutils::{JsError, Script};
     use crate::quickjs_utils::functions;
     use crate::values::{JsValueConvertable, JsValueFacade};
+    //use log::LevelFilter;
     use std::time::Duration;
 
     #[test]
@@ -221,6 +222,8 @@ pub mod tests {
     fn test_ex2() {
         // check if stacktrace is preserved when invoking native methods
 
+        //simple_logging::log_to_stderr(LevelFilter::Info);
+
         let rt = init_test_rt();
         rt.exe_rt_task_in_event_loop(|q_js_rt| {
             let q_ctx = q_js_rt.get_main_realm();
@@ -251,7 +254,12 @@ pub mod tests {
             let func_ref2 = q_ctx
                 .eval(Script::new(
                     "test_ex2.es",
-                    "(function(){\nconsole.log('running f2');\nthrow Error('poof');\n});",
+                    r#"
+                    const f = function(){
+                        throw Error('poof');
+                    };
+                    f
+                    "#,
                 ))
                 .expect("script failed");
 
@@ -265,6 +273,36 @@ pub mod tests {
             }
         });
 
+        let mjsvf = rt
+            .eval_module_sync(
+                None,
+                Script::new(
+                    "test_ex2.es",
+                    r#"
+                                throw Error('poof');
+                                "#,
+                ),
+            )
+            .expect("script compilation failed");
+        match mjsvf {
+            JsValueFacade::JsPromise { cached_promise } => {
+                let pres = cached_promise
+                    .get_promise_result_sync()
+                    .expect("promise timed out");
+                match pres {
+                    Ok(m) => {
+                        log::info!("prom resolved to {}", m.stringify())
+                    }
+                    Err(e) => {
+                        log::info!("prom rejected to {}", e.stringify())
+                    }
+                }
+            }
+            _ => {
+                panic!("not a prom")
+            }
+        }
+
         std::thread::sleep(Duration::from_secs(1));
     }
 }

src/quickjs_utils/typedarrays.rs

@@ -365,7 +365,6 @@ unsafe extern "C" fn free_func(
 
 #[cfg(test)]
 pub mod tests {
-    use crate::builder::QuickJsRuntimeBuilder;
     use crate::jsutils::{JsError, Script};
     use crate::quickjs_utils::typedarrays::{
         detach_array_buffer_buffer_q, get_array_buffer_buffer_copy_q, get_array_buffer_q,
@@ -374,26 +373,15 @@ pub mod tests {
     };
     use crate::values::{JsValueFacade, TypedArrayType};
 
+    use crate::facades::tests::init_test_rt;
     use crate::quickjs_utils::objects::set_property_q;
     use crate::quickjs_utils::{get_global_q, new_undefined_ref};
     use std::thread;
     use std::time::Duration;
 
     #[test]
     fn test_typed() {
-        simple_logging::log_to_stderr(log::LevelFilter::max());
-
-        std::panic::set_hook(Box::new(|panic_info| {
-            let backtrace = backtrace::Backtrace::new();
-            println!("thread panic occurred: {panic_info}\nbacktrace: {backtrace:?}");
-            log::error!(
-                "thread panic occurred: {}\nbacktrace: {:?}",
-                panic_info,
-                backtrace
-            );
-        }));
-
-        let rt = QuickJsRuntimeBuilder::new().build();
+        let rt = init_test_rt();
 
         let res: Result<(), JsError> = rt.exe_rt_task_in_event_loop(|rt| {
             let mut buffer: Vec<u8> = vec![];
@@ -432,19 +420,7 @@ pub mod tests {
 
     #[test]
     fn test_typed2() {
-        simple_logging::log_to_stderr(log::LevelFilter::max());
-
-        std::panic::set_hook(Box::new(|panic_info| {
-            let backtrace = backtrace::Backtrace::new();
-            println!("thread panic occurred: {panic_info}\nbacktrace: {backtrace:?}");
-            log::error!(
-                "thread panic occurred: {}\nbacktrace: {:?}",
-                panic_info,
-                backtrace
-            );
-        }));
-
-        let rt = QuickJsRuntimeBuilder::new().build();
+        let rt = init_test_rt();
 
         let res = rt.loop_realm_sync(None, |_rt, realm| {
             let obj = realm