ceph/src/boost/libs/beast/test/beast/core/buffers_prefix.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_prefix.hpp>
  12
  13 #include <boost/beast/core/buffers_suffix.hpp>
  14 #include <boost/beast/core/type_traits.hpp>
  15 #include <boost/beast/unit_test/suite.hpp>
  16 #include <boost/asio/buffer.hpp>
  17 #include <string>
  18
  19 namespace boost {
  20 namespace beast {
  21
  22 BOOST_STATIC_ASSERT(
  23     std::is_same<boost::asio::const_buffer, decltype(
  24         buffers_prefix(0,
  25             std::declval<boost::asio::const_buffer>()))>::value);
  26
  27 BOOST_STATIC_ASSERT(
  28     boost::asio::is_const_buffer_sequence<decltype(
  29         buffers_prefix(0,
  30             std::declval<boost::asio::const_buffer>()))>::value);
  31
  32 BOOST_STATIC_ASSERT(
  33     std::is_same<boost::asio::mutable_buffer, decltype(
  34         buffers_prefix(0,
  35             std::declval<boost::asio::mutable_buffer>()))>::value);
  36
  37 class buffers_prefix_test : public beast::unit_test::suite
  38 {
  39 public:
  40     template<class ConstBufferSequence>
  41     static
  42     std::size_t
  43     bsize1(ConstBufferSequence const& bs)
  44     {
  45         using boost::asio::buffer_size;
  46         std::size_t n = 0;
  47         for(auto it = bs.begin(); it != bs.end(); ++it)
  48             n += buffer_size(*it);
  49         return n;
  50     }
  51
  52     template<class ConstBufferSequence>
  53     static
  54     std::size_t
  55     bsize2(ConstBufferSequence const& bs)
  56     {
  57         using boost::asio::buffer_size;
  58         std::size_t n = 0;
  59         for(auto it = bs.begin(); it != bs.end(); it++)
  60             n += buffer_size(*it);
  61         return n;
  62     }
  63
  64     template<class ConstBufferSequence>
  65     static
  66     std::size_t
  67     bsize3(ConstBufferSequence const& bs)
  68     {
  69         using boost::asio::buffer_size;
  70         std::size_t n = 0;
  71         for(auto it = bs.end(); it != bs.begin();)
  72             n += buffer_size(*--it);
  73         return n;
  74     }
  75
  76     template<class ConstBufferSequence>
  77     static
  78     std::size_t
  79     bsize4(ConstBufferSequence const& bs)
  80     {
  81         using boost::asio::buffer_size;
  82         std::size_t n = 0;
  83         for(auto it = bs.end(); it != bs.begin();)
  84         {
  85             it--;
  86             n += buffer_size(*it);
  87         }
  88         return n;
  89     }
  90
  91     template<class ConstBufferSequence>
  92     static
  93     std::string
  94     to_string(ConstBufferSequence const& bs)
  95     {
  96         std::string s;
  97         s.reserve(buffer_size(bs));
  98         for(auto b : beast::detail::buffers_range(bs))
  99             s.append(reinterpret_cast<char const*>(b.data()),
 100                 b.size());
 101         return s;
 102     }
 103
 104     template<class BufferType>
 105     void testMatrix()
 106     {
 107         using boost::asio::buffer_size;
 108         std::string s = "Hello, world";
 109         BEAST_EXPECT(s.size() == 12);
 110         for(std::size_t x = 1; x < 4; ++x) {
 111         for(std::size_t y = 1; y < 4; ++y) {
 112         std::size_t z = s.size() - (x + y);
 113         {
 114             std::array<BufferType, 3> bs{{
 115                 BufferType{&s[0], x},
 116                 BufferType{&s[x], y},
 117                 BufferType{&s[x+y], z}}};
 118             for(std::size_t i = 0; i <= s.size() + 1; ++i)
 119             {
 120                 auto pb = buffers_prefix(i, bs);
 121                 BEAST_EXPECT(to_string(pb) == s.substr(0, i));
 122                 auto pb2 = pb;
 123                 BEAST_EXPECT(to_string(pb2) == to_string(pb));
 124                 pb = buffers_prefix(0, bs);
 125                 pb2 = pb;
 126                 BEAST_EXPECT(buffer_size(pb2) == 0);
 127                 pb2 = buffers_prefix(i, bs);
 128                 BEAST_EXPECT(to_string(pb2) == s.substr(0, i));
 129             }
 130         }
 131         }}
 132     }
 133
 134     void testEmptyBuffers()
 135     {
 136         using boost::asio::buffer_copy;
 137         using boost::asio::buffer_size;
 138         using boost::asio::mutable_buffer;
 139         auto pb0 = buffers_prefix(0, mutable_buffer{});
 140         BEAST_EXPECT(buffer_size(pb0) == 0);
 141         auto pb1 = buffers_prefix(1, mutable_buffer{});
 142         BEAST_EXPECT(buffer_size(pb1) == 0);
 143         BEAST_EXPECT(buffer_copy(pb0, pb1) == 0);
 144
 145         using pb_type = decltype(pb0);
 146         buffers_suffix<pb_type> cb(pb0);
 147         BEAST_EXPECT(buffer_size(cb) == 0);
 148         BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
 149         cb.consume(1);
 150         BEAST_EXPECT(buffer_size(cb) == 0);
 151         BEAST_EXPECT(buffer_copy(cb, pb1) == 0);
 152
 153         auto pbc = buffers_prefix(2, cb);
 154         BEAST_EXPECT(buffer_size(pbc) == 0);
 155         BEAST_EXPECT(buffer_copy(pbc, cb) == 0);
 156     }
 157
 158     void testIterator()
 159     {
 160         using boost::asio::buffer_size;
 161         using boost::asio::const_buffer;
 162         char b[3];
 163         std::array<const_buffer, 3> bs{{
 164             const_buffer{&b[0], 1},
 165             const_buffer{&b[1], 1},
 166             const_buffer{&b[2], 1}}};
 167         auto pb = buffers_prefix(2, bs);
 168         BEAST_EXPECT(bsize1(pb) == 2);
 169         BEAST_EXPECT(bsize2(pb) == 2);
 170         BEAST_EXPECT(bsize3(pb) == 2);
 171         BEAST_EXPECT(bsize4(pb) == 2);
 172     }
 173
 174     void run() override
 175     {
 176         testMatrix<boost::asio::const_buffer>();
 177         testMatrix<boost::asio::mutable_buffer>();
 178         testEmptyBuffers();
 179         testIterator();
 180     }
 181 };
 182
 183 BEAST_DEFINE_TESTSUITE(beast,core,buffers_prefix);
 184
 185 } // beast
 186 } // boost