ceph/src/boost/libs/beast/test/beast/core/buffers_suffix.cpp

   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/buffers_suffix.hpp>
  12
  13 #include "test_buffer.hpp"
  14
  15 #include <boost/beast/core/buffer_traits.hpp>
  16 #include <boost/beast/core/buffers_cat.hpp>
  17 #include <boost/beast/_experimental/unit_test/suite.hpp>
  18 #include <boost/asio/buffer.hpp>
  19 #include <string>
  20
  21 namespace boost {
  22 namespace beast {
  23
  24 class buffers_suffix_test : public beast::unit_test::suite
  25 {
  26 public:
  27     void
  28     testBufferSequence()
  29     {
  30         // mutable
  31         {
  32             char buf[13];
  33             auto b = buffers_triple(buf, sizeof(buf));
  34             buffers_suffix<decltype(b)> bs(b);
  35             test_buffer_sequence(bs);
  36         }
  37
  38         // const
  39         {
  40             string_view src = "Hello, world!";
  41             std::array<net::const_buffer, 3> b{{
  42                 net::const_buffer(src.data(),     3),
  43                 net::const_buffer(src.data() + 3, 4),
  44                 net::const_buffer(src.data() + 7, 6) }};
  45             buffers_suffix<decltype(b)> bs(b);
  46             test_buffer_sequence(bs);
  47         }
  48     }
  49
  50     void
  51     testSpecial()
  52     {
  53         // default construction
  54         {
  55             class test_buffer
  56                 : public net::const_buffer
  57             {
  58             public:
  59                 test_buffer()
  60                     : net::const_buffer("\r\n", 2)
  61                 {
  62                 }
  63             };
  64
  65             buffers_suffix<test_buffer> cb;
  66             BEAST_EXPECT(buffers_to_string(cb) == "\r\n");
  67             cb.consume(1);
  68             BEAST_EXPECT(buffers_to_string(cb) == "\n");
  69         }
  70
  71         // in-place init
  72         {
  73             buffers_suffix<buffers_cat_view<
  74                 net::const_buffer,
  75                 net::const_buffer>> cb(
  76                     boost::in_place_init,
  77                         net::const_buffer("\r", 1),
  78                         net::const_buffer("\n", 1));
  79             BEAST_EXPECT(buffers_to_string(cb) == "\r\n");
  80         }
  81
  82         // empty sequence
  83         {
  84             buffers_suffix<net::mutable_buffer> cb(
  85                 net::mutable_buffer{});
  86             BEAST_EXPECT(buffer_bytes(cb) == 0);
  87             buffers_suffix<net::mutable_buffer> cb2(
  88                 net::mutable_buffer{});
  89             BEAST_EXPECT(net::buffer_copy(cb2, cb) == 0);
  90         }
  91     }
  92
  93     template<class BufferSequence>
  94     static
  95     buffers_suffix<BufferSequence>
  96     consumed_buffers(BufferSequence const& bs, std::size_t n)
  97     {
  98         buffers_suffix<BufferSequence> cb(bs);
  99         cb.consume(n);
 100         return cb;
 101     }
 102
 103     template<class Buffers1, class Buffers2>
 104     static
 105     bool
 106     eq(Buffers1 const& lhs, Buffers2 const& rhs)
 107     {
 108         return
 109             buffers_to_string(lhs) ==
 110             buffers_to_string(rhs);
 111     }
 112
 113     void
 114     testMatrix()
 115     {
 116         char buf[12];
 117         std::string const s = "Hello, world";
 118         BEAST_EXPECT(s.size() == sizeof(buf));
 119         net::buffer_copy(net::buffer(buf), net::buffer(s));
 120         BEAST_EXPECT(buffers_to_string(net::buffer(buf)) == s);
 121         for(std::size_t i = 1; i < 4; ++i) {
 122         for(std::size_t j = 1; j < 4; ++j) {
 123         for(std::size_t x = 1; x < 4; ++x) {
 124         for(std::size_t y = 1; y < 4; ++y) {
 125         std::size_t k = sizeof(buf) - (i + j);
 126         std::size_t z = sizeof(buf) - (x + y);
 127         {
 128             std::array<net::const_buffer, 3> bs{{
 129                 net::const_buffer{&buf[0], i},
 130                 net::const_buffer{&buf[i], j},
 131                 net::const_buffer{&buf[i+j], k}}};
 132             buffers_suffix<decltype(bs)> cb(bs);
 133             BEAST_EXPECT(buffers_to_string(cb) == s);
 134             BEAST_EXPECT(buffer_bytes(cb) == s.size());
 135             cb.consume(0);
 136             BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0)));
 137             BEAST_EXPECT(buffers_to_string(cb) == s);
 138             BEAST_EXPECT(buffer_bytes(cb) == s.size());
 139             cb.consume(x);
 140             BEAST_EXPECT(buffers_to_string(cb) == s.substr(x));
 141             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x)));
 142             cb.consume(y);
 143             BEAST_EXPECT(buffers_to_string(cb) == s.substr(x+y));
 144             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y)));
 145             cb.consume(z);
 146             BEAST_EXPECT(buffers_to_string(cb) == "");
 147             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
 148             cb.consume(1);
 149             BEAST_EXPECT(buffers_to_string(cb) == "");
 150             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
 151         }
 152         }}}}
 153     }
 154
 155     void
 156     run() override
 157     {
 158         testBufferSequence();
 159         testSpecial();
 160         testMatrix();
 161     }
 162 };
 163
 164 BEAST_DEFINE_TESTSUITE(beast,core,buffers_suffix);
 165
 166 } // beast
 167 } // boost