Some misc cleanup

1 files changed, 81 insertions, 60 deletions

diff --git a/openssl/src/ssl/test.rs b/openssl/src/ssl/test.rs
index ddcb49ff..150b4cdc 100644
--- a/openssl/src/ssl/test.rs
+++ b/openssl/src/ssl/test.rs
@@ -17,16 +17,16 @@ use tempdir::TempDir;
 use dh::Dh;
 use hash::MessageDigest;
 use ocsp::{OcspResponse, OcspResponseStatus};
+use pkey::PKey;
 use ssl;
-use ssl::{Error, HandshakeError, ShutdownResult, Ssl, SslAcceptor, SslConnector, SslContext,
-          SslFiletype, SslMethod, SslSessionCacheMode, SslStream, MidHandshakeSslStream,
-          SslVerifyMode, StatusType};
 #[cfg(any(ossl110, ossl111))]
 use ssl::SslVersion;
-use x509::{X509, X509Name, X509StoreContext, X509VerifyResult};
+use ssl::{Error, HandshakeError, MidHandshakeSslStream, ShutdownResult, Ssl, SslAcceptor,
+          SslConnector, SslContext, SslFiletype, SslMethod, SslSessionCacheMode, SslStream,
+          SslVerifyMode, StatusType};
 #[cfg(any(ossl102, ossl110))]
 use x509::verify::X509CheckFlags;
-use pkey::PKey;
+use x509::{X509, X509Name, X509StoreContext, X509VerifyResult};
 
 use std::net::UdpSocket;
 
@@ -1391,74 +1391,89 @@ fn _check_kinds() {
     is_sync::<SslStream<TcpStream>>();
 }
 
-#[derive(Debug)]
-struct MemoryStream {
-    incoming: io::Cursor<Vec<u8>>,
-    outgoing: Vec<u8>,
-}
-
-impl MemoryStream {
-    pub fn new() -> Self { Self {
-        incoming: io::Cursor::new(Vec::new()),
-        outgoing: Vec::new(),
-    }}
+#[test]
+#[cfg(ossl111)]
+fn stateless() {
+    use super::SslOptions;
 
-    pub fn extend_incoming(&mut self, data: &[u8]) {
-        self.incoming.get_mut().extend_from_slice(data);
+    #[derive(Debug)]
+    struct MemoryStream {
+        incoming: io::Cursor<Vec<u8>>,
+        outgoing: Vec<u8>,
     }
 
-    pub fn take_outgoing(&mut self) -> Outgoing { Outgoing(&mut self.outgoing) }
-}
+    impl MemoryStream {
+        pub fn new() -> Self {
+            Self {
+                incoming: io::Cursor::new(Vec::new()),
+                outgoing: Vec::new(),
+            }
+        }
 
-impl Read for MemoryStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let n = self.incoming.read(buf)?;
-        if self.incoming.position() == self.incoming.get_ref().len() as u64 {
-            self.incoming.set_position(0);
-            self.incoming.get_mut().clear();
+        pub fn extend_incoming(&mut self, data: &[u8]) {
+            self.incoming.get_mut().extend_from_slice(data);
         }
-        if n == 0 {
-            return Err(io::Error::new(io::ErrorKind::WouldBlock, "no data available"));
+
+        pub fn take_outgoing(&mut self) -> Outgoing {
+            Outgoing(&mut self.outgoing)
         }
-        Ok(n)
     }
-}
 
-impl Write for MemoryStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.outgoing.write(buf)
+    impl Read for MemoryStream {
+        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+            let n = self.incoming.read(buf)?;
+            if self.incoming.position() == self.incoming.get_ref().len() as u64 {
+                self.incoming.set_position(0);
+                self.incoming.get_mut().clear();
+            }
+            if n == 0 {
+                return Err(io::Error::new(
+                    io::ErrorKind::WouldBlock,
+                    "no data available",
+                ));
+            }
+            Ok(n)
+        }
     }
 
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-pub struct Outgoing<'a>(&'a mut Vec<u8>);
+    impl Write for MemoryStream {
+        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+            self.outgoing.write(buf)
+        }
 
-impl<'a> Drop for Outgoing<'a> {
-    fn drop(&mut self) {
-        self.0.clear();
+        fn flush(&mut self) -> io::Result<()> {
+            Ok(())
+        }
     }
-}
 
-impl<'a> ::std::ops::Deref for Outgoing<'a> {
-    type Target = [u8];
-    fn deref(&self) -> &[u8] { &self.0 }
-}
+    pub struct Outgoing<'a>(&'a mut Vec<u8>);
 
