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

   1 //
   2 // Copyright (c) 2016-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 // 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 "buffer_test.hpp"
  14
  15 #include <boost/beast/core/buffers_cat.hpp>
  16 #include <boost/beast/core/ostream.hpp>
  17 #include <boost/beast/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     template<class BufferSequence>
  28     static
  29     buffers_suffix<BufferSequence>
  30     consumed_buffers(BufferSequence const& bs, std::size_t n)
  31     {
  32         buffers_suffix<BufferSequence> cb(bs);
  33         cb.consume(n);
  34         return cb;
  35     }
  36
  37     template<class Buffers1, class Buffers2>
  38     static
  39     bool
  40     eq(Buffers1 const& lhs, Buffers2 const& rhs)
  41     {
  42         using namespace test;
  43         return to_string(lhs) == to_string(rhs);
  44     }
  45
  46     template<class ConstBufferSequence>
  47     void
  48     expect_size(std::size_t n, ConstBufferSequence const& buffers)
  49     {
  50         BEAST_EXPECT(test::size_pre(buffers) == n);
  51         BEAST_EXPECT(test::size_post(buffers) == n);
  52         BEAST_EXPECT(test::size_rev_pre(buffers) == n);
  53         BEAST_EXPECT(test::size_rev_post(buffers) == n);
  54     }
  55
  56     void
  57     testMembers()
  58     {
  59         char buf[12];
  60         buffers_suffix<
  61             boost::asio::const_buffer> cb1{
  62                 boost::in_place_init, buf, sizeof(buf)};
  63         buffers_suffix<
  64             boost::asio::const_buffer> cb2{
  65                 boost::in_place_init, nullptr, 0};
  66         cb2 = cb1;
  67         cb1 = std::move(cb2);
  68     }
  69
  70     void
  71     testMatrix()
  72     {
  73         using namespace test;
  74         using boost::asio::buffer;
  75         using boost::asio::const_buffer;
  76         char buf[12];
  77         std::string const s = "Hello, world";
  78         BEAST_EXPECT(s.size() == sizeof(buf));
  79         buffer_copy(buffer(buf), buffer(s));
  80         BEAST_EXPECT(to_string(buffer(buf)) == s);
  81         for(std::size_t i = 1; i < 4; ++i) {
  82         for(std::size_t j = 1; j < 4; ++j) {
  83         for(std::size_t x = 1; x < 4; ++x) {
  84         for(std::size_t y = 1; y < 4; ++y) {
  85         std::size_t k = sizeof(buf) - (i + j);
  86         std::size_t z = sizeof(buf) - (x + y);
  87         {
  88             std::array<const_buffer, 3> bs{{
  89                 const_buffer{&buf[0], i},
  90                 const_buffer{&buf[i], j},
  91                 const_buffer{&buf[i+j], k}}};
  92             buffers_suffix<decltype(bs)> cb(bs);
  93             BEAST_EXPECT(to_string(cb) == s);
  94             expect_size(s.size(), cb);
  95             cb.consume(0);
  96             BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0)));
  97             BEAST_EXPECT(to_string(cb) == s);
  98             expect_size(s.size(), cb);
  99             cb.consume(x);
 100             BEAST_EXPECT(to_string(cb) == s.substr(x));
 101             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x)));
 102             cb.consume(y);
 103             BEAST_EXPECT(to_string(cb) == s.substr(x+y));
 104             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y)));
 105             cb.consume(z);
 106             BEAST_EXPECT(to_string(cb) == "");
 107             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
 108             cb.consume(1);
 109             BEAST_EXPECT(to_string(cb) == "");
 110             BEAST_EXPECT(eq(cb, consumed_buffers(bs, x+y+z)));
 111         }
 112         }}}}
 113     }
 114
 115     void
 116     testDefaultCtor()
 117     {
 118         using namespace test;
 119         class test_buffer : public boost::asio::const_buffer
 120         {
 121         public:
 122             test_buffer()
 123                 : boost::asio::const_buffer("\r\n", 2)
 124             {
 125             }
 126         };
 127
 128         buffers_suffix<test_buffer> cb;
 129         BEAST_EXPECT(to_string(cb) == "\r\n");
 130     }
 131
 132     void
 133     testInPlace()
 134     {
 135         using namespace test;
 136         buffers_suffix<buffers_cat_view<
 137             boost::asio::const_buffer,
 138             boost::asio::const_buffer>> cb(
 139                 boost::in_place_init,
 140                     boost::asio::const_buffer("\r", 1),
 141                     boost::asio::const_buffer("\n", 1));
 142         BEAST_EXPECT(to_string(cb) == "\r\n");
 143     }
 144
 145     void
 146     testNullBuffers()
 147     {
 148         using boost::asio::buffer_copy;
 149         using boost::asio::buffer_size;
 150         using boost::asio::null_buffers;
 151         buffers_suffix<null_buffers> cb(
 152             null_buffers{});
 153         BEAST_EXPECT(buffer_size(cb) == 0);
 154         buffers_suffix<null_buffers> cb2(
 155             null_buffers{});
 156         BEAST_EXPECT(buffer_copy(cb2, cb) == 0);
 157     }
 158
 159     void
 160     testIterator()
 161     {
 162         using boost::asio::const_buffer;
 163         std::array<const_buffer, 3> ba;
 164         buffers_suffix<decltype(ba)> cb(ba);
 165         std::size_t n = 0;
 166         for(auto it = cb.end(); it != cb.begin(); --it)
 167             ++n;
 168         BEAST_EXPECT(n == 3);
 169     }
 170
 171     void run() override
 172     {
 173         testMembers();
 174         testMatrix();
 175         testDefaultCtor();
 176         testInPlace();
 177         testNullBuffers();
 178         testIterator();
 179     }
 180 };
 181
 182 BEAST_DEFINE_TESTSUITE(beast,core,buffers_suffix);
 183
 184 } // beast
 185 } // boost