Add test for wait_timeout with no lock held

src/sync/condvar.rs

@@ -384,7 +384,7 @@ impl<'a, 'b, T> Future for AwaitNotify<'a, 'b, T> {
             }
             None => {
                 if let Some(key) = self.key {
-                    if self.cond.wakers.complete_if_notified(key, cx) {
+                    if self.cond.wakers.remove_if_notified(key, cx) {
                         self.key = None;
                         Poll::Ready(())
                     } else {

src/sync/waker_set.rs

@@ -84,13 +84,12 @@ impl WakerSet {
     /// the waker for the entry, and return false. If the waker has been notified,
     /// treat the entry as completed and return true.
     #[cfg(feature = "unstable")]
-    pub fn complete_if_notified(&self, key: usize, cx: &Context<'_>) -> bool {
+    pub fn remove_if_notified(&self, key: usize, cx: &Context<'_>) -> bool {
         let mut inner = self.lock();
 
         match &mut inner.entries[key] {
             None => {
                 inner.entries.remove(key);
-                inner.none_count -= 1;
                 true
             }
             Some(w) => {

tests/condvar.rs

@@ -6,7 +6,7 @@ use async_std::sync::{Condvar, Mutex};
 use async_std::task::{self, JoinHandle};
 
 #[test]
-fn wait_timeout() {
+fn wait_timeout_with_lock() {
     task::block_on(async {
         let pair = Arc::new((Mutex::new(false), Condvar::new()));
         let pair2 = pair.clone();
@@ -26,6 +26,19 @@ fn wait_timeout() {
     })
 }
 
+#[test]
+fn wait_timeout_without_lock() {
+    task::block_on(async {
+        let m = Mutex::new(false);
+        let c = Condvar::new();
+
+        let (_, wait_result) = c
+            .wait_timeout(m.lock().await, Duration::from_millis(10))
+            .await;
+        assert!(wait_result.timed_out());
+    })
+}
+
 #[test]
 fn wait_timeout_until_timed_out() {
     task::block_on(async {