modified TcpListener and UnixListener tests to use with_backlog variants where appropriate

Author: BartMassey

library/std/src/net/tcp.rs

@@ -730,6 +730,7 @@ impl TcpListener {
     /// Creates a TCP listener bound to `127.0.0.1:80` with a backlog of 1000:
     ///
     /// ```no_run
+    /// #![feature(bind_with_backlog)]
     /// use std::net::TcpListener;
     ///
     /// let listener = TcpListener::bind_with_backlog("127.0.0.1:80", 1000).unwrap();

library/std/src/net/tcp/tests.rs

@@ -48,7 +48,7 @@ fn connect_error() {
 #[test]
 fn listen_localhost() {
     let socket_addr = next_test_ip4();
-    let listener = t!(TcpListener::bind(&socket_addr));
+    let listener = t!(TcpListener::bind_with_backlog(&socket_addr, 1));
 
     let _t = thread::spawn(move || {
         let mut stream = t!(TcpStream::connect(&("localhost", socket_addr.port())));
@@ -64,7 +64,7 @@ fn listen_localhost() {
 #[test]
 fn connect_loopback() {
     each_ip(&mut |addr| {
-        let acceptor = t!(TcpListener::bind(&addr));
+        let acceptor = t!(TcpListener::bind_with_backlog(&addr, 1));
 
         let _t = thread::spawn(move || {
             let host = match addr {
@@ -85,7 +85,7 @@ fn connect_loopback() {
 #[test]
 fn smoke_test() {
     each_ip(&mut |addr| {
-        let acceptor = t!(TcpListener::bind(&addr));
+        let acceptor = t!(TcpListener::bind_with_backlog(&addr, 1));
 
         let (tx, rx) = channel();
         let _t = thread::spawn(move || {
@@ -172,11 +172,33 @@ fn multiple_connect_serial() {
     })
 }
 
+#[test]
+fn multiple_connect_serial_with_backlog() {
+    each_ip(&mut |addr| {
+        let max = 10;
+        let acceptor = t!(TcpListener::bind_with_backlog(&addr, max));
+
+        let _t = thread::spawn(move || {
+            for _ in 0..max {
+                let mut stream = t!(TcpStream::connect(&addr));
+                t!(stream.write(&[99]));
+            }
+        });
+
+        for stream in acceptor.incoming().take(max) {
+            let mut stream = t!(stream);
+            let mut buf = [0];
+            t!(stream.read(&mut buf));
+            assert_eq!(buf[0], 99);
+        }
+    })
+}
+
 #[test]
 fn multiple_connect_interleaved_greedy_schedule() {
     const MAX: usize = 10;
     each_ip(&mut |addr| {
-        let acceptor = t!(TcpListener::bind(&addr));
+        let acceptor = t!(TcpListener::bind_with_backlog(&addr, MAX));
 
         let _t = thread::spawn(move || {
             let acceptor = acceptor;
@@ -213,7 +235,7 @@ fn multiple_connect_interleaved_greedy_schedule() {
 fn multiple_connect_interleaved_lazy_schedule() {
     const MAX: usize = 10;
     each_ip(&mut |addr| {
-        let acceptor = t!(TcpListener::bind(&addr));
+        let acceptor = t!(TcpListener::bind_with_backlog(&addr, MAX));
 
         let _t = thread::spawn(move || {
             for stream in acceptor.incoming().take(MAX) {

library/std/src/os/unix/net/listener.rs

@@ -98,6 +98,7 @@ impl UnixListener {
     /// # Examples
     ///
     /// ```no_run
+    /// #![feature(bind_with_backlog)]
     /// use std::os::unix::net::UnixListener;
     ///
     /// let listener = match UnixListener::bind_with_backlog("/path/to/the/socket", 1000) {

library/std/src/os/unix/net/tests.rs

@@ -41,7 +41,7 @@ fn basic() {
     let msg1 = b"hello";
     let msg2 = b"world!";
 
-    let listener = or_panic!(UnixListener::bind(&socket_path));
+    let listener = or_panic!(UnixListener::bind_with_backlog(&socket_path, 1));
     let thread = thread::spawn(move || {
         let mut stream = or_panic!(listener.accept()).0;
         let mut buf = [0; 5];
@@ -111,7 +111,7 @@ fn try_clone() {
     let msg1 = b"hello";
     let msg2 = b"world";
 
-    let listener = or_panic!(UnixListener::bind(&socket_path));
+    let listener = or_panic!(UnixListener::bind_with_backlog(&socket_path, 1));
     let thread = thread::spawn(move || {
         let mut stream = or_panic!(listener.accept()).0;
         or_panic!(stream.write_all(msg1));
@@ -135,7 +135,7 @@ fn iter() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
 
-    let listener = or_panic!(UnixListener::bind(&socket_path));
+    let listener = or_panic!(UnixListener::bind_with_backlog(&socket_path, 2));
     let thread = thread::spawn(move || {
         for stream in listener.incoming().take(2) {
             let mut stream = or_panic!(stream);
@@ -423,7 +423,7 @@ fn test_abstract_stream_connect() {
     let msg2 = b"world";
 
     let socket_addr = or_panic!(SocketAddr::from_abstract_namespace(b"namespace"));
-    let listener = or_panic!(UnixListener::bind_addr(&socket_addr));
+    let listener = or_panic!(UnixListener::bind_addr_with_backlog(&socket_addr, 1));
 
     let thread = thread::spawn(move || {
         let mut stream = or_panic!(listener.accept()).0;
@@ -451,7 +451,7 @@ fn test_abstract_stream_connect() {
 #[test]
 fn test_abstract_stream_iter() {
     let addr = or_panic!(SocketAddr::from_abstract_namespace(b"hidden"));
-    let listener = or_panic!(UnixListener::bind_addr(&addr));
+    let listener = or_panic!(UnixListener::bind_addr_with_backlog(&addr, 2));
 
     let thread = thread::spawn(move || {
         for stream in listener.incoming().take(2) {