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#ifndef BOOST_BEAST_TEST_BUFFER_HPP
11#define BOOST_BEAST_TEST_BUFFER_HPP
12
13#include <boost/beast/core/detail/config.hpp>
14#include <boost/beast/_experimental/unit_test/suite.hpp>
15#include <boost/beast/core/buffer_traits.hpp>
16#include <boost/beast/core/buffers_to_string.hpp>
17#include <boost/beast/core/string.hpp>
18#include <boost/beast/core/detail/type_traits.hpp>
19#include <boost/asio/buffer.hpp>
20#include <boost/assert.hpp>
21#include <algorithm>
22#include <string>
23#include <type_traits>
24
25namespace boost {
26namespace beast {
27
28/** A MutableBufferSequence for tests, where length is always 3.
29*/
30class buffers_triple
31{
32 net::mutable_buffer b_[3];
33
34public:
35 using value_type = net::mutable_buffer;
36 using const_iterator = net::mutable_buffer const*;
37
38 buffers_triple(
39 buffers_triple const&) = default;
40
41 buffers_triple& operator=(
42 buffers_triple const&) = default;
43
44 buffers_triple(char* data, std::size_t size)
45 {
46 b_[0] = {data, size/6};
47 data += b_[0].size();
48 size -= b_[0].size();
49
50 b_[1] = {data, 2*size/5};
51 data += b_[1].size();
52 size -= b_[1].size();
53
54 b_[2] = {data, size};
55
56 BOOST_ASSERT(b_[0].size() > 0);
57 BOOST_ASSERT(b_[1].size() > 0);
58 BOOST_ASSERT(b_[2].size() > 0);
59 }
60
61 bool
62 operator==(buffers_triple const& rhs) const noexcept
63 {
64 return
65 b_[0].data() == rhs.b_[0].data() &&
66 b_[0].size() == rhs.b_[0].size() &&
67 b_[1].data() == rhs.b_[1].data() &&
68 b_[1].size() == rhs.b_[1].size() &&
69 b_[2].data() == rhs.b_[2].data() &&
70 b_[2].size() == rhs.b_[2].size();
71 }
72
73 bool
74 operator!=(buffers_triple const& rhs) const noexcept
75 {
76 return !(*this == rhs);
77 }
78
79 const_iterator
80 begin() const noexcept
81 {
82 return &b_[0];
83 }
84
85 const_iterator
86 end() const noexcept
87 {
88 return &b_[3];
89 }
90};
91
92template<class ConstBufferSequence>
93std::size_t
94buffers_length(
95 ConstBufferSequence const& buffers)
96{
97 return std::distance(
98 net::buffer_sequence_begin(buffers),
99 net::buffer_sequence_end(buffers));
100}
101
102//------------------------------------------------------------------------------
103
104namespace detail {
105
106template<class MutableBufferSequence>
107void test_mutable_buffers(
108 MutableBufferSequence const&,
109 net::const_buffer)
110{
111}
112
113template<class MutableBufferSequence>
114void test_mutable_buffers(
115 MutableBufferSequence const& b,
116 net::mutable_buffer)
117{
118 string_view src = "Hello, world!";
119 BOOST_ASSERT(buffer_bytes(b) <= src.size());
120 if(src.size() > buffer_bytes(b))
121 src = {src.data(), buffer_bytes(b)};
122 net::buffer_copy(b, net::const_buffer(
123 src.data(), src.size()));
124 BEAST_EXPECT(beast::buffers_to_string(b) == src);
125}
126
127} // detail
128
129/** Test an instance of a constant or mutable buffer sequence.
130*/
131template<class ConstBufferSequence>
132void
133test_buffer_sequence(
134 ConstBufferSequence const& buffers)
135{
136 BOOST_STATIC_ASSERT(
137 net::is_const_buffer_sequence<
138 ConstBufferSequence>::value);
139
140 using iterator = decltype(
141 net::buffer_sequence_begin(buffers));
142 BEAST_EXPECT(sizeof(iterator) > 0);
143
144 auto const size = buffer_bytes(buffers);
145 BEAST_EXPECT(size > 0 );
146
147 // begin, end
148 auto const length = std::distance(
149 net::buffer_sequence_begin(buffers),
150 net::buffer_sequence_end(buffers));
151 BEAST_EXPECT(length > 0);
152 BEAST_EXPECT(
153 net::buffer_sequence_begin(buffers) !=
154 net::buffer_sequence_end(buffers));
155
156 // copy construction
157 ConstBufferSequence b1(buffers);
158 BEAST_EXPECT(buffer_bytes(b1) == size);
159
160 // copy assignment
161 ConstBufferSequence b2(buffers);
162 b2 = b1;
163 BEAST_EXPECT(buffer_bytes(b2) == size);
164
165 // iterators
166 {
167 iterator it1{};
168 iterator it2{};
169 iterator it3 =
170 net::buffer_sequence_begin(buffers);
171 iterator it4 =
172 net::buffer_sequence_end(buffers);
173 BEAST_EXPECT(it1 == it2);
174 BEAST_EXPECT(it1 != it3);
175 BEAST_EXPECT(it3 != it1);
176 BEAST_EXPECT(it1 != it4);
177 BEAST_EXPECT(it4 != it1);
178 }
179
180 // bidirectional
181 {
182 auto const first =
183 net::buffer_sequence_begin(buffers);
184 auto const last =
185 net::buffer_sequence_end(buffers);
186 std::size_t n, m;
187 iterator it;
188
189 // pre-increment
190 m = 0;
191 n = length;
192 for(it = first; n--; ++it)
193 m += buffer_bytes(*it);
194 BEAST_EXPECT(it == last);
195 BEAST_EXPECT(m == size);
196
197 // post-increment
198 m = 0;
199 n = length;
200 for(it = first; n--;)
201 m += buffer_bytes(*it++);
202 BEAST_EXPECT(it == last);
203 BEAST_EXPECT(m == size);
204
205 // pre-decrement
206 m = 0;
207 n = length;
208 for(it = last; n--;)
209 m += buffer_bytes(*--it);
210 BEAST_EXPECT(it == first);
211 BEAST_EXPECT(m == size);
212
213 // post-decrement
214 m = 0;
215 n = length;
216 for(it = last; n--;)
217 {
218 it--;
219 m += buffer_bytes(*it);
220 }
221 BEAST_EXPECT(it == first);
222 BEAST_EXPECT(m == size);
223 }
224
225 detail::test_mutable_buffers(buffers,
226 buffers_type<ConstBufferSequence>{});
227}
228
229//------------------------------------------------------------------------------
230
231/** Metafunction to determine if a type meets the requirements of MutableDynamicBuffer_v0
232*/
233/* @{ */
234// VFALCO This trait needs tests
235template<class T, class = void>
236struct is_mutable_dynamic_buffer
237 : std::false_type
238{
239};
240
241template<class T>
242struct is_mutable_dynamic_buffer<T, detail::void_t<decltype(
243 std::declval<typename T::const_buffers_type&>() =
244 std::declval<T const&>().data(),
245 std::declval<typename T::const_buffers_type&>() =
246 std::declval<T&>().cdata(),
247 std::declval<typename T::mutable_buffers_type&>() =
248 std::declval<T&>().data()
249 ) > > : net::is_dynamic_buffer_v1<T>
250{
251};
252/** @} */
253
254namespace detail {
255
256template<class MutableBufferSequence>
257void
258buffers_fill(
259 MutableBufferSequence const& buffers,
260 char c)
261{
262 auto const end =
263 net::buffer_sequence_end(buffers);
264 for(auto it = net::buffer_sequence_begin(buffers);
265 it != end; ++it)
266 {
267 net::mutable_buffer b(*it);
268 std::fill(
269 static_cast<char*>(b.data()),
270 static_cast<char*>(b.data()) + b.size(), c);
271 }
272}
273
274template<class MutableDynamicBuffer_v0>
275void
276test_mutable_dynamic_buffer(
277 MutableDynamicBuffer_v0 const&,
278 std::false_type)
279{
280}
281
282template<class MutableDynamicBuffer_v0>
283void
284test_mutable_dynamic_buffer(
285 MutableDynamicBuffer_v0 const& b0,
286 std::true_type)
287{
288 BOOST_STATIC_ASSERT(
289 net::is_mutable_buffer_sequence<typename
290 MutableDynamicBuffer_v0::mutable_buffers_type>::value);
291
292 BOOST_STATIC_ASSERT(
293 std::is_convertible<
294 typename MutableDynamicBuffer_v0::mutable_buffers_type,
295 typename MutableDynamicBuffer_v0::const_buffers_type>::value);
296
297 string_view src = "Hello, world!";
298 if(src.size() > b0.max_size())
299 src = {src.data(), b0.max_size()};
300
301 // modify readable bytes
302 {
303 MutableDynamicBuffer_v0 b(b0);
304 auto const mb = b.prepare(src.size());
305 BEAST_EXPECT(buffer_bytes(mb) == src.size());
306 buffers_fill(mb, '*');
307 b.commit(src.size());
308 BEAST_EXPECT(b.size() == src.size());
309 BEAST_EXPECT(
310 beast::buffers_to_string(b.data()) ==
311 std::string(src.size(), '*'));
312 BEAST_EXPECT(
313 beast::buffers_to_string(b.cdata()) ==
314 std::string(src.size(), '*'));
315 auto const n = net::buffer_copy(
316 b.data(), net::const_buffer(
317 src.data(), src.size()));
318 BEAST_EXPECT(n == src.size());
319 BEAST_EXPECT(
320 beast::buffers_to_string(b.data()) == src);
321 BEAST_EXPECT(
322 beast::buffers_to_string(b.cdata()) == src);
323 }
324
325 // mutable to const sequence conversion
326 {
327 MutableDynamicBuffer_v0 b(b0);
328 b.commit(net::buffer_copy(
329 b.prepare(src.size()),
330 net::const_buffer(src.data(), src.size())));
331 auto mb = b.data();
332 auto cb = static_cast<
333 MutableDynamicBuffer_v0 const&>(b).data();
334 auto cbc = b.cdata();
335 BEAST_EXPECT(
336 beast::buffers_to_string(b.data()) == src);
337 BEAST_EXPECT(
338 beast::buffers_to_string(b.cdata()) == src);
339 beast::test_buffer_sequence(cb);
340 beast::test_buffer_sequence(cbc);
341 beast::test_buffer_sequence(mb);
342 {
343 decltype(mb) mb2(mb);
344 mb = mb2;
345 decltype(cb) cb2(cb);
346 cb = cb2;
347 decltype(cbc) cbc2(cbc);
348 cbc = cbc2;
349 }
350 {
351 decltype(cb) cb2(mb);
352 decltype(cbc) cbc2(mb);
353 cb2 = mb;
354 cbc2 = mb;
355 }
356 }
357}
358
359} // detail
360
361/** Test an instance of a dynamic buffer or mutable dynamic buffer.
362*/
363template<class DynamicBuffer_v0>
364void
365test_dynamic_buffer(
366 DynamicBuffer_v0 const& b0)
367{
368 BOOST_STATIC_ASSERT(
369 net::is_dynamic_buffer_v1<DynamicBuffer_v0>::value);
370
371 BOOST_STATIC_ASSERT(
372 net::is_const_buffer_sequence<typename
373 DynamicBuffer_v0::const_buffers_type>::value);
374
375 BOOST_STATIC_ASSERT(
376 net::is_mutable_buffer_sequence<typename
377 DynamicBuffer_v0::mutable_buffers_type>::value);
378
379 BEAST_EXPECT(b0.size() == 0);
380 BEAST_EXPECT(buffer_bytes(b0.data()) == 0);
381
382 // members
383 {
384 string_view src = "Hello, world!";
385
386 DynamicBuffer_v0 b1(b0);
387 auto const mb = b1.prepare(src.size());
388 b1.commit(net::buffer_copy(mb,
389 net::const_buffer(src.data(), src.size())));
390
391 // copy constructor
392 {
393 DynamicBuffer_v0 b2(b1);
394 BEAST_EXPECT(b2.size() == b1.size());
395 BEAST_EXPECT(
396 buffers_to_string(b1.data()) ==
397 buffers_to_string(b2.data()));
398
399 // https://github.com/boostorg/beast/issues/1621
400 b2.consume(1);
401 DynamicBuffer_v0 b3(b2);
402 BEAST_EXPECT(b3.size() == b2.size());
403 BEAST_EXPECT(
404 buffers_to_string(b2.data()) ==
405 buffers_to_string(b3.data()));
406 }
407
408 // move constructor
409 {
410 DynamicBuffer_v0 b2(b1);
411 DynamicBuffer_v0 b3(std::move(b2));
412 BEAST_EXPECT(b3.size() == b1.size());
413 BEAST_EXPECT(
414 buffers_to_string(b3.data()) ==
415 buffers_to_string(b1.data()));
416 }
417
418 // copy assignment
419 {
420 DynamicBuffer_v0 b2(b0);
421 b2 = b1;
422 BEAST_EXPECT(b2.size() == b1.size());
423 BEAST_EXPECT(
424 buffers_to_string(b1.data()) ==
425 buffers_to_string(b2.data()));
426
427 // self assignment
428 b2 = *&b2;
429 BEAST_EXPECT(b2.size() == b1.size());
430 BEAST_EXPECT(
431 buffers_to_string(b2.data()) ==
432 buffers_to_string(b1.data()));
433
434 // https://github.com/boostorg/beast/issues/1621
435 b2.consume(1);
436 DynamicBuffer_v0 b3(b2);
437 BEAST_EXPECT(b3.size() == b2.size());
438 BEAST_EXPECT(
439 buffers_to_string(b2.data()) ==
440 buffers_to_string(b3.data()));
441
442 }
443
444 // move assignment
445 {
446 DynamicBuffer_v0 b2(b1);
447 DynamicBuffer_v0 b3(b0);
448 b3 = std::move(b2);
449 BEAST_EXPECT(b3.size() == b1.size());
450 BEAST_EXPECT(
451 buffers_to_string(b3.data()) ==
452 buffers_to_string(b1.data()));
453
454 // self move
455 b3 = std::move(b3);
456 BEAST_EXPECT(b3.size() == b1.size());
457 BEAST_EXPECT(
458 buffers_to_string(b3.data()) ==
459 buffers_to_string(b1.data()));
460 }
461
462 // swap
463 {
464 DynamicBuffer_v0 b2(b1);
465 DynamicBuffer_v0 b3(b0);
466 BEAST_EXPECT(b2.size() == b1.size());
467 BEAST_EXPECT(b3.size() == b0.size());
468 using std::swap;
469 swap(b2, b3);
470 BEAST_EXPECT(b2.size() == b0.size());
471 BEAST_EXPECT(b3.size() == b1.size());
472 BEAST_EXPECT(
473 buffers_to_string(b3.data()) ==
474 buffers_to_string(b1.data()));
475 }
476 }
477
478 // n == 0
479 {
480 DynamicBuffer_v0 b(b0);
481 b.commit(1);
482 BEAST_EXPECT(b.size() == 0);
483 BEAST_EXPECT(buffer_bytes(b.prepare(0)) == 0);
484 b.commit(0);
485 BEAST_EXPECT(b.size() == 0);
486 b.commit(1);
487 BEAST_EXPECT(b.size() == 0);
488 b.commit(b.max_size() + 1);
489 BEAST_EXPECT(b.size() == 0);
490 b.consume(0);
491 BEAST_EXPECT(b.size() == 0);
492 b.consume(1);
493 BEAST_EXPECT(b.size() == 0);
494 b.consume(b.max_size() + 1);
495 BEAST_EXPECT(b.size() == 0);
496 }
497
498 // max_size
499 {
500 DynamicBuffer_v0 b(b0);
501 if(BEAST_EXPECT(
502 b.max_size() + 1 > b.max_size()))
503 {
504 try
505 {
506 b.prepare(b.max_size() + 1);
507 BEAST_FAIL();
508 }
509 catch(std::length_error const&)
510 {
511 BEAST_PASS();
512 }
513 catch(...)
514 {
515 BEAST_FAIL();
516 }
517 }
518 }
519
520 // setup source buffer
521 char buf[13];
522 unsigned char k0 = 0;
523 string_view src(buf, sizeof(buf));
524 if(src.size() > b0.max_size())
525 src = {src.data(), b0.max_size()};
526 BEAST_EXPECT(b0.max_size() >= src.size());
527 BEAST_EXPECT(b0.size() == 0);
528 BEAST_EXPECT(buffer_bytes(b0.data()) == 0);
529 auto const make_new_src =
530 [&buf, &k0, &src]
531 {
532 auto k = k0++;
533 for(std::size_t i = 0; i < src.size(); ++i)
534 buf[i] = k++;
535 };
536
537 // readable / writable buffer sequence tests
538 {
539 make_new_src();
540 DynamicBuffer_v0 b(b0);
541 auto const& bc(b);
542 auto const mb = b.prepare(src.size());
543 BEAST_EXPECT(buffer_bytes(mb) == src.size());
544 beast::test_buffer_sequence(mb);
545 b.commit(net::buffer_copy(mb,
546 net::const_buffer(src.data(), src.size())));
547 BEAST_EXPECT(
548 buffer_bytes(bc.data()) == src.size());
549 beast::test_buffer_sequence(bc.data());
550 }
551
552 // h = in size
553 // i = prepare size
554 // j = commit size
555 // k = consume size
556 for(std::size_t h = 1; h <= src.size(); ++h)
557 {
558 string_view in(src.data(), h);
559 for(std::size_t i = 1; i <= in.size(); ++i) {
560 for(std::size_t j = 1; j <= i + 1; ++j) {
561 for(std::size_t k = 1; k <= in.size(); ++k) {
562 {
563 make_new_src();
564
565 DynamicBuffer_v0 b(b0);
566 auto const& bc(b);
567 net::const_buffer cb(in.data(), in.size());
568 while(cb.size() > 0)
569 {
570 auto const mb = b.prepare(
571 std::min<std::size_t>(i,
572 b.max_size() - b.size()));
573 auto const n = net::buffer_copy(mb,
574 net::const_buffer(cb.data(),
575 std::min<std::size_t>(a: j, b: cb.size())));
576 b.commit(n);
577 cb += n;
578 }
579 BEAST_EXPECT(b.size() == in.size());
580 BEAST_EXPECT(
581 buffer_bytes(bc.data()) == in.size());
582 BEAST_EXPECT(beast::buffers_to_string(
583 bc.data()) == in);
584 while(b.size() > 0)
585 b.consume(k);
586 BEAST_EXPECT(buffer_bytes(bc.data()) == 0);
587 }
588 } } }
589 }
590
591 // MutableDynamicBuffer_v0 refinement
592 detail::test_mutable_dynamic_buffer(b0,
593 is_mutable_dynamic_buffer<DynamicBuffer_v0>{});
594}
595
596
597/** Test an instance of a dynamic buffer or mutable dynamic buffer.
598*/
599template<class DynamicBuffer_v0>
600void
601test_dynamic_buffer_ref(DynamicBuffer_v0 b0)
602{
603 BOOST_STATIC_ASSERT(
604 net::is_dynamic_buffer_v1<DynamicBuffer_v0>::value);
605
606 BOOST_STATIC_ASSERT(
607 net::is_const_buffer_sequence<typename
608 DynamicBuffer_v0::const_buffers_type>::value);
609
610 BOOST_STATIC_ASSERT(
611 net::is_mutable_buffer_sequence<typename
612 DynamicBuffer_v0::mutable_buffers_type>::value);
613
614 BEAST_EXPECT(b0.size() == 0);
615 BEAST_EXPECT(buffer_bytes(b0.data()) == 0);
616
617 // members
618 {
619 string_view src = "Hello, world!";
620
621 DynamicBuffer_v0 b1(b0);
622 auto const mb = b1.prepare(src.size());
623 b1.commit(net::buffer_copy(mb,
624 net::const_buffer(src.data(), src.size())));
625
626 // copy constructor
627 {
628 DynamicBuffer_v0 b2(b1);
629 BEAST_EXPECT(b2.size() == b1.size());
630 BEAST_EXPECT(
631 buffers_to_string(b1.data()) ==
632 buffers_to_string(b2.data()));
633
634 // https://github.com/boostorg/beast/issues/1621
635 b2.consume(1);
636 BEAST_EXPECT(b0.size() == b2.size());
637 BEAST_EXPECT(
638 buffers_to_string(b2.data()) ==
639 buffers_to_string(b0.data()));
640 }
641
642 // move constructor
643 {
644 DynamicBuffer_v0 b2(b1);
645 DynamicBuffer_v0 b3(std::move(b2));
646 BEAST_EXPECT(b3.size() == b1.size());
647 BEAST_EXPECT(
648 buffers_to_string(b3.data()) ==
649 buffers_to_string(b1.data()));
650 }
651 }
652
653 // n == 0
654 {
655
656 DynamicBuffer_v0 b(b0);
657
658 const std::size_t len = b0.size();
659 BEAST_EXPECT(b.size() == len);
660 BEAST_EXPECT(buffer_bytes(b.prepare(0)) == 0);
661 b.commit(0);
662 BEAST_EXPECT(b.size() == len);
663 b.commit(1);
664 BEAST_EXPECT(b.size() == len);
665 b.commit(b.max_size() + 1);
666 BEAST_EXPECT(b.size() == len);
667 b.consume(0);
668 BEAST_EXPECT(b.size() == len);
669 b.consume(1);
670 BEAST_EXPECT(b.size() == len - 1);
671 b.consume(len - 1);
672 BEAST_EXPECTS(b.size() == 0, typeid(b).name());
673 }
674
675 // max_size
676 {
677 DynamicBuffer_v0 b(b0);
678 if(b.max_size() + 1 > b.max_size())
679 {
680 try
681 {
682 b.prepare(b.max_size() + 1);
683 BEAST_FAIL();
684 }
685 catch(std::length_error const&)
686 {
687 BEAST_PASS();
688 }
689 catch(...)
690 {
691 BEAST_FAIL();
692 }
693 }
694 else
695 BEAST_EXPECT(b.max_size() == std::numeric_limits<std::size_t>::max());
696 }
697
698 // setup source buffer
699 char buf[13];
700 unsigned char k0 = 0;
701 string_view src(buf, sizeof(buf));
702 if(src.size() > b0.max_size())
703 src = {src.data(), b0.max_size()};
704 BEAST_EXPECT(b0.max_size() >= src.size());
705 BEAST_EXPECT(b0.size() == 0);
706 BEAST_EXPECT(buffer_bytes(b0.data()) == 0);
707 auto const make_new_src =
708 [&buf, &k0, &src]
709 {
710 auto k = k0++;
711 for(std::size_t i = 0; i < src.size(); ++i)
712 buf[i] = k++;
713 };
714
715 // readable / writable buffer sequence tests
716 {
717 make_new_src();
718 DynamicBuffer_v0 b(b0);
719 auto const& bc(b);
720 auto const mb = b.prepare(src.size());
721 BEAST_EXPECT(buffer_bytes(mb) == src.size());
722 beast::test_buffer_sequence(mb);
723 b.commit(net::buffer_copy(mb,
724 net::const_buffer(src.data(), src.size())));
725 BEAST_EXPECT(
726 buffer_bytes(bc.data()) == src.size());
727 beast::test_buffer_sequence(bc.data());
728 }
729
730 // h = in size
731 // i = prepare size
732 // j = commit size
733 // k = consume size
734 for(std::size_t h = 1; h <= src.size(); ++h)
735 {
736 string_view in(src.data(), h);
737 for(std::size_t i = 1; i <= in.size(); ++i) {
738 for(std::size_t j = 1; j <= i + 1; ++j) {
739 for(std::size_t k = 1; k <= in.size(); ++k) {
740 {
741 make_new_src();
742
743 const std::size_t len = b0.size();
744 DynamicBuffer_v0 b(b0);
745
746 auto const& bc(b);
747 net::const_buffer cb(in.data(), in.size());
748 while(cb.size() > 0)
749 {
750 auto const mb = b.prepare(
751 std::min<std::size_t>(i,
752 b.max_size() - b.size()));
753 auto const n = net::buffer_copy(mb,
754 net::const_buffer(cb.data(),
755 std::min<std::size_t>(a: j, b: cb.size())));
756 b.commit(n);
757 cb += n;
758 }
759 BEAST_EXPECT(b.size() == (in.size() + len));
760 BEAST_EXPECT(buffer_bytes(bc.data()) == in.size() + len);
761 BEAST_EXPECT(beast::buffers_to_string(bc.data()).substr(len) == in);
762 while(b.size() > 0)
763 b.consume(k);
764 BEAST_EXPECT(buffer_bytes(bc.data()) == 0);
765 }
766 } } }
767 }
768
769 // MutableDynamicBuffer_v0 refinement
770 detail::test_mutable_dynamic_buffer(b0,
771 is_mutable_dynamic_buffer<DynamicBuffer_v0>{});
772}
773
774} // beast
775} // boost
776
777#endif
778

source code of boost/libs/beast/test/beast/core/test_buffer.hpp