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/core/buffer_traits.hpp>
12 
13 #include <boost/beast/_experimental/unit_test/suite.hpp>
14 #include <boost/beast/core/detail/is_invocable.hpp>
15 #include <array>
16 
17 namespace boost {
18 namespace beast {
19 
20 namespace {
21 
22 struct sequence
23 {
24     struct value_type
25     {
operator net::const_bufferboost::beast::__anon094b093f0111::sequence::value_type26         operator net::const_buffer() const noexcept
27         {
28             return {"Hello, world!", 13};
29         }
30     };
31 
32     using const_iterator = value_type const*;
33 
beginboost::beast::__anon094b093f0111::sequence34     const_iterator begin() const noexcept
35     {
36         return &v_;
37     }
38 
endboost::beast::__anon094b093f0111::sequence39     const_iterator end() const noexcept
40     {
41         return begin() + 1;
42     }
43 
44 private:
45     value_type v_;
46 };
47 
48 struct not_sequence
49 {
50 };
51 
52 } // (anon)
53 
54 class buffer_traits_test : public beast::unit_test::suite
55 {
56 public:
57     // is_const_buffer_sequence
58 
59     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
60             >::value);
61 
62     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
63         net::const_buffer
64             >::value);
65 
66     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
67         net::const_buffer, net::const_buffer
68             >::value);
69 
70     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
71         net::const_buffer, net::mutable_buffer
72             >::value);
73 
74     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
75         net::mutable_buffer, net::mutable_buffer
76             >::value);
77 
78     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
79         net::const_buffer const&
80             >::value);
81 
82     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
83         net::const_buffer const&, net::const_buffer const&
84             >::value);
85 
86     BOOST_STATIC_ASSERT(is_const_buffer_sequence<
87         net::const_buffer const&, net::mutable_buffer const&
88             >::value);
89 
90     // is_mutable_buffer_sequence
91 
92     BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
93             >::value);
94 
95     BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
96         net::mutable_buffer
97             >::value);
98 
99     BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
100         net::mutable_buffer, net::mutable_buffer
101             >::value);
102 
103     BOOST_STATIC_ASSERT(! is_mutable_buffer_sequence<
104         net::const_buffer, net::const_buffer
105             >::value);
106 
107     BOOST_STATIC_ASSERT(! is_mutable_buffer_sequence<
108         net::const_buffer, net::mutable_buffer
109             >::value);
110 
111     BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
112         net::mutable_buffer const&
113             >::value);
114 
115     BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
116         net::mutable_buffer const&, net::mutable_buffer const&
117             >::value);
118 
119     // buffers_type
120 
121     BOOST_STATIC_ASSERT(
122         std::is_same<net::const_buffer, buffers_type<
123             net::const_buffer
124         >>::value);
125 
126     BOOST_STATIC_ASSERT(
127         std::is_same<net::const_buffer, buffers_type<
128             net::const_buffer, net::const_buffer
129         >>::value);
130 
131     BOOST_STATIC_ASSERT(
132         std::is_same<net::const_buffer, buffers_type<
133             net::const_buffer, net::mutable_buffer
134         >>::value);
135 
136     BOOST_STATIC_ASSERT(
137         std::is_same<net::mutable_buffer, buffers_type<
138         >>::value);
139 
140     BOOST_STATIC_ASSERT(
141         std::is_same<net::mutable_buffer, buffers_type<
142             net::mutable_buffer
143         >>::value);
144 
145     BOOST_STATIC_ASSERT(
146         std::is_same<net::mutable_buffer, buffers_type<
147             net::mutable_buffer, net::mutable_buffer
148         >>::value);
149 
150     BOOST_STATIC_ASSERT(
151         std::is_same<net::const_buffer, buffers_type<
152             std::array<net::const_buffer, 3>
153         >>::value);
154 
155     BOOST_STATIC_ASSERT(
156         std::is_same<net::mutable_buffer, buffers_type<
157             std::array<net::mutable_buffer, 3>
158         >>::value);
159 
160     BOOST_STATIC_ASSERT(
161         std::is_same<net::const_buffer, buffers_type<
162             std::array<int, 3>
163         >>::value);
164 
165     // buffers_iterator_type
166 
167     BOOST_STATIC_ASSERT(
168         std::is_same<net::const_buffer const*, buffers_iterator_type<
169             net::const_buffer
170         >>::value);
171 
172     BOOST_STATIC_ASSERT(
173         std::is_same<net::mutable_buffer const*, buffers_iterator_type<
174             net::mutable_buffer
175         >>::value);
176 
177     // javadoc: buffers_type
178     template <class BufferSequence>
179     buffers_type <BufferSequence>
buffers_front(BufferSequence const & buffers)180     buffers_front (BufferSequence const& buffers)
181     {
182         static_assert(
183             net::is_const_buffer_sequence<BufferSequence>::value,
184             "BufferSequence type requirements not met");
185         auto const first = net::buffer_sequence_begin (buffers);
186         if (first == net::buffer_sequence_end (buffers))
187             return {};
188         return *first;
189     }
190 
191     void
testJavadocs()192     testJavadocs()
193     {
194         // buffers_front
195         {
196             net::const_buffer cb;
197             buffers_front(cb);
198 
199             net::mutable_buffer mb;
200             buffers_front(mb);
201         }
202 
203         pass();
204     }
205 
206     void
testFunction()207     testFunction()
208     {
209         BEAST_EXPECT(buffer_bytes(
210             net::const_buffer("Hello, world!", 13)) == 13);
211 
212         BEAST_EXPECT(buffer_bytes(
213             net::mutable_buffer{}) == 0);
214 
215         {
216             sequence s;
217             BEAST_EXPECT(buffer_bytes(s) == 13);
218         }
219 
220         {
221             std::array<net::const_buffer, 2> s({{
222                 net::const_buffer("Hello, world!", 13),
223                 net::const_buffer("Hello, world!", 13)}});
224             BEAST_EXPECT(buffer_bytes(s) == 26);
225         }
226 
227         BOOST_STATIC_ASSERT(! detail::is_invocable<
228             detail::buffer_bytes_impl,
229             std::size_t(not_sequence const&)>::value);
230     }
231 
run()232     void run() override
233     {
234         testJavadocs();
235         testFunction();
236     }
237 };
238 
239 BEAST_DEFINE_TESTSUITE(beast,core,buffer_traits);
240 
241 } // beast
242 } // boost
243