aboutsummaryrefslogtreecommitdiff
path: root/tests/io_buf_writer.rs
diff options
context:
space:
mode:
Diffstat (limited to 'tests/io_buf_writer.rs')
-rw-r--r--tests/io_buf_writer.rs222
1 files changed, 131 insertions, 91 deletions
diff --git a/tests/io_buf_writer.rs b/tests/io_buf_writer.rs
index 7bdcd16..935335b 100644
--- a/tests/io_buf_writer.rs
+++ b/tests/io_buf_writer.rs
@@ -1,13 +1,70 @@
-use futures::executor::block_on;
-use futures::future::{Future, FutureExt};
-use futures::io::{AsyncSeek, AsyncSeekExt, AsyncWrite, AsyncWriteExt, BufWriter, Cursor, SeekFrom};
-use futures::task::{Context, Poll};
-use futures_test::task::noop_context;
-use std::io;
-use std::pin::Pin;
+#[cfg(feature = "std")]
+mod maybe_pending {
+ use futures::io::AsyncWrite;
+ use futures::task::{Context, Poll};
+ use std::io;
+ use std::pin::Pin;
+
+ pub struct MaybePending {
+ pub inner: Vec<u8>,
+ ready: bool,
+ }
+
+ impl MaybePending {
+ pub fn new(inner: Vec<u8>) -> Self {
+ Self { inner, ready: false }
+ }
+ }
+
+ impl AsyncWrite for MaybePending {
+ fn poll_write(
+ mut self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ buf: &[u8],
+ ) -> Poll<io::Result<usize>> {
+ if self.ready {
+ self.ready = false;
+ Pin::new(&mut self.inner).poll_write(cx, buf)
+ } else {
+ self.ready = true;
+ Poll::Pending
+ }
+ }
+
+ fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+ Pin::new(&mut self.inner).poll_flush(cx)
+ }
+
+ fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+ Pin::new(&mut self.inner).poll_close(cx)
+ }
+ }
+}
+
+#[cfg(any(feature = "std", feature = "executor"))]
+mod util {
+ use futures::future::Future;
+
+ pub fn run<F: Future + Unpin>(mut f: F) -> F::Output {
+ use futures::future::FutureExt;
+ use futures::task::Poll;
+ use futures_test::task::noop_context;
+ let mut cx = noop_context();
+ loop {
+ if let Poll::Ready(x) = f.poll_unpin(&mut cx) {
+ return x;
+ }
+ }
+ }
+}
+
+#[cfg(feature = "executor")]
#[test]
fn buf_writer() {
+ use futures::executor::block_on;
+ use futures::io::{AsyncWriteExt, BufWriter};
+
let mut writer = BufWriter::with_capacity(2, Vec::new());
block_on(writer.write(&[0, 1])).unwrap();
@@ -48,8 +105,12 @@ fn buf_writer() {
assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
}
+#[cfg(feature = "executor")]
#[test]
fn buf_writer_inner_flushes() {
+ use futures::executor::block_on;
+ use futures::io::{AsyncWriteExt, BufWriter};
+
let mut w = BufWriter::with_capacity(3, Vec::new());
block_on(w.write(&[0, 1])).unwrap();
assert_eq!(*w.get_ref(), []);
@@ -58,8 +119,12 @@ fn buf_writer_inner_flushes() {
assert_eq!(w, [0, 1]);
}
+#[cfg(feature = "executor")]
#[test]
fn buf_writer_seek() {
+ use futures::executor::block_on;
+ use futures::io::{AsyncSeekExt, AsyncWriteExt, BufWriter, Cursor, SeekFrom};
+
// FIXME: when https://github.com/rust-lang/futures-rs/issues/1510 fixed,
// use `Vec::new` instead of `vec![0; 8]`.
let mut w = BufWriter::with_capacity(3, Cursor::new(vec![0; 8]));
@@ -73,52 +138,14 @@ fn buf_writer_seek() {
assert_eq!(&w.into_inner().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
}
-struct MaybePending {
- inner: Vec<u8>,
- ready: bool,
-}
-
-impl MaybePending {
- fn new(inner: Vec<u8>) -> Self {
- Self { inner, ready: false }
- }
-}
-
-impl AsyncWrite for MaybePending {
- fn poll_write(
- mut self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- buf: &[u8],
- ) -> Poll<io::Result<usize>> {
- if self.ready {
- self.ready = false;
- Pin::new(&mut self.inner).poll_write(cx, buf)
- } else {
- self.ready = true;
- Poll::Pending
- }
- }
-
- fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
- Pin::new(&mut self.inner).poll_flush(cx)
- }
-
- fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
- Pin::new(&mut self.inner).poll_close(cx)
- }
-}
-
-fn run<F: Future + Unpin>(mut f: F) -> F::Output {
- let mut cx = noop_context();
- loop {
- if let Poll::Ready(x) = f.poll_unpin(&mut cx) {
- return x;
- }
- }
-}
-
+#[cfg(feature = "std")]
#[test]
fn maybe_pending_buf_writer() {
+ use futures::io::{AsyncWriteExt, BufWriter};
+
+ use maybe_pending::MaybePending;
+ use util::run;
+
let mut writer = BufWriter::with_capacity(2, MaybePending::new(Vec::new()));
run(writer.write(&[0, 1])).unwrap();
@@ -159,8 +186,14 @@ fn maybe_pending_buf_writer() {
assert_eq!(&writer.get_ref().inner, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
}
+#[cfg(feature = "std")]
#[test]
fn maybe_pending_buf_writer_inner_flushes() {
+ use futures::io::{AsyncWriteExt, BufWriter};
+
+ use maybe_pending::MaybePending;
+ use util::run;
+
let mut w = BufWriter::with_capacity(3, MaybePending::new(Vec::new()));
run(w.write(&[0, 1])).unwrap();
assert_eq!(&w.get_ref().inner, &[]);
@@ -169,59 +202,66 @@ fn maybe_pending_buf_writer_inner_flushes() {
assert_eq!(w, [0, 1]);
}
+#[cfg(feature = "std")]
+#[test]
+fn maybe_pending_buf_writer_seek() {
+ use futures::io::{AsyncSeek, AsyncSeekExt, AsyncWrite, AsyncWriteExt, BufWriter, Cursor, SeekFrom};
+ use futures::task::{Context, Poll};
+ use std::io;
+ use std::pin::Pin;
-struct MaybePendingSeek {
- inner: Cursor<Vec<u8>>,
- ready_write: bool,
- ready_seek: bool,
-}
+ use util::run;
-impl MaybePendingSeek {
- fn new(inner: Vec<u8>) -> Self {
- Self { inner: Cursor::new(inner), ready_write: false, ready_seek: false }
+ struct MaybePendingSeek {
+ inner: Cursor<Vec<u8>>,
+ ready_write: bool,
+ ready_seek: bool,
}
-}
-impl AsyncWrite for MaybePendingSeek {
- fn poll_write(
- mut self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- buf: &[u8],
- ) -> Poll<io::Result<usize>> {
- if self.ready_write {
- self.ready_write = false;
- Pin::new(&mut self.inner).poll_write(cx, buf)
- } else {
- self.ready_write = true;
- Poll::Pending
+ impl MaybePendingSeek {
+ fn new(inner: Vec<u8>) -> Self {
+ Self { inner: Cursor::new(inner), ready_write: false, ready_seek: false }
}
}
- fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
- Pin::new(&mut self.inner).poll_flush(cx)
- }
+ impl AsyncWrite for MaybePendingSeek {
+ fn poll_write(
+ mut self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ buf: &[u8],
+ ) -> Poll<io::Result<usize>> {
+ if self.ready_write {
+ self.ready_write = false;
+ Pin::new(&mut self.inner).poll_write(cx, buf)
+ } else {
+ self.ready_write = true;
+ Poll::Pending
+ }
+ }
- fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
- Pin::new(&mut self.inner).poll_close(cx)
+ fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+ Pin::new(&mut self.inner).poll_flush(cx)
+ }
+
+ fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+ Pin::new(&mut self.inner).poll_close(cx)
+ }
}
-}
-impl AsyncSeek for MaybePendingSeek {
- fn poll_seek(mut self: Pin<&mut Self>, cx: &mut Context<'_>, pos: SeekFrom)
- -> Poll<io::Result<u64>>
- {
- if self.ready_seek {
- self.ready_seek = false;
- Pin::new(&mut self.inner).poll_seek(cx, pos)
- } else {
- self.ready_seek = true;
- Poll::Pending
+ impl AsyncSeek for MaybePendingSeek {
+ fn poll_seek(mut self: Pin<&mut Self>, cx: &mut Context<'_>, pos: SeekFrom)
+ -> Poll<io::Result<u64>>
+ {
+ if self.ready_seek {
+ self.ready_seek = false;
+ Pin::new(&mut self.inner).poll_seek(cx, pos)
+ } else {
+ self.ready_seek = true;
+ Poll::Pending
+ }
}
}
-}
-#[test]
-fn maybe_pending_buf_writer_seek() {
// FIXME: when https://github.com/rust-lang/futures-rs/issues/1510 fixed,
// use `Vec::new` instead of `vec![0; 8]`.
let mut w = BufWriter::with_capacity(3, MaybePendingSeek::new(vec![0; 8]));
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-17 00:23:19 +0000