chore: reduce waste in port allocations of some tests (#7456)

fix some tests to not waste port allocations

net-utils/src/lib.rs

@@ -603,6 +603,7 @@ pub fn bind_more_with_config(
 mod tests {
     use {
         super::*,
+        crate::sockets::unique_port_range_for_tests,
         ip_echo_server::IpEchoServerResponse,
         itertools::Itertools,
         std::{net::Ipv4Addr, time::Duration},
@@ -748,14 +749,16 @@ mod tests {
     #[test]
     fn test_bind_in_range_nil() {
         let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
-        bind_in_range(ip_addr, (2000, 2000)).unwrap_err();
-        bind_in_range(ip_addr, (2000, 1999)).unwrap_err();
+        let range = sockets::unique_port_range_for_tests(2);
+        bind_in_range(ip_addr, (range.end, range.end)).unwrap_err();
+        bind_in_range(ip_addr, (range.end, range.start)).unwrap_err();
     }
 
     #[test]
     fn test_find_available_port_in_range() {
         let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
-        let (pr_s, pr_e) = sockets::localhost_port_range_for_tests();
+        let range = sockets::unique_port_range_for_tests(4);
+        let (pr_s, pr_e) = (range.start, range.end);
         assert_eq!(
             find_available_port_in_range(ip_addr, (pr_s, pr_s + 1)).unwrap(),
             pr_s
@@ -784,12 +787,11 @@ mod tests {
     #[test]
     fn test_bind_common_in_range() {
         let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
-        let (pr_s, pr_e) = sockets::localhost_port_range_for_tests();
+        let range = sockets::unique_port_range_for_tests(5);
         let config = SocketConfig::default();
         let (port, _sockets) =
-            bind_common_in_range_with_config(ip_addr, (pr_s, pr_e), config).unwrap();
-        assert!((pr_s..pr_e).contains(&port));
-
+            bind_common_in_range_with_config(ip_addr, (range.start, range.end), config).unwrap();
+        assert!(range.contains(&port));
         bind_common_in_range_with_config(ip_addr, (port, port + 1), config).unwrap_err();
     }
 
@@ -889,16 +891,18 @@ mod tests {
     fn test_verify_ports_udp_unreachable() {
         solana_logger::setup();
         let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
-        let port_range = sockets::localhost_port_range_for_tests();
+        let port_range = unique_port_range_for_tests(2);
         let config = SocketConfig::default();
         let (_server_port, (server_udp_socket, _server_tcp_listener)) =
-            bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
+            bind_common_in_range_with_config(ip_addr, (port_range.start, port_range.end), config)
+                .unwrap();
 
         // make the socket unreachable by not running the ip echo server!
         let server_ip_echo_addr = server_udp_socket.local_addr().unwrap();
 
         let (_correct_client_port, (client_udp_socket, _client_tcp_listener)) =
-            bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
+            bind_common_in_range_with_config(ip_addr, (port_range.start, port_range.end), config)
+                .unwrap();
 
         let rt = runtime();
         assert!(!rt.block_on(ip_echo_client::verify_all_reachable_udp(
@@ -917,13 +921,16 @@ mod tests {
         let mut tcp_listeners = vec![];
         let mut udp_sockets = vec![];
 
+        let port_range = unique_port_range_for_tests(1);
         let (_server_port, (_, server_tcp_listener)) =
-            bind_common_in_range_with_config(ip_addr, (2200, 2300), config).unwrap();
+            bind_common_in_range_with_config(ip_addr, (port_range.start, port_range.end), config)
+                .unwrap();
         for _ in 0..MAX_PORT_VERIFY_THREADS * 2 {
+            let port_range = unique_port_range_for_tests(1);
             let (_client_port, (client_udp_socket, client_tcp_listener)) =
                 bind_common_in_range_with_config(
                     ip_addr,
-                    (2300, 2300 + (MAX_PORT_VERIFY_THREADS * 3) as u16),
+                    (port_range.start, port_range.end),
                     config,
                 )
                 .unwrap();
@@ -961,18 +968,24 @@ mod tests {
         solana_logger::setup();
         let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
         let offset = 6;
+        let port_range = unique_port_range_for_tests(10);
         if let Ok(((port1, _), (port2, _))) =
-            bind_two_in_range_with_offset(ip_addr, (1024, 65535), offset)
+            bind_two_in_range_with_offset(ip_addr, (port_range.start, port_range.end), offset)
         {
             assert!(port2 == port1 + offset);
         }
-        let offset = 42;
+        let offset = 7;
         if let Ok(((port1, _), (port2, _))) =
-            bind_two_in_range_with_offset(ip_addr, (1024, 65535), offset)
+            bind_two_in_range_with_offset(ip_addr, (port_range.start, port_range.end), offset)
         {
             assert!(port2 == port1 + offset);
         }
-        assert!(bind_two_in_range_with_offset(ip_addr, (1024, 1044), offset).is_err());
+        assert!(bind_two_in_range_with_offset(
+            ip_addr,
+            (port_range.start, port_range.start + 5),
+            offset
+        )
+        .is_err());
     }
 
     #[test]
@@ -980,7 +993,9 @@ mod tests {
         let ip_addr: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
         let config = SocketConfig::default(); //reuseport is false by default
 
-        let result = multi_bind_in_range_with_config(ip_addr, (2010, 2110), config, 2);
+        let port_range = unique_port_range_for_tests(3);
+        let result =
+            multi_bind_in_range_with_config(ip_addr, (port_range.start, port_range.end), config, 2);
 
         assert!(
             result.is_err(),
@@ -995,9 +1010,10 @@ mod tests {
         let ip_a = IpAddr::V4(Ipv4Addr::LOCALHOST);
         let ip_b = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2));
 
-        let server_ports = sockets::localhost_port_range_for_tests();
+        let port_range = sockets::localhost_port_range_for_tests();
+
         let (_srv_udp_port, (srv_udp_sock, srv_tcp_listener)) =
-            bind_common_in_range_with_config(ip_a, server_ports, config).unwrap();
+            bind_common_in_range_with_config(ip_a, port_range, config).unwrap();
 
         let ip_echo_server_addr = srv_udp_sock.local_addr().unwrap();
         let _runtime = ip_echo_server(
@@ -1007,18 +1023,10 @@ mod tests {
         );
 
         let mut udp_sockets = Vec::new();
-        let (_p1, (sock_a, _tl_a)) = bind_common_in_range_with_config(
-            ip_a,
-            sockets::localhost_port_range_for_tests(),
-            config,
-        )
-        .unwrap();
-        let (_p2, (sock_b, _tl_b)) = bind_common_in_range_with_config(
-            ip_b,
-            sockets::localhost_port_range_for_tests(),
-            config,
-        )
-        .unwrap();
+        let (_p1, (sock_a, _tl_a)) =
+            bind_common_in_range_with_config(ip_a, port_range, config).unwrap();
+        let (_p2, (sock_b, _tl_b)) =
+            bind_common_in_range_with_config(ip_b, port_range, config).unwrap();
 
         udp_sockets.push(sock_a);
         udp_sockets.push(sock_b);

streamer/src/recvmmsg.rs

@@ -183,7 +183,7 @@ mod tests {
     use {
         crate::{packet::PACKET_DATA_SIZE, recvmmsg::*},
         solana_net_utils::sockets::{
-            bind_in_range_with_config, localhost_port_range_for_tests,
+            bind_in_range_with_config, localhost_port_range_for_tests, unique_port_range_for_tests,
             SocketConfiguration as SocketConfig,
         },
         std::{
@@ -195,10 +195,20 @@ mod tests {
     type TestConfig = (UdpSocket, SocketAddr, UdpSocket, SocketAddr);
 
     fn test_setup_reader_sender(ip: IpAddr) -> io::Result<TestConfig> {
-        let port_range = localhost_port_range_for_tests();
-        let reader = bind_in_range_with_config(ip, port_range, SocketConfig::default())?.1;
+        let port_range = unique_port_range_for_tests(2);
+        let reader = bind_in_range_with_config(
+            ip,
+            (port_range.start, port_range.end),
+            SocketConfig::default(),
+        )?
+        .1;
         let reader_addr = reader.local_addr()?;
-        let sender = bind_in_range_with_config(ip, port_range, SocketConfig::default())?.1;
+        let sender = bind_in_range_with_config(
+            ip,
+            (port_range.start, port_range.end),
+            SocketConfig::default(),
+        )?
+        .1;
         let sender_addr = sender.local_addr()?;
         Ok((reader, reader_addr, sender, sender_addr))
     }

tpu-client-next/src/workers_cache.rs

@@ -327,10 +327,10 @@ mod tests {
             SendTransactionStats,
         },
         quinn::Endpoint,
-        solana_net_utils::{bind_in_range, sockets::localhost_port_range_for_tests},
+        solana_net_utils::sockets::{bind_to_localhost_unique, unique_port_range_for_tests},
         solana_tls_utils::QuicClientCertificate,
         std::{
-            net::{IpAddr, Ipv4Addr, SocketAddr},
+            net::{Ipv4Addr, SocketAddr},
             sync::Arc,
             time::Duration,
         },
@@ -342,10 +342,7 @@ mod tests {
     const TEST_MAX_TIME: Duration = Duration::from_secs(5);
 
     fn create_test_endpoint() -> Endpoint {
-        let port_range = localhost_port_range_for_tests();
-        let socket = bind_in_range(IpAddr::V4(Ipv4Addr::LOCALHOST), port_range)
-            .unwrap()
-            .1;
+        let socket = bind_to_localhost_unique().unwrap();
         let client_config = create_client_config(&QuicClientCertificate::new(None));
         create_client_endpoint(BindTarget::Socket(socket), client_config).unwrap()
     }
@@ -354,8 +351,8 @@ mod tests {
     async fn test_worker_stopped_after_failed_connect() {
         let endpoint = create_test_endpoint();
 
-        let port_range = localhost_port_range_for_tests();
-        let peer: SocketAddr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port_range.0);
+        let port_range = unique_port_range_for_tests(2);
+        let peer: SocketAddr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port_range.start);
 
         let worker_channel_size = 1;
         let skip_check_transaction_age = true;
@@ -388,8 +385,8 @@ mod tests {
     async fn test_worker_shutdown() {
         let endpoint = create_test_endpoint();
 
-        let port_range = localhost_port_range_for_tests();
-        let peer: SocketAddr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port_range.0);
+        let port_range = unique_port_range_for_tests(2);
+        let peer: SocketAddr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port_range.start);
 
         let worker_channel_size = 1;
         let skip_check_transaction_age = true;
@@ -421,8 +418,8 @@ mod tests {
         let cancel = CancellationToken::new();
         let mut cache = WorkersCache::new(10, cancel.clone());
 
-        let port_range = localhost_port_range_for_tests();
-        let peer: SocketAddr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port_range.0);
+        let port_range = unique_port_range_for_tests(2);
+        let peer: SocketAddr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port_range.start);
         let worker_channel_size = 1;
         let skip_check_transaction_age = true;
         let max_reconnect_attempts = 0;