Debian Codegraph @

.cargo/vendor/getrandom/tests/mod.rs

raw
1 use core::mem::MaybeUninit;
2 use getrandom::{fill, fill_uninit};
3
4 #[cfg(all(feature = "wasm_js", target_arch = "wasm32", target_os = "unknown"))]
5 use wasm_bindgen_test::wasm_bindgen_test as test;
6
7 #[test]
8 fn test_zero() {
9 // Test that APIs are happy with zero-length requests
10 fill(&mut [0u8; 0]).unwrap();
11 let res = fill_uninit(&mut []).unwrap();
12 assert!(res.is_empty());
13 }
14
15 trait DiffBits: Sized {
16 fn diff_bits(ab: (&Self, &Self)) -> usize;
17 }
18
19 impl DiffBits for u8 {
20 fn diff_bits((a, b): (&Self, &Self)) -> usize {
21 (a ^ b).count_ones() as usize
22 }
23 }
24
25 impl DiffBits for u32 {
26 fn diff_bits((a, b): (&Self, &Self)) -> usize {
27 (a ^ b).count_ones() as usize
28 }
29 }
30
31 impl DiffBits for u64 {
32 fn diff_bits((a, b): (&Self, &Self)) -> usize {
33 (a ^ b).count_ones() as usize
34 }
35 }
36
37 // Return the number of bits in which s1 and s2 differ
38 fn num_diff_bits<T: DiffBits>(s1: &[T], s2: &[T]) -> usize {
39 assert_eq!(s1.len(), s2.len());
40 s1.iter().zip(s2.iter()).map(T::diff_bits).sum()
41 }
42
43 // TODO: use `[const { MaybeUninit::uninit() }; N]` after MSRV is bumped to 1.79+
44 // or `MaybeUninit::uninit_array`
45 fn uninit_vec(n: usize) -> Vec<MaybeUninit<u8>> {
46 vec![MaybeUninit::uninit(); n]
47 }
48
49 // Tests the quality of calling getrandom on two large buffers
50 #[test]
51 fn test_diff() {
52 const N: usize = 1000;
53 let mut v1 = [0u8; N];
54 let mut v2 = [0u8; N];
55 fill(&mut v1).unwrap();
56 fill(&mut v2).unwrap();
57
58 let mut t1 = uninit_vec(N);
59 let mut t2 = uninit_vec(N);
60 let r1 = fill_uninit(&mut t1).unwrap();
61 let r2 = fill_uninit(&mut t2).unwrap();
62 assert_eq!(r1.len(), N);
63 assert_eq!(r2.len(), N);
64
65 // Between 3.5 and 4.5 bits per byte should differ. Probability of failure:
66 // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500]
67 let d1 = num_diff_bits(&v1, &v2);
68 assert!(d1 > 3500);
69 assert!(d1 < 4500);
70 let d2 = num_diff_bits(r1, r2);
71 assert!(d2 > 3500);
72 assert!(d2 < 4500);
73 }
74
75 #[test]
76 fn test_diff_u32() {
77 const N: usize = 1000 / 4;
78 let mut v1 = [0u32; N];
79 let mut v2 = [0u32; N];
80 for v in v1.iter_mut() {
81 *v = getrandom::u32().unwrap();
82 }
83 for v in v2.iter_mut() {
84 *v = getrandom::u32().unwrap();
85 }
86
87 // Between 3.5 and 4.5 bits per byte should differ. Probability of failure:
88 // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500]
89 let d1 = num_diff_bits(&v1, &v2);
90 assert!(d1 > 3500);
91 assert!(d1 < 4500);
92 }
93
94 #[test]
95 fn test_diff_u64() {
96 const N: usize = 1000 / 8;
97 let mut v1 = [0u64; N];
98 let mut v2 = [0u64; N];
99 for v in v1.iter_mut() {
100 *v = getrandom::u64().unwrap();
101 }
102 for v in v2.iter_mut() {
103 *v = getrandom::u64().unwrap();
104 }
105
106 // Between 3.5 and 4.5 bits per byte should differ. Probability of failure:
107 // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500]
108 let d1 = num_diff_bits(&v1, &v2);
109 assert!(d1 > 3500);
110 assert!(d1 < 4500);
111 }
112
113 #[test]
114 fn test_small() {
115 const N: usize = 64;
116 // For each buffer size, get at least 256 bytes and check that between
117 // 3 and 5 bits per byte differ. Probability of failure:
118 // ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256]
119 for size in 1..=N {
120 let mut num_bytes = 0;
121 let mut diff_bits = 0;
122 while num_bytes < 256 {
123 let mut buf1 = [0u8; N];
124 let mut buf2 = [0u8; N];
125
126 let s1 = &mut buf1[..size];
127 let s2 = &mut buf2[..size];
128
129 fill(s1).unwrap();
130 fill(s2).unwrap();
131
132 num_bytes += size;
133 diff_bits += num_diff_bits(s1, s2);
134 }
135 assert!(diff_bits > 3 * num_bytes);
136 assert!(diff_bits < 5 * num_bytes);
137 }
138 }
139
140 // Tests the quality of calling getrandom repeatedly on small buffers
141 #[test]
142 fn test_small_uninit() {
143 const N: usize = 64;
144 // For each buffer size, get at least 256 bytes and check that between
145 // 3 and 5 bits per byte differ. Probability of failure:
146 // ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256]
147 for size in 1..=N {
148 let mut num_bytes = 0;
149 let mut diff_bits = 0;
150 while num_bytes < 256 {
151 let mut buf1 = uninit_vec(N);
152 let mut buf2 = uninit_vec(N);
153
154 let s1 = &mut buf1[..size];
155 let s2 = &mut buf2[..size];
156
157 let r1 = fill_uninit(s1).unwrap();
158 let r2 = fill_uninit(s2).unwrap();
159 assert_eq!(r1.len(), size);
160 assert_eq!(r2.len(), size);
161
162 num_bytes += size;
163 diff_bits += num_diff_bits(r1, r2);
164 }
165 assert!(diff_bits > 3 * num_bytes);
166 assert!(diff_bits < 5 * num_bytes);
167 }
168 }
169
170 #[test]
171 fn test_huge() {
172 let mut huge = [0u8; 100_000];
173 fill(&mut huge).unwrap();
174 }
175
176 #[test]
177 fn test_huge_uninit() {
178 const N: usize = 100_000;
179 let mut huge = uninit_vec(N);
180 let res = fill_uninit(&mut huge).unwrap();
181 assert_eq!(res.len(), N);
182 }
183
184 #[test]
185 #[cfg_attr(
186 target_arch = "wasm32",
187 ignore = "The thread API always fails/panics on WASM"
188 )]
189 fn test_multithreading() {
190 extern crate std;
191 use std::{sync::mpsc::channel, thread, vec};
192
193 let mut txs = vec![];
194 for _ in 0..20 {
195 let (tx, rx) = channel();
196 txs.push(tx);
197
198 thread::spawn(move || {
199 // wait until all the tasks are ready to go.
200 rx.recv().unwrap();
201 let mut v = [0u8; 1000];
202
203 for _ in 0..100 {
204 fill(&mut v).unwrap();
205 thread::yield_now();
206 }
207 });
208 }
209
210 // start all the tasks
211 for tx in txs.iter() {
212 tx.send(()).unwrap();
213 }
214 }
215
216 #[cfg(getrandom_backend = "custom")]
217 mod custom {
218 use getrandom::Error;
219
220 struct Xoshiro128PlusPlus {
221 s: [u32; 4],
222 }
223
224 impl Xoshiro128PlusPlus {
225 fn new(mut seed: u64) -> Self {
226 const PHI: u64 = 0x9e3779b97f4a7c15;
227 let mut s = [0u32; 4];
228 for val in s.iter_mut() {
229 seed = seed.wrapping_add(PHI);
230 let mut z = seed;
231 z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
232 z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
233 z = z ^ (z >> 31);
234 *val = z as u32;
235 }
236 Self { s }
237 }
238
239 fn next_u32(&mut self) -> u32 {
240 let res = self.s[0]
241 .wrapping_add(self.s[3])
242 .rotate_left(7)
243 .wrapping_add(self.s[0]);
244
245 let t = self.s[1] << 9;
246
247 self.s[2] ^= self.s[0];
248 self.s[3] ^= self.s[1];
249 self.s[1] ^= self.s[2];
250 self.s[0] ^= self.s[3];
251
252 self.s[2] ^= t;
253
254 self.s[3] = self.s[3].rotate_left(11);
255
256 res
257 }
258 }
259
260 // This implementation uses current timestamp as a PRNG seed.
261 //
262 // WARNING: this custom implementation is for testing purposes ONLY!
263 #[no_mangle]
264 unsafe extern "Rust" fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error> {
265 use std::time::{SystemTime, UNIX_EPOCH};
266
267 assert_ne!(len, 0);
268
269 if len == 142 {
270 return Err(Error::new_custom(142));
271 }
272
273 let dest_u32 = dest.cast::<u32>();
274 let ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
275 let mut rng = Xoshiro128PlusPlus::new(ts.as_nanos() as u64);
276 for i in 0..len / 4 {
277 let val = rng.next_u32();
278 core::ptr::write_unaligned(dest_u32.add(i), val);
279 }
280 if len % 4 != 0 {
281 let start = 4 * (len / 4);
282 for i in start..len {
283 let val = rng.next_u32();
284 core::ptr::write_unaligned(dest.add(i), val as u8);
285 }
286 }
287 Ok(())
288 }
289
290 // Test that enabling the custom feature indeed uses the custom implementation
291 #[test]
292 fn test_custom() {
293 let mut buf = [0u8; 142];
294 let res = getrandom::fill(&mut buf);
295 assert!(res.is_err());
296 }
297 }