1 // Copyright (c) 2023 Huawei Device Co., Ltd.
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13
14 use std::io::ErrorKind;
15
16 use ylong_io::UdpSocket;
17
18 /// SDV test cases for `send()` and `recv()`.
19 ///
20 /// # Brief
21 /// 1. Create UdpSocket and connect to the remote address.
22 /// 2. Sender sends message first.
23 /// 3. Receiver receives message.
24 /// 4. Check if the test results are correct.
25 #[test]
sdv_send_recv()26 fn sdv_send_recv() {
27 let sender_addr = "127.0.0.1:8081".parse().unwrap();
28 let receiver_addr = "127.0.0.1:8082".parse().unwrap();
29
30 let sender = match UdpSocket::bind(sender_addr) {
31 Ok(socket) => socket,
32 Err(e) => {
33 panic!("Bind Socket Failed {}", e);
34 }
35 };
36
37 let receiver = match UdpSocket::bind(receiver_addr) {
38 Ok(socket) => socket,
39 Err(e) => {
40 panic!("Bind Socket Failed {}", e);
41 }
42 };
43
44 let connected_sender = match sender.connect(receiver_addr) {
45 Ok(socket) => socket,
46 Err(e) => {
47 panic!("Connect Socket Failed {}", e);
48 }
49 };
50 let connected_receiver = match receiver.connect(sender_addr) {
51 Ok(socket) => socket,
52 Err(e) => {
53 panic!("Connect Socket Failed {}", e);
54 }
55 };
56
57 match connected_sender.send(b"Hello") {
58 Ok(n) => {
59 assert_eq!(n, "Hello".len());
60 }
61 Err(e) => {
62 panic!("Sender Send Failed {}", e);
63 }
64 }
65
66 let mut recv_buf = [0_u8; 12];
67 let len = loop {
68 match connected_receiver.recv(&mut recv_buf[..]) {
69 Ok(n) => break n,
70 Err(e) if e.kind() == ErrorKind::WouldBlock => {}
71 Err(e) => panic!("{:?}", e),
72 }
73 };
74
75 assert_eq!(&recv_buf[..len], b"Hello");
76 }
77
78 /// SDV test cases for `send_to()` and `recv_from()`.
79 ///
80 /// # Brief
81 /// 1. Create UdpSocket.
82 /// 2. Sender sends message to the specified address.
83 /// 3. Receiver receives message and return the address the message from.
84 /// 4. Check if the test results are correct.
85 #[test]
sdv_send_to_recv_from()86 fn sdv_send_to_recv_from() {
87 let sender_addr = "127.0.0.1:8085".parse().unwrap();
88 let receiver_addr = "127.0.0.1:8086".parse().unwrap();
89
90 let sender = match UdpSocket::bind(sender_addr) {
91 Ok(socket) => socket,
92 Err(e) => {
93 panic!("Bind Socket Failed {}", e);
94 }
95 };
96
97 let receiver = match UdpSocket::bind(receiver_addr) {
98 Ok(socket) => socket,
99 Err(e) => {
100 panic!("Bind Socket Failed {}", e);
101 }
102 };
103
104 match sender.send_to(b"Hello", receiver_addr) {
105 Ok(n) => {
106 assert_eq!(n, "Hello".len());
107 }
108 Err(e) => {
109 panic!("Sender Send Failed {}", e);
110 }
111 }
112
113 let mut recv_buf = [0_u8; 12];
114 let (len, addr) = loop {
115 match receiver.recv_from(&mut recv_buf[..]) {
116 Ok(res) => break res,
117 Err(e) if e.kind() == ErrorKind::WouldBlock => {}
118 Err(e) => panic!("{:?}", e),
119 }
120 };
121 assert_eq!(&recv_buf[..len], b"Hello");
122 assert_eq!(addr, sender_addr);
123 }
124