Add test for notify_all

Author: tmccombs

src/sync/condvar.rs

@@ -15,7 +15,7 @@ pub struct WaitTimeoutResult(bool);
 /// not
 impl WaitTimeoutResult {
     /// Returns `true` if the wait was known to have timed out.
-    pub fn timed_out(&self) -> bool {
+    pub fn timed_out(self) -> bool {
         self.0
     }
 }
@@ -62,6 +62,12 @@ pub struct Condvar {
     blocked: std::sync::Mutex<Slab<Option<Waker>>>,
 }
 
+impl Default for Condvar {
+    fn default() -> Self {
+        Condvar::new()
+    }
+}
+
 impl Condvar {
     /// Creates a new condition variable
     ///
@@ -111,6 +117,7 @@ impl Condvar {
     /// }
     /// # }) }
     /// ```
+    #[allow(clippy::needless_lifetimes)]
     pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
         let mutex = guard_lock(&guard);
 
@@ -161,6 +168,7 @@ impl Condvar {
     /// # }) }
     /// ```
     #[cfg(feature = "unstable")]
+    #[allow(clippy::needless_lifetimes)]
     pub async fn wait_until<'a, T, F>(
         &self,
         mut guard: MutexGuard<'a, T>,
@@ -213,6 +221,7 @@ impl Condvar {
     /// #
     /// # }) }
     /// ```
+    #[allow(clippy::needless_lifetimes)]
     pub async fn wait_timeout<'a, T>(
         &self,
         guard: MutexGuard<'a, T>,
@@ -352,7 +361,6 @@ impl<'a, 'b, T> Drop for AwaitNotify<'a, 'b, T> {
                 // we are dropping it before it can finished.
                 // This may result in a spurious wake-up, but that's ok.
                 notify(blocked, false);
-
             }
         }
     }

tests/condvar.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use async_std::sync::{Condvar, Mutex};
-use async_std::task;
+use async_std::task::{self, JoinHandle};
 
 #[test]
 fn wait_timeout() {
@@ -25,3 +25,38 @@ fn wait_timeout() {
     })
 }
 
+#[test]
+fn notify_all() {
+    task::block_on(async {
+        let mut tasks: Vec<JoinHandle<()>> = Vec::new();
+        let pair = Arc::new((Mutex::new(0u32), Condvar::new()));
+
+        for _ in 0..10 {
+            let pair = pair.clone();
+            tasks.push(task::spawn(async move {
+                let (m, c) = &*pair;
+                let mut count = m.lock().await;
+                while *count == 0 {
+                    count = c.wait(count).await;
+                }
+                *count += 1;
+            }));
+        }
+
+        // Give some time for tasks to start up
+        task::sleep(Duration::from_millis(5)).await;
+
+        let (m, c) = &*pair;
+        {
+            let mut count = m.lock().await;
+            *count += 1;
+            c.notify_all();
+        }
+
+        for t in tasks {
+            t.await;
+        }
+        let count = m.lock().await;
+        assert_eq!(11, *count);
+    })
+}