mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-24 00:00:11 +02:00
121 lines
3.5 KiB
Rust
121 lines
3.5 KiB
Rust
#![warn(rust_2018_idioms)]
|
|
#![cfg(feature = "full")]
|
|
|
|
use tokio::net::UdpSocket;
|
|
|
|
const MSG: &[u8] = b"hello";
|
|
const MSG_LEN: usize = MSG.len();
|
|
|
|
#[tokio::test]
|
|
async fn send_recv() -> std::io::Result<()> {
|
|
let mut sender = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let mut receiver = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
|
sender.connect(receiver.local_addr()?).await?;
|
|
receiver.connect(sender.local_addr()?).await?;
|
|
|
|
sender.send(MSG).await?;
|
|
|
|
let mut recv_buf = [0u8; 32];
|
|
let len = receiver.recv(&mut recv_buf[..]).await?;
|
|
|
|
assert_eq!(&recv_buf[..len], MSG);
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_to_recv_from() -> std::io::Result<()> {
|
|
let mut sender = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let mut receiver = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
|
let receiver_addr = receiver.local_addr()?;
|
|
sender.send_to(MSG, &receiver_addr).await?;
|
|
|
|
let mut recv_buf = [0u8; 32];
|
|
let (len, addr) = receiver.recv_from(&mut recv_buf[..]).await?;
|
|
|
|
assert_eq!(&recv_buf[..len], MSG);
|
|
assert_eq!(addr, sender.local_addr()?);
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn split() -> std::io::Result<()> {
|
|
let socket = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let (mut r, mut s) = socket.split();
|
|
|
|
let addr = s.as_ref().local_addr()?;
|
|
tokio::spawn(async move {
|
|
s.send_to(MSG, &addr).await.unwrap();
|
|
});
|
|
let mut recv_buf = [0u8; 32];
|
|
let (len, _) = r.recv_from(&mut recv_buf[..]).await?;
|
|
assert_eq!(&recv_buf[..len], MSG);
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn reunite() -> std::io::Result<()> {
|
|
let socket = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let (s, r) = socket.split();
|
|
assert!(s.reunite(r).is_ok());
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn reunite_error() -> std::io::Result<()> {
|
|
let socket = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let socket1 = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let (s, _) = socket.split();
|
|
let (_, r1) = socket1.split();
|
|
assert!(s.reunite(r1).is_err());
|
|
Ok(())
|
|
}
|
|
|
|
// # Note
|
|
//
|
|
// This test is purposely written such that each time `sender` sends data on
|
|
// the socket, `receiver` awaits the data. On Unix, it would be okay waiting
|
|
// until the end of the test to receive all the data. On Windows, this would
|
|
// **not** be okay because it's resources are completion based (via IOCP).
|
|
// If data is sent and not yet received, attempting to send more data will
|
|
// result in `ErrorKind::WouldBlock` until the first operation completes.
|
|
#[tokio::test]
|
|
async fn try_send_spawn() {
|
|
const MSG2: &[u8] = b"world!";
|
|
const MSG2_LEN: usize = MSG2.len();
|
|
|
|
let sender = UdpSocket::bind("127.0.0.1:0").await.unwrap();
|
|
let mut receiver = UdpSocket::bind("127.0.0.1:0").await.unwrap();
|
|
|
|
receiver
|
|
.connect(sender.local_addr().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let sent = &sender
|
|
.try_send_to(MSG, receiver.local_addr().unwrap())
|
|
.unwrap();
|
|
assert_eq!(sent, &MSG_LEN);
|
|
let mut buf = [0u8; 32];
|
|
let mut received = receiver.recv(&mut buf[..]).await.unwrap();
|
|
|
|
sender
|
|
.connect(receiver.local_addr().unwrap())
|
|
.await
|
|
.unwrap();
|
|
let sent = &sender.try_send(MSG2).unwrap();
|
|
assert_eq!(sent, &MSG2_LEN);
|
|
received += receiver.recv(&mut buf[..]).await.unwrap();
|
|
|
|
std::thread::spawn(move || {
|
|
let sent = &sender.try_send(MSG).unwrap();
|
|
assert_eq!(sent, &MSG_LEN);
|
|
})
|
|
.join()
|
|
.unwrap();
|
|
received += receiver.recv(&mut buf[..]).await.unwrap();
|
|
|
|
assert_eq!(received, MSG_LEN * 2 + MSG2_LEN);
|
|
}
|