xrpld
Toggle main menu visibility
Loading...
Searching...
No Matches
tests
libxrpl
basics
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
14
namespace
xrpl::test
{
15
16
static_assert
(
std::is_nothrow_move_constructible_v<Buffer>
);
17
static_assert
(
std::is_nothrow_move_assignable_v<Buffer>
);
18
19
struct
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
51
checkEmptyAfterMove
(
Buffer
const
& buf)
52
{
53
EXPECT_TRUE(
sane
(buf));
54
EXPECT_TRUE(buf.
empty
());
55
}
56
57
Buffer
const
emptyBuffer
;
58
Buffer
const
firstHalf
{
kRandomData
.data(),
kHalf
};
59
Buffer
const
secondHalf
{
kRandomData
.data() +
kHalf
,
kHalf
};
60
Buffer
const
whole
{
kRandomData
.data(),
kRandomData
.size()};
61
};
62
63
TEST_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
72
TEST_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
80
TEST_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
91
TEST_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
103
TEST_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
113
TEST_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
125
TEST_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
136
TEST_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
156
TEST_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
178
TEST_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
188
TEST_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
198
TEST_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
210
TEST_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
222
TEST_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
234
TEST_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
251
TEST_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
262
TEST_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
287
TEST_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
324
TEST_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
334
TEST_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
345
TEST_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
array
xrpl::Buffer
Like std::vector<char> but better.
Definition
Buffer.h:19
xrpl::Buffer::empty
bool empty() const noexcept
Definition
Buffer.h:129
xrpl::Buffer::alloc
std::uint8_t * alloc(std::size_t n)
Reallocate the storage.
Definition
Buffer.h:189
xrpl::Buffer::size
std::size_t size() const noexcept
Returns the number of bytes in the buffer.
Definition
Buffer.h:123
xrpl::Buffer::data
std::uint8_t const * data() const noexcept
Return a pointer to beginning of the storage.
Definition
Buffer.h:148
xrpl::Buffer::clear
void clear() noexcept
Reset the buffer.
Definition
Buffer.h:178
xrpl::Buffer::fill
void fill(std::uint8_t value) noexcept
Set every byte in the buffer to the given value.
Definition
Buffer.h:168
xrpl::Slice
An immutable linear range of bytes.
Definition
Slice.h:28
cstddef
cstdint
cstring
std::is_nothrow_move_assignable_v
T is_nothrow_move_assignable_v
std::is_nothrow_move_constructible_v
T is_nothrow_move_constructible_v
std::memcmp
T memcmp(T... args)
std::memcpy
T memcpy(T... args)
xrpl::test::jtx::check
Check operations.
Definition
check.h:18
xrpl::test
Definition
STLedgerEntry.h:21
xrpl::test::TEST_F
TEST_F(BaseUintDeathTest, from_raw_size_mismatch)
Definition
base_uint.cpp:73
std::size_t
xrpl::test::BufferTest
Definition
Buffer.cpp:20
xrpl::test::BufferTest::sane
static bool sane(Buffer const &b)
Definition
Buffer.cpp:30
xrpl::test::BufferTest::firstHalf
Buffer const firstHalf
Definition
Buffer.cpp:58
xrpl::test::BufferTest::checkEmptyAfterMove
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
xrpl::test::BufferTest::whole
Buffer const whole
Definition
Buffer.cpp:60
xrpl::test::BufferTest::emptyBuffer
Buffer const emptyBuffer
Definition
Buffer.cpp:57
xrpl::test::BufferTest::kHalf
static constexpr std::size_t kHalf
Definition
Buffer.cpp:27
xrpl::test::BufferTest::secondHalf
Buffer const secondHalf
Definition
Buffer.cpp:59
xrpl::test::BufferTest::kRandomData
static constexpr auto kRandomData
Definition
Buffer.cpp:21
type_traits
utility
Generated by
1.17.0