dylink 0.11.0

Run-time dynamic linking loader utilities
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// SPDX-FileCopyrightText: 2022-2026 Jonathan A. Thomason <contact@jonathan-thomason.com>
// SPDX-License-Identifier: MIT OR Apache-2.0

mod linux;
mod macos;
mod unix;
mod windows;

use dylink::*;

#[cfg(feature = "unstable")]
#[test]
fn test_leak() {
	let lib = Library::this();
	let _handle = lib.leak();
}

#[test]
fn test_size_exact() {
	let images = img::Images::now().unwrap();
	for weak in images {
		let img = unsafe { &*weak.to_ptr() };
		let img_slice = img.to_bytes().unwrap();
		let len = (*img_slice).len();
		let _data = (*img_slice)[len - 1];
	}
}

#[test]
fn test_try_clone() {
	let lib = Library::this();
	let other = lib.try_clone().unwrap();
	let lib_data = lib.to_image().unwrap().to_bytes().unwrap();
	let other_data = other.to_image().unwrap().to_bytes().unwrap();
	assert_eq!(lib_data, other_data);
	let t = std::thread::spawn(move || {
		println!("other: {:?}", other);
	});
	t.join().unwrap();
	println!("lib: {:?}", lib);
}

#[test]
fn test_iter_images() {
	let images = img::Images::now().unwrap();
	for weak in images {
		print!("weak addr: {:p}, ", weak.to_ptr());
		if let Some(dylib) = weak.upgrade() {
			let hdr = dylib.to_image().unwrap();
			if let Ok(path) = hdr.path() {
				println!("upgraded = {}", path.display());
				assert_eq!(path, dylib.to_image().unwrap().path().unwrap());
			}
			let weak_img = unsafe { weak.to_ptr().as_ref() }.unwrap();
			let weak_data = weak_img.to_bytes().unwrap();
			let hdr_data = hdr.to_bytes().unwrap();
			assert_eq!(weak_data, hdr_data);
		} else if let Some(path) = weak.path() {
			println!("upgrade failed = {}", path.display());
		}
	}
}

// test to see if there are race conditions when getting a path.
#[test]
fn test_path_soundness() {
	use dylink::img::Images;
	let images = Images::now().unwrap();
	let mut vlib = vec![];
	for img in images {
		if let Some(val) = img.upgrade() {
			vlib.push(val)
		}
	}
	let t = std::thread::spawn(|| {
		let images = Images::now().unwrap();
		let mut other_vlib = vec![];
		for img in images {
			if let Some(val) = img.upgrade() {
				other_vlib.push(val)
			}
		}
		for lib in other_vlib.drain(0..) {
			let _ = lib.try_clone().unwrap();
		}
	});
	for lib in vlib.drain(0..) {
		let _ = lib.try_clone().unwrap();
	}
	t.join().unwrap();
}

#[test]
fn test_hdr_path() {
	let images = img::Images::now().unwrap();
	for img in images {
		let maybe_hdr = unsafe { img.to_ptr().as_ref() };
		let Some(hdr) = maybe_hdr else {
			continue;
		};
		if let Some(path) = img.path() {
			assert_eq!(path, hdr.path().unwrap());
		}
	}
}

#[test]
fn test_downgrade_upgrade() {
	let strong = Library::this();
	let weak = Library::downgrade(&strong).unwrap();
	let strong_clone = weak.upgrade();

	assert!(strong_clone.is_some());
}