stream: add next_many and poll_next_many to StreamMap (#6409)

2026-09-06 00:00:10 +02:00 · 2024-03-26 18:38:53 +03:30
parent deff2524c3
commit 4601c84718
4 changed files with 378 additions and 3 deletions
@@ -1,14 +1,17 @@
+use futures::stream::iter;
 use tokio_stream::{self as stream, pending, Stream, StreamExt, StreamMap};
 use tokio_test::{assert_ok, assert_pending, assert_ready, task};

+use std::future::{poll_fn, Future};
+use std::pin::{pin, Pin};
+use std::task::Poll;
+
 mod support {
    pub(crate) mod mpsc;
 }

 use support::mpsc;

-use std::pin::Pin;
-
 macro_rules! assert_ready_some {
    ($($t:tt)*) => {
        match assert_ready!($($t)*) {
@@ -328,3 +331,233 @@ fn one_ready_many_none() {
 fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream<Item = U>>> {
    Box::pin(s)
 }
+
+type UsizeStream = Pin<Box<dyn Stream<Item = usize> + Send>>;
+
+#[tokio::test]
+async fn poll_next_many_zero() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(pending()) as UsizeStream);
+
+    let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut vec![], 0)).await;
+
+    assert_eq!(n, 0);
+}
+
+#[tokio::test]
+async fn poll_next_many_empty() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut vec![], 1)).await;
+
+    assert_eq!(n, 0);
+}
+
+#[tokio::test]
+async fn poll_next_many_pending() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(pending()) as UsizeStream);
+
+    let mut is_pending = false;
+    poll_fn(|cx| {
+        let poll = stream_map.poll_next_many(cx, &mut vec![], 1);
+
+        is_pending = poll.is_pending();
+
+        Poll::Ready(())
+    })
+    .await;
+
+    assert!(is_pending);
+}
+
+#[tokio::test]
+async fn poll_next_many_not_enough() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(iter([0usize].into_iter())) as UsizeStream);
+    stream_map.insert(1, Box::pin(iter([1usize].into_iter())) as UsizeStream);
+
+    let mut buffer = vec![];
+    let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut buffer, 3)).await;
+
+    assert_eq!(n, 2);
+    assert_eq!(buffer.len(), 2);
+    assert!(buffer.contains(&(0, 0)));
+    assert!(buffer.contains(&(1, 1)));
+}
+
+#[tokio::test]
+async fn poll_next_many_enough() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(iter([0usize].into_iter())) as UsizeStream);
+    stream_map.insert(1, Box::pin(iter([1usize].into_iter())) as UsizeStream);
+
+    let mut buffer = vec![];
+    let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut buffer, 2)).await;
+
+    assert_eq!(n, 2);
+    assert_eq!(buffer.len(), 2);
+    assert!(buffer.contains(&(0, 0)));
+    assert!(buffer.contains(&(1, 1)));
+}
+
+#[tokio::test]
+async fn poll_next_many_correctly_loops_around() {
+    for _ in 0..10 {
+        let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+        stream_map.insert(0, Box::pin(iter([0usize].into_iter())) as UsizeStream);
+        stream_map.insert(1, Box::pin(iter([0usize, 1].into_iter())) as UsizeStream);
+        stream_map.insert(2, Box::pin(iter([0usize, 1, 2].into_iter())) as UsizeStream);
+
+        let mut buffer = vec![];
+
+        let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut buffer, 3)).await;
+        assert_eq!(n, 3);
+        assert_eq!(
+            std::mem::take(&mut buffer)
+                .into_iter()
+                .map(|(_, v)| v)
+                .collect::<Vec<_>>(),
+            vec![0, 0, 0]
+        );
+
+        let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut buffer, 2)).await;
+        assert_eq!(n, 2);
+        assert_eq!(
+            std::mem::take(&mut buffer)
+                .into_iter()
+                .map(|(_, v)| v)
+                .collect::<Vec<_>>(),
+            vec![1, 1]
+        );
+
+        let n = poll_fn(|cx| stream_map.poll_next_many(cx, &mut buffer, 1)).await;
+        assert_eq!(n, 1);
+        assert_eq!(
+            std::mem::take(&mut buffer)
+                .into_iter()
+                .map(|(_, v)| v)
+                .collect::<Vec<_>>(),
+            vec![2]
+        );
+    }
+}
+
+#[tokio::test]
+async fn next_many_zero() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(pending()) as UsizeStream);
+
+    let n = poll_fn(|cx| pin!(stream_map.next_many(&mut vec![], 0)).poll(cx)).await;
+
+    assert_eq!(n, 0);
+}
+
+#[tokio::test]
+async fn next_many_empty() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    let n = stream_map.next_many(&mut vec![], 1).await;
+
+    assert_eq!(n, 0);
+}
+
+#[tokio::test]
+async fn next_many_pending() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(pending()) as UsizeStream);
+
+    let mut is_pending = false;
+    poll_fn(|cx| {
+        let poll = pin!(stream_map.next_many(&mut vec![], 1)).poll(cx);
+
+        is_pending = poll.is_pending();
+
+        Poll::Ready(())
+    })
+    .await;
+
+    assert!(is_pending);
+}
+
+#[tokio::test]
+async fn next_many_not_enough() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(iter([0usize].into_iter())) as UsizeStream);
+    stream_map.insert(1, Box::pin(iter([1usize].into_iter())) as UsizeStream);
+
+    let mut buffer = vec![];
+    let n = poll_fn(|cx| pin!(stream_map.next_many(&mut buffer, 3)).poll(cx)).await;
+
+    assert_eq!(n, 2);
+    assert_eq!(buffer.len(), 2);
+    assert!(buffer.contains(&(0, 0)));
+    assert!(buffer.contains(&(1, 1)));
+}
+
+#[tokio::test]
+async fn next_many_enough() {
+    let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+    stream_map.insert(0, Box::pin(iter([0usize].into_iter())) as UsizeStream);
+    stream_map.insert(1, Box::pin(iter([1usize].into_iter())) as UsizeStream);
+
+    let mut buffer = vec![];
+    let n = poll_fn(|cx| pin!(stream_map.next_many(&mut buffer, 2)).poll(cx)).await;
+
+    assert_eq!(n, 2);
+    assert_eq!(buffer.len(), 2);
+    assert!(buffer.contains(&(0, 0)));
+    assert!(buffer.contains(&(1, 1)));
+}
+
+#[tokio::test]
+async fn next_many_correctly_loops_around() {
+    for _ in 0..10 {
+        let mut stream_map: StreamMap<usize, UsizeStream> = StreamMap::new();
+
+        stream_map.insert(0, Box::pin(iter([0usize].into_iter())) as UsizeStream);
+        stream_map.insert(1, Box::pin(iter([0usize, 1].into_iter())) as UsizeStream);
+        stream_map.insert(2, Box::pin(iter([0usize, 1, 2].into_iter())) as UsizeStream);
+
+        let mut buffer = vec![];
+
+        let n = poll_fn(|cx| pin!(stream_map.next_many(&mut buffer, 3)).poll(cx)).await;
+        assert_eq!(n, 3);
+        assert_eq!(
+            std::mem::take(&mut buffer)
+                .into_iter()
+                .map(|(_, v)| v)
+                .collect::<Vec<_>>(),
+            vec![0, 0, 0]
+        );
+
+        let n = poll_fn(|cx| pin!(stream_map.next_many(&mut buffer, 2)).poll(cx)).await;
+        assert_eq!(n, 2);
+        assert_eq!(
+            std::mem::take(&mut buffer)
+                .into_iter()
+                .map(|(_, v)| v)
+                .collect::<Vec<_>>(),
+            vec![1, 1]
+        );
+
+        let n = poll_fn(|cx| pin!(stream_map.next_many(&mut buffer, 1)).poll(cx)).await;
+        assert_eq!(n, 1);
+        assert_eq!(
+            std::mem::take(&mut buffer)
+                .into_iter()
+                .map(|(_, v)| v)
+                .collect::<Vec<_>>(),
+            vec![2]
+        );
+    }
+}