more test work

veilid-core/src/tests/android/mod.rs

@@ -0,0 +1,58 @@
+use crate::*;
+use backtrace::Backtrace;
+use jni::{
+    objects::GlobalRef, objects::JClass, objects::JObject, objects::JString, JNIEnv, JavaVM,
+};
+use lazy_static::*;
+use std::panic;
+use tracing::*;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::*;
+
+#[no_mangle]
+#[allow(non_snake_case)]
+pub extern "system" fn Java_com_veilid_veilid_1core_1android_1tests_MainActivity_run_1tests(
+    env: JNIEnv,
+    _class: JClass,
+    ctx: JObject,
+) {
+    crate::intf::utils::android::veilid_core_setup_android_tests(env, ctx);
+    run_all_tests();
+}
+
+pub fn veilid_core_setup_android_tests(env: JNIEnv, ctx: JObject) {
+    // Set up subscriber and layers
+    use tracing_subscriber::{filter, fmt, prelude::*};
+    let filter = VeilidLayerFilter::new(VeilidConfigLogLevel::Trace, None);
+    let layer = tracing_android::layer("veilid-core").expect("failed to set up android logging");
+    tracing_subscriber::registry()
+        .with(filters)
+        .with(fmt_layer)
+        .init();
+
+    // Set up panic hook for backtraces
+    panic::set_hook(Box::new(|panic_info| {
+        let bt = Backtrace::new();
+        if let Some(location) = panic_info.location() {
+            error!(
+                "panic occurred in file '{}' at line {}",
+                location.file(),
+                location.line(),
+            );
+        } else {
+            error!("panic occurred but can't get location information...");
+        }
+        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
+            error!("panic payload: {:?}", s);
+        } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
+            error!("panic payload: {:?}", s);
+        } else if let Some(a) = panic_info.payload().downcast_ref::<std::fmt::Arguments>() {
+            error!("panic payload: {:?}", a);
+        } else {
+            error!("no panic payload");
+        }
+        error!("Backtrace:\n{:?}", bt);
+    }));
+
+    veilid_core_setup_android(env, ctx);
+}

veilid-core/src/tests/android/veilid_core_android_tests/app/build.gradle

@@ -60,10 +60,10 @@ dependencies {
 apply plugin: 'org.mozilla.rust-android-gradle.rust-android'
 
 cargo {
-    module  = "../../../../"
+    module  = "../../../../../"
     libname = "veilid_core"
     targets = ["arm", "arm64", "x86", "x86_64"]
-    targetDirectory = "../../../../../target"
+    targetDirectory = "../../../../../../target"
     prebuiltToolchains = true
     profile = gradle.startParameter.taskNames.any{it.toLowerCase().contains("debug")} ? "debug" : "release"
     pythonCommand = "python3"

veilid-core/src/tests/ios/mod.rs

@@ -0,0 +1,45 @@
+use crate::*;
+use backtrace::Backtrace;
+use std::panic;
+
+#[no_mangle]
+#[allow(dead_code)]
+pub extern "C" fn run_veilid_core_tests() {
+    veilid_core_setup_ios_tests();
+    run_all_tests();
+}
+
+pub fn veilid_core_setup_ios_tests() {
+    // Set up subscriber and layers
+    use tracing_subscriber::{filter, fmt, prelude::*};
+    let filter = VeilidLayerFilter::new(VeilidConfigLogLevel::Trace, None);
+    let fmt_layer = fmt::layer();
+    let layer = tracing_android::layer("veilid-core").expect("failed to set up android logging");
+    tracing_subscriber::registry()
+        .with(filters)
+        .with(fmt_layer)
+        .init();
+
+    panic::set_hook(Box::new(|panic_info| {
+        let bt = Backtrace::new();
+        if let Some(location) = panic_info.location() {
+            error!(
+                "panic occurred in file '{}' at line {}",
+                location.file(),
+                location.line(),
+            );
+        } else {
+            error!("panic occurred but can't get location information...");
+        }
+        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
+            error!("panic payload: {:?}", s);
+        } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
+            error!("panic payload: {:?}", s);
+        } else if let Some(a) = panic_info.payload().downcast_ref::<std::fmt::Arguments>() {
+            error!("panic payload: {:?}", a);
+        } else {
+            error!("no panic payload");
+        }
+        error!("Backtrace:\n{:?}", bt);
+    }));
+}

veilid-core/src/tests/mod.rs

@@ -1,7 +1,7 @@
-#[cfg(target_os = "android")]
+#[cfg(all(target_os = "android", feature = "veilid_core_android_tests"))]
 mod android;
 pub mod common;
-#[cfg(target_os = "ios")]
+#[cfg(all(target_os = "ios", feature = "veilid_core_ios_tests"))]
 mod ios;
 #[cfg(not(target_arch = "wasm32"))]
 mod native;

veilid-core/src/tests/native/mod.rs

@@ -5,44 +5,6 @@ use crate::network_manager::tests::*;
 use crate::tests::common::*;
 use crate::*;
 
-#[cfg(all(target_os = "android", feature = "veilid_core_android_tests"))]
-use jni::{objects::JClass, objects::JObject, JNIEnv};
-
-#[cfg(all(target_os = "android", feature = "veilid_core_android_tests"))]
-#[no_mangle]
-#[allow(non_snake_case)]
-pub extern "system" fn Java_com_veilid_veilid_1core_1android_1tests_MainActivity_run_1tests(
-    env: JNIEnv,
-    _class: JClass,
-    ctx: JObject,
-) {
-    crate::intf::utils::android::veilid_core_setup_android(
-        env,
-        ctx,
-        "veilid_core",
-        crate::veilid_config::VeilidConfigLogLevel::Trace,
-    );
-    run_all_tests();
-}
-
-#[cfg(all(target_os = "ios", feature = "veilid_core_ios_tests"))]
-#[no_mangle]
-pub extern "C" fn run_veilid_core_tests() {
-    let log_path: std::path::PathBuf = [
-        std::env::var("HOME").unwrap().as_str(),
-        "Documents",
-        "veilid-core.log",
-    ]
-    .iter()
-    .collect();
-    crate::intf::utils::ios_test_setup::veilid_core_setup(
-        "veilid-core",
-        Some(Level::Trace),
-        Some((Level::Trace, log_path.as_path())),
-    );
-    run_all_tests();
-}
-
 ///////////////////////////////////////////////////////////////////////////
 
 #[allow(dead_code)]
@@ -130,18 +92,26 @@ fn exec_test_envelope_receipt() {
 cfg_if! {
     if #[cfg(test)] {
         use serial_test::serial;
-        use simplelog::*;
         use std::sync::Once;
 
         static SETUP_ONCE: Once = Once::new();
 
         pub fn setup() {
             SETUP_ONCE.call_once(|| {
-                let mut cb = ConfigBuilder::new();
-                for ig in crate::DEFAULT_LOG_IGNORE_LIST {
-                    cb.add_filter_ignore_str(ig);
+                cfg_if! {
+                    if #[cfg(feature = "tracing")] {
+                        use tracing_subscriber::{filter, fmt, prelude::*};
+                        let mut filters = filter::Targets::new().with_default(filter::LevelFilter::TRACE);
+                        for ig in DEFAULT_LOG_IGNORE_LIST {
+                            filters = filters.with_target(ig, filter::LevelFilter::OFF);
+                        }
+                        let fmt_layer = fmt::layer();
+                        tracing_subscriber::registry()
+                            .with(fmt_layer)
+                            .with(filters)
+                            .init();
+                    }
                 }
-                TestLogger::init(LevelFilter::Trace, cb.build()).unwrap();
             });
         }