Add a test for the previous patch

Cargo.toml

@@ -72,6 +72,7 @@ version = "0.25.0"
 optional = true
 
 [dev-dependencies]
+waker-fn = "1"
 tempfile = "3.1.0"
 socket2 = { version = "0.5.2", features = ["all"] }
 tokio = { version = "1.0", features = ["macros", "rt", "rt-multi-thread"] }

src/conn/pool/mod.rs

@@ -390,10 +390,14 @@ mod test {
         poll, try_join, FutureExt,
     };
     use tokio::time::{sleep, timeout};
+    use waker_fn::waker_fn;
 
     use std::{
         cmp::Reverse,
-        task::{Poll, RawWaker, RawWakerVTable, Waker},
+        future::Future,
+        pin::pin,
+        sync::{Arc, OnceLock},
+        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
         time::Duration,
     };
 
@@ -1047,6 +1051,46 @@ mod test {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn save_last_waker() {
+        // Test that if passed multiple wakers, we call the last one.
+
+        let pool = pool_with_one_connection();
+
+        // Get a connection, so we know the next future will be
+        // queued.
+        let conn = pool.get_conn().await.unwrap();
+        let mut pending_fut = pin!(pool.get_conn());
+
+        let build_waker = || {
+            let called = Arc::new(OnceLock::new());
+            let called2 = called.clone();
+            let waker = waker_fn(move || called2.set(()).unwrap());
+            (called, waker)
+        };
+
+        let mut assert_pending = |waker| {
+            let mut context = Context::from_waker(&waker);
+            let p = pending_fut.as_mut().poll(&mut context);
+            assert!(matches!(p, Poll::Pending));
+        };
+
+        let (first_called, waker) = build_waker();
+        assert_pending(waker);
+
+        let (second_called, waker) = build_waker();
+        assert_pending(waker);
+
+        drop(conn);
+
+        while second_called.get().is_none() {
+            assert!(first_called.get().is_none());
+            tokio::time::sleep(Duration::from_millis(100)).await;
+        }
+
+        assert!(first_called.get().is_none());
+    }
+
     #[tokio::test]
     async fn check_priorities() -> super::Result<()> {
         let pool = pool_with_one_connection();