Use rust-skeptic for doc tests (tokio-rs#296)

Author: bIgBV

ci/test.sh

@@ -1,18 +1,4 @@
 #!/bin/sh
 set -ex
 
-if [ ! -d tmp ]; then
-  cargo new tmp
-  cat >> tmp/Cargo.toml <<-EOF
-futures = "0.1.18"
-tokio = "0.1.5"
-EOF
-  cargo build --manifest-path tmp/Cargo.toml
-fi
-
-rand=$(ls tmp/target/debug/deps/librand-*.rlib | head -1)
-echo $rand
-for f in $(git ls-files | grep 'md$' | grep -v 'legacy'); do
-  echo "$f"
-  rustdoc --edition 2018 --test "$f" -L tmp/target/debug/deps --extern "rand=$rand"
-done
+cd doc-test && cargo test

content/docs/futures/basic.md

@@ -49,6 +49,8 @@ impl Future for HelloWorld {
         Ok(Async::Ready("hello world".to_string()))
     }
 }
+
+# fn main() {}
 ```
 
 The `Item` and `Error` associated types define the types returned by the future
@@ -112,6 +114,8 @@ where
         Ok(Async::Ready(()))
     }
 }
+
+# fn main() {}
 ```
 
 The `Display` takes a future that yields items that can be displayed. When it is
@@ -143,8 +147,10 @@ extern crate tokio;
 #     }
 # }
 
+# fn main() {
 let future = Display(HelloWorld);
 tokio::run(future);
+# }
 ```
 
 Running this results in "hello world" being outputted to standard out.

content/docs/futures/combinators.md

@@ -292,6 +292,8 @@ fn get_ok_data() -> Result<Vec<Data>, io::Error> {
 
     Ok(dst)
 }
+
+# fn main() {}
 ```
 
 This works because the closure passed to `and_then` is able to obtain a mutable
@@ -375,6 +377,8 @@ fn print_multi() -> impl Future<Item = (), Error = io::Error> {
     future::join_all(futures)
         .map(|_| ())
 }
+
+# fn main() {}
 ```
 
 ## Returning futures
@@ -399,11 +403,13 @@ fn with_future<T: Future<Item = String>>(f: T) {
 # drop(f);
 }
 
+# fn main() {
 let my_future = get_message().map(|message| {
     format!("MESSAGE = {}", message)
 });
 
 with_future(my_future);
+# }
 ```
 
 However, for returning futures, it isn't as simple. There are a few options with
@@ -428,6 +434,8 @@ fn add_10<F>(f: F) -> impl Future<Item = i32, Error = F::Error>
 {
     f.map(|i| i + 10)
 }
+
+# fn main() {}
 ```
 
 The `add_10` function has a return type that is "something that implements

content/docs/futures/spawning.md

@@ -27,6 +27,7 @@ extern crate futures;
 
 use futures::future::lazy;
 
+# fn main() {
 tokio::run(lazy(|| {
     for i in 0..4 {
         tokio::spawn(lazy(move || {
@@ -37,6 +38,7 @@ tokio::run(lazy(|| {
 
     Ok(())
 }));
+# }
 ```
 
 The `tokio::run` function will block until the the future passed to `run`
@@ -70,6 +72,7 @@ use futures::Future;
 use futures::future::lazy;
 use futures::sync::oneshot;
 
