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;
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;
}
}
}
#[test]
fn buf_writer() {
let mut writer = BufWriter::with_capacity(
2, Vec::new());
block_on(writer.write(&[
0,
1])).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(*writer.get_ref(), [
0,
1]);
block_on(writer.write(&[
2])).unwrap();
assert_eq!(writer.buffer(), [
2]);
assert_eq!(*writer.get_ref(), [
0,
1]);
block_on(writer.write(&[
3])).unwrap();
assert_eq!(writer.buffer(), [
2,
3]);
assert_eq!(*writer.get_ref(), [
0,
1]);
block_on(writer.flush()).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(*writer.get_ref(), [
0,
1,
2,
3]);
block_on(writer.write(&[
4])).unwrap();
block_on(writer.write(&[
5])).unwrap();
assert_eq!(writer.buffer(), [
4,
5]);
assert_eq!(*writer.get_ref(), [
0,
1,
2,
3]);
block_on(writer.write(&[
6])).unwrap();
assert_eq!(writer.buffer(), [
6]);
assert_eq!(*writer.get_ref(), [
0,
1,
2,
3,
4,
5]);
block_on(writer.write(&[
7,
8])).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(*writer.get_ref(), [
0,
1,
2,
3,
4,
5,
6,
7,
8]);
block_on(writer.write(&[
9,
10,
11])).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(*writer.get_ref(), [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11]);
block_on(writer.flush()).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(*writer.get_ref(), [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11]);
}
#[test]
fn buf_writer_inner_flushes() {
let mut w = BufWriter::with_capacity(
3, Vec::new());
block_on(w.write(&[
0,
1])).unwrap();
assert_eq!(*w.get_ref(), []);
block_on(w.flush()).unwrap();
let w = w.into_inner();
assert_eq!(w, [
0,
1]);
}
#[test]
fn 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, Cursor::new(vec![
0;
8]));
block_on(w.write_all(&[
0,
1,
2,
3,
4,
5])).unwrap();
block_on(w.write_all(&[
6,
7])).unwrap();
assert_eq!(block_on(w.seek(SeekFrom::Current(
0))).ok(), Some(
8));
assert_eq!(&w.get_ref().get_ref()[..], &[
0,
1,
2,
3,
4,
5,
6,
7][..]);
assert_eq!(block_on(w.seek(SeekFrom::Start(
2))).ok(), Some(
2));
block_on(w.write_all(&[
8,
9])).unwrap();
block_on(w.flush()).unwrap();
assert_eq!(&w.into_inner().into_inner()[..], &[
0,
1,
8,
9,
4,
5,
6,
7]);
}
#[test]
fn maybe_pending_buf_writer() {
let mut writer = BufWriter::with_capacity(
2, MaybePending::new(Vec::new()));
run(writer.write(&[
0,
1])).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(&writer.get_ref().inner, &[
0,
1]);
run(writer.write(&[
2])).unwrap();
assert_eq!(writer.buffer(), [
2]);
assert_eq!(&writer.get_ref().inner, &[
0,
1]);
run(writer.write(&[
3])).unwrap();
assert_eq!(writer.buffer(), [
2,
3]);
assert_eq!(&writer.get_ref().inner, &[
0,
1]);
run(writer.flush()).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(&writer.get_ref().inner, &[
0,
1,
2,
3]);
run(writer.write(&[
4])).unwrap();
run(writer.write(&[
5])).unwrap();
assert_eq!(writer.buffer(), [
4,
5]);
assert_eq!(&writer.get_ref().inner, &[
0,
1,
2,
3]);
run(writer.write(&[
6])).unwrap();
assert_eq!(writer.buffer(), [
6]);
assert_eq!(writer.get_ref().inner, &[
0,
1,
2,
3,
4,
5]);
run(writer.write(&[
7,
8])).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(writer.get_ref().inner, &[
0,
1,
2,
3,
4,
5,
6,
7,
8]);
run(writer.write(&[
9,
10,
11])).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(writer.get_ref().inner, &[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11]);
run(writer.flush()).unwrap();
assert_eq!(writer.buffer(), []);
assert_eq!(&writer.get_ref().inner, &[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11]);
}
#[test]
fn maybe_pending_buf_writer_inner_flushes() {
let mut w = BufWriter::with_capacity(
3, MaybePending::new(Vec::new()));
run(w.write(&[
0,
1])).unwrap();
assert_eq!(&w.get_ref().inner, &[]);
run(w.flush()).unwrap();
let w = w.into_inner().inner;
assert_eq!(w, [
0,
1]);
}
#[test]
fn maybe_pending_buf_writer_seek() {
struct MaybePendingSeek {
inner: Cursor<Vec<u8>>,
ready_write: bool,
ready_seek: bool,
}
impl MaybePendingSeek {
fn new(inner: Vec<u8>) ->
Self {
Self { inner: Cursor::new(inner), ready_write:
false, ready_seek:
false }
}
}
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_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
}
}
}
// 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]));
run(w.write_all(&[
0,
1,
2,
3,
4,
5])).unwrap();
run(w.write_all(&[
6,
7])).unwrap();
assert_eq!(run(w.seek(SeekFrom::Current(
0))).ok(), Some(
8));
assert_eq!(&w.get_ref().inner.get_ref()[..], &[
0,
1,
2,
3,
4,
5,
6,
7][..]);
assert_eq!(run(w.seek(SeekFrom::Start(
2))).ok(), Some(
2));
run(w.write_all(&[
8,
9])).unwrap();
run(w.flush()).unwrap();
assert_eq!(&w.into_inner().inner.into_inner()[..], &[
0,
1,
8,
9,
4,
5,
6,
7]);
}
