fix Session init race condition

rbran · rbran · commit e467111775de · 2025-02-04T13:46:49.000Z
diff --git a/rust/tests/background_task.rs b/rust/tests/background_task.rs
@@ -3,13 +3,12 @@ use binaryninja::headless::Session;
 use rstest::*;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_background_task_registered(_session: &Session) {
+fn test_background_task_registered(_session: Session) {
     let task_progress = "test registered";
     let task = BackgroundTask::new(task_progress, false);
     BackgroundTask::running_tasks()
@@ -25,7 +24,7 @@ fn test_background_task_registered(_session: &Session) {
 }
 
 #[rstest]
-fn test_background_task_cancellable(_session: &Session) {
+fn test_background_task_cancellable(_session: Session) {
     let task_progress = "test cancellable";
     let task = BackgroundTask::new(task_progress, false);
     BackgroundTask::running_tasks()
@@ -38,7 +37,7 @@ fn test_background_task_cancellable(_session: &Session) {
 }
 
 #[rstest]
-fn test_background_task_progress(_session: &Session) {
+fn test_background_task_progress(_session: Session) {
     let task = BackgroundTask::new("test progress", false);
     let first_progress = task.progress_text().to_string();
     assert_eq!(first_progress, "test progress");
diff --git a/rust/tests/binary_reader.rs b/rust/tests/binary_reader.rs
@@ -6,13 +6,12 @@ use std::io::{Read, Seek, SeekFrom};
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_binary_reader_seek(_session: &Session) {
+fn test_binary_reader_seek(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut reader = BinaryReader::new(&view);
@@ -50,7 +49,7 @@ fn test_binary_reader_seek(_session: &Session) {
 }
 
 #[rstest]
-fn test_binary_reader_read(_session: &Session) {
+fn test_binary_reader_read(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut reader = BinaryReader::new(&view);
diff --git a/rust/tests/binary_view.rs b/rust/tests/binary_view.rs
@@ -6,13 +6,12 @@ use rstest::*;
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_binary_loading(_session: &Session) {
+fn test_binary_loading(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     assert!(view.has_initial_analysis(), "No initial analysis");
@@ -22,7 +21,7 @@ fn test_binary_loading(_session: &Session) {
 }
 
 #[rstest]
-fn test_binary_saving(_session: &Session) {
+fn test_binary_saving(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     // Verify the contents before we modify.
@@ -45,7 +44,7 @@ fn test_binary_saving(_session: &Session) {
 }
 
 #[rstest]
-fn test_binary_saving_database(_session: &Session) {
+fn test_binary_saving_database(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     // Update a symbol to verify modification
diff --git a/rust/tests/binary_writer.rs b/rust/tests/binary_writer.rs
@@ -7,13 +7,12 @@ use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_binary_writer_seek(_session: &Session) {
+fn test_binary_writer_seek(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut writer = BinaryWriter::new(&view);
@@ -51,7 +50,7 @@ fn test_binary_writer_seek(_session: &Session) {
 }
 
 #[rstest]
-fn test_binary_writer_write(_session: &Session) {
+fn test_binary_writer_write(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut reader = BinaryReader::new(&view);
diff --git a/rust/tests/collaboration.rs b/rust/tests/collaboration.rs
@@ -9,7 +9,6 @@ use serial_test::serial;
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
@@ -58,7 +57,7 @@ fn temp_project_scope<T: Fn(&RemoteProject)>(remote: &Remote, project_name: &str
 
 #[rstest]
 #[serial]
-fn test_connection(_session: &Session) {
+fn test_connection(_session: Session) {
     if !has_collaboration_support() {
         eprintln!("No collaboration support, skipping test...");
         return;
@@ -74,7 +73,7 @@ fn test_connection(_session: &Session) {
 
 #[rstest]
 #[serial]
-fn test_project_creation(_session: &Session) {
+fn test_project_creation(_session: Session) {
     if !has_collaboration_support() {
         eprintln!("No collaboration support, skipping test...");
         return;
@@ -155,7 +154,7 @@ fn test_project_creation(_session: &Session) {
 
 #[rstest]
 #[serial]
-fn test_project_sync(_session: &Session) {
+fn test_project_sync(_session: Session) {
     if !has_collaboration_support() {
         eprintln!("No collaboration support, skipping test...");
         return;
diff --git a/rust/tests/component.rs b/rust/tests/component.rs
@@ -5,13 +5,12 @@ use rstest::*;
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_component_creation(_session: &Session) {
+fn test_component_creation(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let component = ComponentBuilder::new(view.clone()).name("test").finalize();
diff --git a/rust/tests/demangler.rs b/rust/tests/demangler.rs
@@ -9,13 +9,12 @@ use binaryninja::types::{QualifiedName, Type};
 use rstest::*;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_demangler_simple(_session: &Session) {
+fn test_demangler_simple(_session: Session) {
     let placeholder_arch = CoreArchitecture::by_name("x86").expect("x86 exists");
     // Example LLVM-style mangled name
     let llvm_mangled = "_Z3fooi"; // "foo(int)" in LLVM mangling
@@ -46,7 +45,7 @@ fn test_demangler_simple(_session: &Session) {
 }
 
 #[rstest]
-fn test_custom_demangler(_session: &Session) {
+fn test_custom_demangler(_session: Session) {
     struct TestDemangler;
 
     impl CustomDemangler for TestDemangler {
diff --git a/rust/tests/high_level_il.rs b/rust/tests/high_level_il.rs
@@ -5,13 +5,12 @@ use rstest::*;
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_hlil_info(_session: &Session) {
+fn test_hlil_info(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
 
diff --git a/rust/tests/low_level_il.rs b/rust/tests/low_level_il.rs
@@ -12,13 +12,12 @@ use rstest::*;
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_llil_info(_session: &Session) {
+fn test_llil_info(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
 
@@ -170,7 +169,7 @@ fn test_llil_info(_session: &Session) {
 }
 
 #[rstest]
-fn test_llil_visitor(_session: &Session) {
+fn test_llil_visitor(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let platform = view.default_platform().unwrap();
diff --git a/rust/tests/main_thread.rs b/rust/tests/main_thread.rs
@@ -4,19 +4,18 @@ use rstest::*;
 // TODO: Add a test for MainThreadHandler
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_not_main_thread(_session: &Session) {
+fn test_not_main_thread(_session: Session) {
     // We should never be the main thread.
     assert!(!binaryninja::is_main_thread())
 }
 
 #[rstest]
-fn test_main_thread_different(_session: &Session) {
+fn test_main_thread_different(_session: Session) {
     let calling_thread = std::thread::current();
     binaryninja::main_thread::execute_on_main_thread_and_wait(move || {
         let main_thread = std::thread::current();
diff --git a/rust/tests/medium_level_il.rs b/rust/tests/medium_level_il.rs
@@ -5,13 +5,12 @@ use rstest::*;
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_mlil_info(_session: &Session) {
+fn test_mlil_info(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
 
diff --git a/rust/tests/platform.rs b/rust/tests/platform.rs
@@ -3,13 +3,12 @@ use binaryninja::platform::Platform;
 use rstest::*;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_platform_lifetime(_session: &Session) {
+fn test_platform_lifetime(_session: Session) {
     let platform_0 = Platform::by_name("windows-x86_64").expect("windows-x86_64 exists");
     let platform_types_0 = platform_0.types();
     let platform_1 = Platform::by_name("windows-x86_64").expect("windows-x86_64 exists");
@@ -19,15 +18,15 @@ fn test_platform_lifetime(_session: &Session) {
 }
 
 #[rstest]
-fn test_platform_types(_session: &Session) {
+fn test_platform_types(_session: Session) {
     let platform = Platform::by_name("windows-x86_64").expect("windows-x86_64 exists");
     let platform_types = platform.types();
     // windows-x86_64 has a few thousand, not zero.
     assert_ne!(platform_types.len(), 0);
 }
 
 #[rstest]
-fn test_platform_calling_conventions(_session: &Session) {
+fn test_platform_calling_conventions(_session: Session) {
     let platform = Platform::by_name("windows-x86_64").expect("windows-x86_64 exists");
     assert_eq!(platform.calling_conventions().len(), 1);
 }
diff --git a/rust/tests/project.rs b/rust/tests/project.rs
@@ -8,7 +8,6 @@ use std::time::SystemTime;
 // TODO: We should use tempdir to manage the project directory.
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
@@ -18,7 +17,7 @@ fn unique_project(name: &str) -> String {
 }
 
 #[rstest]
-fn create_delete_empty(_session: &Session) {
+fn create_delete_empty(_session: Session) {
     use std::fs::canonicalize;
 
     let project_name = "create_delete_empty_project";
@@ -47,7 +46,7 @@ fn create_delete_empty(_session: &Session) {
 }
 
 #[rstest]
-fn create_close_open_close(_session: &Session) {
+fn create_close_open_close(_session: Session) {
     let project_name = "create_close_open_close";
     let project_path = unique_project(project_name);
     // create the project
@@ -75,7 +74,7 @@ fn create_close_open_close(_session: &Session) {
 }
 
 #[rstest]
-fn modify_project(_session: &Session) {
+fn modify_project(_session: Session) {
     let project_name = "modify_project_project";
     let project_path = unique_project(project_name);
     // create the project
diff --git a/rust/tests/render_layer.rs b/rust/tests/render_layer.rs
@@ -8,21 +8,20 @@ use rstest::{fixture, rstest};
 use std::path::PathBuf;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[rstest]
-fn test_render_layer_register(_session: &Session) {
+fn test_render_layer_register(_session: Session) {
     struct EmptyRenderLayer;
     impl RenderLayer for EmptyRenderLayer {}
     register_render_layer("Test Render Layer", EmptyRenderLayer, Default::default());
     CoreRenderLayer::render_layer_by_name("Test Render Layer").expect("Failed to get render layer");
 }
 
 #[rstest]
-fn test_render_layer_linear_view(_session: &Session) {
+fn test_render_layer_linear_view(_session: Session) {
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
 
diff --git a/rust/tests/type_archive.rs b/rust/tests/type_archive.rs
@@ -7,19 +7,17 @@ use binaryninja::type_archive::TypeArchive;
 use rstest::*;
 
 #[fixture]
-#[once]
 fn session() -> Session {
     Session::new().expect("Failed to initialize session")
 }
 
 #[fixture]
-#[once]
 fn empty_view() -> Ref<BinaryView> {
     BinaryView::from_data(&FileMetadata::new(), &[]).expect("Failed to create view")
 }
 
 #[rstest]
-fn test_create_archive(_session: &Session) {
+fn test_create_archive(_session: Session) {
     let placeholder_platform = Platform::by_name("x86_64").expect("Failed to get platform");
 
     let temp_dir = tempfile::tempdir().unwrap();
diff --git a/rust/tests/type_container.rs b/rust/tests/type_container.rs
diff --git a/rust/tests/type_parser.rs b/rust/tests/type_parser.rs
diff --git a/rust/tests/types.rs b/rust/tests/types.rs
diff --git a/rust/tests/worker_thread.rs b/rust/tests/worker_thread.rs
diff --git a/rust/tests/workflow.rs b/rust/tests/workflow.rs
