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::{IoSlice, IoSliceMut, Read, Write};
15 use std::net::SocketAddr;
16 use std::{io, net, thread};
17
18 use ylong_io::TcpListener;
19
20 /// SDV for TcpStream read and write
21 ///
22 /// # Brief
23 /// 1. Create a Tcp server
24 /// 2. Write `hello` to client
25 /// 3. Read `hello` from client
26 #[test]
sdv_tcp_server()27 fn sdv_tcp_server() {
28 let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
29 let server = TcpListener::bind(addr).unwrap();
30 let addr = server.local_addr().unwrap();
31
32 let thread = thread::spawn(move || {
33 let (mut stream, _) = loop {
34 let stream = server.accept();
35 match stream {
36 Ok(stream) => break stream,
37 Err(e) if e.kind() == io::ErrorKind::WouldBlock => continue,
38 Err(e) => panic!("tcp accept failed: {e:?}"),
39 }
40 };
41 let mut ret = stream.write(b"hello");
42 loop {
43 match &ret {
44 Ok(n) => {
45 assert_eq!(*n, 5);
46 break;
47 }
48 Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
49 ret = stream.write(b"hello");
50 }
51 Err(e) => panic!("tcp write failed: {e:?}"),
52 }
53 }
54
55 let mut read_stream = stream.try_clone().unwrap();
56
57 let mut buf = [0; 5];
58 loop {
59 let ret = read_stream.read(&mut buf);
60 match &ret {
61 Ok(n) => {
62 assert_eq!(*n, 5);
63 assert_eq!(&buf, b"hello");
64 break;
65 }
66 Err(e) if e.kind() == io::ErrorKind::WouldBlock => continue,
67 Err(e) => panic!("tcp write failed: {e:?}"),
68 }
69 }
70 });
71
72 let mut client = loop {
73 let tcp = net::TcpStream::connect(addr);
74 match tcp {
75 Err(_) => continue,
76 Ok(stream) => break stream,
77 }
78 };
79 let mut buf = [0; 5];
80 let ret = client.read(&mut buf).unwrap();
81 assert_eq!(ret, 5);
82 assert_eq!(&buf, b"hello");
83
84 let ret = client.write(&buf).unwrap();
85 assert_eq!(ret, 5);
86
87 thread.join().unwrap();
88 }
89
90 /// SDV for TcpStream read_vectored and write_vectored
91 ///
92 /// # Brief
93 /// 1. Create a Tcp server
94 /// 2. Write `hello` to client
95 /// 3. Read `hello` from client
96 #[test]
sdv_tcp_server_vectored()97 fn sdv_tcp_server_vectored() {
98 let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
99 let server = TcpListener::bind(addr).unwrap();
100 let addr = server.local_addr().unwrap();
101
102 let thread = thread::spawn(move || {
103 let (mut stream, _) = loop {
104 let stream = server.accept();
105 match stream {
106 Ok(stream) => break stream,
107 Err(e) if e.kind() == io::ErrorKind::WouldBlock => continue,
108 Err(e) => panic!("tcp accept failed: {e:?}"),
109 }
110 };
111 let vec = b"hello";
112 let slice = IoSlice::new(vec);
113 let mut ret = stream.write_vectored(&[slice]);
114 loop {
115 match &ret {
116 Ok(n) => {
117 assert_eq!(*n, 5);
118 break;
119 }
120 Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
121 ret = stream.write(b"hello");
122 stream.flush().unwrap();
123 }
124 Err(e) => panic!("tcp write failed: {e:?}"),
125 }
126 }
127
128 let mut read_stream = stream.try_clone().unwrap();
129
130 loop {
131 let mut buf = [0; 5];
132 let slice = IoSliceMut::new(&mut buf);
133 let ret = read_stream.read_vectored(&mut [slice]);
134 match &ret {
135 Ok(n) => {
136 assert_eq!(*n, 5);
137 assert_eq!(&buf, b"hello");
138 break;
139 }
140 Err(e) if e.kind() == io::ErrorKind::WouldBlock => continue,
141 Err(e) => panic!("tcp write failed: {e:?}"),
142 }
143 }
144 });
145
146 let mut client = loop {
147 let tcp = net::TcpStream::connect(addr);
148 match tcp {
149 Err(_) => continue,
150 Ok(stream) => break stream,
151 }
152 };
153 let mut buf = [0; 5];
154 let ret = client.read(&mut buf).unwrap();
155 assert_eq!(ret, 5);
156 assert_eq!(&buf, b"hello");
157
158 let ret = client.write(&buf).unwrap();
159 assert_eq!(ret, 5);
160
161 thread.join().unwrap();
162 }
163