fix test_0rtt

Author: dignifiedquire

src/acceptor.rs

@@ -4,10 +4,10 @@ use crate::server;
 use futures::io::{AsyncRead, AsyncWrite};
 use rustls::{ServerConfig, ServerSession};
 use std::future::Future;
+use std::io;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::io;
 
 /// The TLS accepting part. The acceptor drives
 /// the server side of the TLS handshake process. It works
@@ -73,4 +73,4 @@ impl From<Arc<ServerConfig>> for TlsAcceptor {
     fn from(inner: Arc<ServerConfig>) -> TlsAcceptor {
         TlsAcceptor { inner }
     }
-}
+}

src/client.rs

@@ -1,5 +1,5 @@
-use crate::rusttls::stream::Stream;
 use crate::common::tls_state::TlsState;
+use crate::rusttls::stream::Stream;
 use futures::io::{AsyncRead, AsyncWrite};
 use rustls::ClientSession;
 use std::future::Future;

src/common/tls_state.rs

@@ -36,4 +36,4 @@ impl TlsState {
             _ => true,
         }
     }
-}
+}

src/connector.rs

@@ -3,27 +3,27 @@ use crate::common::tls_state::TlsState;
 use crate::client;
 
 use futures::io::{AsyncRead, AsyncWrite};
-use rustls::{ClientConfig,ClientSession};
+use rustls::{ClientConfig, ClientSession};
 use std::future::Future;
+use std::io;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::io;
 use webpki::DNSNameRef;
 
 /// The TLS connecting part. The acceptor drives
 /// the client side of the TLS handshake process. It works
 /// on any asynchronous stream.
-/// 
+///
 /// It provides a simple interface (`connect`), returning a future
 /// that will resolve when the handshake process completed. On
 /// success, it will hand you an async `TlsStream`.
-/// 
+///
 /// To create a `TlsConnector` with a non-default configuation, create
 /// a `rusttls::ClientConfig` and call `.into()` on it.
 ///
 /// ## Example
-/// 
+///
 /// ```rust
 /// #![feature(async_await)]
 ///
@@ -67,7 +67,7 @@ impl Default for TlsConnector {
 
 impl TlsConnector {
     /// Create a new TlsConnector with default configuration.
-    /// 
+    ///
     /// This is the same as calling `TlsConnector::default()`.
     pub fn new() -> Self {
         Default::default()
@@ -157,7 +157,3 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Connect<IO> {
         Pin::new(&mut self.0).poll(cx)
     }
 }
-
-#[cfg(feature = "early-data")]
-#[cfg(test)]
-mod test_0rtt;

src/lib.rs

@@ -2,12 +2,16 @@
 
 #![deny(unsafe_code)]
 
+mod acceptor;
 pub mod client;
-pub mod server;
 mod common;
-mod rusttls;
 mod connector;
-mod acceptor;
+mod rusttls;
+pub mod server;
+
+pub use acceptor::TlsAcceptor;
+pub use connector::TlsConnector;
 
-pub use acceptor::TlsAcceptor as TlsAcceptor;
-pub use connector::TlsConnector as TlsConnector;
+#[cfg(feature = "early-data")]
+#[cfg(test)]
+mod test_0rtt;

src/rusttls/mod.rs

@@ -1 +1 @@
-pub(crate) mod stream;
+pub(crate) mod stream;

src/rusttls/stream.rs

@@ -258,5 +258,5 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> AsyncWrite for Stream<'
 }
 
 #[cfg(test)]
-#[path="test_stream.rs"]
+#[path = "test_stream.rs"]
 mod test_stream;

src/server.rs

@@ -1,5 +1,5 @@
-use crate::rusttls::stream::Stream;
 use crate::common::tls_state::TlsState;
+use crate::rusttls::stream::Stream;
 
 use futures::io::{AsyncRead, AsyncWrite};
 use rustls::ServerSession;

src/test_0rtt.rs

@@ -1,11 +1,11 @@
 use crate::{client::TlsStream, TlsConnector};
+use async_std::net::TcpStream;
+use async_std::sync::Arc;
 use futures::executor;
 use futures::prelude::*;
-use romio::tcp::TcpStream;
 use rustls::ClientConfig;
 use std::io;
 use std::net::ToSocketAddrs;
-use std::sync::Arc;
 
 async fn get(
     config: Arc<ClientConfig>,
@@ -16,11 +16,10 @@ async fn get(
     let input = format!("GET / HTTP/1.0\r\nHost: {}\r\n\r\n", domain);
 
     let addr = (domain, 443).to_socket_addrs()?.next().unwrap();
-    let domain = webpki::DNSNameRef::try_from_ascii_str(&domain).unwrap();
     let mut buf = Vec::new();
 
     let stream = TcpStream::connect(&addr).await?;
-    let mut stream = connector.connect(domain, stream).await?;
+    let mut stream = connector.connect(domain, stream)?.await?;
     stream.write_all(input.as_bytes()).await?;
     stream.read_to_end(&mut buf).await?;