-impl<'a> AsRef<[u8]> for Outgoing<'a> {
-    fn as_ref(&self) -> &[u8] { &self.0 }
-}
+    impl<'a> Drop for Outgoing<'a> {
+        fn drop(&mut self) {
+            self.0.clear();
+        }
+    }
 
-fn send(from: &mut MemoryStream, to: &mut MemoryStream) {
-    to.extend_incoming(&from.take_outgoing());
-}
+    impl<'a> ::std::ops::Deref for Outgoing<'a> {
+        type Target = [u8];
+        fn deref(&self) -> &[u8] {
+            &self.0
+        }
+    }
 
-#[test]
-#[cfg(ossl111)]
-fn stateless() {
-    use super::SslOptions;
+    impl<'a> AsRef<[u8]> for Outgoing<'a> {
+        fn as_ref(&self) -> &[u8] {
+            &self.0
+        }
+    }
 
-    fn hs<S: ::std::fmt::Debug>(stream: Result<SslStream<S>, HandshakeError<S>>) -> Result<SslStream<S>, MidHandshakeSslStream<S>> {
+    fn send(from: &mut MemoryStream, to: &mut MemoryStream) {
+        to.extend_incoming(&from.take_outgoing());
+    }
+
+    fn hs<S: ::std::fmt::Debug>(
+        stream: Result<SslStream<S>, HandshakeError<S>>,
+    ) -> Result<SslStream<S>, MidHandshakeSslStream<S>> {
         match stream {
             Ok(stream) => Ok(stream),
             Err(HandshakeError::WouldBlock(stream)) => Err(stream),
@@ -1475,14 +1490,20 @@ fn stateless() {
     let client_stream = Ssl::new(&client_ctx.build()).unwrap();
 
     let mut server_ctx = SslContext::builder(SslMethod::tls()).unwrap();
-    server_ctx.set_certificate_file(&Path::new("test/cert.pem"), SslFiletype::PEM)
+    server_ctx
+        .set_certificate_file(&Path::new("test/cert.pem"), SslFiletype::PEM)
         .unwrap();
-    server_ctx.set_private_key_file(&Path::new("test/key.pem"), SslFiletype::PEM)
+    server_ctx
+        .set_private_key_file(&Path::new("test/key.pem"), SslFiletype::PEM)
         .unwrap();
     const COOKIE: &[u8] = b"chocolate chip";
-    server_ctx.set_stateless_cookie_generate_cb(|_tls, buf| { buf[0..COOKIE.len()].copy_from_slice(COOKIE); Ok(COOKIE.len()) });
+    server_ctx.set_stateless_cookie_generate_cb(|_tls, buf| {
+        buf[0..COOKIE.len()].copy_from_slice(COOKIE);
+        Ok(COOKIE.len())
+    });
     server_ctx.set_stateless_cookie_verify_cb(|_tls, buf| buf == COOKIE);
-    let mut server_stream = ssl::SslStreamBuilder::new(Ssl::new(&server_ctx.build()).unwrap(), MemoryStream::new());
+    let mut server_stream =
+        ssl::SslStreamBuilder::new(Ssl::new(&server_ctx.build()).unwrap(), MemoryStream::new());
 
     //
     // Handshake