1//
2// buffered_stream.cpp
3// ~~~~~~~~~~~~~~~~~~~
4//
5// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6//
7// Distributed under the Boost Software License, Version 1.0. (See accompanying
8// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9//
10
11// Disable autolinking for unit tests.
12#if !defined(BOOST_ALL_NO_LIB)
13#define BOOST_ALL_NO_LIB 1
14#endif // !defined(BOOST_ALL_NO_LIB)
15
16// Test that header file is self-contained.
17#include <boost/asio/buffered_stream.hpp>
18
19#include <cstring>
20#include <functional>
21#include "archetypes/async_result.hpp"
22#include <boost/asio/buffer.hpp>
23#include <boost/asio/io_context.hpp>
24#include <boost/asio/ip/tcp.hpp>
25#include <boost/system/system_error.hpp>
26#include "unit_test.hpp"
27
28#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
29# include <boost/array.hpp>
30#else // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
31# include <array>
32#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
33
34typedef boost::asio::buffered_stream<
35 boost::asio::ip::tcp::socket> stream_type;
36
37void write_some_handler(const boost::system::error_code&, std::size_t)
38{
39}
40
41void flush_handler(const boost::system::error_code&, std::size_t)
42{
43}
44
45void fill_handler(const boost::system::error_code&, std::size_t)
46{
47}
48
49void read_some_handler(const boost::system::error_code&, std::size_t)
50{
51}
52
53void test_compile()
54{
55#if defined(BOOST_ASIO_HAS_BOOST_ARRAY)
56 using boost::array;
57#else // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
58 using std::array;
59#endif // defined(BOOST_ASIO_HAS_BOOST_ARRAY)
60
61 using namespace boost::asio;
62
63 try
64 {
65 io_context ioc;
66 char mutable_char_buffer[128] = "";
67 const char const_char_buffer[128] = "";
68 array<boost::asio::mutable_buffer, 2> mutable_buffers = {.elems: {
69 boost::asio::buffer(data&: mutable_char_buffer, max_size_in_bytes: 10),
70 boost::asio::buffer(data: mutable_char_buffer + 10, size_in_bytes: 10) }};
71 array<boost::asio::const_buffer, 2> const_buffers = {.elems: {
72 boost::asio::buffer(data: const_char_buffer, max_size_in_bytes: 10),
73 boost::asio::buffer(data: const_char_buffer + 10, size_in_bytes: 10) }};
74 archetypes::lazy_handler lazy;
75 boost::system::error_code ec;
76
77 stream_type stream1(ioc);
78 stream_type stream2(ioc, 1024, 1024);
79
80 stream_type::executor_type ex = stream1.get_executor();
81 (void)ex;
82
83 stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
84 (void)lowest_layer;
85
86 stream1.write_some(buffers: buffer(data&: mutable_char_buffer));
87 stream1.write_some(buffers: buffer(data: const_char_buffer));
88 stream1.write_some(buffers: mutable_buffers);
89 stream1.write_some(buffers: const_buffers);
90 stream1.write_some(buffers: null_buffers());
91 stream1.write_some(buffers: buffer(data&: mutable_char_buffer), ec);
92 stream1.write_some(buffers: buffer(data: const_char_buffer), ec);
93 stream1.write_some(buffers: mutable_buffers, ec);
94 stream1.write_some(buffers: const_buffers, ec);
95 stream1.write_some(buffers: null_buffers(), ec);
96
97 stream1.async_write_some(buffers: buffer(data&: mutable_char_buffer), handler: &write_some_handler);
98 stream1.async_write_some(buffers: buffer(data: const_char_buffer), handler: &write_some_handler);
99 stream1.async_write_some(buffers: mutable_buffers, handler: &write_some_handler);
100 stream1.async_write_some(buffers: const_buffers, handler: &write_some_handler);
101 stream1.async_write_some(buffers: null_buffers(), handler: &write_some_handler);
102 int i1 = stream1.async_write_some(buffers: buffer(data&: mutable_char_buffer), handler&: lazy);
103 (void)i1;
104 int i2 = stream1.async_write_some(buffers: buffer(data: const_char_buffer), handler&: lazy);
105 (void)i2;
106 int i3 = stream1.async_write_some(buffers: mutable_buffers, handler&: lazy);
107 (void)i3;
108 int i4 = stream1.async_write_some(buffers: const_buffers, handler&: lazy);
109 (void)i4;
110 int i5 = stream1.async_write_some(buffers: null_buffers(), handler&: lazy);
111 (void)i5;
112
113 stream1.flush();
114 stream1.flush(ec);
115
116 stream1.async_flush(handler: &flush_handler);
117 int i6 = stream1.async_flush(handler&: lazy);
118 (void)i6;
119
120 stream1.fill();
121 stream1.fill(ec);
122
123 stream1.async_fill(handler: &fill_handler);
124 int i7 = stream1.async_fill(handler&: lazy);
125 (void)i7;
126
127 stream1.read_some(buffers: buffer(data&: mutable_char_buffer));
128 stream1.read_some(buffers: mutable_buffers);
129 stream1.read_some(buffers: null_buffers());
130 stream1.read_some(buffers: buffer(data&: mutable_char_buffer), ec);
131 stream1.read_some(buffers: mutable_buffers, ec);
132 stream1.read_some(buffers: null_buffers(), ec);
133
134 stream1.async_read_some(buffers: buffer(data&: mutable_char_buffer), handler: &read_some_handler);
135 stream1.async_read_some(buffers: mutable_buffers, handler: &read_some_handler);
136 stream1.async_read_some(buffers: null_buffers(), handler: &read_some_handler);
137 int i8 = stream1.async_read_some(buffers: buffer(data&: mutable_char_buffer), handler&: lazy);
138 (void)i8;
139 int i9 = stream1.async_read_some(buffers: mutable_buffers, handler&: lazy);
140 (void)i9;
141 int i10 = stream1.async_read_some(buffers: null_buffers(), handler&: lazy);
142 (void)i10;
143 }
144 catch (std::exception&)
145 {
146 }
147}
148
149void test_sync_operations()
150{
151 using namespace std; // For memcmp.
152
153 boost::asio::io_context io_context;
154
155 boost::asio::ip::tcp::acceptor acceptor(io_context,
156 boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
157 boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
158 server_endpoint.address(addr: boost::asio::ip::address_v4::loopback());
159
160 stream_type client_socket(io_context);
161 client_socket.lowest_layer().connect(peer_endpoint: server_endpoint);
162
163 stream_type server_socket(io_context);
164 acceptor.accept(peer&: server_socket.lowest_layer());
165
166 const char write_data[]
167 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
168 const boost::asio::const_buffer write_buf = boost::asio::buffer(data: write_data);
169
170 std::size_t bytes_written = 0;
171 while (bytes_written < sizeof(write_data))
172 {
173 bytes_written += client_socket.write_some(
174 buffers: boost::asio::buffer(b: write_buf + bytes_written));
175 client_socket.flush();
176 }
177
178 char read_data[sizeof(write_data)];
179 const boost::asio::mutable_buffer read_buf = boost::asio::buffer(data&: read_data);
180
181 std::size_t bytes_read = 0;
182 while (bytes_read < sizeof(read_data))
183 {
184 bytes_read += server_socket.read_some(
185 buffers: boost::asio::buffer(b: read_buf + bytes_read));
186 }
187
188 BOOST_ASIO_CHECK(bytes_written == sizeof(write_data));
189 BOOST_ASIO_CHECK(bytes_read == sizeof(read_data));
190 BOOST_ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
191
192 bytes_written = 0;
193 while (bytes_written < sizeof(write_data))
194 {
195 bytes_written += server_socket.write_some(
196 buffers: boost::asio::buffer(b: write_buf + bytes_written));
197 server_socket.flush();
198 }
199
200 bytes_read = 0;
201 while (bytes_read < sizeof(read_data))
202 {
203 bytes_read += client_socket.read_some(
204 buffers: boost::asio::buffer(b: read_buf + bytes_read));
205 }
206
207 BOOST_ASIO_CHECK(bytes_written == sizeof(write_data));
208 BOOST_ASIO_CHECK(bytes_read == sizeof(read_data));
209 BOOST_ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
210
211 server_socket.close();
212 boost::system::error_code error;
213 bytes_read = client_socket.read_some(
214 buffers: boost::asio::buffer(b: read_buf), ec&: error);
215
216 BOOST_ASIO_CHECK(bytes_read == 0);
217 BOOST_ASIO_CHECK(error == boost::asio::error::eof);
218
219 client_socket.close(ec&: error);
220}
221
222void handle_accept(const boost::system::error_code& e)
223{
224 BOOST_ASIO_CHECK(!e);
225}
226
227void handle_write(const boost::system::error_code& e,
228 std::size_t bytes_transferred,
229 std::size_t* total_bytes_written)
230{
231 BOOST_ASIO_CHECK(!e);
232 if (e)
233 throw boost::system::system_error(e); // Terminate test.
234 *total_bytes_written += bytes_transferred;
235}
236
237void handle_flush(const boost::system::error_code& e)
238{
239 BOOST_ASIO_CHECK(!e);
240}
241
242void handle_read(const boost::system::error_code& e,
243 std::size_t bytes_transferred,
244 std::size_t* total_bytes_read)
245{
246 BOOST_ASIO_CHECK(!e);
247 if (e)
248 throw boost::system::system_error(e); // Terminate test.
249 *total_bytes_read += bytes_transferred;
250}
251
252void handle_read_eof(const boost::system::error_code& e,
253 std::size_t bytes_transferred)
254{
255 BOOST_ASIO_CHECK(e == boost::asio::error::eof);
256 BOOST_ASIO_CHECK(bytes_transferred == 0);
257}
258
259void test_async_operations()
260{
261 using namespace std; // For memcmp.
262
263 namespace bindns = std;
264 using bindns::placeholders::_1;
265 using bindns::placeholders::_2;
266
267 boost::asio::io_context io_context;
268
269 boost::asio::ip::tcp::acceptor acceptor(io_context,
270 boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
271 boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
272 server_endpoint.address(addr: boost::asio::ip::address_v4::loopback());
273
274 stream_type client_socket(io_context);
275 client_socket.lowest_layer().connect(peer_endpoint: server_endpoint);
276
277 stream_type server_socket(io_context);
278 acceptor.async_accept(peer&: server_socket.lowest_layer(), token: &handle_accept);
279 io_context.run();
280 io_context.restart();
281
282 const char write_data[]
283 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
284 const boost::asio::const_buffer write_buf = boost::asio::buffer(data: write_data);
285
286 std::size_t bytes_written = 0;
287 while (bytes_written < sizeof(write_data))
288 {
289 client_socket.async_write_some(
290 buffers: boost::asio::buffer(b: write_buf + bytes_written),
291 handler: bindns::bind(f&: handle_write, args: _1, args: _2, args: &bytes_written));
292 io_context.run();
293 io_context.restart();
294 client_socket.async_flush(
295 handler: bindns::bind(f&: handle_flush, args: _1));
296 io_context.run();
297 io_context.restart();
298 }
299
300 char read_data[sizeof(write_data)];
301 const boost::asio::mutable_buffer read_buf = boost::asio::buffer(data&: read_data);
302
303 std::size_t bytes_read = 0;
304 while (bytes_read < sizeof(read_data))
305 {
306 server_socket.async_read_some(
307 buffers: boost::asio::buffer(b: read_buf + bytes_read),
308 handler: bindns::bind(f&: handle_read, args: _1, args: _2, args: &bytes_read));
309 io_context.run();
310 io_context.restart();
311 }
312
313 BOOST_ASIO_CHECK(bytes_written == sizeof(write_data));
314 BOOST_ASIO_CHECK(bytes_read == sizeof(read_data));
315 BOOST_ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
316
317 bytes_written = 0;
318 while (bytes_written < sizeof(write_data))
319 {
320 server_socket.async_write_some(
321 buffers: boost::asio::buffer(b: write_buf + bytes_written),
322 handler: bindns::bind(f&: handle_write, args: _1, args: _2, args: &bytes_written));
323 io_context.run();
324 io_context.restart();
325 server_socket.async_flush(
326 handler: bindns::bind(f&: handle_flush, args: _1));
327 io_context.run();
328 io_context.restart();
329 }
330
331 bytes_read = 0;
332 while (bytes_read < sizeof(read_data))
333 {
334 client_socket.async_read_some(
335 buffers: boost::asio::buffer(b: read_buf + bytes_read),
336 handler: bindns::bind(f&: handle_read, args: _1, args: _2, args: &bytes_read));
337 io_context.run();
338 io_context.restart();
339 }
340
341 BOOST_ASIO_CHECK(bytes_written == sizeof(write_data));
342 BOOST_ASIO_CHECK(bytes_read == sizeof(read_data));
343 BOOST_ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
344
345 server_socket.close();
346 client_socket.async_read_some(buffers: boost::asio::buffer(b: read_buf), handler&: handle_read_eof);
347}
348
349BOOST_ASIO_TEST_SUITE
350(
351 "buffered_stream",
352 BOOST_ASIO_COMPILE_TEST_CASE(test_compile)
353 BOOST_ASIO_TEST_CASE(test_sync_operations)
354 BOOST_ASIO_TEST_CASE(test_async_operations)
355)
356

source code of boost/libs/asio/test/buffered_stream.cpp