+# fn main() {
 tokio::run(lazy(|| {
     let (tx, rx) = oneshot::channel();
 
@@ -84,6 +87,7 @@ tokio::run(lazy(|| {
     })
     .map_err(|e| println!("error = {:?}", e))
 }));
+# }
 ```
 
 And `mpsc` is good for sending a stream of values to another task:
@@ -96,6 +100,7 @@ use futures::{stream, Future, Stream, Sink};
 use futures::future::lazy;
 use futures::sync::mpsc;
 
+# fn main() {
 tokio::run(lazy(|| {
     let (tx, rx) = mpsc::channel(1_024);
 
@@ -112,6 +117,7 @@ tokio::run(lazy(|| {
         Ok(())
     })
 }));
+# }
 ```
 
 These two message passing primitives will also be used in the examples below to
@@ -154,6 +160,7 @@ use tokio::io;
 use tokio::net::TcpListener;
 use futures::{Future, Stream};
 
+# fn main() {
 let addr = "127.0.0.1:0".parse().unwrap();
 let listener = TcpListener::bind(&addr).unwrap();
 
@@ -179,6 +186,7 @@ tokio::run({
     .map_err(|e| println!("listener error = {:?}", e))
 });
 # }
+# }
 ```
 
 The listener task and the tasks that process each socket are completely
@@ -270,6 +278,7 @@ fn bg_task(rx: mpsc::Receiver<usize>)
     .map(|_| ())
 }
 
+# fn main() {
 # if false {
 // Start the application
 tokio::run(lazy(|| {
@@ -310,6 +319,7 @@ tokio::run(lazy(|| {
     .map_err(|e| println!("listener error = {:?}", e))
 }));
 # }
+# }
 ```
 
 ## Coordinating access to a resource
@@ -390,6 +400,7 @@ fn rtt(tx: mpsc::Sender<Message>)
         })
 }
 
+# fn main() {
 # if false {
 // Start the application
 tokio::run(lazy(|| {
@@ -415,6 +426,7 @@ tokio::run(lazy(|| {
     Ok(())
 }));
 # }
+# }
 ```
 
 # When not to spawn tasks

content/docs/futures/streams.md

@@ -100,6 +100,8 @@ impl Stream for Fibonacci {
         Ok(Async::Ready(Some(curr)))
     }
 }
+
+# fn main() {}
 ```
 
 To use the stream, a future must be built that consumes it. The following future
@@ -160,17 +162,19 @@ extern crate tokio;
 # extern crate futures;
 # struct Fibonacci;
 # impl Fibonacci { fn new() { } }
-# struct Display10<T> { v: T };
+# struct Display10<T> { v: T }
 # impl<T> Display10<T> {
 # fn new(_: T) -> futures::future::FutureResult<(), ()> {
 # futures::future::ok(())
 # }
 # }
 
+# fn main() {
 let fib = Fibonacci::new();
 let display = Display10::new(fib);
 
 tokio::run(display);
+# }
 ```
 
 ## Getting asynchronous
@@ -245,7 +249,7 @@ extern crate tokio;
 # extern crate futures;
 # struct Fibonacci;
 # impl Fibonacci { fn new(dur: Duration) { } }
-# struct Display10<T> { v: T };
+# struct Display10<T> { v: T }
 # impl<T> Display10<T> {
 # fn new(_: T) -> futures::future::FutureResult<(), ()> {
 # futures::future::ok(())
@@ -254,10 +258,12 @@ extern crate tokio;
 
 use std::time::Duration;
 
+# fn main() {
 let fib = Fibonacci::new(Duration::from_secs(1));
 let display = Display10::new(fib);
 
 tokio::run(display);
+# }
 ```
 
 # Combinators
@@ -280,6 +286,7 @@ fn fibonacci() -> impl Stream<Item = u64, Error = ()> {
         Some(Ok((curr, (next, new_next))))
     })
 }
+# fn main() {}
 ```
 
 Just like with futures, using stream combinators requires a functional style of
@@ -298,13 +305,15 @@ use futures::Stream;
 # stream::once(Ok(1))
 # }
 
+# fn main() {
 tokio::run(
     fibonacci().take(10)
         .for_each(|num| {
             println!("{}", num);
             Ok(())
         })
 );
+# }
 ```
 
 The [`take`] combinator limits the fibonacci stream to 10 values. The [`for_each`]
@@ -337,6 +346,7 @@ extern crate futures;
 
 use futures::{stream, Stream};
 
+# fn main() {
 let values = vec!["one", "two", "three"];
 
 tokio::run(
@@ -345,6 +355,7 @@ tokio::run(
         Ok(())
     })
 )
