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
17namespace boost {
18namespace beast {
19
20namespace {
21
22struct sequence
23{
24 struct value_type
25 {
26 operator net::const_buffer() const noexcept
27 {
28 return {"Hello, world!", 13};
29 }
30 };
31
32 using const_iterator = value_type const*;
33
34 const_iterator begin() const noexcept
35 {
36 return &v_;
37 }
38
39 const_iterator end() const noexcept
40 {
41 return begin() + 1;
42 }
43
44private:
45 value_type v_;
46};
47
48struct not_sequence
49{
50};
51
52} // (anon)
53
54class buffer_traits_test : public beast::unit_test::suite
55{
56public:
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>
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
192 testJavadocs()
193 {
194 // buffers_front
195 {
196 net::const_buffer cb;
197 buffers_front(buffers: cb);
198
199 net::mutable_buffer mb;
200 buffers_front(buffers: mb);
201 }
202
203 pass();
204 }
205
206 void
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({._M_elems: {
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
232 void run() override
233 {
234 testJavadocs();
235 testFunction();
236 }
237};
238
239BEAST_DEFINE_TESTSUITE(beast,core,buffer_traits);
240
241} // beast
242} // boost
243

source code of boost/libs/beast/test/beast/core/buffer_traits.cpp