Move tests from src/socket.rs into tests/socket.rs

Also removes the tempdir dependency.

Author: Thomasdezeeuw

Cargo.toml

@@ -38,9 +38,6 @@ libc = "0.2.81"
 [target."cfg(windows)".dependencies]
 winapi = { version = "0.3.9", features = ["handleapi", "ws2ipdef", "ws2tcpip"] }
 
-[dev-dependencies]
-tempdir = "0.3"
-
 [features]
 # Enable all API, even ones not available on all OSes.
 all = []

src/socket.rs

@@ -1315,109 +1315,3 @@ impl Drop for Socket {
         sys::close(self.inner);
     }
 }
-
-#[cfg(test)]
-mod test {
-    use std::net::SocketAddr;
-
-    use super::*;
-
-    #[test]
-    #[cfg(all(feature = "all", unix))]
-    fn pair() {
-        let (mut a, mut b) = Socket::pair(Domain::UNIX, Type::STREAM, None).unwrap();
-        a.write_all(b"hello world").unwrap();
-        let mut buf = [0; 11];
-        b.read_exact(&mut buf).unwrap();
-        assert_eq!(buf, &b"hello world"[..]);
-    }
-
-    #[test]
-    #[cfg(all(feature = "all", unix))]
-    fn unix() {
-        use tempdir::TempDir;
-
-        let dir = TempDir::new("unix").unwrap();
-        let addr = SockAddr::unix(dir.path().join("sock")).unwrap();
-
-        let listener = Socket::new(Domain::UNIX, Type::STREAM, None).unwrap();
-        listener.bind(&addr).unwrap();
-        listener.listen(10).unwrap();
-
-        let mut a = Socket::new(Domain::UNIX, Type::STREAM, None).unwrap();
-        a.connect(&addr).unwrap();
-
-        let mut b = listener.accept().unwrap().0;
-
-        a.write_all(b"hello world").unwrap();
-        let mut buf = [0; 11];
-        b.read_exact(&mut buf).unwrap();
-        assert_eq!(buf, &b"hello world"[..]);
-    }
-
-    #[test]
-    fn nodelay() {
-        let socket = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
-
-        assert!(socket.set_nodelay(true).is_ok());
-
-        let result = socket.nodelay();
-
-        assert!(result.is_ok());
-        assert!(result.unwrap());
-    }
-
-    #[test]
-    #[cfg(feature = "all")]
-    fn out_of_band_inline() {
-        let socket = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
-
-        assert_eq!(socket.out_of_band_inline().unwrap(), false);
-
-        socket.set_out_of_band_inline(true).unwrap();
-        assert_eq!(socket.out_of_band_inline().unwrap(), true);
-    }
-
-    #[test]
-    #[cfg(all(feature = "all", any(windows, target_os = "linux")))]
-    fn out_of_band_send_recv() {
-        let s1 = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
-        s1.bind(&"127.0.0.1:0".parse::<SocketAddr>().unwrap().into())
-            .unwrap();
-        let s1_addr = s1.local_addr().unwrap();
-        s1.listen(1).unwrap();
-
-        let s2 = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
-        s2.connect(&s1_addr).unwrap();
-
-        let (s3, _) = s1.accept().unwrap();
-
-        let mut buf = [0; 10];
-        // send some plain inband data
-        s2.send(&mut buf).unwrap();
-        // send a single out of band byte
-        assert_eq!(s2.send_out_of_band(&mut [b"!"[0]]).unwrap(), 1);
-        // recv the OOB data first
-        assert_eq!(s3.recv_out_of_band(&mut buf).unwrap(), 1);
-        assert_eq!(buf[0], b"!"[0]);
-        assert_eq!(s3.recv(&mut buf).unwrap(), 10);
-    }
-
-    #[test]
-    fn tcp() {
-        let s1 = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
-        s1.bind(&"127.0.0.1:0".parse::<SocketAddr>().unwrap().into())
-            .unwrap();
-        let s1_addr = s1.local_addr().unwrap();
-        s1.listen(1).unwrap();
-
-        let s2 = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
-        s2.connect(&s1_addr).unwrap();
-
-        let (s3, _) = s1.accept().unwrap();
-
-        let mut buf = [0; 11];
-        assert_eq!(s2.send(&mut buf).unwrap(), 11);
-        assert_eq!(s3.recv(&mut buf).unwrap(), 11);
-    }
-}

tests/socket.rs

@@ -2,16 +2,24 @@
 use std::ffi::CStr;
 #[cfg(any(windows, target_vendor = "apple"))]
 use std::io;
