From 0a15a51199add512d5a9baec0f9d4a7de2320cc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BE=90=E6=9C=AA=E6=9D=A5?= Date: Tue, 25 Jul 2023 17:32:10 +0800 Subject: [PATCH] ToSocketAddrs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 徐未来 --- .../bin/ylong_runtime_async_benchmark.rs | 9 +- .../bin/ylong_runtime_tcp_client_perf.rs | 2 +- .../bin/ylong_runtime_tcp_server_perf.rs | 2 +- .../benches/bin/ylong_tokio_tcp_perf.rs | 4 +- ylong_runtime/benches/ylong_tokio_udp.rs | 4 +- ylong_runtime/src/net/mod.rs | 1 + ylong_runtime/src/net/sys/addr.rs | 200 +++++++++++++ ylong_runtime/src/net/sys/mod.rs | 2 + ylong_runtime/src/net/sys/tcp/listener.rs | 22 +- ylong_runtime/src/net/sys/tcp/stream.rs | 23 +- ylong_runtime/src/net/sys/udp.rs | 265 +++++++++++++----- ylong_runtime/tests/async_buf_read.rs | 16 +- ylong_runtime/tests/async_buf_write.rs | 8 +- ylong_runtime/tests/async_read.rs | 4 +- ylong_runtime/tests/join_set.rs | 4 +- ylong_runtime/tests/tcp_test.rs | 8 +- ylong_runtime/tests/udp_test.rs | 36 +-- 17 files changed, 483 insertions(+), 127 deletions(-) create mode 100644 ylong_runtime/src/net/sys/addr.rs diff --git a/ylong_runtime/benches/bin/ylong_runtime_async_benchmark.rs b/ylong_runtime/benches/bin/ylong_runtime_async_benchmark.rs index 944760c..34b9582 100644 --- a/ylong_runtime/benches/bin/ylong_runtime_async_benchmark.rs +++ b/ylong_runtime/benches/bin/ylong_runtime_async_benchmark.rs @@ -13,7 +13,6 @@ //! Tcp async benchmark -use std::net::SocketAddr; use std::time::Instant; use ylong_runtime::builder::RuntimeBuilder; @@ -21,10 +20,9 @@ use ylong_runtime::io::{AsyncReadExt, AsyncWriteExt}; use ylong_runtime::net::{TcpListener, TcpStream}; async fn run_client(addr: &str) { - let socket_addr: SocketAddr = addr.parse().unwrap(); - let mut client_stream = TcpStream::connect(socket_addr).await; + let mut client_stream = TcpStream::connect(addr).await; while client_stream.is_err() { - client_stream = TcpStream::connect(socket_addr).await + client_stream = TcpStream::connect(addr).await } let mut client = client_stream.unwrap(); for _ in 0..100 { @@ -38,8 +36,7 @@ async fn run_client(addr: &str) { } async fn run_server(addr: &str) { - let socket_addr: SocketAddr = addr.parse().unwrap(); - let socket = TcpListener::bind(socket_addr).await.unwrap(); + let socket = TcpListener::bind(addr).await.unwrap(); let mut server = socket.accept().await.unwrap().0; for _ in 0..100 { diff --git a/ylong_runtime/benches/bin/ylong_runtime_tcp_client_perf.rs b/ylong_runtime/benches/bin/ylong_runtime_tcp_client_perf.rs index cf843df..74b3823 100644 --- a/ylong_runtime/benches/bin/ylong_runtime_tcp_client_perf.rs +++ b/ylong_runtime/benches/bin/ylong_runtime_tcp_client_perf.rs @@ -21,7 +21,7 @@ use ylong_runtime::net::TcpStream; fn main() -> io::Result<()> { let handle = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8080".parse().unwrap(); + let addr = "127.0.0.1:8080"; let mut stream = match TcpStream::connect(addr).await { Ok(stream) => stream, Err(err) => return Err(err), diff --git a/ylong_runtime/benches/bin/ylong_runtime_tcp_server_perf.rs b/ylong_runtime/benches/bin/ylong_runtime_tcp_server_perf.rs index f670082..d2d6c04 100644 --- a/ylong_runtime/benches/bin/ylong_runtime_tcp_server_perf.rs +++ b/ylong_runtime/benches/bin/ylong_runtime_tcp_server_perf.rs @@ -23,7 +23,7 @@ use ylong_runtime::net::TcpListener; fn main() -> io::Result<()> { let runtime = RuntimeBuilder::new_multi_thread().build().unwrap(); let handle = runtime.spawn(async move { - let addr = "127.0.0.1:8080".parse().unwrap(); + let addr = "127.0.0.1:8080"; let server = match TcpListener::bind(addr).await { Ok(server) => server, Err(_) => return, diff --git a/ylong_runtime/benches/bin/ylong_tokio_tcp_perf.rs b/ylong_runtime/benches/bin/ylong_tokio_tcp_perf.rs index 3579052..9fe58e3 100644 --- a/ylong_runtime/benches/bin/ylong_tokio_tcp_perf.rs +++ b/ylong_runtime/benches/bin/ylong_tokio_tcp_perf.rs @@ -34,7 +34,7 @@ fn ylong_create_client() { let mut recv_buf = [0_u8; 12]; let runtime = RuntimeBuilder::new_multi_thread().build().unwrap(); let handle = runtime.spawn(async move { - let addr = "127.0.0.1:9081".parse().unwrap(); + let addr = "127.0.0.1:9081"; loop { if let Ok(mut client) = TcpStream::connect(addr).await { match client.write(b"hello server").await { @@ -104,7 +104,7 @@ fn main() { println!("ylong tcp read()+write() Loops: {}", LOOP_NUMS); let runtime = RuntimeBuilder::new_multi_thread().build().unwrap(); - let addr = "127.0.0.1:9081".parse().unwrap(); + let addr = "127.0.0.1:9081"; let st = Instant::now(); for _ in 0..LOOP_NUMS { diff --git a/ylong_runtime/benches/ylong_tokio_udp.rs b/ylong_runtime/benches/ylong_tokio_udp.rs index b7cbc18..57101e7 100644 --- a/ylong_runtime/benches/ylong_tokio_udp.rs +++ b/ylong_runtime/benches/ylong_tokio_udp.rs @@ -36,8 +36,8 @@ mod udp_bench { /// 2. Bind and Connect. #[bench] fn ylong_udp_connect(b: &mut Bencher) { - let sender_addr = "127.0.0.1:8093".parse().unwrap(); - let receiver_addr = "127.0.0.1:8094".parse().unwrap(); + let sender_addr = "127.0.0.1:8093"; + let receiver_addr = "127.0.0.1:8094"; b.iter(|| { let handle = ylong_runtime::spawn(async move { let sender = UdpSocket::bind(sender_addr).await.unwrap(); diff --git a/ylong_runtime/src/net/mod.rs b/ylong_runtime/src/net/mod.rs index 79d7393..3828e01 100644 --- a/ylong_runtime/src/net/mod.rs +++ b/ylong_runtime/src/net/mod.rs @@ -32,6 +32,7 @@ cfg_net! { pub use sys::{TcpListener, TcpStream}; pub use sys::{UdpSocket, ConnectedUdpSocket}; pub use sys::{SplitReadHalf, SplitWriteHalf}; + pub use sys::ToSocketAddrs; } #[cfg(not(feature = "ffrt"))] diff --git a/ylong_runtime/src/net/sys/addr.rs b/ylong_runtime/src/net/sys/addr.rs new file mode 100644 index 0000000..f267268 --- /dev/null +++ b/ylong_runtime/src/net/sys/addr.rs @@ -0,0 +1,200 @@ +// Copyright (c) 2023 Huawei Device Co., Ltd. +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use std::future::Future; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; +use std::pin::Pin; +use std::task::{Context, Poll}; +use std::{io, mem, option, vec}; + +use crate::spawn_blocking; +use crate::task::JoinHandle; + +pub(crate) async fn each_addr(addr: A, mut f: F) -> io::Result +where + F: FnMut(SocketAddr) -> io::Result, +{ + let addrs = addr.to_socket_addrs().await?; + + let mut last_e = None; + + for addr in addrs { + match f(addr) { + Ok(res) => return Ok(res), + Err(e) => last_e = Some(e), + } + } + + Err(last_e.unwrap_or(io::Error::new( + io::ErrorKind::InvalidInput, + "addr could not resolve to any address", + ))) +} + +/// Convert the type that implements the trait to [`SocketAddr`] +pub trait ToSocketAddrs { + /// Returned iterator of SocketAddr. + type Iter: Iterator; + + /// Converts this object to an iterator of resolved `SocketAddr`s. + fn to_socket_addrs(&self) -> State; +} + +/// Parsing process status, str and (&str, u16) types may be Block +pub enum State { + Block(JoinHandle>), + Ready(io::Result), + Done, +} + +impl> Future for State { + type Output = io::Result; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let this = self.get_mut(); + + match mem::replace(this, State::Done) { + State::Block(mut task) => { + let poll = Pin::new(&mut task).poll(cx)?; + if poll.is_pending() { + *this = State::Block(task); + } + poll + } + State::Ready(res) => Poll::Ready(res), + State::Done => unreachable!("cannot poll a completed future"), + } + } +} + +impl Unpin for State {} + +impl ToSocketAddrs for SocketAddr { + type Iter = option::IntoIter; + + fn to_socket_addrs(&self) -> State { + State::Ready(Ok(Some(*self).into_iter())) + } +} + +impl ToSocketAddrs for SocketAddrV4 { + type Iter = option::IntoIter; + + fn to_socket_addrs(&self) -> State { + SocketAddr::V4(*self).to_socket_addrs() + } +} + +impl ToSocketAddrs for SocketAddrV6 { + type Iter = option::IntoIter; + + fn to_socket_addrs(&self) -> State { + SocketAddr::V6(*self).to_socket_addrs() + } +} + +impl ToSocketAddrs for (IpAddr, u16) { + type Iter = option::IntoIter; + + fn to_socket_addrs(&self) -> State { + let (ip, port) = *self; + match ip { + IpAddr::V4(ip_type) => (ip_type, port).to_socket_addrs(), + IpAddr::V6(ip_type) => (ip_type, port).to_socket_addrs(), + } + } +} + +impl ToSocketAddrs for (Ipv4Addr, u16) { + type Iter = option::IntoIter; + + fn to_socket_addrs(&self) -> State { + let (ip, port) = *self; + SocketAddrV4::new(ip, port).to_socket_addrs() + } +} + +impl ToSocketAddrs for (Ipv6Addr, u16) { + type Iter = option::IntoIter; + + fn to_socket_addrs(&self) -> State { + let (ip, port) = *self; + SocketAddrV6::new(ip, port, 0, 0).to_socket_addrs() + } +} + +impl ToSocketAddrs for (&str, u16) { + type Iter = vec::IntoIter; + + fn to_socket_addrs(&self) -> State { + let (host, port) = *self; + + if let Ok(addr) = host.parse::() { + let addr = SocketAddrV4::new(addr, port); + return State::Ready(Ok(vec![SocketAddr::V4(addr)].into_iter())); + } + + if let Ok(addr) = host.parse::() { + let addr = SocketAddrV6::new(addr, port, 0, 0); + return State::Ready(Ok(vec![SocketAddr::V6(addr)].into_iter())); + } + + let host = host.to_string(); + let task = spawn_blocking(move || { + let addr = (host.as_str(), port); + std::net::ToSocketAddrs::to_socket_addrs(&addr) + }); + State::Block(task) + } +} + +impl ToSocketAddrs for str { + type Iter = vec::IntoIter; + + fn to_socket_addrs(&self) -> State { + if let Ok(addr) = self.parse() { + return State::Ready(Ok(vec![addr].into_iter())); + } + + let addr = self.to_string(); + let task = spawn_blocking(move || { + let addr = addr.as_str(); + std::net::ToSocketAddrs::to_socket_addrs(addr) + }); + State::Block(task) + } +} + +impl<'a> ToSocketAddrs for &'a [SocketAddr] { + type Iter = std::iter::Cloned>; + + fn to_socket_addrs(&self) -> State { + State::Ready(Ok(self.iter().cloned())) + } +} + +impl ToSocketAddrs for String { + type Iter = vec::IntoIter; + + fn to_socket_addrs(&self) -> State { + (**self).to_socket_addrs() + } +} + +impl ToSocketAddrs for &T { + type Iter = T::Iter; + + fn to_socket_addrs(&self) -> State { + (**self).to_socket_addrs() + } +} diff --git a/ylong_runtime/src/net/sys/mod.rs b/ylong_runtime/src/net/sys/mod.rs index 4ea3bbb..5ef15e4 100644 --- a/ylong_runtime/src/net/sys/mod.rs +++ b/ylong_runtime/src/net/sys/mod.rs @@ -16,6 +16,8 @@ use std::net::SocketAddr; use std::sync::Arc; cfg_net! { + mod addr; + pub use addr::ToSocketAddrs; mod tcp; pub use tcp::{TcpListener, TcpStream}; mod udp; diff --git a/ylong_runtime/src/net/sys/tcp/listener.rs b/ylong_runtime/src/net/sys/tcp/listener.rs index 76b397c..0dcf7b0 100644 --- a/ylong_runtime/src/net/sys/tcp/listener.rs +++ b/ylong_runtime/src/net/sys/tcp/listener.rs @@ -16,6 +16,7 @@ use std::net::SocketAddr; use ylong_io::Interest; +use crate::net::sys::addr::ToSocketAddrs; use crate::net::{AsyncSource, TcpStream}; /// An asynchronous version of [`std::net::TcpListener`]. Provides async @@ -28,7 +29,7 @@ use crate::net::{AsyncSource, TcpStream}; /// use ylong_runtime::net::TcpListener; /// /// async fn io_func() -> io::Result<()> { -/// let addr = "127.0.0.1:8080".parse().unwrap(); +/// let addr = "127.0.0.1:8080"; /// let server = TcpListener::bind(addr).await?; /// let (stream, address) = server.accept().await?; /// Ok(()) @@ -45,6 +46,13 @@ impl TcpListener { /// listens for incoming TCP connections asynchronously. These /// connections can be accepted by calling [`TcpListener::accept`] /// + /// # Note + /// + /// If there are multiple addresses in SocketAddr, it will attempt to + /// connect them in sequence until one of the addrs returns success. If + /// all connections fail, it returns the error of the last connection. + /// This behavior is consistent with std. + /// /// # Example /// ```rust /// use std::io; @@ -52,14 +60,16 @@ impl TcpListener { /// use ylong_runtime::net::TcpListener; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; /// let server = TcpListener::bind(addr).await?; /// Ok(()) /// } /// ``` - pub async fn bind(addr: SocketAddr) -> io::Result { - let listener = ylong_io::TcpListener::bind(addr)?; - TcpListener::new(listener) + pub async fn bind(addr: A) -> io::Result { + super::super::addr::each_addr(addr, ylong_io::TcpListener::bind) + .await + .map(TcpListener::new) + .and_then(|op| op) } /// Asynchronously accepts a new incoming connection from this listener. @@ -75,7 +85,7 @@ impl TcpListener { /// use ylong_runtime::net::TcpListener; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; /// let server = TcpListener::bind(addr).await?; /// let (stream, address) = server.accept().await?; /// Ok(()) diff --git a/ylong_runtime/src/net/sys/tcp/stream.rs b/ylong_runtime/src/net/sys/tcp/stream.rs index dbfaab5..12e58f7 100644 --- a/ylong_runtime/src/net/sys/tcp/stream.rs +++ b/ylong_runtime/src/net/sys/tcp/stream.rs @@ -14,13 +14,14 @@ use std::fmt::{Debug, Formatter}; use std::io; use std::io::IoSlice; -use std::net::{Shutdown, SocketAddr}; +use std::net::Shutdown; use std::pin::Pin; use std::task::{Context, Poll}; use ylong_io::Interest; use crate::io::{AsyncRead, AsyncWrite, ReadBuf}; +use crate::net::sys::ToSocketAddrs; use crate::net::AsyncSource; /// An asynchronous version of [`std::net::TcpStream`] @@ -39,7 +40,7 @@ use crate::net::AsyncSource; /// use ylong_runtime::net::TcpStream; /// /// async fn io_func() -> io::Result<()> { -/// let addr = "127.0.0.1:8080".parse().unwrap(); +/// let addr = "127.0.0.1:8080"; /// let mut stream = TcpStream::connect(addr).await?; /// /// let _ = stream.write(b"hello client").await?; @@ -66,6 +67,13 @@ impl Debug for TcpStream { impl TcpStream { /// Opens a TCP connection to a remote host asynchronously. /// + /// # Note + /// + /// If there are multiple addresses in SocketAddr, it will attempt to + /// connect them in sequence until one of the addrs returns success. If + /// all connections fail, it returns the error of the last connection. + /// This behavior is consistent with std. + /// /// # Example /// ```rust /// use std::io; @@ -73,13 +81,18 @@ impl TcpStream { /// use ylong_runtime::net::TcpStream; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; /// let mut stream = TcpStream::connect(addr).await?; /// Ok(()) /// } /// ``` - pub async fn connect(addr: SocketAddr) -> io::Result { - let stream = TcpStream::new(ylong_io::TcpStream::connect(addr)?)?; + pub async fn connect(addr: A) -> io::Result { + let stream = super::super::addr::each_addr(addr, ylong_io::TcpStream::connect).await?; + Self::connect_inner(stream).await + } + + async fn connect_inner(stream: ylong_io::TcpStream) -> io::Result { + let stream = TcpStream::new(stream)?; stream .source .async_process( diff --git a/ylong_runtime/src/net/sys/udp.rs b/ylong_runtime/src/net/sys/udp.rs index 9af739b..18645c6 100644 --- a/ylong_runtime/src/net/sys/udp.rs +++ b/ylong_runtime/src/net/sys/udp.rs @@ -20,6 +20,7 @@ use std::task::{Context, Poll}; use ylong_io::Interest; use crate::io::ReadBuf; +use crate::net::sys::ToSocketAddrs; use crate::net::AsyncSource; /// Asynchronous UdpSocket. @@ -32,8 +33,8 @@ use crate::net::AsyncSource; /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { -/// let sender_addr = "127.0.0.1:8081".parse().unwrap(); -/// let receiver_addr = "127.0.0.1:8082".parse().unwrap(); +/// let sender_addr = "127.0.0.1:8081"; +/// let receiver_addr = "127.0.0.1:8082"; /// let mut sender = UdpSocket::bind(sender_addr).await?; /// let mut receiver = UdpSocket::bind(sender_addr).await?; /// @@ -87,8 +88,14 @@ impl Debug for ConnectedUdpSocket { } impl UdpSocket { - /// Creates a new UDP socket and attempts to bind it to the address - /// provided, + /// Creates a new UDP socket and attempts to bind it to the address provided + /// + /// # Note + /// + /// If there are multiple addresses in SocketAddr, it will attempt to + /// connect them in sequence until one of the addrs returns success. If + /// all connections fail, it returns the error of the last connection. + /// This behavior is consistent with std. /// /// # Examples /// @@ -98,13 +105,16 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; /// let mut sock = UdpSocket::bind(addr).await?; /// Ok(()) /// } /// ``` - pub async fn bind(addr: SocketAddr) -> io::Result { - UdpSocket::new(ylong_io::UdpSocket::bind(addr)?) + pub async fn bind(addr: A) -> io::Result { + super::addr::each_addr(addr, ylong_io::UdpSocket::bind) + .await + .map(UdpSocket::new) + .and_then(|op| op) } /// Internal interfaces. @@ -119,6 +129,14 @@ impl UdpSocket { /// those that are read via recv from the specific address. /// /// Returns the connected UdpSocket if succeeds. + /// + /// # Note + /// + /// If there are multiple addresses in SocketAddr, it will attempt to + /// connect them in sequence until one of the addrs returns success. If + /// all connections fail, it returns the error of the last connection. + /// This behavior is consistent with std. + /// /// # Examples /// /// ```rust @@ -127,9 +145,9 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -139,15 +157,26 @@ impl UdpSocket { /// Ok(()) /// } /// ``` - pub async fn connect(self, addr: SocketAddr) -> io::Result { + pub async fn connect(self, addr: A) -> io::Result { let local_addr = self.local_addr().unwrap(); drop(self); - let socket = ylong_io::UdpSocket::bind(local_addr)?; - let connected_socket = match socket.connect(addr) { - Ok(socket) => socket, - Err(e) => return Err(e), - }; - ConnectedUdpSocket::new(connected_socket) + + let addrs = addr.to_socket_addrs().await?; + + let mut last_e = None; + + for addr in addrs { + let socket = ylong_io::UdpSocket::bind(local_addr)?; + match socket.connect(addr) { + Ok(socket) => return ConnectedUdpSocket::new(socket), + Err(e) => last_e = Some(e), + } + } + + Err(last_e.unwrap_or(io::Error::new( + io::ErrorKind::InvalidInput, + "addr could not resolve to any address", + ))) } /// Returns the local address that this socket is bound to. @@ -160,7 +189,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; /// let mut sock = UdpSocket::bind(addr).await?; /// let local_addr = sock.local_addr()?; /// Ok(()) @@ -188,18 +217,26 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let len = sock.send_to(b"hello world", remote_addr).await?; /// println!("Sent {} bytes", len); /// Ok(()) /// } /// ``` - pub async fn send_to(&self, buf: &[u8], target: SocketAddr) -> io::Result { - self.source - .async_process(Interest::WRITABLE, || self.source.send_to(buf, target)) - .await + pub async fn send_to(&self, buf: &[u8], target: A) -> io::Result { + match target.to_socket_addrs().await?.next() { + Some(addr) => { + self.source + .async_process(Interest::WRITABLE, || self.source.send_to(buf, addr)) + .await + } + None => Err(io::Error::new( + io::ErrorKind::InvalidInput, + "addr could not resolve to address", + )), + } } /// Attempts to send data on the socket to the given address. @@ -222,7 +259,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); /// let len = sock.try_send_to(b"hello world", remote_addr)?; @@ -254,7 +291,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); /// let len = poll_fn(|cx| sock.poll_send_to(cx, b"Hello", remote_addr)).await?; @@ -292,7 +329,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; /// let mut recv_buf = [0_u8; 12]; /// let (len, addr) = sock.recv_from(&mut recv_buf).await?; @@ -329,7 +366,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; /// let mut recv_buf = [0_u8; 12]; /// let (len, addr) = sock.try_recv_from(&mut recv_buf)?; @@ -353,7 +390,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; /// sock.readable().await?; /// let mut buf = [0; 12]; @@ -377,7 +414,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let remote_addr = "127.0.0.1:8080".parse().unwrap(); /// let sock = UdpSocket::bind(local_addr).await?; /// sock.writable().await?; @@ -412,7 +449,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; /// let mut recv_buf = [0_u8; 12]; /// let mut read = ReadBuf::new(&mut recv_buf); @@ -453,7 +490,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let broadcast_socket = UdpSocket::bind(local_addr).await?; /// if broadcast_socket.broadcast()? == false { /// broadcast_socket.set_broadcast(true)?; @@ -476,7 +513,7 @@ impl UdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let broadcast_socket = UdpSocket::bind(local_addr).await?; /// assert_eq!(broadcast_socket.broadcast()?, false); /// Ok(()) @@ -506,9 +543,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; /// let mut sock = UdpSocket::bind(addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -534,8 +571,8 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let addr = "127.0.0.1:8080".parse().unwrap(); - /// let peer_addr = "127.0.0.1:8081".parse().unwrap(); + /// let addr = "127.0.0.1:8080"; + /// let peer_addr = "127.0.0.1:8081"; /// let mut sock = UdpSocket::bind(addr).await?; /// let connected_sock = match sock.connect(peer_addr).await { /// Ok(socket) => socket, @@ -543,7 +580,7 @@ impl ConnectedUdpSocket { /// return Err(e); /// } /// }; - /// assert_eq!(connected_sock.peer_addr()?, peer_addr); + /// assert_eq!(connected_sock.peer_addr()?, peer_addr.parse().unwrap()); /// Ok(()) /// } /// ``` @@ -568,9 +605,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -608,9 +645,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -648,9 +685,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -686,9 +723,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -731,9 +768,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -776,9 +813,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::UdpSocket; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -820,9 +857,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::{ConnectedUdpSocket, UdpSocket}; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -852,9 +889,9 @@ impl ConnectedUdpSocket { /// use ylong_runtime::net::{ConnectedUdpSocket, UdpSocket}; /// /// async fn io_func() -> io::Result<()> { - /// let local_addr = "127.0.0.1:8080".parse().unwrap(); + /// let local_addr = "127.0.0.1:8080"; /// let sock = UdpSocket::bind(local_addr).await?; - /// let remote_addr = "127.0.0.1:8081".parse().unwrap(); + /// let remote_addr = "127.0.0.1:8081"; /// let connected_sock = match sock.connect(remote_addr).await { /// Ok(socket) => socket, /// Err(e) => { @@ -875,6 +912,8 @@ impl ConnectedUdpSocket { #[cfg(test)] mod tests { + use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; + use crate::futures::poll_fn; use crate::io::ReadBuf; use crate::net::UdpSocket; @@ -889,8 +928,8 @@ mod tests { /// 4. Check if the test results are correct. #[test] fn test_send_recv_poll() { - let sender_addr = "127.0.0.1:8083".parse().unwrap(); - let receiver_addr = "127.0.0.1:8084".parse().unwrap(); + let sender_addr = "127.0.0.1:8083"; + let receiver_addr = "127.0.0.1:8084"; let handle = spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -949,8 +988,9 @@ mod tests { /// 4. Check if the test results are correct. #[test] fn test_send_to_recv_from_poll() { - let sender_addr = "127.0.0.1:8087".parse().unwrap(); - let receiver_addr = "127.0.0.1:8088".parse().unwrap(); + let sender_addr = "127.0.0.1:8087"; + let receiver_addr = "127.0.0.1:8088"; + let receiver_addr_socket = "127.0.0.1:8088".parse().unwrap(); let handle = spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -966,7 +1006,7 @@ mod tests { } }; - match poll_fn(|cx| sender.poll_send_to(cx, b"Hello", receiver_addr)).await { + match poll_fn(|cx| sender.poll_send_to(cx, b"Hello", receiver_addr_socket)).await { Ok(n) => { assert_eq!(n, "Hello".len()); } @@ -981,7 +1021,7 @@ mod tests { .await .unwrap(); assert_eq!(read.filled(), b"Hello"); - assert_eq!(addr, sender_addr); + assert_eq!(addr, sender_addr.parse().unwrap()); }); block_on(handle).expect("block_on failed"); } @@ -995,7 +1035,7 @@ mod tests { /// 4. Check if the test results are correct. #[test] fn ut_set_get_broadcast() { - let local_addr = "127.0.0.1:8091".parse().unwrap(); + let local_addr = "127.0.0.1:8091"; let handle = spawn(async move { let broadcast_socket = match UdpSocket::bind(local_addr).await { @@ -1021,8 +1061,8 @@ mod tests { /// 3. Check if the test results are correct. #[test] fn ut_get_local_addr() { - let local_addr = "127.0.0.1:8092".parse().unwrap(); - let remote_addr = "127.0.0.1:8093".parse().unwrap(); + let local_addr = "127.0.0.1:8092"; + let remote_addr = "127.0.0.1:8093"; let handle = spawn(async move { let sock = match UdpSocket::bind(local_addr).await { @@ -1038,7 +1078,7 @@ mod tests { } }; let local_addr1 = connected_sock.local_addr().expect("local_addr failed"); - assert_eq!(local_addr1, local_addr); + assert_eq!(local_addr1, local_addr.parse().unwrap()); }); block_on(handle).expect("block_on failed"); } @@ -1052,8 +1092,8 @@ mod tests { /// 3. Check if the test results are correct. #[test] fn ut_get_peer_addr() { - let local_addr = "127.0.0.1:8094".parse().unwrap(); - let peer_addr = "127.0.0.1:8095".parse().unwrap(); + let local_addr = "127.0.0.1:8094"; + let peer_addr = "127.0.0.1:8095"; let handle = spawn(async move { let sock = match UdpSocket::bind(local_addr).await { Ok(socket) => socket, @@ -1069,9 +1109,102 @@ mod tests { }; assert_eq!( connected_sock.peer_addr().expect("peer_addr failed"), - peer_addr + peer_addr.parse().unwrap() ); }); block_on(handle).expect("block_on failed"); } + + macro_rules! socket_addr { + ($sender_addr:ident, $receiver_addr:ident) => { + let handle = spawn(async move { + let sender = match UdpSocket::bind($sender_addr).await { + Ok(socket) => socket, + Err(e) => { + panic!("Bind Socket Failed {}", e); + } + }; + + let connected_sender = match sender.connect($receiver_addr).await { + Ok(socket) => socket, + Err(e) => { + panic!("Connect Socket Failed {}", e); + } + }; + + match connected_sender.send(b"Hello").await { + Ok(n) => assert_eq!(n, 5), + Err(e) => { + panic!("send message Failed {}", e); + } + } + }); + block_on(handle).expect("block_on failed"); + }; + } + + /// UT test cases for `ToSocketAddrs` blocking. + /// + /// # Brief + /// 1. Create UdpSocket with "localhost". + /// 2. Connect to the remote address. + /// 3. Check if the test results are correct. + #[test] + fn test_udp_to_socket_addrs_blocking() { + let sender_addr = "localhost:8096"; + let receiver_addr = "localhost:8097"; + socket_addr!(sender_addr, receiver_addr); + } + + /// UT test cases for `ToSocketAddrs` (&str, u16). + /// + /// # Brief + /// 1. Create UdpSocket with (&str, u16). + /// 2. Connect to the remote address. + /// 3. Check if the test results are correct. + #[test] + fn test_udp_to_socket_addrs_str_u16() { + let sender_addr = ("localhost", 8098); + let receiver_addr = ("localhost", 8099); + socket_addr!(sender_addr, receiver_addr); + } + + /// UT test cases for `ToSocketAddrs` (IpAddr, u16). + /// + /// # Brief + /// 1. Create UdpSocket with (IpAddr, u16). + /// 2. Connect to the remote address. + /// 3. Check if the test results are correct. + #[test] + fn test_udp_to_socket_addrs_ipaddr_u16() { + let sender_addr = (IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8101); + let receiver_addr = (IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8102); + socket_addr!(sender_addr, receiver_addr); + } + + /// UT test cases for `ToSocketAddrs` (Ipv4Addr, u16). + /// + /// # Brief + /// 1. Create UdpSocket with (Ipv4Addr, u16). + /// 2. Connect to the remote address. + /// 3. Check if the test results are correct. + #[test] + fn test_udp_to_socket_addrs_ipv4addr_u16() { + let sender_addr = (Ipv4Addr::new(127, 0, 0, 1), 8103); + let receiver_addr = (Ipv4Addr::new(127, 0, 0, 1), 8104); + socket_addr!(sender_addr, receiver_addr); + } + + /// UT test cases for `ToSocketAddrs` (Ipv6Addr, u16). + /// + /// # Brief + /// 1. Create UdpSocket with (Ipv6Addr, u16). + /// 2. Connect to the remote address. + /// 3. Check if the test results are correct. + #[test] + fn test_udp_to_socket_addrs_ipv6addr_u16() { + let sender_addr = (Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8105); + let receiver_addr = (Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8106); + socket_addr!(sender_addr, receiver_addr); + } } diff --git a/ylong_runtime/tests/async_buf_read.rs b/ylong_runtime/tests/async_buf_read.rs index 54a799c..3e0b336 100644 --- a/ylong_runtime/tests/async_buf_read.rs +++ b/ylong_runtime/tests/async_buf_read.rs @@ -34,7 +34,7 @@ use ylong_runtime::net::{TcpListener, TcpStream}; #[test] fn sdv_buf_reader_read_until() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8180".parse().unwrap(); + let addr = "127.0.0.1:8180"; let tcp = TcpListener::bind(addr).await.unwrap(); let (stream, _) = tcp.accept().await.unwrap(); let mut buf_reader = AsyncBufReader::new(stream); @@ -50,7 +50,7 @@ fn sdv_buf_reader_read_until() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8180".parse().unwrap(); + let addr = "127.0.0.1:8180"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; @@ -78,7 +78,7 @@ fn sdv_buf_reader_read_until() { #[test] fn sdv_buf_reader_read_line() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8181".parse().unwrap(); + let addr = "127.0.0.1:8181"; let tcp = TcpListener::bind(addr).await.unwrap(); let (stream, _) = tcp.accept().await.unwrap(); let mut buf_reader = AsyncBufReader::new(stream); @@ -92,7 +92,7 @@ fn sdv_buf_reader_read_line() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8181".parse().unwrap(); + let addr = "127.0.0.1:8181"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; @@ -119,7 +119,7 @@ fn sdv_buf_reader_read_line() { #[test] fn sdv_buf_reader_split() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8182".parse().unwrap(); + let addr = "127.0.0.1:8182"; let tcp = TcpListener::bind(addr).await.unwrap(); let (stream, _) = tcp.accept().await.unwrap(); let buf_reader = AsyncBufReader::new(stream); @@ -131,7 +131,7 @@ fn sdv_buf_reader_split() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8182".parse().unwrap(); + let addr = "127.0.0.1:8182"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; @@ -158,7 +158,7 @@ fn sdv_buf_reader_split() { #[test] fn sdv_buf_reader_lines() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8183".parse().unwrap(); + let addr = "127.0.0.1:8183"; let tcp = TcpListener::bind(addr).await.unwrap(); let (stream, _) = tcp.accept().await.unwrap(); let buf_reader = AsyncBufReader::new(stream); @@ -179,7 +179,7 @@ fn sdv_buf_reader_lines() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8183".parse().unwrap(); + let addr = "127.0.0.1:8183"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; diff --git a/ylong_runtime/tests/async_buf_write.rs b/ylong_runtime/tests/async_buf_write.rs index 9ee233e..5a0c627 100644 --- a/ylong_runtime/tests/async_buf_write.rs +++ b/ylong_runtime/tests/async_buf_write.rs @@ -29,7 +29,7 @@ use ylong_runtime::net::{TcpListener, TcpStream}; #[test] fn sdv_buf_writer_write() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8184".parse().unwrap(); + let addr = "127.0.0.1:8184"; let tcp = TcpListener::bind(addr).await.unwrap(); let (mut stream, _) = tcp.accept().await.unwrap(); @@ -40,7 +40,7 @@ fn sdv_buf_writer_write() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8184".parse().unwrap(); + let addr = "127.0.0.1:8184"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; @@ -68,7 +68,7 @@ fn sdv_buf_writer_write() { #[test] fn sdv_buf_writer_write_vectored() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8185".parse().unwrap(); + let addr = "127.0.0.1:8185"; let tcp = TcpListener::bind(addr).await.unwrap(); let (mut stream, _) = tcp.accept().await.unwrap(); @@ -79,7 +79,7 @@ fn sdv_buf_writer_write_vectored() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8185".parse().unwrap(); + let addr = "127.0.0.1:8185"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; diff --git a/ylong_runtime/tests/async_read.rs b/ylong_runtime/tests/async_read.rs index 27733a1..b7813a2 100644 --- a/ylong_runtime/tests/async_read.rs +++ b/ylong_runtime/tests/async_read.rs @@ -59,7 +59,7 @@ fn sdv_async_read_slice() { #[test] fn sdv_buf_reader_read_to_string() { let server = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8186".parse().unwrap(); + let addr = "127.0.0.1:8186"; let tcp = TcpListener::bind(addr).await.unwrap(); let (stream, _) = tcp.accept().await.unwrap(); let mut buf_reader = AsyncBufReader::new(stream); @@ -70,7 +70,7 @@ fn sdv_buf_reader_read_to_string() { }); let client = ylong_runtime::spawn(async move { - let addr = "127.0.0.1:8186".parse().unwrap(); + let addr = "127.0.0.1:8186"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; diff --git a/ylong_runtime/tests/join_set.rs b/ylong_runtime/tests/join_set.rs index 8649cb6..c9d3361 100644 --- a/ylong_runtime/tests/join_set.rs +++ b/ylong_runtime/tests/join_set.rs @@ -95,7 +95,7 @@ fn sdv_join_set_spawn_io() { let mut set = JoinSet::new(); let handle = ylong_runtime::spawn(async move { set.spawn(async move { - let addr = "127.0.0.1:9001".parse().unwrap(); + let addr = "127.0.0.1:9001"; let listener = TcpListener::bind(addr).await.unwrap(); let mut server = listener.accept().await.unwrap().0; let mut buf = [0; 100]; @@ -106,7 +106,7 @@ fn sdv_join_set_spawn_io() { }); set.spawn(async move { - let addr = "127.0.0.1:9001".parse().unwrap(); + let addr = "127.0.0.1:9001"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; diff --git a/ylong_runtime/tests/tcp_test.rs b/ylong_runtime/tests/tcp_test.rs index 14a15d7..dbbc7bf 100644 --- a/ylong_runtime/tests/tcp_test.rs +++ b/ylong_runtime/tests/tcp_test.rs @@ -20,7 +20,7 @@ fn test_tcp_client() { let mut recv_buf = [0_u8; 12]; let handle = ylong_runtime::spawn(async move { loop { - let addr = "127.0.0.1:8081".parse().unwrap(); + let addr = "127.0.0.1:8081"; if let Ok(mut client) = TcpStream::connect(addr).await { match client.write(b"hello server").await { Ok(n) => { @@ -53,7 +53,7 @@ fn test_tcp_client() { fn sdv_tcp_global_runtime() { // Start a thread as client side thread::spawn(test_tcp_client); - let addr = "127.0.0.1:8081".parse().unwrap(); + let addr = "127.0.0.1:8081"; let handle = ylong_runtime::spawn(async move { let listener = TcpListener::bind(addr).await; if let Err(e) = listener { @@ -103,7 +103,7 @@ fn sdv_tcp_multi_runtime() { let runtime = RuntimeBuilder::new_multi_thread().build().unwrap(); let server = runtime.spawn(async move { - let addr = "127.0.0.1:8082".parse().unwrap(); + let addr = "127.0.0.1:8082"; let tcp = TcpListener::bind(addr).await.unwrap(); let (mut stream, _) = tcp.accept().await.unwrap(); let mut buf = [0; 100]; @@ -115,7 +115,7 @@ fn sdv_tcp_multi_runtime() { }); let client = runtime.spawn(async move { - let addr = "127.0.0.1:8082".parse().unwrap(); + let addr = "127.0.0.1:8082"; let mut tcp = TcpStream::connect(addr).await; while tcp.is_err() { tcp = TcpStream::connect(addr).await; diff --git a/ylong_runtime/tests/udp_test.rs b/ylong_runtime/tests/udp_test.rs index 8989227..53bea76 100644 --- a/ylong_runtime/tests/udp_test.rs +++ b/ylong_runtime/tests/udp_test.rs @@ -24,8 +24,8 @@ use ylong_runtime::net::UdpSocket; /// 4. Check if the test results are correct. #[test] fn sdv_udp_send_recv() { - let sender_addr = "127.0.0.1:8081".parse().unwrap(); - let receiver_addr = "127.0.0.1:8082".parse().unwrap(); + let sender_addr = "127.0.0.1:8081"; + let receiver_addr = "127.0.0.1:8082"; let handle = ylong_runtime::spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -80,8 +80,8 @@ fn sdv_udp_send_recv() { /// 4. Check if the test results are correct. #[test] fn sdv_udp_send_to_recv_from() { - let sender_addr = "127.0.0.1:8085".parse().unwrap(); - let receiver_addr = "127.0.0.1:8086".parse().unwrap(); + let sender_addr = "127.0.0.1:8085"; + let receiver_addr = "127.0.0.1:8086"; let handle = ylong_runtime::spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -109,14 +109,14 @@ fn sdv_udp_send_to_recv_from() { let mut recv_buf = [0_u8; 12]; let (len, addr) = receiver.recv_from(&mut recv_buf[..]).await.unwrap(); assert_eq!(&recv_buf[..len], b"Hello"); - assert_eq!(addr, sender_addr); + assert_eq!(addr, sender_addr.parse().unwrap()); }); ylong_runtime::block_on(handle).expect("block_on failed"); } fn sdv_udp_send() { - let sender_addr = "127.0.0.1:8089".parse().unwrap(); - let receiver_addr = "127.0.0.1:8090".parse().unwrap(); + let sender_addr = "127.0.0.1:8089"; + let receiver_addr = "127.0.0.1:8090"; let handle = ylong_runtime::spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -154,8 +154,8 @@ fn sdv_udp_send() { /// 4. Check if the test results are correct. #[test] fn sdv_udp_recv() { - let sender_addr = "127.0.0.1:8089".parse().unwrap(); - let receiver_addr = "127.0.0.1:8090".parse().unwrap(); + let sender_addr = "127.0.0.1:8089"; + let receiver_addr = "127.0.0.1:8090"; let handle = ylong_runtime::spawn(async move { let receiver = match UdpSocket::bind(receiver_addr).await { Ok(socket) => socket, @@ -189,8 +189,8 @@ fn sdv_udp_recv() { /// 4. Check if the test results are correct. #[test] fn sdv_udp_try_recv_from() { - let sender_addr = "127.0.0.1:8091".parse().unwrap(); - let receiver_addr = "127.0.0.1:8092".parse().unwrap(); + let sender_addr = "127.0.0.1:8091"; + let receiver_addr = "127.0.0.1:8092"; let handle = ylong_runtime::spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -207,10 +207,10 @@ fn sdv_udp_try_recv_from() { }; sender.writable().await.unwrap(); - let mut ret = sender.try_send_to(b"Hello", receiver_addr); + let mut ret = sender.try_send_to(b"Hello", receiver_addr.parse().unwrap()); while let Err(ref e) = ret { if e.kind() == io::ErrorKind::WouldBlock { - ret = sender.try_send_to(b"Hello", receiver_addr); + ret = sender.try_send_to(b"Hello", receiver_addr.parse().unwrap()); } else { panic!("try_send_to failed: {}", e); } @@ -230,14 +230,14 @@ fn sdv_udp_try_recv_from() { } let (len, peer_addr) = ret.unwrap(); assert_eq!(&recv_buf[..len], b"Hello"); - assert_eq!(peer_addr, sender_addr); + assert_eq!(peer_addr, sender_addr.parse().unwrap()); }); ylong_runtime::block_on(handle).expect("block_on failed"); } fn sdv_udp_try_send() { - let sender_addr = "127.0.0.1:8093".parse().unwrap(); - let receiver_addr = "127.0.0.1:8094".parse().unwrap(); + let sender_addr = "127.0.0.1:8093"; + let receiver_addr = "127.0.0.1:8094"; let handle = ylong_runtime::spawn(async move { let sender = match UdpSocket::bind(sender_addr).await { Ok(socket) => socket, @@ -278,8 +278,8 @@ fn sdv_udp_try_send() { /// 4. Check if the test results are correct. #[test] fn sdv_udp_try_recv() { - let sender_addr = "127.0.0.1:8093".parse().unwrap(); - let receiver_addr = "127.0.0.1:8094".parse().unwrap(); + let sender_addr = "127.0.0.1:8093"; + let receiver_addr = "127.0.0.1:8094"; let handle = ylong_runtime::spawn(async move { let receiver = match UdpSocket::bind(receiver_addr).await { Ok(socket) => socket, -- Gitee