ceph/src/Beast/test/core/buffers_adapter.cpp

   1 //
   2 // Copyright (c) 2013-2017 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
   8 // Test that header file is self-contained.
   9 #include <beast/core/buffers_adapter.hpp>
  10
  11 #include <beast/core/streambuf.hpp>
  12 #include <beast/unit_test/suite.hpp>
  13 #include <boost/asio/buffer.hpp>
  14 #include <boost/asio/streambuf.hpp>
  15 #include <iterator>
  16
  17 namespace beast {
  18
  19 class buffers_adapter_test : public unit_test::suite
  20 {
  21 public:
  22     template<class ConstBufferSequence>
  23     static
  24     std::string
  25     to_string(ConstBufferSequence const& bs)
  26     {
  27         using boost::asio::buffer_cast;
  28         using boost::asio::buffer_size;
  29         std::string s;
  30         s.reserve(buffer_size(bs));
  31         for(auto const& b : bs)
  32             s.append(buffer_cast<char const*>(b),
  33                 buffer_size(b));
  34         return s;
  35     }
  36
  37     void testBuffersAdapter()
  38     {
  39         using boost::asio::buffer;
  40         using boost::asio::buffer_cast;
  41         using boost::asio::buffer_size;
  42         using boost::asio::const_buffer;
  43         using boost::asio::mutable_buffer;
  44         char buf[12];
  45         std::string const s = "Hello, world";
  46         BEAST_EXPECT(s.size() == sizeof(buf));
  47         for(std::size_t i = 1; i < 4; ++i) {
  48         for(std::size_t j = 1; j < 4; ++j) {
  49         for(std::size_t x = 1; x < 4; ++x) {
  50         for(std::size_t y = 1; y < 4; ++y) {
  51         for(std::size_t t = 1; t < 4; ++ t) {
  52         for(std::size_t u = 1; u < 4; ++ u) {
  53         std::size_t k = sizeof(buf) - (i + j);
  54         std::size_t z = sizeof(buf) - (x + y);
  55         std::size_t v = sizeof(buf) - (t + u);
  56         {
  57             std::memset(buf, 0, sizeof(buf));
  58             std::array<mutable_buffer, 3> bs{{
  59                 mutable_buffer{&buf[0], i},
  60                 mutable_buffer{&buf[i], j},
  61                 mutable_buffer{&buf[i+j], k}}};
  62             buffers_adapter<decltype(bs)> ba(std::move(bs));
  63             BEAST_EXPECT(ba.max_size() == sizeof(buf));
  64             {
  65                 auto d = ba.prepare(z);
  66                 BEAST_EXPECT(buffer_size(d) == z);
  67             }
  68             {
  69                 auto d = ba.prepare(0);
  70                 BEAST_EXPECT(buffer_size(d) == 0);
  71             }
  72             {
  73                 auto d = ba.prepare(y);
  74                 BEAST_EXPECT(buffer_size(d) == y);
  75             }
  76             {
  77                 auto d = ba.prepare(x);
  78                 BEAST_EXPECT(buffer_size(d) == x);
  79                 ba.commit(buffer_copy(d, buffer(s.data(), x)));
  80             }
  81             BEAST_EXPECT(ba.size() == x);
  82             BEAST_EXPECT(ba.max_size() == sizeof(buf) - x);
  83             BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
  84             {
  85                 auto d = ba.prepare(x);
  86                 BEAST_EXPECT(buffer_size(d) == x);
  87             }
  88             {
  89                 auto d = ba.prepare(0);
  90                 BEAST_EXPECT(buffer_size(d) == 0);
  91             }
  92             {
  93                 auto d = ba.prepare(z);
  94                 BEAST_EXPECT(buffer_size(d) == z);
  95             }
  96             {
  97                 auto d = ba.prepare(y);
  98                 BEAST_EXPECT(buffer_size(d) == y);
  99                 ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
 100             }
 101             ba.commit(1);
 102             BEAST_EXPECT(ba.size() == x + y);
 103             BEAST_EXPECT(ba.max_size() == sizeof(buf) - (x + y));
 104             BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
 105             {
 106                 auto d = ba.prepare(x);
 107                 BEAST_EXPECT(buffer_size(d) == x);
 108             }
 109             {
 110                 auto d = ba.prepare(y);
 111                 BEAST_EXPECT(buffer_size(d) == y);
 112             }
 113             {
 114                 auto d = ba.prepare(0);
 115                 BEAST_EXPECT(buffer_size(d) == 0);
 116             }
 117             {
 118                 auto d = ba.prepare(z); BEAST_EXPECT(buffer_size(d) == z);
 119                 ba.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
 120             }
 121             ba.commit(2);
 122             BEAST_EXPECT(ba.size() == x + y + z);
 123             BEAST_EXPECT(ba.max_size() == 0);
 124             BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
 125             BEAST_EXPECT(to_string(ba.data()) == s);
 126             ba.consume(t);
 127             {
 128                 auto d = ba.prepare(0);
 129                 BEAST_EXPECT(buffer_size(d) == 0);
 130             }
 131             BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
 132             ba.consume(u);
 133             BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
 134             ba.consume(v);
 135             BEAST_EXPECT(to_string(ba.data()) == "");
 136             ba.consume(1);
 137             {
 138                 auto d = ba.prepare(0);
 139                 BEAST_EXPECT(buffer_size(d) == 0);
 140             }
 141             try
 142             {
 143                 ba.prepare(1);
 144                 fail();
 145             }
 146             catch(...)
 147             {
 148                 pass();
 149             }
 150         }
 151         }}}}}}
 152     }
 153     void testCommit()
 154     {
 155         using boost::asio::buffer_size;
 156         {
 157             using sb_type = boost::asio::streambuf;
 158             sb_type sb;
 159             buffers_adapter<
 160                 sb_type::mutable_buffers_type> ba(sb.prepare(3));
 161             BEAST_EXPECT(buffer_size(ba.prepare(3)) == 3);
 162             ba.commit(2);
 163             BEAST_EXPECT(buffer_size(ba.data()) == 2);
 164         }
 165         {
 166             using sb_type = beast::streambuf;
 167             sb_type sb(2);
 168             sb.prepare(3);
 169             buffers_adapter<
 170                 sb_type::mutable_buffers_type> ba(sb.prepare(8));
 171             BEAST_EXPECT(buffer_size(ba.prepare(8)) == 8);
 172             ba.commit(2);
 173             BEAST_EXPECT(buffer_size(ba.data()) == 2);
 174             ba.consume(1);
 175             ba.commit(6);
 176             ba.consume(2);
 177             BEAST_EXPECT(buffer_size(ba.data()) == 5);
 178             ba.consume(5);
 179         }
 180     }
 181     void run() override
 182     {
 183         testBuffersAdapter();
 184         testCommit();
 185     }
 186 };
 187
 188 BEAST_DEFINE_TESTSUITE(buffers_adapter,core,beast);
 189
 190 } // beast