]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // udp.cpp | |
3 | // ~~~~~~~ | |
4 | // | |
5 | // Copyright (c) 2003-2016 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/ip/udp.hpp> | |
18 | ||
19 | #include <cstring> | |
20 | #include <boost/asio/io_service.hpp> | |
21 | #include "../unit_test.hpp" | |
22 | #include "../archetypes/gettable_socket_option.hpp" | |
23 | #include "../archetypes/async_result.hpp" | |
24 | #include "../archetypes/io_control_command.hpp" | |
25 | #include "../archetypes/settable_socket_option.hpp" | |
26 | ||
27 | #if defined(BOOST_ASIO_HAS_BOOST_BIND) | |
28 | # include <boost/bind.hpp> | |
29 | #else // defined(BOOST_ASIO_HAS_BOOST_BIND) | |
30 | # include <functional> | |
31 | #endif // defined(BOOST_ASIO_HAS_BOOST_BIND) | |
32 | ||
33 | //------------------------------------------------------------------------------ | |
34 | ||
35 | // ip_udp_socket_compile test | |
36 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
37 | // The following test checks that all public member functions on the class | |
38 | // ip::udp::socket compile and link correctly. Runtime failures are ignored. | |
39 | ||
40 | namespace ip_udp_socket_compile { | |
41 | ||
42 | void connect_handler(const boost::system::error_code&) | |
43 | { | |
44 | } | |
45 | ||
46 | void send_handler(const boost::system::error_code&, std::size_t) | |
47 | { | |
48 | } | |
49 | ||
50 | void receive_handler(const boost::system::error_code&, std::size_t) | |
51 | { | |
52 | } | |
53 | ||
54 | void test() | |
55 | { | |
56 | using namespace boost::asio; | |
57 | namespace ip = boost::asio::ip; | |
58 | ||
59 | try | |
60 | { | |
61 | io_service ios; | |
62 | char mutable_char_buffer[128] = ""; | |
63 | const char const_char_buffer[128] = ""; | |
64 | socket_base::message_flags in_flags = 0; | |
65 | archetypes::settable_socket_option<void> settable_socket_option1; | |
66 | archetypes::settable_socket_option<int> settable_socket_option2; | |
67 | archetypes::settable_socket_option<double> settable_socket_option3; | |
68 | archetypes::gettable_socket_option<void> gettable_socket_option1; | |
69 | archetypes::gettable_socket_option<int> gettable_socket_option2; | |
70 | archetypes::gettable_socket_option<double> gettable_socket_option3; | |
71 | archetypes::io_control_command io_control_command; | |
72 | archetypes::lazy_handler lazy; | |
73 | boost::system::error_code ec; | |
74 | ||
75 | // basic_datagram_socket constructors. | |
76 | ||
77 | ip::udp::socket socket1(ios); | |
78 | ip::udp::socket socket2(ios, ip::udp::v4()); | |
79 | ip::udp::socket socket3(ios, ip::udp::v6()); | |
80 | ip::udp::socket socket4(ios, ip::udp::endpoint(ip::udp::v4(), 0)); | |
81 | ip::udp::socket socket5(ios, ip::udp::endpoint(ip::udp::v6(), 0)); | |
82 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
83 | ip::udp::socket::native_handle_type native_socket1 | |
84 | = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); | |
85 | ip::udp::socket socket6(ios, ip::udp::v4(), native_socket1); | |
86 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
87 | ||
88 | #if defined(BOOST_ASIO_HAS_MOVE) | |
89 | ip::udp::socket socket7(std::move(socket6)); | |
90 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
91 | ||
92 | // basic_datagram_socket operators. | |
93 | ||
94 | #if defined(BOOST_ASIO_HAS_MOVE) | |
95 | socket1 = ip::udp::socket(ios); | |
96 | socket1 = std::move(socket2); | |
97 | #endif // defined(BOOST_ASIO_HAS_MOVE) | |
98 | ||
99 | // basic_io_object functions. | |
100 | ||
101 | io_service& ios_ref = socket1.get_io_service(); | |
102 | (void)ios_ref; | |
103 | ||
104 | // basic_socket functions. | |
105 | ||
106 | ip::udp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer(); | |
107 | (void)lowest_layer; | |
108 | ||
109 | const ip::udp::socket& socket8 = socket1; | |
110 | const ip::udp::socket::lowest_layer_type& lowest_layer2 | |
111 | = socket8.lowest_layer(); | |
112 | (void)lowest_layer2; | |
113 | ||
114 | socket1.open(ip::udp::v4()); | |
115 | socket1.open(ip::udp::v6()); | |
116 | socket1.open(ip::udp::v4(), ec); | |
117 | socket1.open(ip::udp::v6(), ec); | |
118 | ||
119 | #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
120 | ip::udp::socket::native_handle_type native_socket2 | |
121 | = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); | |
122 | socket1.assign(ip::udp::v4(), native_socket2); | |
123 | ip::udp::socket::native_handle_type native_socket3 | |
124 | = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); | |
125 | socket1.assign(ip::udp::v4(), native_socket3, ec); | |
126 | #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) | |
127 | ||
128 | bool is_open = socket1.is_open(); | |
129 | (void)is_open; | |
130 | ||
131 | socket1.close(); | |
132 | socket1.close(ec); | |
133 | ||
134 | ip::udp::socket::native_type native_socket4 = socket1.native(); | |
135 | (void)native_socket4; | |
136 | ||
137 | ip::udp::socket::native_handle_type native_socket5 | |
138 | = socket1.native_handle(); | |
139 | (void)native_socket5; | |
140 | ||
141 | socket1.cancel(); | |
142 | socket1.cancel(ec); | |
143 | ||
144 | bool at_mark1 = socket1.at_mark(); | |
145 | (void)at_mark1; | |
146 | bool at_mark2 = socket1.at_mark(ec); | |
147 | (void)at_mark2; | |
148 | ||
149 | std::size_t available1 = socket1.available(); | |
150 | (void)available1; | |
151 | std::size_t available2 = socket1.available(ec); | |
152 | (void)available2; | |
153 | ||
154 | socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0)); | |
155 | socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0)); | |
156 | socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0), ec); | |
157 | socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0), ec); | |
158 | ||
159 | socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0)); | |
160 | socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0)); | |
161 | socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0), ec); | |
162 | socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0), ec); | |
163 | ||
164 | socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), | |
165 | &connect_handler); | |
166 | socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), | |
167 | &connect_handler); | |
168 | int i1 = socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), lazy); | |
169 | (void)i1; | |
170 | int i2 = socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), lazy); | |
171 | (void)i2; | |
172 | ||
173 | socket1.set_option(settable_socket_option1); | |
174 | socket1.set_option(settable_socket_option1, ec); | |
175 | socket1.set_option(settable_socket_option2); | |
176 | socket1.set_option(settable_socket_option2, ec); | |
177 | socket1.set_option(settable_socket_option3); | |
178 | socket1.set_option(settable_socket_option3, ec); | |
179 | ||
180 | socket1.get_option(gettable_socket_option1); | |
181 | socket1.get_option(gettable_socket_option1, ec); | |
182 | socket1.get_option(gettable_socket_option2); | |
183 | socket1.get_option(gettable_socket_option2, ec); | |
184 | socket1.get_option(gettable_socket_option3); | |
185 | socket1.get_option(gettable_socket_option3, ec); | |
186 | ||
187 | socket1.io_control(io_control_command); | |
188 | socket1.io_control(io_control_command, ec); | |
189 | ||
190 | bool non_blocking1 = socket1.non_blocking(); | |
191 | (void)non_blocking1; | |
192 | socket1.non_blocking(true); | |
193 | socket1.non_blocking(false, ec); | |
194 | ||
195 | bool non_blocking2 = socket1.native_non_blocking(); | |
196 | (void)non_blocking2; | |
197 | socket1.native_non_blocking(true); | |
198 | socket1.native_non_blocking(false, ec); | |
199 | ||
200 | ip::udp::endpoint endpoint1 = socket1.local_endpoint(); | |
201 | ip::udp::endpoint endpoint2 = socket1.local_endpoint(ec); | |
202 | ||
203 | ip::udp::endpoint endpoint3 = socket1.remote_endpoint(); | |
204 | ip::udp::endpoint endpoint4 = socket1.remote_endpoint(ec); | |
205 | ||
206 | socket1.shutdown(socket_base::shutdown_both); | |
207 | socket1.shutdown(socket_base::shutdown_both, ec); | |
208 | ||
209 | // basic_datagram_socket functions. | |
210 | ||
211 | socket1.send(buffer(mutable_char_buffer)); | |
212 | socket1.send(buffer(const_char_buffer)); | |
213 | socket1.send(null_buffers()); | |
214 | socket1.send(buffer(mutable_char_buffer), in_flags); | |
215 | socket1.send(buffer(const_char_buffer), in_flags); | |
216 | socket1.send(null_buffers(), in_flags); | |
217 | socket1.send(buffer(mutable_char_buffer), in_flags, ec); | |
218 | socket1.send(buffer(const_char_buffer), in_flags, ec); | |
219 | socket1.send(null_buffers(), in_flags, ec); | |
220 | ||
221 | socket1.async_send(buffer(mutable_char_buffer), &send_handler); | |
222 | socket1.async_send(buffer(const_char_buffer), &send_handler); | |
223 | socket1.async_send(null_buffers(), &send_handler); | |
224 | socket1.async_send(buffer(mutable_char_buffer), in_flags, &send_handler); | |
225 | socket1.async_send(buffer(const_char_buffer), in_flags, &send_handler); | |
226 | socket1.async_send(null_buffers(), in_flags, &send_handler); | |
227 | int i3 = socket1.async_send(buffer(mutable_char_buffer), lazy); | |
228 | (void)i3; | |
229 | int i4 = socket1.async_send(buffer(const_char_buffer), lazy); | |
230 | (void)i4; | |
231 | int i5 = socket1.async_send(null_buffers(), lazy); | |
232 | (void)i5; | |
233 | int i6 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy); | |
234 | (void)i6; | |
235 | int i7 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy); | |
236 | (void)i7; | |
237 | int i8 = socket1.async_send(null_buffers(), in_flags, lazy); | |
238 | (void)i8; | |
239 | ||
240 | socket1.send_to(buffer(mutable_char_buffer), | |
241 | ip::udp::endpoint(ip::udp::v4(), 0)); | |
242 | socket1.send_to(buffer(mutable_char_buffer), | |
243 | ip::udp::endpoint(ip::udp::v6(), 0)); | |
244 | socket1.send_to(buffer(const_char_buffer), | |
245 | ip::udp::endpoint(ip::udp::v4(), 0)); | |
246 | socket1.send_to(buffer(const_char_buffer), | |
247 | ip::udp::endpoint(ip::udp::v6(), 0)); | |
248 | socket1.send_to(null_buffers(), | |
249 | ip::udp::endpoint(ip::udp::v4(), 0)); | |
250 | socket1.send_to(null_buffers(), | |
251 | ip::udp::endpoint(ip::udp::v6(), 0)); | |
252 | socket1.send_to(buffer(mutable_char_buffer), | |
253 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags); | |
254 | socket1.send_to(buffer(mutable_char_buffer), | |
255 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags); | |
256 | socket1.send_to(buffer(const_char_buffer), | |
257 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags); | |
258 | socket1.send_to(buffer(const_char_buffer), | |
259 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags); | |
260 | socket1.send_to(null_buffers(), | |
261 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags); | |
262 | socket1.send_to(null_buffers(), | |
263 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags); | |
264 | socket1.send_to(buffer(mutable_char_buffer), | |
265 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec); | |
266 | socket1.send_to(buffer(mutable_char_buffer), | |
267 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec); | |
268 | socket1.send_to(buffer(const_char_buffer), | |
269 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec); | |
270 | socket1.send_to(buffer(const_char_buffer), | |
271 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec); | |
272 | socket1.send_to(null_buffers(), | |
273 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec); | |
274 | socket1.send_to(null_buffers(), | |
275 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec); | |
276 | ||
277 | socket1.async_send_to(buffer(mutable_char_buffer), | |
278 | ip::udp::endpoint(ip::udp::v4(), 0), &send_handler); | |
279 | socket1.async_send_to(buffer(mutable_char_buffer), | |
280 | ip::udp::endpoint(ip::udp::v6(), 0), &send_handler); | |
281 | socket1.async_send_to(buffer(const_char_buffer), | |
282 | ip::udp::endpoint(ip::udp::v4(), 0), &send_handler); | |
283 | socket1.async_send_to(buffer(const_char_buffer), | |
284 | ip::udp::endpoint(ip::udp::v6(), 0), &send_handler); | |
285 | socket1.async_send_to(null_buffers(), | |
286 | ip::udp::endpoint(ip::udp::v4(), 0), &send_handler); | |
287 | socket1.async_send_to(null_buffers(), | |
288 | ip::udp::endpoint(ip::udp::v6(), 0), &send_handler); | |
289 | socket1.async_send_to(buffer(mutable_char_buffer), | |
290 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, &send_handler); | |
291 | socket1.async_send_to(buffer(mutable_char_buffer), | |
292 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, &send_handler); | |
293 | socket1.async_send_to(buffer(const_char_buffer), | |
294 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, &send_handler); | |
295 | socket1.async_send_to(buffer(const_char_buffer), | |
296 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, &send_handler); | |
297 | socket1.async_send_to(null_buffers(), | |
298 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, &send_handler); | |
299 | socket1.async_send_to(null_buffers(), | |
300 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, &send_handler); | |
301 | int i9 = socket1.async_send_to(buffer(mutable_char_buffer), | |
302 | ip::udp::endpoint(ip::udp::v4(), 0), lazy); | |
303 | (void)i9; | |
304 | int i10 = socket1.async_send_to(buffer(mutable_char_buffer), | |
305 | ip::udp::endpoint(ip::udp::v6(), 0), lazy); | |
306 | (void)i10; | |
307 | int i11 = socket1.async_send_to(buffer(const_char_buffer), | |
308 | ip::udp::endpoint(ip::udp::v4(), 0), lazy); | |
309 | (void)i11; | |
310 | int i12 = socket1.async_send_to(buffer(const_char_buffer), | |
311 | ip::udp::endpoint(ip::udp::v6(), 0), lazy); | |
312 | (void)i12; | |
313 | int i13 = socket1.async_send_to(null_buffers(), | |
314 | ip::udp::endpoint(ip::udp::v4(), 0), lazy); | |
315 | (void)i13; | |
316 | int i14 = socket1.async_send_to(null_buffers(), | |
317 | ip::udp::endpoint(ip::udp::v6(), 0), lazy); | |
318 | (void)i14; | |
319 | int i15 = socket1.async_send_to(buffer(mutable_char_buffer), | |
320 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy); | |
321 | (void)i15; | |
322 | int i16 = socket1.async_send_to(buffer(mutable_char_buffer), | |
323 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy); | |
324 | (void)i16; | |
325 | int i17 = socket1.async_send_to(buffer(const_char_buffer), | |
326 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy); | |
327 | (void)i17; | |
328 | int i18 = socket1.async_send_to(buffer(const_char_buffer), | |
329 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy); | |
330 | (void)i18; | |
331 | int i19 = socket1.async_send_to(null_buffers(), | |
332 | ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy); | |
333 | (void)i19; | |
334 | int i20 = socket1.async_send_to(null_buffers(), | |
335 | ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy); | |
336 | (void)i20; | |
337 | ||
338 | socket1.receive(buffer(mutable_char_buffer)); | |
339 | socket1.receive(null_buffers()); | |
340 | socket1.receive(buffer(mutable_char_buffer), in_flags); | |
341 | socket1.receive(null_buffers(), in_flags); | |
342 | socket1.receive(buffer(mutable_char_buffer), in_flags, ec); | |
343 | socket1.receive(null_buffers(), in_flags, ec); | |
344 | ||
345 | socket1.async_receive(buffer(mutable_char_buffer), &receive_handler); | |
346 | socket1.async_receive(null_buffers(), &receive_handler); | |
347 | socket1.async_receive(buffer(mutable_char_buffer), in_flags, | |
348 | &receive_handler); | |
349 | socket1.async_receive(null_buffers(), in_flags, &receive_handler); | |
350 | int i21 = socket1.async_receive(buffer(mutable_char_buffer), lazy); | |
351 | (void)i21; | |
352 | int i22 = socket1.async_receive(null_buffers(), lazy); | |
353 | (void)i22; | |
354 | int i23 = socket1.async_receive(buffer(mutable_char_buffer), | |
355 | in_flags, lazy); | |
356 | (void)i23; | |
357 | int i24 = socket1.async_receive(null_buffers(), in_flags, lazy); | |
358 | (void)i24; | |
359 | ||
360 | ip::udp::endpoint endpoint; | |
361 | socket1.receive_from(buffer(mutable_char_buffer), endpoint); | |
362 | socket1.receive_from(null_buffers(), endpoint); | |
363 | socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags); | |
364 | socket1.receive_from(null_buffers(), endpoint, in_flags); | |
365 | socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec); | |
366 | socket1.receive_from(null_buffers(), endpoint, in_flags, ec); | |
367 | ||
368 | socket1.async_receive_from(buffer(mutable_char_buffer), | |
369 | endpoint, &receive_handler); | |
370 | socket1.async_receive_from(null_buffers(), | |
371 | endpoint, &receive_handler); | |
372 | socket1.async_receive_from(buffer(mutable_char_buffer), | |
373 | endpoint, in_flags, &receive_handler); | |
374 | socket1.async_receive_from(null_buffers(), | |
375 | endpoint, in_flags, &receive_handler); | |
376 | int i25 = socket1.async_receive_from(buffer(mutable_char_buffer), | |
377 | endpoint, lazy); | |
378 | (void)i25; | |
379 | int i26 = socket1.async_receive_from(null_buffers(), | |
380 | endpoint, lazy); | |
381 | (void)i26; | |
382 | int i27 = socket1.async_receive_from(buffer(mutable_char_buffer), | |
383 | endpoint, in_flags, lazy); | |
384 | (void)i27; | |
385 | int i28 = socket1.async_receive_from(null_buffers(), | |
386 | endpoint, in_flags, lazy); | |
387 | (void)i28; | |
388 | } | |
389 | catch (std::exception&) | |
390 | { | |
391 | } | |
392 | } | |
393 | ||
394 | } // namespace ip_udp_socket_compile | |
395 | ||
396 | //------------------------------------------------------------------------------ | |
397 | ||
398 | // ip_udp_socket_runtime test | |
399 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
400 | // The following test checks the runtime operation of the ip::udp::socket class. | |
401 | ||
402 | namespace ip_udp_socket_runtime { | |
403 | ||
404 | void handle_send(size_t expected_bytes_sent, | |
405 | const boost::system::error_code& err, size_t bytes_sent) | |
406 | { | |
407 | BOOST_ASIO_CHECK(!err); | |
408 | BOOST_ASIO_CHECK(expected_bytes_sent == bytes_sent); | |
409 | } | |
410 | ||
411 | void handle_recv(size_t expected_bytes_recvd, | |
412 | const boost::system::error_code& err, size_t bytes_recvd) | |
413 | { | |
414 | BOOST_ASIO_CHECK(!err); | |
415 | BOOST_ASIO_CHECK(expected_bytes_recvd == bytes_recvd); | |
416 | } | |
417 | ||
418 | void test() | |
419 | { | |
420 | using namespace std; // For memcmp and memset. | |
421 | using namespace boost::asio; | |
422 | namespace ip = boost::asio::ip; | |
423 | ||
424 | #if defined(BOOST_ASIO_HAS_BOOST_BIND) | |
425 | namespace bindns = boost; | |
426 | #else // defined(BOOST_ASIO_HAS_BOOST_BIND) | |
427 | namespace bindns = std; | |
428 | using std::placeholders::_1; | |
429 | using std::placeholders::_2; | |
430 | #endif // defined(BOOST_ASIO_HAS_BOOST_BIND) | |
431 | ||
432 | io_service ios; | |
433 | ||
434 | ip::udp::socket s1(ios, ip::udp::endpoint(ip::udp::v4(), 0)); | |
435 | ip::udp::endpoint target_endpoint = s1.local_endpoint(); | |
436 | target_endpoint.address(ip::address_v4::loopback()); | |
437 | ||
438 | ip::udp::socket s2(ios); | |
439 | s2.open(ip::udp::v4()); | |
440 | s2.bind(ip::udp::endpoint(ip::udp::v4(), 0)); | |
441 | char send_msg[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; | |
442 | s2.send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint); | |
443 | ||
444 | char recv_msg[sizeof(send_msg)]; | |
445 | ip::udp::endpoint sender_endpoint; | |
446 | size_t bytes_recvd = s1.receive_from(buffer(recv_msg, sizeof(recv_msg)), | |
447 | sender_endpoint); | |
448 | ||
449 | BOOST_ASIO_CHECK(bytes_recvd == sizeof(send_msg)); | |
450 | BOOST_ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0); | |
451 | ||
452 | memset(recv_msg, 0, sizeof(recv_msg)); | |
453 | ||
454 | target_endpoint = sender_endpoint; | |
455 | s1.async_send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint, | |
456 | bindns::bind(handle_send, sizeof(send_msg), _1, _2)); | |
457 | s2.async_receive_from(buffer(recv_msg, sizeof(recv_msg)), sender_endpoint, | |
458 | bindns::bind(handle_recv, sizeof(recv_msg), _1, _2)); | |
459 | ||
460 | ios.run(); | |
461 | ||
462 | BOOST_ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0); | |
463 | } | |
464 | ||
465 | } // namespace ip_udp_socket_runtime | |
466 | ||
467 | //------------------------------------------------------------------------------ | |
468 | ||
469 | // ip_udp_resolver_compile test | |
470 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
471 | // The following test checks that all public member functions on the class | |
472 | // ip::udp::resolver compile and link correctly. Runtime failures are ignored. | |
473 | ||
474 | namespace ip_udp_resolver_compile { | |
475 | ||
476 | void resolve_handler(const boost::system::error_code&, | |
477 | boost::asio::ip::udp::resolver::iterator) | |
478 | { | |
479 | } | |
480 | ||
481 | void test() | |
482 | { | |
483 | using namespace boost::asio; | |
484 | namespace ip = boost::asio::ip; | |
485 | ||
486 | try | |
487 | { | |
488 | io_service ios; | |
489 | archetypes::lazy_handler lazy; | |
490 | boost::system::error_code ec; | |
491 | ip::udp::resolver::query q(ip::udp::v4(), "localhost", "0"); | |
492 | ip::udp::endpoint e(ip::address_v4::loopback(), 0); | |
493 | ||
494 | // basic_resolver constructors. | |
495 | ||
496 | ip::udp::resolver resolver(ios); | |
497 | ||
498 | // basic_io_object functions. | |
499 | ||
500 | io_service& ios_ref = resolver.get_io_service(); | |
501 | (void)ios_ref; | |
502 | ||
503 | // basic_resolver functions. | |
504 | ||
505 | resolver.cancel(); | |
506 | ||
507 | ip::udp::resolver::iterator iter1 = resolver.resolve(q); | |
508 | (void)iter1; | |
509 | ||
510 | ip::udp::resolver::iterator iter2 = resolver.resolve(q, ec); | |
511 | (void)iter2; | |
512 | ||
513 | ip::udp::resolver::iterator iter3 = resolver.resolve(e); | |
514 | (void)iter3; | |
515 | ||
516 | ip::udp::resolver::iterator iter4 = resolver.resolve(e, ec); | |
517 | (void)iter4; | |
518 | ||
519 | resolver.async_resolve(q, &resolve_handler); | |
520 | int i1 = resolver.async_resolve(q, lazy); | |
521 | (void)i1; | |
522 | ||
523 | resolver.async_resolve(e, &resolve_handler); | |
524 | int i2 = resolver.async_resolve(e, lazy); | |
525 | (void)i2; | |
526 | } | |
527 | catch (std::exception&) | |
528 | { | |
529 | } | |
530 | } | |
531 | ||
532 | } // namespace ip_udp_resolver_compile | |
533 | ||
534 | //------------------------------------------------------------------------------ | |
535 | ||
536 | BOOST_ASIO_TEST_SUITE | |
537 | ( | |
538 | "ip/udp", | |
539 | BOOST_ASIO_TEST_CASE(ip_udp_socket_compile::test) | |
540 | BOOST_ASIO_TEST_CASE(ip_udp_socket_runtime::test) | |
541 | BOOST_ASIO_TEST_CASE(ip_udp_resolver_compile::test) | |
542 | ) |