[ceph.git] / ceph / src / Beast / test / core / static_streambuf.cpp

//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

// Test that header file is self-contained.
#include <beast/core/static_streambuf.hpp>

#include <beast/unit_test/suite.hpp>
#include <boost/asio/buffer.hpp>
#include <string>

namespace beast {

class static_streambuf_test : public beast::unit_test::suite
{
public:
    template<class ConstBufferSequence>
    static
    std::string
    to_string(ConstBufferSequence const& bs)
    {
        using boost::asio::buffer_cast;
        using boost::asio::buffer_size;
        std::string s;
        s.reserve(buffer_size(bs));
        for(auto const& b : bs)
            s.append(buffer_cast<char const*>(b),
                buffer_size(b));
        return s;
    }

    void testStaticStreambuf()
    {
        using boost::asio::buffer;
        using boost::asio::buffer_cast;
        using boost::asio::buffer_size;
        char buf[12];
        std::string const s = "Hello, world";
        BEAST_EXPECT(s.size() == sizeof(buf));
        for(std::size_t i = 1; i < 4; ++i) {
        for(std::size_t j = 1; j < 4; ++j) {
        for(std::size_t x = 1; x < 4; ++x) {
        for(std::size_t y = 1; y < 4; ++y) {
        for(std::size_t t = 1; t < 4; ++ t) {
        for(std::size_t u = 1; u < 4; ++ u) {
        std::size_t z = sizeof(buf) - (x + y);
        std::size_t v = sizeof(buf) - (t + u);
        {
            std::memset(buf, 0, sizeof(buf));
            static_streambuf_n<sizeof(buf)> ba;
            {
                auto d = ba.prepare(z);
                BEAST_EXPECT(buffer_size(d) == z);
            }
            {
                auto d = ba.prepare(0);
                BEAST_EXPECT(buffer_size(d) == 0);
            }
            {
                auto d = ba.prepare(y);
                BEAST_EXPECT(buffer_size(d) == y);
            }
            {
                auto d = ba.prepare(x);
                BEAST_EXPECT(buffer_size(d) == x);
                ba.commit(buffer_copy(d, buffer(s.data(), x)));
            }
            BEAST_EXPECT(ba.size() == x);
            BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
            {
                auto d = ba.prepare(x);
                BEAST_EXPECT(buffer_size(d) == x);
            }
            {
                auto d = ba.prepare(0);
                BEAST_EXPECT(buffer_size(d) == 0);
            }
            {
                auto d = ba.prepare(z);
                BEAST_EXPECT(buffer_size(d) == z);
            }
            {
                auto d = ba.prepare(y);
                BEAST_EXPECT(buffer_size(d) == y);
                ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
            }
            ba.commit(1);
            BEAST_EXPECT(ba.size() == x + y);
            BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
            {
                auto d = ba.prepare(x);
                BEAST_EXPECT(buffer_size(d) == x);
            }
            {
                auto d = ba.prepare(y);
                BEAST_EXPECT(buffer_size(d) == y);
            }
            {
                auto d = ba.prepare(0);
                BEAST_EXPECT(buffer_size(d) == 0);
            }
            {
                auto d = ba.prepare(z);
                BEAST_EXPECT(buffer_size(d) == z);
                ba.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
            }
            ba.commit(2);
            BEAST_EXPECT(ba.size() == x + y + z);
            BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
            BEAST_EXPECT(to_string(ba.data()) == s);
            ba.consume(t);
            {
                auto d = ba.prepare(0);
                BEAST_EXPECT(buffer_size(d) == 0);
            }
            BEAST_EXPECT(to_string(ba.data()) == s.substr(t, std::string::npos));
            ba.consume(u);
            BEAST_EXPECT(to_string(ba.data()) == s.substr(t + u, std::string::npos));
            ba.consume(v);
            BEAST_EXPECT(to_string(ba.data()) == "");
            ba.consume(1);
            {
                auto d = ba.prepare(0);
                BEAST_EXPECT(buffer_size(d) == 0);
            }
            try
            {
                ba.prepare(1);
                fail();
            }
            catch(...)
            {
                pass();
            }
        }
        }}}}}}
    }

    void testIterators()
    {
        static_streambuf_n<2> ba;
        {
            auto mb = ba.prepare(2);
            std::size_t n;
            n = 0;
            for(auto it = mb.begin();
                    it != mb.end(); it++)
                ++n;
            BEAST_EXPECT(n == 1);
            mb = ba.prepare(2);
            n = 0;
            for(auto it = mb.begin();
                    it != mb.end(); ++it)
                ++n;
            BEAST_EXPECT(n == 1);
            mb = ba.prepare(2);
            n = 0;
            for(auto it = mb.end();
                    it != mb.begin(); it--)
                ++n;
            BEAST_EXPECT(n == 1);
            mb = ba.prepare(2);
            n = 0;
            for(auto it = mb.end();
                    it != mb.begin(); --it)
                ++n;
            BEAST_EXPECT(n == 1);
        }
        ba.prepare(2);
        ba.commit(1);
        std::size_t n;
        n = 0;
        for(auto it = ba.data().begin();
                it != ba.data().end(); it++)
            ++n;
        BEAST_EXPECT(n == 1);
        n = 0;
        for(auto it = ba.data().begin();
                it != ba.data().end(); ++it)
            ++n;
        BEAST_EXPECT(n == 1);
        n = 0;
        for(auto it = ba.data().end();
                it != ba.data().begin(); it--)
            ++n;
        BEAST_EXPECT(n == 1);
        n = 0;
        for(auto it = ba.data().end();
                it != ba.data().begin(); --it)
            ++n;
        BEAST_EXPECT(n == 1);
    }

    void run() override
    {
        testStaticStreambuf();
        testIterators();
    }
};

BEAST_DEFINE_TESTSUITE(static_streambuf,core,beast);

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