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/multi_buffer.hpp>
12
13#include "test_buffer.hpp"
14
15#include <boost/beast/core/buffer_traits.hpp>
16#include <boost/beast/core/ostream.hpp>
17#include <boost/beast/core/read_size.hpp>
18#include <boost/beast/core/string.hpp>
19#include <boost/beast/test/test_allocator.hpp>
20#include <boost/beast/_experimental/unit_test/suite.hpp>
21#include <boost/asio/buffer.hpp>
22#include <boost/asio/buffers_iterator.hpp>
23#include <algorithm>
24#include <atomic>
25#include <cctype>
26#include <memory>
27#include <string>
28
29namespace boost {
30namespace beast {
31
32class multi_buffer_test : public beast::unit_test::suite
33{
34public:
35 BOOST_STATIC_ASSERT(
36 is_mutable_dynamic_buffer<multi_buffer>::value);
37
38#if ! BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000) && \
39 ! BOOST_WORKAROUND(BOOST_MSVC, < 1910)
40// BOOST_STATIC_ASSERT(std::is_trivially_copyable<
41// multi_buffer::const_buffers_type>::value);
42// BOOST_STATIC_ASSERT(std::is_trivially_copyable<
43// multi_buffer::mutable_data_type>::value);
44#endif
45
46 template<class Alloc1, class Alloc2>
47 static
48 bool
49 eq( basic_multi_buffer<Alloc1> const& mb1,
50 basic_multi_buffer<Alloc2> const& mb2)
51 {
52 return buffers_to_string(mb1.data()) ==
53 buffers_to_string(mb2.data());
54 }
55
56 void
57 testShrinkToFit()
58 {
59 // empty list
60
61 {
62 multi_buffer b;
63 BEAST_EXPECT(b.size() == 0);
64 BEAST_EXPECT(b.capacity() == 0);
65 b.shrink_to_fit();
66 BEAST_EXPECT(b.size() == 0);
67 BEAST_EXPECT(b.capacity() == 0);
68 }
69
70 // zero readable bytes
71
72 {
73 multi_buffer b;
74 b.prepare(n: 512);
75 b.shrink_to_fit();
76 BEAST_EXPECT(b.size() == 0);
77 BEAST_EXPECT(b.capacity() == 0);
78 }
79
80 {
81 multi_buffer b;
82 b.prepare(n: 512);
83 b.commit(n: 32);
84 b.consume(n: 32);
85 b.shrink_to_fit();
86 BEAST_EXPECT(b.size() == 0);
87 BEAST_EXPECT(b.capacity() == 0);
88 }
89
90 {
91 multi_buffer b;
92 b.prepare(n: 512);
93 b.commit(n: 512);
94 b.prepare(n: 512);
95 b.clear();
96 b.shrink_to_fit();
97 BEAST_EXPECT(b.size() == 0);
98 BEAST_EXPECT(b.capacity() == 0);
99 }
100
101 // unused list
102
103 {
104 multi_buffer b;
105 b.prepare(n: 512);
106 b.commit(n: 512);
107 b.prepare(n: 512);
108 b.shrink_to_fit();
109 BEAST_EXPECT(b.size() == 512);
110 BEAST_EXPECT(b.capacity() == 512);
111 }
112
113 {
114 multi_buffer b;
115 b.prepare(n: 512);
116 b.commit(n: 512);
117 b.prepare(n: 512);
118 b.prepare(n: 1024);
119 b.shrink_to_fit();
120 BEAST_EXPECT(b.size() == 512);
121 BEAST_EXPECT(b.capacity() == 512);
122 }
123
124 // partial last buffer
125
126 {
127 multi_buffer b;
128 b.prepare(n: 512);
129 b.commit(n: 512);
130 b.prepare(n: 512);
131 b.commit(n: 88);
132 b.shrink_to_fit();
133 BEAST_EXPECT(b.size() == 600);
134 BEAST_EXPECT(b.capacity() == 600);
135 }
136
137 // shrink front of first buffer
138
139 {
140 multi_buffer b;
141 b.prepare(n: 512);
142 b.commit(n: 512);
143 b.consume(n: 12);
144 b.shrink_to_fit();
145 BEAST_EXPECT(b.size() == 500);
146 BEAST_EXPECT(b.capacity() == 500);
147 }
148
149 // shrink ends of first buffer
150
151 {
152 multi_buffer b;
153 b.prepare(n: 512);
154 b.commit(n: 500);
155 b.consume(n: 100);
156 b.shrink_to_fit();
157 BEAST_EXPECT(b.size() == 400);
158 BEAST_EXPECT(b.capacity() == 400);
159 }
160 }
161
162 void
163 testDynamicBuffer()
164 {
165 multi_buffer b(30);
166 BEAST_EXPECT(b.max_size() == 30);
167 test_dynamic_buffer(b0: b);
168 }
169
170 void
171 testMembers()
172 {
173 using namespace test;
174
175 // compare equal
176 using equal_t = test::test_allocator<char,
177 true, true, true, true, true>;
178
179 // compare not equal
180 using unequal_t = test::test_allocator<char,
181 false, true, true, true, true>;
182
183 // construction
184 {
185 {
186 multi_buffer b;
187 BEAST_EXPECT(b.capacity() == 0);
188 }
189 {
190 multi_buffer b{500};
191 BEAST_EXPECT(b.capacity() == 0);
192 BEAST_EXPECT(b.max_size() == 500);
193 }
194 {
195 unequal_t a1;
196 basic_multi_buffer<unequal_t> b{a1};
197 BEAST_EXPECT(b.get_allocator() == a1);
198 BEAST_EXPECT(b.get_allocator() != unequal_t{});
199 }
200 {
201 unequal_t a1;
202 basic_multi_buffer<unequal_t> b{500, a1};
203 BEAST_EXPECT(b.capacity() == 0);
204 BEAST_EXPECT(b.max_size() == 500);
205 BEAST_EXPECT(b.get_allocator() == a1);
206 BEAST_EXPECT(b.get_allocator() != unequal_t{});
207 }
208 }
209
210 // move construction
211 {
212 {
213 basic_multi_buffer<equal_t> b1{30};
214 BEAST_EXPECT(b1.get_allocator()->nmove == 0);
215 ostream(b1) << "Hello";
216 basic_multi_buffer<equal_t> b2{std::move(b1)};
217 BEAST_EXPECT(b2.get_allocator()->nmove == 1);
218 BEAST_EXPECT(b1.size() == 0);
219 BEAST_EXPECT(b1.capacity() == 0);
220 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
221 BEAST_EXPECT(b1.max_size() == b2.max_size());
222 }
223 // allocators equal
224 {
225 basic_multi_buffer<equal_t> b1{30};
226 ostream(buffer&: b1) << "Hello";
227 equal_t a;
228 basic_multi_buffer<equal_t> b2{std::move(b1), a};
229 BEAST_EXPECT(b1.size() == 0);
230 BEAST_EXPECT(b1.capacity() == 0);
231 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
232 BEAST_EXPECT(b1.max_size() == b2.max_size());
233 }
234 {
235 // allocators unequal
236 basic_multi_buffer<unequal_t> b1{30};
237 ostream(buffer&: b1) << "Hello";
238 unequal_t a;
239 basic_multi_buffer<unequal_t> b2{std::move(b1), a};
240 BEAST_EXPECT(b1.size() != 0);
241 BEAST_EXPECT(b1.capacity() != 0);
242 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
243 BEAST_EXPECT(b1.max_size() == b2.max_size());
244 }
245 }
246
247 // copy construction
248 {
249 {
250 basic_multi_buffer<equal_t> b1;
251 ostream(buffer&: b1) << "Hello";
252 basic_multi_buffer<equal_t> b2{b1};
253 BEAST_EXPECT(b1.get_allocator() == b2.get_allocator());
254 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
255 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
256 }
257 {
258 basic_multi_buffer<unequal_t> b1;
259 ostream(buffer&: b1) << "Hello";
260 unequal_t a;
261 basic_multi_buffer<unequal_t> b2(b1, a);
262 BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
263 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
264 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
265 }
266 {
267 basic_multi_buffer<equal_t> b1;
268 ostream(buffer&: b1) << "Hello";
269 basic_multi_buffer<unequal_t> b2(b1);
270 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
271 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
272 }
273 {
274 basic_multi_buffer<unequal_t> b1;
275 ostream(buffer&: b1) << "Hello";
276 equal_t a;
277 basic_multi_buffer<equal_t> b2(b1, a);
278 BEAST_EXPECT(b2.get_allocator() == a);
279 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
280 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
281 }
282 }
283
284 // move assignment
285 {
286 {
287 multi_buffer b1;
288 ostream(buffer&: b1) << "Hello";
289 multi_buffer b2;
290 b2 = std::move(b1);
291 BEAST_EXPECT(b1.size() == 0);
292 BEAST_EXPECT(b1.capacity() == 0);
293 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
294 }
295 {
296 using na_t = test::test_allocator<char,
297 false, true, false, true, true>;
298 basic_multi_buffer<na_t> b1;
299 ostream(b1) << "Hello";
300 basic_multi_buffer<na_t> b2;
301 b2 = std::move(b1);
302 BEAST_EXPECT(b1.get_allocator() != b2.get_allocator());
303 BEAST_EXPECT(b1.size() != 0);
304 BEAST_EXPECT(b1.capacity() != 0);
305 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
306 }
307 {
308 // propagate_on_container_move_assignment : true
309 using pocma_t = test::test_allocator<char,
310 true, true, true, true, true>;
311 basic_multi_buffer<pocma_t> b1;
312 ostream(b1) << "Hello";
313 basic_multi_buffer<pocma_t> b2;
314 b2 = std::move(b1);
315 BEAST_EXPECT(b1.size() == 0);
316 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
317 }
318 {
319 // propagate_on_container_move_assignment : false
320 using pocma_t = test::test_allocator<char,
321 true, true, false, true, true>;
322 basic_multi_buffer<pocma_t> b1;
323 ostream(b1) << "Hello";
324 basic_multi_buffer<pocma_t> b2;
325 b2 = std::move(b1);
326 BEAST_EXPECT(b1.size() == 0);
327 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
328 }
329 }
330
331 // copy assignment
332 {
333 {
334 multi_buffer b1;
335 ostream(buffer&: b1) << "Hello";
336 multi_buffer b2;
337 b2 = b1;
338 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
339 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
340 basic_multi_buffer<equal_t> b3;
341 b3 = b2;
342 BEAST_EXPECT(buffers_to_string(b3.data()) == "Hello");
343 }
344 {
345 // propagate_on_container_copy_assignment : true
346 using pocca_t = test::test_allocator<char,
347 true, true, true, true, true>;
348 basic_multi_buffer<pocca_t> b1;
349 ostream(b1) << "Hello";
350 basic_multi_buffer<pocca_t> b2;
351 b2 = b1;
352 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
353 }
354 {
355 // propagate_on_container_copy_assignment : false
356 using pocca_t = test::test_allocator<char,
357 true, false, true, true, true>;
358 basic_multi_buffer<pocca_t> b1;
359 ostream(b1) << "Hello";
360 basic_multi_buffer<pocca_t> b2;
361 b2 = b1;
362 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
363 }
364 }
365
366 // max_size
367 {
368 multi_buffer b{10};
369 BEAST_EXPECT(b.max_size() == 10);
370 b.max_size(n: 32);
371 BEAST_EXPECT(b.max_size() == 32);
372 }
373
374 // allocator max_size
375 {
376 basic_multi_buffer<equal_t> b;
377 auto a = b.get_allocator();
378 BOOST_STATIC_ASSERT(
379 ! std::is_const<decltype(a)>::value);
380 a->max_size = 30;
381 try
382 {
383 b.prepare(n: 1000);
384 fail(reason: "", __FILE__, __LINE__);
385 }
386 catch(std::length_error const&)
387 {
388 pass();
389 }
390 try
391 {
392 b.reserve(n: 1000);
393 fail(reason: "", __FILE__, __LINE__);
394 }
395 catch(std::length_error const&)
396 {
397 pass();
398 }
399 }
400
401
402 // prepare
403 {
404 {
405 multi_buffer b{100};
406 try
407 {
408 b.prepare(n: b.max_size() + 1);
409 fail(reason: "", __FILE__, __LINE__);
410 }
411 catch(std::length_error const&)
412 {
413 pass();
414 }
415 }
416 {
417 string_view const s = "Hello, world!";
418 multi_buffer b1{64};
419 BEAST_EXPECT(b1.size() == 0);
420 BEAST_EXPECT(b1.max_size() == 64);
421 BEAST_EXPECT(b1.capacity() == 0);
422 ostream(buffer&: b1) << s;
423 BEAST_EXPECT(buffers_to_string(b1.data()) == s);
424 {
425 multi_buffer b2{b1};
426 BEAST_EXPECT(buffers_to_string(b2.data()) == s);
427 b2.consume(n: 7);
428 BEAST_EXPECT(buffers_to_string(b2.data()) == s.substr(7));
429 }
430 {
431 multi_buffer b2{64};
432 b2 = b1;
433 BEAST_EXPECT(buffers_to_string(b2.data()) == s);
434 b2.consume(n: 7);
435 BEAST_EXPECT(buffers_to_string(b2.data()) == s.substr(7));
436 }
437 }
438 {
439 multi_buffer b;
440 b.prepare(n: 1000);
441 BEAST_EXPECT(b.capacity() >= 1000);
442 b.commit(n: 1);
443 BEAST_EXPECT(b.size() == 1);
444 BEAST_EXPECT(b.capacity() >= 1000);
445 b.prepare(n: 1000);
446 BEAST_EXPECT(b.size() == 1);
447 BEAST_EXPECT(b.capacity() >= 1000);
448 b.prepare(n: 1500);
449 BEAST_EXPECT(b.capacity() >= 1000);
450 }
451 {
452 multi_buffer b;
453 b.prepare(n: 1000);
454 BEAST_EXPECT(b.capacity() >= 1000);
455 b.commit(n: 1);
456 BEAST_EXPECT(b.capacity() >= 1000);
457 b.prepare(n: 1000);
458 BEAST_EXPECT(b.capacity() >= 1000);
459 b.prepare(n: 2000);
460 BEAST_EXPECT(b.capacity() >= 2000);
461 b.commit(n: 2);
462 }
463 {
464 multi_buffer b;
465 b.prepare(n: 1000);
466 BEAST_EXPECT(b.capacity() >= 1000);
467 b.prepare(n: 2000);
468 BEAST_EXPECT(b.capacity() >= 2000);
469 b.prepare(n: 4000);
470 BEAST_EXPECT(b.capacity() >= 4000);
471 b.prepare(n: 50);
472 BEAST_EXPECT(b.capacity() >= 50);
473 }
474 }
475
476 // commit
477 {
478 {
479 multi_buffer b;
480 b.prepare(n: 16);
481 b.commit(n: 16);
482 auto const n =
483 b.capacity() - b.size();
484 b.prepare(n);
485 b.commit(n);
486 auto const size =
487 b.size();
488 auto const capacity =
489 b.capacity();
490 b.commit(n: 1);
491 BEAST_EXPECT(b.size() == size);
492 BEAST_EXPECT(b.capacity() == capacity);
493 }
494
495 multi_buffer b;
496 b.prepare(n: 1000);
497 BEAST_EXPECT(b.capacity() >= 1000);
498 b.commit(n: 1000);
499 BEAST_EXPECT(b.size() == 1000);
500 BEAST_EXPECT(b.capacity() >= 1000);
501 b.consume(n: 1000);
502 BEAST_EXPECT(b.size() == 0);
503 BEAST_EXPECT(b.capacity() == 0);
504 b.prepare(n: 1000);
505 b.commit(n: 650);
506 BEAST_EXPECT(b.size() == 650);
507 BEAST_EXPECT(b.capacity() >= 1000);
508 b.prepare(n: 1000);
509 BEAST_EXPECT(b.capacity() >= 1650);
510 b.commit(n: 100);
511 BEAST_EXPECT(b.size() == 750);
512 BEAST_EXPECT(b.capacity() >= 1000);
513 b.prepare(n: 1000);
514 BEAST_EXPECT(b.capacity() >= 2000);
515 b.commit(n: 500);
516 }
517
518 // consume
519 {
520 multi_buffer b;
521 b.prepare(n: 1000);
522 BEAST_EXPECT(b.capacity() >= 1000);
523 b.commit(n: 1000);
524 BEAST_EXPECT(b.size() == 1000);
525 BEAST_EXPECT(b.capacity() >= 1000);
526 b.prepare(n: 1000);
527 BEAST_EXPECT(b.capacity() >= 2000);
528 b.commit(n: 750);
529 BEAST_EXPECT(b.size() == 1750);
530 b.consume(n: 500);
531 BEAST_EXPECT(b.size() == 1250);
532 b.consume(n: 500);
533 BEAST_EXPECT(b.size() == 750);
534 b.prepare(n: 250);
535 b.consume(n: 750);
536 BEAST_EXPECT(b.size() == 0);
537 b.prepare(n: 1000);
538 b.commit(n: 800);
539 BEAST_EXPECT(b.size() == 800);
540 b.prepare(n: 1000);
541 b.commit(n: 600);
542 BEAST_EXPECT(b.size() == 1400);
543 b.consume(n: 1400);
544 BEAST_EXPECT(b.size() == 0);
545 }
546
547 // reserve
548 {
549 multi_buffer b;
550 BEAST_EXPECT(b.capacity() == 0);
551 b.reserve(n: 50);
552 BEAST_EXPECT(b.capacity() >= 50);
553 b.prepare(n: 20);
554 b.commit(n: 20);
555 b.reserve(n: 50);
556 BEAST_EXPECT(b.capacity() >= 50);
557 BEAST_EXPECT(b.size() > 1);
558 auto capacity = b.capacity();
559 b.reserve(n: b.size() - 1);
560 BEAST_EXPECT(b.capacity() == capacity);
561 b.reserve(n: b.capacity() + 1);
562 BEAST_EXPECT(b.capacity() > capacity);
563 capacity = b.capacity();
564 BEAST_EXPECT(buffers_length(
565 b.prepare(b.capacity() + 200)) > 1);
566 BEAST_EXPECT(b.capacity() > capacity);
567 b.reserve(n: b.capacity() + 2);
568 BEAST_EXPECT(b.capacity() > capacity);
569 capacity = b.capacity();
570 b.reserve(n: b.capacity());
571 BEAST_EXPECT(b.capacity() == capacity);
572 }
573
574 // shrink to fit
575 {
576 {
577 multi_buffer b;
578 BEAST_EXPECT(b.capacity() == 0);
579 b.prepare(n: 50);
580 BEAST_EXPECT(b.capacity() >= 50);
581 b.commit(n: 50);
582 BEAST_EXPECT(b.capacity() >= 50);
583 b.prepare(n: 75);
584 BEAST_EXPECT(b.capacity() >= 125);
585 b.shrink_to_fit();
586 BEAST_EXPECT(b.capacity() >= b.size());
587 }
588 {
589 multi_buffer b;
590 b.prepare(n: 2000);
591 BEAST_EXPECT(b.capacity() == 2000);
592 b.commit(n: 1800);
593 BEAST_EXPECT(b.size() == 1800);
594 BEAST_EXPECT(b.capacity() == 2000);
595 b.prepare(n: 5000);
596 BEAST_EXPECT(b.capacity() == 6800);
597 b.shrink_to_fit();
598 BEAST_EXPECT(b.capacity() == 2000);
599 }
600 }
601
602 // clear
603 {
604 multi_buffer b;
605 BEAST_EXPECT(b.capacity() == 0);
606 b.prepare(n: 50);
607 b.commit(n: 50);
608 BEAST_EXPECT(b.size() == 50);
609 BEAST_EXPECT(b.capacity() == 512);
610 b.clear();
611 BEAST_EXPECT(b.size() == 0);
612 BEAST_EXPECT(b.capacity() == 512);
613 }
614
615 // swap
616 {
617 {
618 // propagate_on_container_swap : true
619 using pocs_t = test::test_allocator<char,
620 false, true, true, true, true>;
621 pocs_t a1, a2;
622 BEAST_EXPECT(a1 != a2);
623 basic_multi_buffer<pocs_t> b1{a1};
624 ostream(b1) << "Hello";
625 basic_multi_buffer<pocs_t> b2{a2};
626 BEAST_EXPECT(b1.get_allocator() == a1);
627 BEAST_EXPECT(b2.get_allocator() == a2);
628 swap(b1, b2);
629 BEAST_EXPECT(b1.get_allocator() == a2);
630 BEAST_EXPECT(b2.get_allocator() == a1);
631 BEAST_EXPECT(b1.size() == 0);
632 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
633 swap(b1, b2);
634 BEAST_EXPECT(b1.get_allocator() == a1);
635 BEAST_EXPECT(b2.get_allocator() == a2);
636 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
637 BEAST_EXPECT(b2.size() == 0);
638 }
639 {
640 // propagate_on_container_swap : false
641 using pocs_t = test::test_allocator<char,
642 true, true, true, false, true>;
643 pocs_t a1, a2;
644 BEAST_EXPECT(a1 == a2);
645 BEAST_EXPECT(a1.id() != a2.id());
646 basic_multi_buffer<pocs_t> b1{a1};
647 ostream(b1) << "Hello";
648 basic_multi_buffer<pocs_t> b2{a2};
649 BEAST_EXPECT(b1.get_allocator() == a1);
650 BEAST_EXPECT(b2.get_allocator() == a2);
651 swap(b1, b2);
652 BEAST_EXPECT(b1.get_allocator().id() == a1.id());
653 BEAST_EXPECT(b2.get_allocator().id() == a2.id());
654 BEAST_EXPECT(b1.size() == 0);
655 BEAST_EXPECT(buffers_to_string(b2.data()) == "Hello");
656 swap(b1, b2);
657 BEAST_EXPECT(b1.get_allocator().id() == a1.id());
658 BEAST_EXPECT(b2.get_allocator().id() == a2.id());
659 BEAST_EXPECT(buffers_to_string(b1.data()) == "Hello");
660 BEAST_EXPECT(b2.size() == 0);
661 }
662 }
663
664 // read_size
665 {
666 multi_buffer b{10};
667 BEAST_EXPECT(read_size(b, 512) == 10);
668 b.prepare(n: 4);
669 b.commit(n: 4);
670 BEAST_EXPECT(read_size(b, 512) == 6);
671 b.consume(n: 2);
672 BEAST_EXPECT(read_size(b, 512) == 8);
673 b.prepare(n: 8);
674 b.commit(n: 8);
675 BEAST_EXPECT(read_size(b, 512) == 0);
676 }
677 }
678
679 void
680 testMatrix1()
681 {
682 string_view s = "Hello, world";
683 BEAST_EXPECT(s.size() == 12);
684 for(std::size_t i = 1; i < 12; ++i) {
685 for(std::size_t x = 1; x < 4; ++x) {
686 for(std::size_t y = 1; y < 4; ++y) {
687 std::size_t z = s.size() - (x + y);
688 {
689 multi_buffer b;
690 b.commit(n: net::buffer_copy(
691 target: b.prepare(n: x), source: net::buffer(data: s.data(), size_in_bytes: x)));
692 b.commit(n: net::buffer_copy(
693 target: b.prepare(n: y), source: net::buffer(data: s.data()+x, size_in_bytes: y)));
694 b.commit(n: net::buffer_copy(
695 target: b.prepare(n: z), source: net::buffer(data: s.data()+x+y, size_in_bytes: z)));
696 BEAST_EXPECT(buffers_to_string(b.data()) == s);
697 {
698 multi_buffer mb2{b};
699 BEAST_EXPECT(eq(b, mb2));
700 }
701 {
702 multi_buffer mb2;
703 mb2 = b;
704 BEAST_EXPECT(eq(b, mb2));
705 }
706 {
707 multi_buffer mb2{std::move(b)};
708 BEAST_EXPECT(buffers_to_string(mb2.data()) == s);
709 BEAST_EXPECT(b.size() == 0);
710 BEAST_EXPECT(buffer_bytes(b.data()) == 0);
711 b = std::move(mb2);
712 BEAST_EXPECT(buffers_to_string(b.data()) == s);
713 BEAST_EXPECT(mb2.size() == 0);
714 BEAST_EXPECT(buffer_bytes(mb2.data()) == 0);
715 }
716 }
717 }}}
718 }
719
720 void
721 testMatrix2()
722 {
723 using namespace test;
724 std::string const s = "Hello, world";
725 BEAST_EXPECT(s.size() == 12);
726 for(std::size_t i = 1; i < 12; ++i) {
727 for(std::size_t x = 1; x < 4; ++x) {
728 for(std::size_t y = 1; y < 4; ++y) {
729 for(std::size_t t = 1; t < 4; ++ t) {
730 for(std::size_t u = 1; u < 4; ++ u) {
731 std::size_t z = s.size() - (x + y);
732 std::size_t v = s.size() - (t + u);
733 {
734 multi_buffer b;
735 {
736 auto d = b.prepare(n: z);
737 BEAST_EXPECT(buffer_bytes(d) == z);
738 }
739 {
740 auto d = b.prepare(n: 0);
741 BEAST_EXPECT(buffer_bytes(d) == 0);
742 }
743 {
744 auto d = b.prepare(n: y);
745 BEAST_EXPECT(buffer_bytes(d) == y);
746 }
747 {
748 auto d = b.prepare(n: x);
749 BEAST_EXPECT(buffer_bytes(d) == x);
750 b.commit(n: buffer_copy(target: d, source: net::buffer(data: s.data(), size_in_bytes: x)));
751 }
752 BEAST_EXPECT(b.size() == x);
753 BEAST_EXPECT(buffer_bytes(b.data()) == b.size());
754 {
755 auto d = b.prepare(n: x);
756 BEAST_EXPECT(buffer_bytes(d) == x);
757 }
758 {
759 auto d = b.prepare(n: 0);
760 BEAST_EXPECT(buffer_bytes(d) == 0);
761 }
762 {
763 auto d = b.prepare(n: z);
764 BEAST_EXPECT(buffer_bytes(d) == z);
765 }
766 {
767 auto d = b.prepare(n: y);
768 BEAST_EXPECT(buffer_bytes(d) == y);
769 b.commit(n: buffer_copy(target: d, source: net::buffer(data: s.data()+x, size_in_bytes: y)));
770 }
771 b.commit(n: 1);
772 BEAST_EXPECT(b.size() == x + y);
773 BEAST_EXPECT(buffer_bytes(b.data()) == b.size());
774 {
775 auto d = b.prepare(n: x);
776 BEAST_EXPECT(buffer_bytes(d) == x);
777 }
778 {
779 auto d = b.prepare(n: y);
780 BEAST_EXPECT(buffer_bytes(d) == y);
781 }
782 {
783 auto d = b.prepare(n: 0);
784 BEAST_EXPECT(buffer_bytes(d) == 0);
785 }
786 {
787 auto d = b.prepare(n: z);
788 BEAST_EXPECT(buffer_bytes(d) == z);
789 b.commit(n: buffer_copy(target: d, source: net::buffer(data: s.data()+x+y, size_in_bytes: z)));
790 }
791 b.commit(n: 2);
792 BEAST_EXPECT(b.size() == x + y + z);
793 BEAST_EXPECT(buffer_bytes(b.data()) == b.size());
794 BEAST_EXPECT(buffers_to_string(b.data()) == s);
795 b.consume(n: t);
796 {
797 auto d = b.prepare(n: 0);
798 BEAST_EXPECT(buffer_bytes(d) == 0);
799 }
800 BEAST_EXPECT(buffers_to_string(b.data()) ==
801 s.substr(t, std::string::npos));
802 b.consume(n: u);
803 BEAST_EXPECT(buffers_to_string(b.data()) ==
804 s.substr(t + u, std::string::npos));
805 b.consume(n: v);
806 BEAST_EXPECT(buffers_to_string(b.data()).empty());
807 b.consume(n: 1);
808 {
809 auto d = b.prepare(n: 0);
810 BEAST_EXPECT(buffer_bytes(d) == 0);
811 }
812 }
813 }}}}}
814 }
815
816 void
817 run() override
818 {
819 testShrinkToFit();
820 testDynamicBuffer();
821 testMembers();
822 testMatrix1();
823 testMatrix2();
824 }
825};
826
827BEAST_DEFINE_TESTSUITE(beast,core,multi_buffer);
828
829} // beast
830} // boost
831

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