1 files changed, 104 insertions, 2 deletions
diff --git a/openssl/src/ssl/tests/mod.rs b/openssl/src/ssl/tests/mod.rs
index af3c005e..be35d7ef 100644
--- a/openssl/src/ssl/tests/mod.rs
+++ b/openssl/src/ssl/tests/mod.rs
@@ -9,6 +9,7 @@ use std::net::{TcpStream, TcpListener, SocketAddr};
 use std::path::Path;
 use std::process::{Command, Child, Stdio, ChildStdin};
 use std::thread;
+use std::time::Duration;
 
 use net2::TcpStreamExt;
 
@@ -79,7 +80,7 @@ impl Server {
             match TcpStream::connect(&addr) {
                 Ok(s) => return (server, s),
                 Err(ref e) if e.kind() == io::ErrorKind::ConnectionRefused => {
-                    thread::sleep_ms(100);
+                    thread::sleep(Duration::from_millis(100));
                 }
                 Err(e) => panic!("wut: {}", e),
             }
@@ -117,7 +118,7 @@ impl Server {
         // Need to wait for the UDP socket to get bound in our child process,
         // but don't currently have a great way to do that so just wait for a
         // bit.
-        thread::sleep_ms(100);
+        thread::sleep(Duration::from_millis(100));
         let socket = UdpSocket::bind(next_addr()).unwrap();
         socket.connect(&addr).unwrap();
         (s, UdpConnected(socket))
@@ -957,3 +958,104 @@ fn broken_try_clone_doesnt_crash() {
     let stream1 = SslStream::connect(&context, inner).unwrap();
     let _stream2 = stream1.try_clone().unwrap();
 }
+
+#[test]
+#[should_panic(expected = "blammo")]
+#[cfg(feature = "nightly")]
+fn write_panic() {
+    struct ExplodingStream(TcpStream);
+
+    impl Read for ExplodingStream {
+        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+            self.0.read(buf)
+        }
+    }
+
+    impl Write for ExplodingStream {
+        fn write(&mut self, _: &[u8]) -> io::Result<usize> {
+            panic!("blammo");
+        }
+
+        fn flush(&mut self) -> io::Result<()> {
+            self.0.flush()
+        }
+    }
+
+    let (_s, stream) = Server::new();
+    let stream = ExplodingStream(stream);
+
+    let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
+    let _ = SslStream::connect(&ctx, stream);
+}
+
+#[test]
+#[should_panic(expected = "blammo")]
+#[cfg(feature = "nightly")]
+fn read_panic() {
+    struct ExplodingStream(TcpStream);
+
+    impl Read for ExplodingStream {
+        fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
+            panic!("blammo");
+        }
+    }
+
+    impl Write for ExplodingStream {
+        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+            self.0.write(buf)
+        }
+
+        fn flush(&mut self) -> io::Result<()> {
+            self.0.flush()
+        }
+    }
+
+    let (_s, stream) = Server::new();
+    let stream = ExplodingStream(stream);
+
+    let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
+    let _ = SslStream::connect(&ctx, stream);
+}
+
+#[test]
+#[should_panic(expected = "blammo")]
+#[cfg(feature = "nightly")]
+fn flush_panic() {
+    struct ExplodingStream(TcpStream);
+
+    impl Read for ExplodingStream {
+        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+            self.0.read(buf)
+        }
+    }
+
+    impl Write for ExplodingStream {
+        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+            self.0.write(buf)
+        }
+
+        fn flush(&mut self) -> io::Result<()> {
+            panic!("blammo");
+        }
+    }
+
+    let (_s, stream) = Server::new();
+    let stream = ExplodingStream(stream);
+
+    let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
+    let mut stream = SslStream::connect(&ctx, stream).unwrap();
+    let _ = stream.flush();
+}
+
+#[test]
+fn refcount_ssl_context() {
+    let ssl = {
+        let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
+        ssl::Ssl::new(&ctx).unwrap()
+    };
+
+    {
+        let new_ctx_a = SslContext::new(SslMethod::Sslv23).unwrap();
+        let _new_ctx_b = ssl.set_ssl_context(&new_ctx_a);
+    }
+}