Branch data Line data Source code
1 : : // Copyright (c) 2012-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <streams.h>
6 : : #include <test/util/random.h>
7 : : #include <test/util/setup_common.h>
8 : : #include <util/fs.h>
9 : : #include <util/strencodings.h>
10 : :
11 : : #include <boost/test/unit_test.hpp>
12 : :
13 : : using namespace std::string_literals;
14 : :
15 : 0 : BOOST_FIXTURE_TEST_SUITE(streams_tests, BasicTestingSetup)
16 : :
17 : 0 : BOOST_AUTO_TEST_CASE(xor_file)
18 : : {
19 : 0 : fs::path xor_path{m_args.GetDataDirBase() / "test_xor.bin"};
20 : 0 : auto raw_file{[&](const auto& mode) { return fsbridge::fopen(xor_path, mode); }};
21 : 0 : const std::vector<uint8_t> test1{1, 2, 3};
22 : 0 : const std::vector<uint8_t> test2{4, 5};
23 : 0 : const std::vector<std::byte> xor_pat{std::byte{0xff}, std::byte{0x00}};
24 : : {
25 : : // Check errors for missing file
26 : 0 : AutoFile xor_file{raw_file("rb"), xor_pat};
27 : 0 : BOOST_CHECK_EXCEPTION(xor_file << std::byte{}, std::ios_base::failure, HasReason{"AutoFile::write: file handle is nullpt"});
28 : 0 : BOOST_CHECK_EXCEPTION(xor_file >> std::byte{}, std::ios_base::failure, HasReason{"AutoFile::read: file handle is nullpt"});
29 : 0 : BOOST_CHECK_EXCEPTION(xor_file.ignore(1), std::ios_base::failure, HasReason{"AutoFile::ignore: file handle is nullpt"});
30 : 0 : }
31 : : {
32 : 0 : AutoFile xor_file{raw_file("wbx"), xor_pat};
33 : 0 : xor_file << test1 << test2;
34 : 0 : }
35 : : {
36 : : // Read raw from disk
37 : 0 : AutoFile non_xor_file{raw_file("rb")};
38 : 0 : std::vector<std::byte> raw(7);
39 : 0 : non_xor_file >> Span{raw};
40 : 0 : BOOST_CHECK_EQUAL(HexStr(raw), "fc01fd03fd04fa");
41 : : // Check that no padding exists
42 : 0 : BOOST_CHECK_EXCEPTION(non_xor_file.ignore(1), std::ios_base::failure, HasReason{"AutoFile::ignore: end of file"});
43 : 0 : }
44 : : {
45 : 0 : AutoFile xor_file{raw_file("rb"), xor_pat};
46 : 0 : std::vector<std::byte> read1, read2;
47 : 0 : xor_file >> read1 >> read2;
48 : 0 : BOOST_CHECK_EQUAL(HexStr(read1), HexStr(test1));
49 : 0 : BOOST_CHECK_EQUAL(HexStr(read2), HexStr(test2));
50 : : // Check that eof was reached
51 : 0 : BOOST_CHECK_EXCEPTION(xor_file >> std::byte{}, std::ios_base::failure, HasReason{"AutoFile::read: end of file"});
52 : 0 : }
53 : : {
54 : 0 : AutoFile xor_file{raw_file("rb"), xor_pat};
55 : 0 : std::vector<std::byte> read2;
56 : : // Check that ignore works
57 : 0 : xor_file.ignore(4);
58 : 0 : xor_file >> read2;
59 : 0 : BOOST_CHECK_EQUAL(HexStr(read2), HexStr(test2));
60 : : // Check that ignore and read fail now
61 : 0 : BOOST_CHECK_EXCEPTION(xor_file.ignore(1), std::ios_base::failure, HasReason{"AutoFile::ignore: end of file"});
62 : 0 : BOOST_CHECK_EXCEPTION(xor_file >> std::byte{}, std::ios_base::failure, HasReason{"AutoFile::read: end of file"});
63 : 0 : }
64 : 0 : }
65 : :
66 : 0 : BOOST_AUTO_TEST_CASE(streams_vector_writer)
67 : : {
68 : 0 : unsigned char a(1);
69 : 0 : unsigned char b(2);
70 : 0 : unsigned char bytes[] = { 3, 4, 5, 6 };
71 : 0 : std::vector<unsigned char> vch;
72 : :
73 : : // Each test runs twice. Serializing a second time at the same starting
74 : 0 : // point should yield the same results, even if the first test grew the
75 : : // vector.
76 : :
77 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 0, a, b};
78 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{1, 2}}));
79 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 0, a, b};
80 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{1, 2}}));
81 : 0 : vch.clear();
82 : :
83 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
84 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2}}));
85 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
86 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2}}));
87 : 0 : vch.clear();
88 : :
89 : 0 : vch.resize(5, 0);
90 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
91 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2, 0}}));
92 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
93 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2, 0}}));
94 : 0 : vch.clear();
95 : :
96 : 0 : vch.resize(4, 0);
97 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 3, a, b};
98 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 1, 2}}));
99 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 3, a, b};
100 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 1, 2}}));
101 : 0 : vch.clear();
102 : :
103 : 0 : vch.resize(4, 0);
104 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 4, a, b};
105 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 0, 1, 2}}));
106 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 4, a, b};
107 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 0, 1, 2}}));
108 : 0 : vch.clear();
109 : :
110 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 0, bytes};
111 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{3, 4, 5, 6}}));
112 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 0, bytes};
113 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{3, 4, 5, 6}}));
114 : 0 : vch.clear();
115 : :
116 : 0 : vch.resize(4, 8);
117 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, bytes, b};
118 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{8, 8, 1, 3, 4, 5, 6, 2}}));
119 : 0 : CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, bytes, b};
120 : 0 : BOOST_CHECK((vch == std::vector<unsigned char>{{8, 8, 1, 3, 4, 5, 6, 2}}));
121 : 0 : vch.clear();
122 : 0 : }
123 : :
124 : 0 : BOOST_AUTO_TEST_CASE(streams_vector_reader)
125 : : {
126 : 0 : std::vector<unsigned char> vch = {1, 255, 3, 4, 5, 6};
127 : :
128 : 0 : SpanReader reader{INIT_PROTO_VERSION, vch};
129 : 0 : BOOST_CHECK_EQUAL(reader.size(), 6U);
130 : 0 : BOOST_CHECK(!reader.empty());
131 : :
132 : : // Read a single byte as an unsigned char.
133 : : unsigned char a;
134 : 0 : reader >> a;
135 : 0 : BOOST_CHECK_EQUAL(a, 1);
136 : 0 : BOOST_CHECK_EQUAL(reader.size(), 5U);
137 : 0 : BOOST_CHECK(!reader.empty());
138 : :
139 : : // Read a single byte as a signed char.
140 : : signed char b;
141 : 0 : reader >> b;
142 : 0 : BOOST_CHECK_EQUAL(b, -1);
143 : 0 : BOOST_CHECK_EQUAL(reader.size(), 4U);
144 : 0 : BOOST_CHECK(!reader.empty());
145 : :
146 : : // Read a 4 bytes as an unsigned int.
147 : : unsigned int c;
148 : 0 : reader >> c;
149 : 0 : BOOST_CHECK_EQUAL(c, 100992003U); // 3,4,5,6 in little-endian base-256
150 : 0 : BOOST_CHECK_EQUAL(reader.size(), 0U);
151 : 0 : BOOST_CHECK(reader.empty());
152 : :
153 : : // Reading after end of byte vector throws an error.
154 : : signed int d;
155 : 0 : BOOST_CHECK_THROW(reader >> d, std::ios_base::failure);
156 : :
157 : : // Read a 4 bytes as a signed int from the beginning of the buffer.
158 : 0 : SpanReader new_reader{INIT_PROTO_VERSION, vch};
159 : 0 : new_reader >> d;
160 : 0 : BOOST_CHECK_EQUAL(d, 67370753); // 1,255,3,4 in little-endian base-256
161 : 0 : BOOST_CHECK_EQUAL(new_reader.size(), 2U);
162 : 0 : BOOST_CHECK(!new_reader.empty());
163 : :
164 : : // Reading after end of byte vector throws an error even if the reader is
165 : : // not totally empty.
166 : 0 : BOOST_CHECK_THROW(new_reader >> d, std::ios_base::failure);
167 : 0 : }
168 : :
169 : 0 : BOOST_AUTO_TEST_CASE(streams_vector_reader_rvalue)
170 : : {
171 : 0 : std::vector<uint8_t> data{0x82, 0xa7, 0x31};
172 : 0 : SpanReader reader{INIT_PROTO_VERSION, data};
173 : 0 : uint32_t varint = 0;
174 : : // Deserialize into r-value
175 : 0 : reader >> VARINT(varint);
176 : 0 : BOOST_CHECK_EQUAL(varint, 54321U);
177 : 0 : BOOST_CHECK(reader.empty());
178 : 0 : }
179 : :
180 : 0 : BOOST_AUTO_TEST_CASE(bitstream_reader_writer)
181 : : {
182 : 0 : DataStream data{};
183 : :
184 : 0 : BitStreamWriter bit_writer{data};
185 : 0 : bit_writer.Write(0, 1);
186 : 0 : bit_writer.Write(2, 2);
187 : 0 : bit_writer.Write(6, 3);
188 : 0 : bit_writer.Write(11, 4);
189 : 0 : bit_writer.Write(1, 5);
190 : 0 : bit_writer.Write(32, 6);
191 : 0 : bit_writer.Write(7, 7);
192 : 0 : bit_writer.Write(30497, 16);
193 : 0 : bit_writer.Flush();
194 : :
195 : 0 : DataStream data_copy{data};
196 : : uint32_t serialized_int1;
197 : 0 : data >> serialized_int1;
198 : 0 : BOOST_CHECK_EQUAL(serialized_int1, uint32_t{0x7700C35A}); // NOTE: Serialized as LE
199 : : uint16_t serialized_int2;
200 : 0 : data >> serialized_int2;
201 : 0 : BOOST_CHECK_EQUAL(serialized_int2, uint16_t{0x1072}); // NOTE: Serialized as LE
202 : :
203 : 0 : BitStreamReader bit_reader{data_copy};
204 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(1), 0U);
205 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(2), 2U);
206 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(3), 6U);
207 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(4), 11U);
208 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(5), 1U);
209 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(6), 32U);
210 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(7), 7U);
211 : 0 : BOOST_CHECK_EQUAL(bit_reader.Read(16), 30497U);
212 : 0 : BOOST_CHECK_THROW(bit_reader.Read(8), std::ios_base::failure);
213 : 0 : }
214 : :
215 : 0 : BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
216 : : {
217 : 0 : std::vector<std::byte> in;
218 : :
219 : : // Degenerate case
220 : : {
221 : 0 : DataStream ds{in};
222 : 0 : ds.Xor({0x00, 0x00});
223 : 0 : BOOST_CHECK_EQUAL(""s, ds.str());
224 : 0 : }
225 : :
226 : 0 : in.push_back(std::byte{0x0f});
227 : 0 : in.push_back(std::byte{0xf0});
228 : :
229 : : // Single character key
230 : : {
231 : 0 : DataStream ds{in};
232 : 0 : ds.Xor({0xff});
233 : 0 : BOOST_CHECK_EQUAL("\xf0\x0f"s, ds.str());
234 : 0 : }
235 : :
236 : : // Multi character key
237 : :
238 : 0 : in.clear();
239 : 0 : in.push_back(std::byte{0xf0});
240 : 0 : in.push_back(std::byte{0x0f});
241 : :
242 : : {
243 : 0 : DataStream ds{in};
244 : 0 : ds.Xor({0xff, 0x0f});
245 : 0 : BOOST_CHECK_EQUAL("\x0f\x00"s, ds.str());
246 : 0 : }
247 : 0 : }
248 : :
249 : 0 : BOOST_AUTO_TEST_CASE(streams_buffered_file)
250 : : {
251 : 0 : fs::path streams_test_filename = m_args.GetDataDirBase() / "streams_test_tmp";
252 : 0 : CAutoFile file{fsbridge::fopen(streams_test_filename, "w+b"), 333};
253 : :
254 : : // The value at each offset is the offset.
255 : 0 : for (uint8_t j = 0; j < 40; ++j) {
256 : 0 : file << j;
257 : 0 : }
258 : 0 : std::rewind(file.Get());
259 : :
260 : : // The buffer size (second arg) must be greater than the rewind
261 : : // amount (third arg).
262 : : try {
263 : 0 : BufferedFile bfbad{file, 25, 25};
264 : 0 : BOOST_CHECK(false);
265 : 0 : } catch (const std::exception& e) {
266 : 0 : BOOST_CHECK(strstr(e.what(),
267 : : "Rewind limit must be less than buffer size") != nullptr);
268 : 0 : }
269 : :
270 : : // The buffer is 25 bytes, allow rewinding 10 bytes.
271 : 0 : BufferedFile bf{file, 25, 10};
272 : 0 : BOOST_CHECK(!bf.eof());
273 : :
274 : : // This member has no functional effect.
275 : 0 : BOOST_CHECK_EQUAL(bf.GetVersion(), 333);
276 : :
277 : : uint8_t i;
278 : 0 : bf >> i;
279 : 0 : BOOST_CHECK_EQUAL(i, 0);
280 : 0 : bf >> i;
281 : 0 : BOOST_CHECK_EQUAL(i, 1);
282 : :
283 : : // After reading bytes 0 and 1, we're positioned at 2.
284 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 2U);
285 : :
286 : : // Rewind to offset 0, ok (within the 10 byte window).
287 : 0 : BOOST_CHECK(bf.SetPos(0));
288 : 0 : bf >> i;
289 : 0 : BOOST_CHECK_EQUAL(i, 0);
290 : :
291 : : // We can go forward to where we've been, but beyond may fail.
292 : 0 : BOOST_CHECK(bf.SetPos(2));
293 : 0 : bf >> i;
294 : 0 : BOOST_CHECK_EQUAL(i, 2);
295 : :
296 : : // If you know the maximum number of bytes that should be
297 : : // read to deserialize the variable, you can limit the read
298 : : // extent. The current file offset is 3, so the following
299 : : // SetLimit() allows zero bytes to be read.
300 : 0 : BOOST_CHECK(bf.SetLimit(3));
301 : : try {
302 : 0 : bf >> i;
303 : 0 : BOOST_CHECK(false);
304 : 0 : } catch (const std::exception& e) {
305 : 0 : BOOST_CHECK(strstr(e.what(),
306 : : "Attempt to position past buffer limit") != nullptr);
307 : 0 : }
308 : : // The default argument removes the limit completely.
309 : 0 : BOOST_CHECK(bf.SetLimit());
310 : : // The read position should still be at 3 (no change).
311 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 3U);
312 : :
313 : : // Read from current offset, 3, forward until position 10.
314 : 0 : for (uint8_t j = 3; j < 10; ++j) {
315 : 0 : bf >> i;
316 : 0 : BOOST_CHECK_EQUAL(i, j);
317 : 0 : }
318 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 10U);
319 : :
320 : : // We're guaranteed (just barely) to be able to rewind to zero.
321 : 0 : BOOST_CHECK(bf.SetPos(0));
322 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 0U);
323 : 0 : bf >> i;
324 : 0 : BOOST_CHECK_EQUAL(i, 0);
325 : :
326 : : // We can set the position forward again up to the farthest
327 : : // into the stream we've been, but no farther. (Attempting
328 : : // to go farther may succeed, but it's not guaranteed.)
329 : 0 : BOOST_CHECK(bf.SetPos(10));
330 : 0 : bf >> i;
331 : 0 : BOOST_CHECK_EQUAL(i, 10);
332 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 11U);
333 : :
334 : : // Now it's only guaranteed that we can rewind to offset 1
335 : : // (current read position, 11, minus rewind amount, 10).
336 : 0 : BOOST_CHECK(bf.SetPos(1));
337 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 1U);
338 : 0 : bf >> i;
339 : 0 : BOOST_CHECK_EQUAL(i, 1);
340 : :
341 : : // We can stream into large variables, even larger than
342 : : // the buffer size.
343 : 0 : BOOST_CHECK(bf.SetPos(11));
344 : : {
345 : : uint8_t a[40 - 11];
346 : 0 : bf >> a;
347 : 0 : for (uint8_t j = 0; j < sizeof(a); ++j) {
348 : 0 : BOOST_CHECK_EQUAL(a[j], 11 + j);
349 : 0 : }
350 : : }
351 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 40U);
352 : :
353 : : // We've read the entire file, the next read should throw.
354 : : try {
355 : 0 : bf >> i;
356 : 0 : BOOST_CHECK(false);
357 : 0 : } catch (const std::exception& e) {
358 : 0 : BOOST_CHECK(strstr(e.what(),
359 : : "BufferedFile::Fill: end of file") != nullptr);
360 : 0 : }
361 : : // Attempting to read beyond the end sets the EOF indicator.
362 : 0 : BOOST_CHECK(bf.eof());
363 : :
364 : : // Still at offset 40, we can go back 10, to 30.
365 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 40U);
366 : 0 : BOOST_CHECK(bf.SetPos(30));
367 : 0 : bf >> i;
368 : 0 : BOOST_CHECK_EQUAL(i, 30);
369 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 31U);
370 : :
371 : : // We're too far to rewind to position zero.
372 : 0 : BOOST_CHECK(!bf.SetPos(0));
373 : : // But we should now be positioned at least as far back as allowed
374 : : // by the rewind window (relative to our farthest read position, 40).
375 : 0 : BOOST_CHECK(bf.GetPos() <= 30U);
376 : :
377 : : // We can explicitly close the file, or the destructor will do it.
378 : 0 : file.fclose();
379 : :
380 : 0 : fs::remove(streams_test_filename);
381 : 0 : }
382 : :
383 : 0 : BOOST_AUTO_TEST_CASE(streams_buffered_file_skip)
384 : : {
385 : 0 : fs::path streams_test_filename = m_args.GetDataDirBase() / "streams_test_tmp";
386 : 0 : CAutoFile file{fsbridge::fopen(streams_test_filename, "w+b"), 333};
387 : : // The value at each offset is the byte offset (e.g. byte 1 in the file has the value 0x01).
388 : 0 : for (uint8_t j = 0; j < 40; ++j) {
389 : 0 : file << j;
390 : 0 : }
391 : 0 : std::rewind(file.Get());
392 : :
393 : : // The buffer is 25 bytes, allow rewinding 10 bytes.
394 : 0 : BufferedFile bf{file, 25, 10};
395 : :
396 : : uint8_t i;
397 : : // This is like bf >> (7-byte-variable), in that it will cause data
398 : : // to be read from the file into memory, but it's not copied to us.
399 : 0 : bf.SkipTo(7);
400 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 7U);
401 : 0 : bf >> i;
402 : 0 : BOOST_CHECK_EQUAL(i, 7);
403 : :
404 : : // The bytes in the buffer up to offset 7 are valid and can be read.
405 : 0 : BOOST_CHECK(bf.SetPos(0));
406 : 0 : bf >> i;
407 : 0 : BOOST_CHECK_EQUAL(i, 0);
408 : 0 : bf >> i;
409 : 0 : BOOST_CHECK_EQUAL(i, 1);
410 : :
411 : 0 : bf.SkipTo(11);
412 : 0 : bf >> i;
413 : 0 : BOOST_CHECK_EQUAL(i, 11);
414 : :
415 : : // SkipTo() honors the transfer limit; we can't position beyond the limit.
416 : 0 : bf.SetLimit(13);
417 : : try {
418 : 0 : bf.SkipTo(14);
419 : 0 : BOOST_CHECK(false);
420 : 0 : } catch (const std::exception& e) {
421 : 0 : BOOST_CHECK(strstr(e.what(), "Attempt to position past buffer limit") != nullptr);
422 : 0 : }
423 : :
424 : : // We can position exactly to the transfer limit.
425 : 0 : bf.SkipTo(13);
426 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), 13U);
427 : :
428 : 0 : file.fclose();
429 : 0 : fs::remove(streams_test_filename);
430 : 0 : }
431 : :
432 : 0 : BOOST_AUTO_TEST_CASE(streams_buffered_file_rand)
433 : : {
434 : : // Make this test deterministic.
435 : 0 : SeedInsecureRand(SeedRand::ZEROS);
436 : :
437 : 0 : fs::path streams_test_filename = m_args.GetDataDirBase() / "streams_test_tmp";
438 : 0 : for (int rep = 0; rep < 50; ++rep) {
439 : 0 : CAutoFile file{fsbridge::fopen(streams_test_filename, "w+b"), 333};
440 : 0 : size_t fileSize = InsecureRandRange(256);
441 : 0 : for (uint8_t i = 0; i < fileSize; ++i) {
442 : 0 : file << i;
443 : 0 : }
444 : 0 : std::rewind(file.Get());
445 : :
446 : 0 : size_t bufSize = InsecureRandRange(300) + 1;
447 : 0 : size_t rewindSize = InsecureRandRange(bufSize);
448 : 0 : BufferedFile bf{file, bufSize, rewindSize};
449 : 0 : size_t currentPos = 0;
450 : 0 : size_t maxPos = 0;
451 : 0 : for (int step = 0; step < 100; ++step) {
452 : 0 : if (currentPos >= fileSize)
453 : 0 : break;
454 : :
455 : : // We haven't read to the end of the file yet.
456 : 0 : BOOST_CHECK(!bf.eof());
457 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), currentPos);
458 : :
459 : : // Pretend the file consists of a series of objects of varying
460 : : // sizes; the boundaries of the objects can interact arbitrarily
461 : : // with the CBufferFile's internal buffer. These first three
462 : : // cases simulate objects of various sizes (1, 2, 5 bytes).
463 : 0 : switch (InsecureRandRange(6)) {
464 : : case 0: {
465 : : uint8_t a[1];
466 : 0 : if (currentPos + 1 > fileSize)
467 : 0 : continue;
468 : 0 : bf.SetLimit(currentPos + 1);
469 : 0 : bf >> a;
470 : 0 : for (uint8_t i = 0; i < 1; ++i) {
471 : 0 : BOOST_CHECK_EQUAL(a[i], currentPos);
472 : 0 : currentPos++;
473 : 0 : }
474 : 0 : break;
475 : : }
476 : : case 1: {
477 : : uint8_t a[2];
478 : 0 : if (currentPos + 2 > fileSize)
479 : 0 : continue;
480 : 0 : bf.SetLimit(currentPos + 2);
481 : 0 : bf >> a;
482 : 0 : for (uint8_t i = 0; i < 2; ++i) {
483 : 0 : BOOST_CHECK_EQUAL(a[i], currentPos);
484 : 0 : currentPos++;
485 : 0 : }
486 : 0 : break;
487 : : }
488 : : case 2: {
489 : : uint8_t a[5];
490 : 0 : if (currentPos + 5 > fileSize)
491 : 0 : continue;
492 : 0 : bf.SetLimit(currentPos + 5);
493 : 0 : bf >> a;
494 : 0 : for (uint8_t i = 0; i < 5; ++i) {
495 : 0 : BOOST_CHECK_EQUAL(a[i], currentPos);
496 : 0 : currentPos++;
497 : 0 : }
498 : 0 : break;
499 : : }
500 : : case 3: {
501 : : // SkipTo is similar to the "read" cases above, except
502 : : // we don't receive the data.
503 : 0 : size_t skip_length{static_cast<size_t>(InsecureRandRange(5))};
504 : 0 : if (currentPos + skip_length > fileSize) continue;
505 : 0 : bf.SetLimit(currentPos + skip_length);
506 : 0 : bf.SkipTo(currentPos + skip_length);
507 : 0 : currentPos += skip_length;
508 : 0 : break;
509 : : }
510 : : case 4: {
511 : : // Find a byte value (that is at or ahead of the current position).
512 : 0 : size_t find = currentPos + InsecureRandRange(8);
513 : 0 : if (find >= fileSize)
514 : 0 : find = fileSize - 1;
515 : 0 : bf.FindByte(std::byte(find));
516 : : // The value at each offset is the offset.
517 : 0 : BOOST_CHECK_EQUAL(bf.GetPos(), find);
518 : 0 : currentPos = find;
519 : :
520 : 0 : bf.SetLimit(currentPos + 1);
521 : : uint8_t i;
522 : 0 : bf >> i;
523 : 0 : BOOST_CHECK_EQUAL(i, currentPos);
524 : 0 : currentPos++;
525 : 0 : break;
526 : : }
527 : : case 5: {
528 : 0 : size_t requestPos = InsecureRandRange(maxPos + 4);
529 : 0 : bool okay = bf.SetPos(requestPos);
530 : : // The new position may differ from the requested position
531 : : // because we may not be able to rewind beyond the rewind
532 : : // window, and we may not be able to move forward beyond the
533 : : // farthest position we've reached so far.
534 : 0 : currentPos = bf.GetPos();
535 : 0 : BOOST_CHECK_EQUAL(okay, currentPos == requestPos);
536 : : // Check that we can position within the rewind window.
537 : 0 : if (requestPos <= maxPos &&
538 : 0 : maxPos > rewindSize &&
539 : 0 : requestPos >= maxPos - rewindSize) {
540 : : // We requested a position within the rewind window.
541 : 0 : BOOST_CHECK(okay);
542 : 0 : }
543 : 0 : break;
544 : : }
545 : : }
546 : 0 : if (maxPos < currentPos)
547 : 0 : maxPos = currentPos;
548 : 0 : }
549 : 0 : }
550 : 0 : fs::remove(streams_test_filename);
551 : 0 : }
552 : :
553 : 0 : BOOST_AUTO_TEST_CASE(streams_hashed)
554 : : {
555 : 0 : DataStream stream{};
556 : 0 : HashedSourceWriter hash_writer{stream};
557 : 0 : const std::string data{"bitcoin"};
558 : 0 : hash_writer << data;
559 : :
560 : 0 : HashVerifier hash_verifier{stream};
561 : 0 : std::string result;
562 : 0 : hash_verifier >> result;
563 : 0 : BOOST_CHECK_EQUAL(data, result);
564 : 0 : BOOST_CHECK_EQUAL(hash_writer.GetHash(), hash_verifier.GetHash());
565 : 0 : }
566 : :
567 : 0 : BOOST_AUTO_TEST_SUITE_END()
|
