Merging upstream version 1.68.2+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 81 insertions, 52 deletions

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<unsafe extern fn(u32) -> u32> = lib.get(b"test_identity_u32\0").unwrap();
+        let lib = Library::new(lib_path()).unwrap();
+        let f: Symbol<unsafe extern "C" fn(u32) -> 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<unsafe extern fn(S) -> 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<unsafe extern "C" fn(S) -> 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<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct\0").unwrap();
-        let f2: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct").unwrap();
+        let lib = Library::new(lib_path()).unwrap();
+        let f: Symbol<unsafe extern "C" fn(S) -> S> = lib.get(b"test_identity_struct\0").unwrap();
+        let f2: Symbol<unsafe extern "C" fn(S) -> 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::<T>(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<unsafe extern fn() -> u32> = lib.get(b"test_get_static_u32\0").unwrap();
+        let help: Symbol<unsafe extern "C" fn() -> 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<unsafe extern fn() -> bool> =
+        let works: Symbol<unsafe extern "C" fn() -> 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<unsafe extern fn(u32) -> 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<unsafe extern "C" fn(u32) -> 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::<unsafe extern "C" fn()>(b"test_identity_u32").is_err());
+        assert!(this
+            .get::<unsafe extern "C" fn()>(b"test_identity_u32")
+            .is_err());
         // Something obscure from libc...
         assert!(this.get::<unsafe extern "C" fn()>(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::<unsafe extern "C" fn()>(b"test_identity_u32").is_err());
+        assert!(this
+            .get::<unsafe extern "C" fn()>(b"test_identity_u32")
+            .is_err());
         // Something "obscure" from kernel32...
         assert!(this.get::<unsafe extern "C" fn()>(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();