Fix the LineWriter bug and documentation tests

Signed-off-by: Kirill Mironov <[email protected]>

Author: Drevoed

src/io/buf_writer.rs

@@ -34,34 +34,40 @@ const DEFAULT_CAPACITY: usize = 8 * 1024;
 ///
 /// Let's write the numbers one through ten to a [`TcpStream`]:
 ///
-/*/ ```no_run
-/ use std::io::prelude::*;
-/ use std::net::TcpStream;
-/
-/ let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
-/
-/ for i in 0..10 {
-/     stream.write(&[i+1]).unwrap();
-/ }
-/ ```*/
+/// ```no_run
+/// # #![feature(async_await)]
+/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+/// use async_std::net::TcpStream;
+/// use async_std::io::Write;
+///
+/// let mut stream = TcpStream::connect("127.0.0.1:34254").await?;
+///
+/// for i in 0..10 {
+///     let arr = [i+1];
+///     stream.write(&arr).await?;
+/// }
+/// #
+/// # Ok(()) }) }
+/// ```
 ///
 /// Because we're not buffering, we write each one in turn, incurring the
 /// overhead of a system call per byte written. We can fix this with a
 /// `BufWriter`:
 ///
 /// ```no_run
-/// use async_std::io::prelude::*;
+/// # #![feature(async_await)]
+/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
 /// use async_std::io::BufWriter;
 /// use async_std::net::TcpStream;
-/// use futures::AsyncWrite;
 /// use async_std::io::Write;
 ///
-/// async_std::task::block_on(async {
-///     let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
-///     for i in 0..10 {
-///         stream.write(&[i+1]).await;
-///     }
-/// });
+/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").await?);
+/// for i in 0..10 {
+///     let arr = [i+1];
+///     stream.write(&arr).await?;
+/// };
+/// #
+/// # Ok(()) }) }
 /// ```
 ///
 /// By wrapping the stream with a `BufWriter`, these ten writes are all grouped
@@ -88,10 +94,15 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
     /// # Examples
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # #![allow(unused_mut)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::io::BufWriter;
     /// use async_std::net::TcpStream;
     ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").await?);
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn new(inner: W) -> BufWriter<W> {
         BufWriter::with_capacity(DEFAULT_CAPACITY, inner)
@@ -104,11 +115,16 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
     /// Creating a buffer with a buffer of a hundred bytes.
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # #![allow(unused_mut)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::io::BufWriter;
     /// use async_std::net::TcpStream;
     ///
-    /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
+    /// let stream = TcpStream::connect("127.0.0.1:34254").await?;
     /// let mut buffer = BufWriter::with_capacity(100, stream);
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn with_capacity(capacity: usize, inner: W) -> BufWriter<W> {
         BufWriter {
@@ -123,13 +139,18 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
     /// # Examples
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # #![allow(unused_mut)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::io::BufWriter;
     /// use async_std::net::TcpStream;
     ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").await?);
     ///
-    /// // we can use reference just like buffer
+    /// // We can use reference just like buffer
     /// let reference = buffer.get_ref();
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn get_ref(&self) -> &W {
         &self.inner
@@ -142,13 +163,17 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
     /// # Examples
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::io::BufWriter;
     /// use async_std::net::TcpStream;
     ///
-    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").await?);
     ///
-    /// // we can use reference just like buffer
+    /// // We can use reference just like buffer
     /// let reference = buffer.get_mut();
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn get_mut(&mut self) -> &mut W {
         &mut self.inner
@@ -177,13 +202,17 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
     /// # Examples
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::io::BufWriter;
     /// use async_std::net::TcpStream;
     ///
-    /// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    /// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34251").await?);
     ///
     /// // See how many bytes are currently buffered
     /// let bytes_buffered = buf_writer.buffer().len();
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn buffer(&self) -> &[u8] {
         &self.buf
@@ -276,16 +305,15 @@ impl<W: AsyncWrite + Unpin> LineWriter<W> {
     /// # Examples
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::fs::File;
     /// use async_std::io::LineWriter;
     ///
-    /// fn main() -> std::io::Result<()> {
-    /// async_std::task::block_on(async {
-    ///         let file = File::create("poem.txt").await?;
-    ///         let file = LineWriter::new(file);
-    ///         Ok(())
-    ///     })
-    /// }
+    /// let file = File::create("poem.txt").await?;
+    /// let file = LineWriter::new(file);
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn new(inner: W) -> LineWriter<W> {
         // Lines typically aren't that long, don't use a giant buffer
@@ -298,16 +326,15 @@ impl<W: AsyncWrite + Unpin> LineWriter<W> {
     /// # Examples
     ///
     /// ```no_run
+    /// # #![feature(async_await)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
     /// use async_std::fs::File;
     /// use async_std::io::LineWriter;
     ///
-    /// fn main() -> std::io::Result<()> {
-    ///     async_std::task::block_on(async {
-    ///         let file = File::create("poem.txt").await?;
-    ///         let file = LineWriter::with_capacity(100, file);
-    ///         Ok(())
-    ///     })
-    /// }
+    /// let file = File::create("poem.txt").await?;
+    /// let file = LineWriter::with_capacity(100, file);
+    /// #
+    /// # Ok(()) }) }
     /// ```
     pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W> {
         LineWriter {
@@ -342,7 +369,7 @@ impl<W: AsyncWrite + Unpin> AsyncWrite for LineWriter<W> {
 
         let n = ready!(self.as_mut().inner().as_mut().poll_write(cx, &buf[..=i])?);
         *self.as_mut().need_flush() = true;
-        if ready!(self.as_mut().poll_flush(cx)).is_err() || n != 1 + 1 {
+        if ready!(self.as_mut().poll_flush(cx)).is_err() || n != i + 1 {
             return Poll::Ready(Ok(n))
         }
         match ready!(self.inner().poll_write(cx, &buf[i + 1..])) {
@@ -389,13 +416,11 @@ mod tests {
             assert_eq!(*writer.get_ref(), []);
             writer.flush().await.unwrap();
             assert_eq!(*writer.get_ref(), [0, 1]);
-            writer.write(&[0, b'\n', 1, b'\n']).await.unwrap();
+            writer.write(&[0, b'\n', 1, b'\n', 2]).await.unwrap();
             assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
             writer.flush().await.unwrap();
-            //assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
-            println!("{:?}", *writer.get_ref());
+            assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
             writer.write(&[3, b'\n']).await.unwrap();
-            println!("{:?}", *writer.get_ref());
             assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
         })
     }