1 #![cfg(feature = "full")]
2 
3 use std::sync::Arc;
4 use tokio::sync::Semaphore;
5 
6 #[test]
try_acquire()7 fn 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()20 fn 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()36 async 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()48 async 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()63 async 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()74 fn 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()87 async 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