]>
Commit | Line | Data |
---|---|---|
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 |