+# }
 ```
 
 ## Adapters

content/docs/getting-started/echo.md

@@ -128,7 +128,7 @@ copying operation is complete, resolving to the amount of data that was copied.
 
 Let's take a look at the closure we passed to `for_each` again.
 
-```rust
+```rust, no_run
 # #![deny(deprecated)]
 # extern crate tokio;
 # extern crate futures;

content/docs/getting-started/futures.md

@@ -34,6 +34,7 @@ let n = socket.read(&mut buf).unwrap();
 
 // Do something with &buf[..n];
 # }
+# fn main() {}
 ```
 
 When `socket.read` is called, either the socket has pending data in its receive

content/docs/going-deeper/chat.md

@@ -141,6 +141,7 @@ Here is how the shared state is defined (the `Tx` type alias was done above):
 struct Shared {
     peers: HashMap<SocketAddr, Tx>,
 }
+# fn main() {}
 ```
 
 Then, at the very top of the `main` function, the state instance is created.
@@ -151,7 +152,9 @@ connections.
 # #![deny(deprecated)]
 # use std::sync::{Arc, Mutex};
 # type Shared = String;
+# fn main() {
 let state = Arc::new(Mutex::new(Shared::new()));
+# }
 ```
 
 Now we can handle processing incoming connections. The server task is updated to

content/docs/going-deeper/frames.md

@@ -35,6 +35,8 @@ pub struct LinesCodec {
     // only look at `de\n` before returning.
     next_index: usize,
 }
+
+# fn main() {}
 ```
 
 The comments here explain how, since the bytes are buffered until a line is
@@ -58,7 +60,7 @@ Let's look at how `Decoder::decode` is implemented for `LinesCodec`.
 # use std::str;
 # use bytes::BytesMut;
 # use tokio_io::codec::*;
-# struct LinesCodec { next_index: usize };
+# struct LinesCodec { next_index: usize }
 # impl Decoder for LinesCodec {
 #    type Item = String;
 #    type Error = io::Error;
@@ -100,6 +102,7 @@ fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<String>, io::Error> {
     }
 }
 # }
+# fn main() {}
 ```
 
 The `Encoder::encode` method is called when a frame must be written to the
@@ -116,7 +119,7 @@ Let's now look at how `Encoder::encode` is implemented for `LinesCodec`.
 # use std::str;
 # use bytes::*;
 # use tokio_io::codec::*;
-# struct LinesCodec { next_index: usize };
+# struct LinesCodec { next_index: usize }
 # impl Encoder for LinesCodec {
 #    type Item = String;
 #    type Error = io::Error;
@@ -137,6 +140,7 @@ fn encode(&mut self, line: String, buf: &mut BytesMut) -> Result<(), io::Error>
     Ok(())
 }
 # }
+# fn main() {}
 ```
 
 It's often simpler to encode information. Here we simply reserve the space
@@ -158,6 +162,7 @@ and `AsyncWrite` traits using the `AsyncRead::framed` method.
 # use futures::prelude::*;
 # use tokio::net::TcpStream;
 # use tokio_codec::{Framed, LinesCodec};
+# fn main() {
 # let addr = "127.0.0.1:5000".parse().expect("invalid socket address");
 TcpStream::connect(&addr).and_then(|sock| {
     let framed_sock = Framed::new(sock, LinesCodec::new());
@@ -166,4 +171,5 @@ TcpStream::connect(&addr).and_then(|sock| {
         Ok(())
     })
 });
+# }
 ```

content/docs/going-deeper/futures.md

@@ -248,6 +248,8 @@ And the `ResolveAndConnect` future is defined as:
 pub struct ResolveAndConnect {
     state: State,
 }
+
+# fn main() {}
 ```
 
 Now, the implementation: