1 use std::mem::MaybeUninit; 2 use test_programs::wasi::random; 3 main()4fn main() { 5 let p1_random_size: usize = std::env::var("TEST_P1_RANDOM_LEN") 6 .map(|v| v.parse().expect("TEST_P1_RANDOM_LEN should be a usize")) 7 .unwrap_or(256); 8 let mut bytes: Box<[MaybeUninit<u8>]> = Box::new_uninit_slice(p1_random_size); 9 unsafe { 10 wasip1::random_get(bytes.as_mut_ptr() as *mut u8, bytes.len()).unwrap(); 11 } 12 13 assert!(bytes.iter().any(|x| unsafe { x.assume_init() } != 0)); 14 15 let p2_random_size: u64 = std::env::var("TEST_P2_RANDOM_LEN") 16 .map(|v| v.parse().expect("TEST_P2_RANDOM_LEN should be a u64")) 17 .unwrap_or(256); 18 // Acquired random bytes should be of the expected length. 19 let array = random::random::get_random_bytes(p2_random_size); 20 assert_eq!(array.len(), p2_random_size as usize); 21 22 // It shouldn't take 100+ tries to get a nonzero random integer. 23 for i in 0.. { 24 if random::random::get_random_u64() == 0 { 25 continue; 26 } 27 assert!(i < 100); 28 break; 29 } 30 31 // The `insecure_seed` API should return the same result each time. 32 let (a1, b1) = random::insecure_seed::insecure_seed(); 33 let (a2, b2) = random::insecure_seed::insecure_seed(); 34 assert_eq!(a1, a2); 35 assert_eq!(b1, b2); 36 37 let p2_insecure_random_size: u64 = std::env::var("TEST_P2_INSECURE_RANDOM_LEN") 38 .map(|v| { 39 v.parse() 40 .expect("TEST_P2_INSECURE_RANDOM_LEN should be a u64") 41 }) 42 .unwrap_or(256); 43 // Acquired random bytes should be of the expected length. 44 let array = random::insecure::get_insecure_random_bytes(p2_insecure_random_size); 45 assert_eq!(array.len(), p2_insecure_random_size as usize); 46 47 // It shouldn't take 100+ tries to get a nonzero random integer. 48 for i in 0.. { 49 if random::insecure::get_insecure_random_u64() == 0 { 50 continue; 51 } 52 assert!(i < 100); 53 break; 54 } 55 } 56