1 //
2 // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
3 //
4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // Official repository: https://github.com/boostorg/beast
8 //
9 
10 // Test that header file is self-contained.
11 #include <boost/beast/websocket/stream.hpp>
12 
13 #include <boost/beast/_experimental/test/stream.hpp>
14 #include <boost/beast/_experimental/test/tcp.hpp>
15 #include <boost/beast/core/flat_buffer.hpp>
16 
17 namespace boost {
18 namespace beast {
19 namespace websocket {
20 
21 class read1_test : public unit_test::suite
22 {
23 public:
24     void
testTimeout()25     testTimeout()
26     {
27         using tcp = net::ip::tcp;
28 
29         net::io_context ioc;
30 
31         // success
32 
33         {
34             stream<tcp::socket> ws1(ioc);
35             stream<tcp::socket> ws2(ioc);
36             test::connect(ws1.next_layer(), ws2.next_layer());
37             ws1.async_handshake("test", "/", test::success_handler());
38             ws2.async_accept(test::success_handler());
39             test::run(ioc);
40 
41             flat_buffer b;
42             ws1.async_write(net::const_buffer("Hello, world!", 13),
43                 test::success_handler());
44             ws2.async_read(b, test::success_handler());
45             test::run(ioc);
46         }
47 
48         {
49             stream<test::stream> ws1(ioc);
50             stream<test::stream> ws2(ioc);
51             test::connect(ws1.next_layer(), ws2.next_layer());
52             ws1.async_handshake("test", "/", test::success_handler());
53             ws2.async_accept(test::success_handler());
54             test::run(ioc);
55 
56             flat_buffer b;
57             ws1.async_write(net::const_buffer("Hello, world!", 13),
58                 test::success_handler());
59             ws2.async_read(b, test::success_handler());
60             test::run(ioc);
61         }
62 
63         // success, timeout enabled
64 
65         {
66             stream<tcp::socket> ws1(ioc);
67             stream<tcp::socket> ws2(ioc);
68             test::connect(ws1.next_layer(), ws2.next_layer());
69             ws1.async_handshake("test", "/", test::success_handler());
70             ws2.async_accept(test::success_handler());
71             test::run(ioc);
72 
73             flat_buffer b;
74             ws1.set_option(stream_base::timeout{
75                 stream_base::none(),
76                 std::chrono::milliseconds(50),
77                 false});
78             ws1.async_read(b, test::success_handler());
79             ws2.async_write(net::const_buffer("Hello, world!", 13),
80                 test::success_handler());
81             test::run(ioc);
82         }
83 
84         {
85             stream<test::stream> ws1(ioc);
86             stream<test::stream> ws2(ioc);
87             test::connect(ws1.next_layer(), ws2.next_layer());
88             ws1.async_handshake("test", "/", test::success_handler());
89             ws2.async_accept(test::success_handler());
90             test::run(ioc);
91 
92             flat_buffer b;
93             ws1.set_option(stream_base::timeout{
94                 stream_base::none(),
95                 std::chrono::milliseconds(50),
96                 false});
97             ws1.async_read(b, test::success_handler());
98             ws2.async_write(net::const_buffer("Hello, world!", 13),
99                 test::success_handler());
100             test::run(ioc);
101         }
102 
103         // timeout
104 
105         {
106             stream<tcp::socket> ws1(ioc);
107             stream<tcp::socket> ws2(ioc);
108             test::connect(ws1.next_layer(), ws2.next_layer());
109             ws1.async_handshake("test", "/", test::success_handler());
110             ws2.async_accept(test::success_handler());
111             test::run(ioc);
112 
113             flat_buffer b;
114             ws1.set_option(stream_base::timeout{
115                 stream_base::none(),
116                 std::chrono::milliseconds(50),
117                 false});
118             ws1.async_read(b, test::fail_handler(
119                 beast::error::timeout));
120             test::run(ioc);
121         }
122 
123         {
124             stream<test::stream> ws1(ioc);
125             stream<test::stream> ws2(ioc);
126             test::connect(ws1.next_layer(), ws2.next_layer());
127             ws1.async_handshake("test", "/", test::success_handler());
128             ws2.async_accept(test::success_handler());
129             test::run(ioc);
130 
131             flat_buffer b;
132             ws1.set_option(stream_base::timeout{
133                 stream_base::none(),
134                 std::chrono::milliseconds(50),
135                 false});
136             ws1.async_read(b, test::fail_handler(
137                 beast::error::timeout));
138             test::run(ioc);
139         }
140     }
141 
142     void
run()143     run() override
144     {
145         testTimeout();
146     }
147 };
148 
149 BEAST_DEFINE_TESTSUITE(beast,websocket,read1);
150 
151 } // websocket
152 } // beast
153 } // boost
154