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