From 64d98f8ee037282c35007b64c2649055c56af1db Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:19:03 +0200 Subject: Merging upstream version 1.68.2+dfsg1. Signed-off-by: Daniel Baumann --- vendor/libloading/tests/functions.rs | 133 +++++++++++++++++++++-------------- 1 file changed, 81 insertions(+), 52 deletions(-) (limited to 'vendor/libloading/tests/functions.rs') diff --git a/vendor/libloading/tests/functions.rs b/vendor/libloading/tests/functions.rs index 795f0cfe9..c8d1952b3 100644 --- a/vendor/libloading/tests/functions.rs +++ b/vendor/libloading/tests/functions.rs @@ -2,19 +2,26 @@ extern crate winapi; extern crate libloading; -use libloading::{Symbol, Library}; +use libloading::{Library, Symbol}; -const LIBPATH: &'static str = "target/libtest_helpers.module"; +const TARGET_DIR: Option<&'static str> = option_env!("CARGO_TARGET_DIR"); +const TARGET_TMPDIR: Option<&'static str> = option_env!("CARGO_TARGET_TMPDIR"); + +fn lib_path() -> std::path::PathBuf { + [ + TARGET_TMPDIR.unwrap_or(TARGET_DIR.unwrap_or("target")), + "libtest_helpers.module", + ] + .iter() + .collect() +} fn make_helpers() { static ONCE: ::std::sync::Once = ::std::sync::Once::new(); ONCE.call_once(|| { - let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| { "rustc".into() }); + let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into()); let mut cmd = ::std::process::Command::new(rustc); - cmd - .arg("src/test_helpers.rs") - .arg("-o") - .arg(LIBPATH); + cmd.arg("src/test_helpers.rs").arg("-o").arg(lib_path()); if let Some(target) = std::env::var_os("TARGET") { cmd.arg("--target").arg(target); } else { @@ -23,8 +30,7 @@ fn make_helpers() { assert!(cmd .status() .expect("could not compile the test helpers!") - .success() - ); + .success()); }); } @@ -32,28 +38,41 @@ fn make_helpers() { fn test_id_u32() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); - let f: Symbol u32> = lib.get(b"test_identity_u32\0").unwrap(); + let lib = Library::new(lib_path()).unwrap(); + let f: Symbol u32> = lib.get(b"test_identity_u32\0").unwrap(); assert_eq!(42, f(42)); } } #[repr(C)] -#[derive(Clone,Copy,PartialEq,Debug)] +#[derive(Clone, Copy, PartialEq, Debug)] struct S { a: u64, b: u32, c: u16, - d: u8 + d: u8, } #[test] fn test_id_struct() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); - let f: Symbol S> = lib.get(b"test_identity_struct\0").unwrap(); - assert_eq!(S { a: 1, b: 2, c: 3, d: 4 }, f(S { a: 1, b: 2, c: 3, d: 4 })); + let lib = Library::new(lib_path()).unwrap(); + let f: Symbol S> = lib.get(b"test_identity_struct\0").unwrap(); + assert_eq!( + S { + a: 1, + b: 2, + c: 3, + d: 4 + }, + f(S { + a: 1, + b: 2, + c: 3, + d: 4 + }) + ); } } @@ -61,9 +80,9 @@ fn test_id_struct() { fn test_0_no_0() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); - let f: Symbol S> = lib.get(b"test_identity_struct\0").unwrap(); - let f2: Symbol S> = lib.get(b"test_identity_struct").unwrap(); + let lib = Library::new(lib_path()).unwrap(); + let f: Symbol S> = lib.get(b"test_identity_struct\0").unwrap(); + let f2: Symbol S> = lib.get(b"test_identity_struct").unwrap(); assert_eq!(*f, *f2); } } @@ -71,7 +90,9 @@ fn test_0_no_0() { #[test] fn wrong_name_fails() { unsafe { - Library::new("target/this_location_is_definitely_non existent:^~").err().unwrap(); + Library::new("target/this_location_is_definitely_non existent:^~") + .err() + .unwrap(); } } @@ -79,7 +100,7 @@ fn wrong_name_fails() { fn missing_symbol_fails() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); + let lib = Library::new(lib_path()).unwrap(); lib.get::<*mut ()>(b"test_does_not_exist").err().unwrap(); lib.get::<*mut ()>(b"test_does_not_exist\0").err().unwrap(); } @@ -89,9 +110,11 @@ fn missing_symbol_fails() { fn interior_null_fails() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); + let lib = Library::new(lib_path()).unwrap(); lib.get::<*mut ()>(b"test_does\0_not_exist").err().unwrap(); - lib.get::<*mut ()>(b"test\0_does_not_exist\0").err().unwrap(); + lib.get::<*mut ()>(b"test\0_does_not_exist\0") + .err() + .unwrap(); } } @@ -99,10 +122,10 @@ fn interior_null_fails() { fn test_incompatible_type() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); + let lib = Library::new(lib_path()).unwrap(); assert!(match lib.get::<()>(b"test_identity_u32\0") { - Err(libloading::Error::IncompatibleSize) => true, - _ => false, + Err(libloading::Error::IncompatibleSize) => true, + _ => false, }) } } @@ -114,10 +137,10 @@ fn test_incompatible_type_named_fn() { l.get::(b"test_identity_u32\0") } unsafe { - let lib = Library::new(LIBPATH).unwrap(); + let lib = Library::new(lib_path()).unwrap(); assert!(match get(&lib, test_incompatible_type_named_fn) { - Err(libloading::Error::IncompatibleSize) => true, - _ => false, + Err(libloading::Error::IncompatibleSize) => true, + _ => false, }) } } @@ -126,10 +149,11 @@ fn test_incompatible_type_named_fn() { fn test_static_u32() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); + let lib = Library::new(lib_path()).unwrap(); let var: Symbol<*mut u32> = lib.get(b"TEST_STATIC_U32\0").unwrap(); **var = 42; - let help: Symbol u32> = lib.get(b"test_get_static_u32\0").unwrap(); + let help: Symbol u32> = + lib.get(b"test_get_static_u32\0").unwrap(); assert_eq!(42, help()); } } @@ -138,10 +162,10 @@ fn test_static_u32() { fn test_static_ptr() { make_helpers(); unsafe { - let lib = Library::new(LIBPATH).unwrap(); + let lib = Library::new(lib_path()).unwrap(); let var: Symbol<*mut *mut ()> = lib.get(b"TEST_STATIC_PTR\0").unwrap(); **var = *var as *mut _; - let works: Symbol bool> = + let works: Symbol bool> = lib.get(b"test_check_static_ptr\0").unwrap(); assert!(works()); } @@ -152,25 +176,26 @@ fn test_static_ptr() { // and unloaded many times. So far it seems like an issue with mingw, not libloading, so ignoring // the target. Especially since it is very unlikely to be fixed given the state of support its // support. -#[cfg(not(all(target_arch="x86", target_os="windows", target_env="gnu")))] +#[cfg(not(all(target_arch = "x86", target_os = "windows", target_env = "gnu")))] fn manual_close_many_times() { make_helpers(); - let join_handles: Vec<_> = (0..16).map(|_| { - std::thread::spawn(|| unsafe { - for _ in 0..10000 { - let lib = Library::new(LIBPATH).expect("open library"); - let _: Symbol u32> = - lib.get(b"test_identity_u32").expect("get fn"); - lib.close().expect("close is successful"); - } + let join_handles: Vec<_> = (0..16) + .map(|_| { + std::thread::spawn(|| unsafe { + for _ in 0..10000 { + let lib = Library::new(lib_path()).expect("open library"); + let _: Symbol u32> = + lib.get(b"test_identity_u32").expect("get fn"); + lib.close().expect("close is successful"); + } + }) }) - }).collect(); + .collect(); for handle in join_handles { handle.join().expect("thread should succeed"); } } - #[cfg(unix)] #[test] fn library_this_get() { @@ -178,10 +203,12 @@ fn library_this_get() { make_helpers(); // SAFE: functions are never called unsafe { - let _lib = Library::new(LIBPATH).unwrap(); + let _lib = Library::new(lib_path()).unwrap(); let this = Library::this(); // Library we loaded in `_lib` (should be RTLD_LOCAL). - assert!(this.get::(b"test_identity_u32").is_err()); + assert!(this + .get::(b"test_identity_u32") + .is_err()); // Something obscure from libc... assert!(this.get::(b"freopen").is_ok()); } @@ -194,11 +221,13 @@ fn library_this() { make_helpers(); unsafe { // SAFE: well-known library without initialisers is loaded. - let _lib = Library::new(LIBPATH).unwrap(); + let _lib = Library::new(lib_path()).unwrap(); let this = Library::this().expect("this library"); // SAFE: functions are never called. // Library we loaded in `_lib`. - assert!(this.get::(b"test_identity_u32").is_err()); + assert!(this + .get::(b"test_identity_u32") + .is_err()); // Something "obscure" from kernel32... assert!(this.get::(b"GetLastError").is_err()); } @@ -207,9 +236,9 @@ fn library_this() { #[cfg(windows)] #[test] fn works_getlasterror() { - use winapi::um::errhandlingapi; - use winapi::shared::minwindef::DWORD; use libloading::os::windows::{Library, Symbol}; + use winapi::shared::minwindef::DWORD; + use winapi::um::errhandlingapi; unsafe { let lib = Library::new("kernel32.dll").unwrap(); @@ -222,9 +251,9 @@ fn works_getlasterror() { #[cfg(windows)] #[test] fn works_getlasterror0() { - use winapi::um::errhandlingapi; - use winapi::shared::minwindef::DWORD; use libloading::os::windows::{Library, Symbol}; + use winapi::shared::minwindef::DWORD; + use winapi::um::errhandlingapi; unsafe { let lib = Library::new("kernel32.dll").unwrap(); -- cgit v1.2.3