xrpld
Loading...
Searching...
No Matches
Buffer.cpp
1#include <xrpl/basics/Buffer.h>
2
3#include <xrpl/basics/Slice.h>
4
5#include <gtest/gtest.h>
6
7#include <array>
8#include <cstddef>
9#include <cstdint>
10#include <cstring>
11#include <type_traits>
12#include <utility>
13
14namespace xrpl::test {
15
18
19struct BufferTest : public ::testing::Test
20{
21 static constexpr auto kRandomData = std::to_array<std::uint8_t>({
22 0xa8, 0xa1, 0x38, 0x45, 0x23, 0xec, 0xe4, 0x23, 0x71, 0x6d, 0x2a,
23 0x18, 0xb4, 0x70, 0xcb, 0xf5, 0xac, 0x2d, 0x89, 0x4d, 0x19, 0x9c,
24 0xf0, 0x2c, 0x15, 0xd1, 0xf9, 0x9b, 0x66, 0xd2, 0x30, 0xd3,
25 });
26
27 static constexpr std::size_t kHalf = kRandomData.size() / 2;
28
29 static bool
30 sane(Buffer const& b)
31 {
32 if (b.empty())
33 return b.data() == nullptr;
34
35 return b.data() != nullptr;
36 }
37
50 static void
52 {
53 EXPECT_TRUE(sane(buf));
54 EXPECT_TRUE(buf.empty());
55 }
56
60 Buffer const whole{kRandomData.data(), kRandomData.size()};
61};
62
63TEST_F(BufferTest, default_constructed_is_empty)
64{
65 Buffer const b;
66
67 EXPECT_TRUE(sane(b));
68 EXPECT_TRUE(b.empty());
69 EXPECT_EQ(b.data(), nullptr);
70}
71
72TEST_F(BufferTest, zero_sized_construction_is_empty)
73{
74 Buffer const b{0};
75
76 EXPECT_TRUE(sane(b));
77 EXPECT_TRUE(b.empty());
78}
79
80TEST_F(BufferTest, alloc_grows_an_empty_buffer)
81{
82 Buffer b{0};
83 std::memcpy(b.alloc(kHalf), kRandomData.data(), kHalf);
84
85 EXPECT_TRUE(sane(b));
86 EXPECT_FALSE(b.empty());
87 EXPECT_EQ(b.size(), kHalf);
88 EXPECT_EQ(b, firstHalf);
89}
90
91TEST_F(BufferTest, sized_construction_reserves_without_filling)
92{
93 Buffer b{kHalf};
94
95 EXPECT_TRUE(sane(b));
96 EXPECT_FALSE(b.empty());
97 EXPECT_EQ(b.size(), kHalf);
98
99 std::memcpy(b.data(), kRandomData.data() + kHalf, kHalf);
100 EXPECT_EQ(b, secondHalf);
101}
102
103TEST_F(BufferTest, construction_copies_raw_memory)
104{
105 Buffer const b{kRandomData.data(), kRandomData.size()};
106
107 EXPECT_TRUE(sane(b));
108 EXPECT_FALSE(b.empty());
109 EXPECT_EQ(b.size(), kRandomData.size());
110 EXPECT_EQ(std::memcmp(b.data(), kRandomData.data(), b.size()), 0);
111}
112
113TEST_F(BufferTest, equality_compares_contents)
114{
115 // Uses EXPECT_TRUE rather than EXPECT_EQ/EXPECT_NE because the operators are what is under test
116 // here.
117 EXPECT_TRUE(emptyBuffer == emptyBuffer);
118 EXPECT_TRUE(firstHalf == firstHalf);
119
120 EXPECT_TRUE(emptyBuffer != firstHalf);
121 EXPECT_TRUE(firstHalf != secondHalf);
122 EXPECT_TRUE(secondHalf != whole);
123}
124
125TEST_F(BufferTest, copy_construction)
126{
127 Buffer const fromEmpty{emptyBuffer};
128 EXPECT_TRUE(sane(fromEmpty));
129 EXPECT_EQ(fromEmpty, emptyBuffer);
130
131 Buffer const fromNonEmpty{firstHalf};
132 EXPECT_TRUE(sane(fromNonEmpty));
133 EXPECT_EQ(fromNonEmpty, firstHalf);
134}
135
136TEST_F(BufferTest, copy_assignment)
137{
138 Buffer b{emptyBuffer};
139
140 // empty <- non-empty
141 b = secondHalf;
142 EXPECT_TRUE(sane(b));
143 EXPECT_EQ(b, secondHalf);
144
145 // non-empty <- non-empty of a different size
146 b = whole;
147 EXPECT_TRUE(sane(b));
148 EXPECT_EQ(b, whole);
149
150 // non-empty <- empty
151 b = emptyBuffer;
152 EXPECT_TRUE(sane(b));
153 EXPECT_EQ(b, emptyBuffer);
154}
155
156TEST_F(BufferTest, self_assignment_preserves_contents)
157{
158#ifdef __clang__
159#pragma clang diagnostic push
160#pragma clang diagnostic ignored "-Wself-assign-overloaded"
161#endif
162
163 Buffer emptyCopy{emptyBuffer};
164 emptyCopy = emptyCopy;
165 EXPECT_TRUE(sane(emptyCopy));
166 EXPECT_EQ(emptyCopy, emptyBuffer);
167
168 Buffer wholeCopy{whole};
169 wholeCopy = wholeCopy;
170 EXPECT_TRUE(sane(wholeCopy));
171 EXPECT_EQ(wholeCopy, whole);
172
173#ifdef __clang__
174#pragma clang diagnostic pop
175#endif
176}
177
178TEST_F(BufferTest, move_construct_from_empty)
179{
180 Buffer source;
181 Buffer const moved{std::move(source)};
182
183 checkEmptyAfterMove(source); // NOLINT(bugprone-use-after-move)
184 EXPECT_TRUE(sane(moved));
185 EXPECT_TRUE(moved.empty());
186}
187
188TEST_F(BufferTest, move_construct_from_non_empty)
189{
190 Buffer source{firstHalf};
191 Buffer const moved{std::move(source)};
192
193 checkEmptyAfterMove(source); // NOLINT(bugprone-use-after-move)
194 EXPECT_TRUE(sane(moved));
195 EXPECT_EQ(moved, firstHalf);
196}
197
198TEST_F(BufferTest, move_assign_empty_to_empty)
199{
200 Buffer target;
201 Buffer source;
202
203 target = std::move(source);
204
205 EXPECT_TRUE(sane(target));
206 EXPECT_TRUE(target.empty());
207 checkEmptyAfterMove(source); // NOLINT(bugprone-use-after-move)
208}
209
210TEST_F(BufferTest, move_assign_non_empty_to_empty)
211{
212 Buffer target;
213 Buffer source{firstHalf};
214
215 target = std::move(source);
216
217 EXPECT_TRUE(sane(target));
218 EXPECT_EQ(target, firstHalf);
219 checkEmptyAfterMove(source); // NOLINT(bugprone-use-after-move)
220}
221
222TEST_F(BufferTest, move_assign_empty_to_non_empty)
223{
224 Buffer target{firstHalf};
225 Buffer source;
226
227 target = std::move(source);
228
229 EXPECT_TRUE(sane(target));
230 EXPECT_TRUE(target.empty());
231 checkEmptyAfterMove(source); // NOLINT(bugprone-use-after-move)
232}
233
234TEST_F(BufferTest, move_assign_non_empty_to_non_empty)
235{
236 Buffer target{firstHalf};
237 Buffer sameSize{secondHalf};
238 Buffer largerSize{whole};
239
240 target = std::move(sameSize);
241 EXPECT_TRUE(sane(target));
242 EXPECT_EQ(target, secondHalf);
243 checkEmptyAfterMove(sameSize); // NOLINT(bugprone-use-after-move)
244
245 target = std::move(largerSize);
246 EXPECT_TRUE(sane(target));
247 EXPECT_EQ(target, whole);
248 checkEmptyAfterMove(largerSize); // NOLINT(bugprone-use-after-move)
249}
250
251TEST_F(BufferTest, construction_from_slice)
252{
253 Buffer const fromEmpty{static_cast<Slice>(emptyBuffer)};
254 EXPECT_TRUE(sane(fromEmpty));
255 EXPECT_EQ(fromEmpty, emptyBuffer);
256
257 Buffer const fromNonEmpty{static_cast<Slice>(whole)};
258 EXPECT_TRUE(sane(fromNonEmpty));
259 EXPECT_EQ(fromNonEmpty, whole);
260}
261
262TEST_F(BufferTest, assignment_from_slice)
263{
264 Buffer b;
265
266 // empty <- empty slice
267 b = static_cast<Slice>(emptyBuffer);
268 EXPECT_TRUE(sane(b));
269 EXPECT_EQ(b, emptyBuffer);
270
271 // empty <- non-empty slice
272 b = static_cast<Slice>(firstHalf);
273 EXPECT_TRUE(sane(b));
274 EXPECT_EQ(b, firstHalf);
275
276 // non-empty <- non-empty slice
277 b = static_cast<Slice>(secondHalf);
278 EXPECT_TRUE(sane(b));
279 EXPECT_EQ(b, secondHalf);
280
281 // non-empty <- empty slice
282 b = static_cast<Slice>(emptyBuffer);
283 EXPECT_TRUE(sane(b));
284 EXPECT_EQ(b, emptyBuffer);
285}
286
287TEST_F(BufferTest, resize_allocates_and_clear_releases)
288{
289 auto const check = [](Buffer const& original, std::size_t size) {
290 SCOPED_TRACE(::testing::Message() << "size: " << size);
291
292 Buffer b{original};
293
294 // Resizing to zero is equivalent to clearing.
295 b(size);
296 EXPECT_TRUE(sane(b));
297 EXPECT_EQ(b.size(), size);
298 EXPECT_EQ(b.data() == nullptr, size == 0);
299
300 b(size + 1);
301 EXPECT_TRUE(sane(b));
302 EXPECT_EQ(b.size(), size + 1);
303 EXPECT_NE(b.data(), nullptr);
304
305 b.clear();
306 EXPECT_TRUE(sane(b));
307 EXPECT_TRUE(b.empty());
308 EXPECT_EQ(b.data(), nullptr);
309
310 // clear() is idempotent.
311 b.clear();
312 EXPECT_TRUE(sane(b));
313 EXPECT_TRUE(b.empty());
314 EXPECT_EQ(b.data(), nullptr);
315 };
316
317 for (auto size = 0uz; size < kHalf; ++size)
318 {
319 check(emptyBuffer, size);
320 check(firstHalf, size);
321 }
322}
323
324TEST_F(BufferTest, fill_sets_every_byte)
325{
326 Buffer b{4};
327 b.fill(0xab);
328
329 EXPECT_EQ(b.size(), 4);
330 for (auto const byte : Slice{b})
331 EXPECT_EQ(byte, 0xab);
332}
333
334TEST_F(BufferTest, fill_overwrites_and_keeps_size)
335{
336 Buffer b{4};
337 b.fill(0xab);
338 b.fill(0x00);
339
340 EXPECT_EQ(b.size(), 4);
341 for (auto const byte : Slice{b})
342 EXPECT_EQ(byte, 0x00);
343}
344
345TEST_F(BufferTest, fill_on_empty_buffer_is_a_noop)
346{
347 Buffer empty;
348 empty.fill(0xff);
349
350 EXPECT_TRUE(empty.empty());
351 EXPECT_EQ(empty.data(), nullptr);
352}
353
354} // namespace xrpl::test
Like std::vector<char> but better.
Definition Buffer.h:19
bool empty() const noexcept
Definition Buffer.h:129
std::uint8_t * alloc(std::size_t n)
Reallocate the storage.
Definition Buffer.h:189
std::size_t size() const noexcept
Returns the number of bytes in the buffer.
Definition Buffer.h:123
std::uint8_t const * data() const noexcept
Return a pointer to beginning of the storage.
Definition Buffer.h:148
void clear() noexcept
Reset the buffer.
Definition Buffer.h:178
void fill(std::uint8_t value) noexcept
Set every byte in the buffer to the given value.
Definition Buffer.h:168
An immutable linear range of bytes.
Definition Slice.h:28
T is_nothrow_move_assignable_v
T is_nothrow_move_constructible_v
T memcmp(T... args)
T memcpy(T... args)
Check operations.
Definition check.h:18
TEST_F(BaseUintDeathTest, from_raw_size_mismatch)
Definition base_uint.cpp:73
static bool sane(Buffer const &b)
Definition Buffer.cpp:30
Buffer const firstHalf
Definition Buffer.cpp:58
static void checkEmptyAfterMove(Buffer const &buf)
Check the state Buffer documents for a moved-from buffer: "the other buffer is reset",...
Definition Buffer.cpp:51
Buffer const whole
Definition Buffer.cpp:60
Buffer const emptyBuffer
Definition Buffer.cpp:57
static constexpr std::size_t kHalf
Definition Buffer.cpp:27
Buffer const secondHalf
Definition Buffer.cpp:59
static constexpr auto kRandomData
Definition Buffer.cpp:21