+#[cfg(all(unix, feature = "all"))]
+use std::io::Read;
 use std::io::Write;
 #[cfg(not(target_os = "redox"))]
 use std::io::{IoSlice, IoSliceMut};
+#[cfg(feature = "all")]
+use std::net::{Ipv4Addr, SocketAddrV4};
 use std::net::{Ipv6Addr, SocketAddr, SocketAddrV6};
 #[cfg(unix)]
 use std::os::unix::io::AsRawFd;
 #[cfg(windows)]
 use std::os::windows::io::AsRawSocket;
 use std::str;
+#[cfg(feature = "all")]
+use std::thread;
 use std::time::Duration;
+#[cfg(all(unix, feature = "all"))]
+use std::{env, fs};
 
 #[cfg(windows)]
 use winapi::shared::minwindef::DWORD;
@@ -20,7 +28,7 @@ use winapi::um::handleapi::GetHandleInformation;
 #[cfg(windows)]
 use winapi::um::winbase::HANDLE_FLAG_INHERIT;
 
-#[cfg(all(unix, feature = "all"))]
+#[cfg(feature = "all")]
 use socket2::SockAddr;
 use socket2::{Domain, Protocol, Socket, TcpKeepalive, Type};
 
@@ -297,6 +305,77 @@ where
     assert_eq!(flags, want as _, "non-blocking option");
 }
 
+#[cfg(feature = "all")]
+const DATA: &[u8] = b"hello world";
+
+#[test]
+#[cfg(all(feature = "all", unix))]
+fn pair() {
+    let (mut a, mut b) = Socket::pair(Domain::UNIX, Type::STREAM, None).unwrap();
+    a.write(DATA).unwrap();
+    let mut buf = [0; DATA.len() + 1];
+    let n = b.read(&mut buf).unwrap();
+    assert_eq!(n, DATA.len());
+    assert_eq!(&buf[..n], DATA);
+}
+
+#[test]
+#[cfg(all(feature = "all", unix))]
+fn unix() {
+    let mut path = env::temp_dir();
+    path.push("socket2");
+    let _ = fs::remove_dir_all(&path);
+    fs::create_dir_all(&path).unwrap();
+    path.push("unix");
+
+    let addr = SockAddr::unix(path).unwrap();
+
+    let listener = Socket::new(Domain::UNIX, Type::STREAM, None).unwrap();
+    listener.bind(&addr).unwrap();
+    listener.listen(10).unwrap();
+
+    let mut a = Socket::new(Domain::UNIX, Type::STREAM, None).unwrap();
+    a.connect(&addr).unwrap();
+    let mut b = listener.accept().unwrap().0;
+
+    a.write(DATA).unwrap();
+    let mut buf = [0; DATA.len() + 1];
+    let n = b.read(&mut buf).unwrap();
+    assert_eq!(n, DATA.len());
+    assert_eq!(&buf[..n], DATA);
+}
+
+#[test]
+#[cfg(feature = "all")]
+fn out_of_band() {
+    let listener = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
+    listener.bind(&any_ipv4()).unwrap();
+    listener.listen(1).unwrap();
+
+    let sender = Socket::new(Domain::IPV4, Type::STREAM, None).unwrap();
+    sender.bind(&any_ipv4()).unwrap();
+    sender.connect(&listener.local_addr().unwrap()).unwrap();
+
+    let (receiver, _) = listener.accept().unwrap();
+
+    sender.send(&DATA).unwrap();
+
+    const FIRST: &[u8] = b"!";
+    assert_eq!(sender.send_out_of_band(FIRST).unwrap(), FIRST.len());
+    // On macOS if no `MSG_OOB` is available it will return `EINVAL`, to prevent
+    // this from happening we'll sleep to ensure the data is present.
+    thread::sleep(Duration::from_millis(10));
+
+    let mut buf = [1; DATA.len() + 1];
+    let n = receiver.recv_out_of_band(&mut buf).unwrap();
+    assert_eq!(n, FIRST.len());
+    assert_eq!(&buf[..n], FIRST);
+
+    let n = receiver.recv(&mut buf).unwrap();
+    assert_eq!(n, DATA.len());
+    assert_eq!(&buf[..n], DATA);
+}
+
 #[test]
 #[cfg(not(target_os = "redox"))]
 fn send_recv_vectored() {
@@ -567,6 +646,11 @@ fn device() {
     }
 }
 
+#[cfg(feature = "all")]
+fn any_ipv4() -> SockAddr {
+    SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0).into()
+}
+
 /// Macro to create a simple test to set and get a socket option.
 macro_rules! test {
     // Test using the `arg`ument as expected return value.