Add test to reproduce issue in impl Stream for Entries causing file…

…name truncation (#1)

This is from edera-dev/tokio-tar#3

---

I tracked down this issue in
astral-sh/uv#5450 (comment)

>
https://github.com/edera-dev/tokio-tar/blob/4ee357285b5053e6bfada7f117e530b4da94b74a/src/archive.rs#L317
> 
> ```rust
> if is_recognized_header &&
entry.header().entry_type().is_pax_local_extensions() {
>                 if self.pax_extensions.is_some() {
>                     return Poll::Ready(Some(Err(other(
>                         "two pax extensions entries describing \
>                          the same member",
>                     ))));
>                 }
>                 let mut ef = EntryFields::from(entry);
> let val = ready_err!(Pin::new(&mut ef).poll_read_all(cx));
>                 self.pax_extensions = Some(val);
>                 continue;
>             }
> ```
> 
> if `Pin::new(&mut ef).poll_read_all(cx)` is `Poll::Pending` then
`ready_err!` returns it, so the Pax extension is lost. The same would
apply to a pending poll that occurs while a > longlink or longname is
being prepared. When `poll_next` is called again the next entry header
is parsed.

This PR demonstrates the issue by creating an AsyncRead impl which pends
every second time it is polled.

Commenting out [this
line](https://github.com/RazerM/tokio-tar/blob/15466052f63c47cf47decd4409a9b0e936302773/tests/all.rs#L816)
makes the test pass, because the reader doesn't enter a pending state in
the "wrong" place.

It is probably also the cause of
dignifiedquire/async-tar#39

tests/all.rs

@@ -762,6 +762,68 @@ async fn pax_simple() {
     assert_eq!(third.value(), Ok("1453146164.953123768"));
 }
 
+#[tokio::test]
+async fn pax_pending_interrupted() {
+    use std::pin::Pin;
+
+    struct SirPendalot<R> {
+        inner: R,
+        n: usize,
+    }
+
+    impl<R> SirPendalot<R>
+    where
+        R: AsyncRead + Unpin,
+    {
+        fn new(reader: R) -> Self {
+            Self {
+                inner: reader,
+                n: 0,
+            }
+        }
+
+        fn project(self: Pin<&mut Self>) -> (Pin<&mut R>, &mut usize) {
+            let Self { inner, n } = std::pin::Pin::into_inner(self);
+            (Pin::new(inner), n)
+        }
+    }
+    impl<R> AsyncRead for SirPendalot<R>
+    where
+        R: AsyncRead + Unpin,
+    {
+        fn poll_read(
+            self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+            buf: &mut tokio::io::ReadBuf<'_>,
+        ) -> std::task::Poll<std::io::Result<()>> {
+            use std::task::Poll;
+
+            let (inner, n) = self.project();
+
+            let pend = *n % 2 == 0;
+            *n += 1;
+
+            if pend {
+                cx.waker().wake_by_ref();
+                return Poll::Pending;
+            }
+
+            inner.poll_read(cx, buf)
+        }
+    }
+
+    let ar = tar!("paxlongname.tar");
+    let ar = SirPendalot::new(ar);
+    let mut ar = Archive::new(ar);
+    let mut entries = t!(ar.entries());
+
+    let entry = t!(entries.next().await.unwrap());
+    let path = t!(entry.path());
+    let path = path.to_str().unwrap();
+
+    assert_eq!(path, "this_file_name_will_be_one_hundred_and_one_characters_long_once_i_add_some_more_characters_at_the_end");
+}
+
 #[tokio::test]
 async fn pax_path() {
     let mut ar = Archive::new(tar!("pax2.tar"));