ceph/src/Beast/test/core/dynabuf_readstream.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/dynabuf_readstream.hpp>
  10
  11 #include <beast/core/streambuf.hpp>
  12 #include <beast/test/fail_stream.hpp>
  13 #include <beast/test/string_istream.hpp>
  14 #include <beast/test/yield_to.hpp>
  15 #include <beast/unit_test/suite.hpp>
  16 #include <boost/asio.hpp>
  17
  18 namespace beast {
  19
  20 class dynabuf_readstream_test
  21     : public unit_test::suite
  22     , public test::enable_yield_to
  23 {
  24     using self = dynabuf_readstream_test;
  25
  26 public:
  27     void testSpecialMembers()
  28     {
  29         using socket_type = boost::asio::ip::tcp::socket;
  30         boost::asio::io_service ios;
  31         {
  32             dynabuf_readstream<socket_type, streambuf> srs(ios);
  33             dynabuf_readstream<socket_type, streambuf> srs2(std::move(srs));
  34             srs = std::move(srs2);
  35             BEAST_EXPECT(&srs.get_io_service() == &ios);
  36             BEAST_EXPECT(&srs.get_io_service() == &srs2.get_io_service());
  37         }
  38         {
  39             socket_type sock(ios);
  40             dynabuf_readstream<socket_type&, streambuf> srs(sock);
  41             dynabuf_readstream<socket_type&, streambuf> srs2(std::move(srs));
  42         }
  43     }
  44
  45     void testRead(yield_context do_yield)
  46     {
  47         using boost::asio::buffer;
  48         using boost::asio::buffer_copy;
  49         static std::size_t constexpr limit = 100;
  50         std::size_t n;
  51         std::string s;
  52         s.resize(13);
  53
  54         for(n = 0; n < limit; ++n)
  55         {
  56             test::fail_stream<
  57                 test::string_istream> fs(n, ios_, ", world!");
  58             dynabuf_readstream<
  59                 decltype(fs)&, streambuf> srs(fs);
  60             srs.buffer().commit(buffer_copy(
  61                 srs.buffer().prepare(5), buffer("Hello", 5)));
  62             error_code ec;
  63             boost::asio::read(srs, buffer(&s[0], s.size()), ec);
  64             if(! ec)
  65             {
  66                 BEAST_EXPECT(s == "Hello, world!");
  67                 break;
  68             }
  69         }
  70         BEAST_EXPECT(n < limit);
  71
  72         for(n = 0; n < limit; ++n)
  73         {
  74             test::fail_stream<
  75                 test::string_istream> fs(n, ios_, ", world!");
  76             dynabuf_readstream<
  77                 decltype(fs)&, streambuf> srs(fs);
  78             srs.capacity(3);
  79             srs.buffer().commit(buffer_copy(
  80                 srs.buffer().prepare(5), buffer("Hello", 5)));
  81             error_code ec;
  82             boost::asio::read(srs, buffer(&s[0], s.size()), ec);
  83             if(! ec)
  84             {
  85                 BEAST_EXPECT(s == "Hello, world!");
  86                 break;
  87             }
  88         }
  89         BEAST_EXPECT(n < limit);
  90
  91         for(n = 0; n < limit; ++n)
  92         {
  93             test::fail_stream<
  94                 test::string_istream> fs(n, ios_, ", world!");
  95             dynabuf_readstream<
  96                 decltype(fs)&, streambuf> srs(fs);
  97             srs.buffer().commit(buffer_copy(
  98                 srs.buffer().prepare(5), buffer("Hello", 5)));
  99             error_code ec;
 100             boost::asio::async_read(
 101                 srs, buffer(&s[0], s.size()), do_yield[ec]);
 102             if(! ec)
 103             {
 104                 BEAST_EXPECT(s == "Hello, world!");
 105                 break;
 106             }
 107         }
 108         BEAST_EXPECT(n < limit);
 109
 110         for(n = 0; n < limit; ++n)
 111         {
 112             test::fail_stream<
 113                 test::string_istream> fs(n, ios_, ", world!");
 114             dynabuf_readstream<
 115                 decltype(fs)&, streambuf> srs(fs);
 116             srs.capacity(3);
 117             srs.buffer().commit(buffer_copy(
 118                 srs.buffer().prepare(5), buffer("Hello", 5)));
 119             error_code ec;
 120             boost::asio::async_read(
 121                 srs, buffer(&s[0], s.size()), do_yield[ec]);
 122             if(! ec)
 123             {
 124                 BEAST_EXPECT(s == "Hello, world!");
 125                 break;
 126             }
 127         }
 128         BEAST_EXPECT(n < limit);
 129     }
 130
 131     void run() override
 132     {
 133         testSpecialMembers();
 134
 135         yield_to(&self::testRead, this);
 136     }
 137 };
 138
 139 BEAST_DEFINE_TESTSUITE(dynabuf_readstream,core,beast);
 140
 141 } // beast
 142