1 //
2 // stream_handle.cpp
3 // ~~~~~~~~~~~~~~~~~
4 //
5 // Copyright (c) 2003-2021 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/windows/stream_handle.hpp>
18
19 #include <boost/asio/io_context.hpp>
20 #include "../archetypes/async_result.hpp"
21 #include "../unit_test.hpp"
22
23 //------------------------------------------------------------------------------
24
25 // windows_stream_handle_compile test
26 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27 // The following test checks that all public member functions on the class
28 // windows::stream_handle compile and link correctly. Runtime failures are
29 // ignored.
30
31 namespace windows_stream_handle_compile {
32
write_some_handler(const boost::system::error_code &,std::size_t)33 void write_some_handler(const boost::system::error_code&, std::size_t)
34 {
35 }
36
read_some_handler(const boost::system::error_code &,std::size_t)37 void read_some_handler(const boost::system::error_code&, std::size_t)
38 {
39 }
40
test()41 void test()
42 {
43 #if defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
44 using namespace boost::asio;
45 namespace win = boost::asio::windows;
46
47 try
48 {
49 io_context ioc;
50 const io_context::executor_type ioc_ex = ioc.get_executor();
51 char mutable_char_buffer[128] = "";
52 const char const_char_buffer[128] = "";
53 archetypes::lazy_handler lazy;
54 boost::system::error_code ec;
55
56 // basic_stream_handle constructors.
57
58 win::stream_handle handle1(ioc);
59 HANDLE native_handle1 = INVALID_HANDLE_VALUE;
60 #if defined(BOOST_ASIO_MSVC) && (_MSC_VER < 1910)
61 // Skip this on older MSVC due to mysterious ambiguous overload errors.
62 #else
63 win::stream_handle handle2(ioc, native_handle1);
64 #endif
65
66 win::stream_handle handle3(ioc_ex);
67 HANDLE native_handle2 = INVALID_HANDLE_VALUE;
68 win::stream_handle handle4(ioc_ex, native_handle2);
69
70 #if defined(BOOST_ASIO_HAS_MOVE)
71 win::stream_handle handle5(std::move(handle4));
72 #endif // defined(BOOST_ASIO_HAS_MOVE)
73
74 // basic_stream_handle operators.
75
76 #if defined(BOOST_ASIO_HAS_MOVE)
77 handle1 = win::stream_handle(ioc);
78 handle1 = std::move(handle4);
79 #endif // defined(BOOST_ASIO_HAS_MOVE)
80
81 // basic_io_object functions.
82
83 windows::stream_handle::executor_type ex = handle1.get_executor();
84 (void)ex;
85
86 // basic_overlapped_handle functions.
87
88 win::stream_handle::lowest_layer_type& lowest_layer
89 = handle1.lowest_layer();
90 (void)lowest_layer;
91
92 const win::stream_handle& handle6 = handle1;
93 const win::stream_handle::lowest_layer_type& lowest_layer2
94 = handle6.lowest_layer();
95 (void)lowest_layer2;
96
97 HANDLE native_handle3 = INVALID_HANDLE_VALUE;
98 handle1.assign(native_handle3);
99
100 bool is_open = handle1.is_open();
101 (void)is_open;
102
103 handle1.close();
104 handle1.close(ec);
105
106 win::stream_handle::native_handle_type native_handle4
107 = handle1.native_handle();
108 (void)native_handle4;
109
110 handle1.cancel();
111 handle1.cancel(ec);
112
113 // basic_stream_handle functions.
114
115 handle1.write_some(buffer(mutable_char_buffer));
116 handle1.write_some(buffer(const_char_buffer));
117 handle1.write_some(buffer(mutable_char_buffer), ec);
118 handle1.write_some(buffer(const_char_buffer), ec);
119
120 handle1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
121 handle1.async_write_some(buffer(const_char_buffer), &write_some_handler);
122 int i1 = handle1.async_write_some(buffer(mutable_char_buffer), lazy);
123 (void)i1;
124 int i2 = handle1.async_write_some(buffer(const_char_buffer), lazy);
125 (void)i2;
126
127 handle1.read_some(buffer(mutable_char_buffer));
128 handle1.read_some(buffer(mutable_char_buffer), ec);
129
130 handle1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
131 int i3 = handle1.async_read_some(buffer(mutable_char_buffer), lazy);
132 (void)i3;
133 }
134 catch (std::exception&)
135 {
136 }
137 #endif // defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
138 }
139
140 } // namespace windows_stream_handle_compile
141
142 //------------------------------------------------------------------------------
143
144 BOOST_ASIO_TEST_SUITE
145 (
146 "windows/stream_handle",
147 BOOST_ASIO_TEST_CASE(windows_stream_handle_compile::test)
148 )
149