1 #![cfg(feature = "sync")] 2 3 #[cfg(target_arch = "wasm32")] 4 use wasm_bindgen_test::wasm_bindgen_test as test; 5 6 use std::sync::Arc; 7 use tokio::sync::Semaphore; 8 9 #[test] try_acquire()10fn try_acquire() { 11 let sem = Arc::new(Semaphore::new(1)); 12 { 13 let p1 = sem.clone().try_acquire_owned(); 14 assert!(p1.is_ok()); 15 let p2 = sem.clone().try_acquire_owned(); 16 assert!(p2.is_err()); 17 } 18 let p3 = sem.try_acquire_owned(); 19 assert!(p3.is_ok()); 20 } 21 22 #[test] try_acquire_many()23fn try_acquire_many() { 24 let sem = Arc::new(Semaphore::new(42)); 25 { 26 let p1 = sem.clone().try_acquire_many_owned(42); 27 assert!(p1.is_ok()); 28 let p2 = sem.clone().try_acquire_owned(); 29 assert!(p2.is_err()); 30 } 31 let p3 = sem.clone().try_acquire_many_owned(32); 32 assert!(p3.is_ok()); 33 let p4 = sem.clone().try_acquire_many_owned(10); 34 assert!(p4.is_ok()); 35 assert!(sem.try_acquire_owned().is_err()); 36 } 37 38 #[tokio::test] 39 #[cfg(feature = "full")] acquire()40async fn acquire() { 41 let sem = Arc::new(Semaphore::new(1)); 42 let p1 = sem.clone().try_acquire_owned().unwrap(); 43 let sem_clone = sem.clone(); 44 let j = tokio::spawn(async move { 45 let _p2 = sem_clone.acquire_owned().await; 46 }); 47 drop(p1); 48 j.await.unwrap(); 49 } 50 51 #[tokio::test] 52 #[cfg(feature = "full")] acquire_many()53async fn acquire_many() { 54 let semaphore = Arc::new(Semaphore::new(42)); 55 let permit32 = semaphore.clone().try_acquire_many_owned(32).unwrap(); 56 let (sender, receiver) = tokio::sync::oneshot::channel(); 57 let join_handle = tokio::spawn(async move { 58 let _permit10 = semaphore.clone().acquire_many_owned(10).await.unwrap(); 59 sender.send(()).unwrap(); 60 let _permit32 = semaphore.acquire_many_owned(32).await.unwrap(); 61 }); 62 receiver.await.unwrap(); 63 drop(permit32); 64 join_handle.await.unwrap(); 65 } 66 67 #[tokio::test] 68 #[cfg(feature = "full")] add_permits()69async fn add_permits() { 70 let sem = Arc::new(Semaphore::new(0)); 71 let sem_clone = sem.clone(); 72 let j = tokio::spawn(async move { 73 let _p2 = sem_clone.acquire_owned().await; 74 }); 75 sem.add_permits(1); 76 j.await.unwrap(); 77 } 78 79 #[test] forget()80fn forget() { 81 let sem = Arc::new(Semaphore::new(1)); 82 { 83 let p = sem.clone().try_acquire_owned().unwrap(); 84 assert_eq!(sem.available_permits(), 0); 85 p.forget(); 86 assert_eq!(sem.available_permits(), 0); 87 } 88 assert_eq!(sem.available_permits(), 0); 89 assert!(sem.try_acquire_owned().is_err()); 90 } 91 92 #[tokio::test] 93 #[cfg(feature = "full")] stresstest()94async fn stresstest() { 95 let sem = Arc::new(Semaphore::new(5)); 96 let mut join_handles = Vec::new(); 97 for _ in 0..1000 { 98 let sem_clone = sem.clone(); 99 join_handles.push(tokio::spawn(async move { 100 let _p = sem_clone.acquire_owned().await; 101 })); 102 } 103 for j in join_handles { 104 j.await.unwrap(); 105 } 106 // there should be exactly 5 semaphores available now 107 let _p1 = sem.clone().try_acquire_owned().unwrap(); 108 let _p2 = sem.clone().try_acquire_owned().unwrap(); 109 let _p3 = sem.clone().try_acquire_owned().unwrap(); 110 let _p4 = sem.clone().try_acquire_owned().unwrap(); 111 let _p5 = sem.clone().try_acquire_owned().unwrap(); 112 assert!(sem.try_acquire_owned().is_err()); 113 } 114