29:I[49813,["/_next/static/chunks/3z--bwudlglfp.js","/_next/static/chunks/2u04xn-9yg2co.js","/_next/static/chunks/1b5-8ftwqgmtb.js","/_next/static/chunks/3nqo6bdos11l6.js","/_next/static/chunks/0fz0mlrjifmq7.js","/_next/static/chunks/2l43yyot7shmw.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/2ziic7alkvd8r.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2a:Te244,/** * Copyright (c) 2011-2026 libbitcoin developers * * This file is part of libbitcoin. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ #include "../../test.hpp" #include BOOST_AUTO_TEST_SUITE(stream_tests) BC_PUSH_WARNING(NO_CASTS_FOR_ARITHMETIC_CONVERSION) BOOST_AUTO_TEST_CASE(byte_reader__construct__default__default_resource) { const data_chunk data{}; stream::in::fast stream(data); read::bytes::fast source(stream); BOOST_REQUIRE_EQUAL(source.get_arena(), test::get_default_resource()); BOOST_REQUIRE_EQUAL(source.get_arena(), source.get_allocator().resource()); } BOOST_AUTO_TEST_CASE(byte_reader__construct__arena__assigned_resource) { const data_chunk data{}; stream::in::fast stream(data); auto arena = test::get_test_resource(); read::bytes::fast source(stream, arena); BOOST_REQUIRE_EQUAL(source.get_arena(), arena); } BOOST_AUTO_TEST_CASE(byte_reader__constructor__arena_reader__success) { const auto genesis = settings(chain::selection::mainnet).genesis_block; const auto data = genesis.to_data(true); stream::in::fast stream(data); read::bytes::fast source(stream, test::get_test_resource()); const chain::block block(source, true); BOOST_REQUIRE(block.is_valid()); } // Failed get/peek reads are populated with 0x00 by the reader. constexpr uint8_t pad = 0x00; #define BYTE_READER_CONTEXT #define BYTE_READER_BIG_ENDIAN #define BYTE_READER_LITTLE_ENDIAN #define BYTE_READER_BYTES #define BYTE_READER_STRINGS #ifdef BYTE_READER_CONTEXT // bool BOOST_AUTO_TEST_CASE(byte_reader__bool__stream_default__true) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__bool__not_empty__true) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__bool__stream_end__true) { std::istringstream stream{ "*" }; stream.get(); read::bytes::istream reader(stream); BOOST_REQUIRE(reader); } // !bool BOOST_AUTO_TEST_CASE(byte_reader__not_bool__stream_invalid__true) { std::istringstream stream{ "*" }; stream.get(); stream.get(); read::bytes::istream reader(stream); BOOST_REQUIRE(!reader); } // is_exhausted BOOST_AUTO_TEST_CASE(byte_reader__is_exhausted__default__true) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(stream); } BOOST_AUTO_TEST_CASE(byte_reader__is_exhausted__not_empty__false) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); BOOST_REQUIRE(!reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__is_exhausted__end__true) { std::istringstream stream{ "*" }; stream.get(); read::bytes::istream reader(stream); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__is_exhausted__invalid__true) { std::istringstream stream{ "*" }; stream.get(); stream.get(); read::bytes::istream reader(stream); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__is_exhausted__valid__does_not_change_state) { std::istringstream stream; read::bytes::istream reader(stream); const auto state = stream.rdstate(); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE_EQUAL(stream.rdstate(), state); BOOST_REQUIRE(stream); } BOOST_AUTO_TEST_CASE(byte_reader__is_exhausted__invalid__does_not_change_state) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); stream.get(); stream.get(); const auto state = stream.rdstate(); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE_EQUAL(stream.rdstate(), state); BOOST_REQUIRE(!stream); } // invalidate BOOST_AUTO_TEST_CASE(byte_reader__invalidate__empty__exhausts_reader) { std::istringstream stream; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__invalidate__empty__invalid) { std::istringstream stream; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__invalidate__not_empty__stream_invalid) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(!stream); } // skip BOOST_AUTO_TEST_CASE(byte_reader__skip_byte__default_empty__invalid) { std::istringstream stream; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__skip_byte__default_single__exhausted) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__skip_bytes__end__exhausted) { constexpr auto size = 42; std::istringstream stream{ std::string(size, 0x00) }; read::bytes::istream reader(stream); reader.skip_bytes(size); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__skip_bytes__past_end__invalid) { constexpr auto size = 42; std::istringstream stream{ std::string(size, 0x00) }; read::bytes::istream reader(stream); reader.skip_bytes(add1(size)); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__skip_variable__empty__invalid) { std::istringstream stream; read::bytes::istream reader(stream); reader.skip_variable(); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__skip_variable__one_end__exhausted) { const std::string value{ 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); reader.skip_variable(); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__skip_variable__two_end__exhausted) { const std::string value{ static_cast(varint_two_bytes), 0x01, 0x02 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); reader.skip_variable(); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__skip_variable__four_end__exhausted) { const std::string value{ static_cast(varint_four_bytes), 0x01, 0x02, 0x03, 0x04 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); reader.skip_variable(); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__skip_variable__eight_end__exhausted) { const std::string value{ static_cast(varint_eight_bytes), 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); reader.skip_variable(); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__skip_variable__eight_from_nine__expected) { constexpr auto expected = 42; const std::string value{ static_cast(varint_eight_bytes), 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, expected }; std::istringstream stream{ value }; read::bytes::istream reader(stream); reader.skip_variable(); BOOST_REQUIRE_EQUAL(reader.read_byte(), expected); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } // rewind BOOST_AUTO_TEST_CASE(byte_reader__rewind__default_single__expected) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); BOOST_REQUIRE(reader.is_exhausted()); reader.rewind_byte(); BOOST_REQUIRE(!reader.is_exhausted()); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__rewind__skip_to_end_rewind_to_middle__expected) { constexpr auto size = 42; const std::string value(size, 0x00); std::istringstream stream{ value + "*" + value }; read::bytes::istream reader(stream); reader.skip_bytes(size); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); reader.skip_bytes(size); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); reader.rewind_bytes(add1(size)); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__rewind__past_begin__invalid) { constexpr auto size = 42; std::istringstream stream{ std::string(size, 0x00) }; read::bytes::istream reader(stream); reader.skip_bytes(size); reader.rewind_bytes(add1(size)); BOOST_REQUIRE(!reader); } // get_read_position/set_position BOOST_AUTO_TEST_CASE(byte_reader__get_read_position__read_and_reset__expected) { std::istringstream stream{ "*" }; read::bytes::istream reader(stream); const auto position = reader.get_read_position(); BOOST_REQUIRE(!reader.is_exhausted()); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); BOOST_REQUIRE(reader.is_exhausted()); reader.set_position(position); BOOST_REQUIRE(!reader.is_exhausted()); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__get_read_position__skip_to_end_set_to_middle__expected) { constexpr auto size = 42; const std::string value(size, 0x00); std::istringstream stream{ value + "*" + value }; read::bytes::istream reader(stream); reader.skip_bytes(size); const auto position = reader.get_read_position(); BOOST_REQUIRE(!reader.is_exhausted()); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); reader.skip_bytes(size); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); reader.set_position(position); BOOST_REQUIRE_EQUAL(reader.read_byte(), '*'); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__set_position__empty__valid) { std::istringstream stream{}; read::bytes::istream reader(stream); reader.set_position(0); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); reader.read_byte(); BOOST_REQUIRE(!reader); reader.set_position(0); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__set_position__past_end__invalid) { constexpr auto size = 42; std::istringstream stream{ std::string(size, 0x00) }; read::bytes::istream reader(stream); reader.set_position(sub1(size)); BOOST_REQUIRE(!reader.is_exhausted()); reader.set_position(add1(size)); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__set_position__invalid__clears) { constexpr auto size = 42; std::istringstream stream{ std::string(size, 0x42) }; read::bytes::istream reader(stream); reader.set_position(add1(size)); BOOST_REQUIRE(!reader); reader.set_position(sub1(size)); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.read_byte(), 0x42u); BOOST_REQUIRE(reader.is_exhausted()); } BOOST_AUTO_TEST_CASE(byte_reader__set_limit__default__unlimited) { constexpr auto size = 42; std::istringstream stream{ std::string(size, 0x42) }; read::bytes::istream reader(stream); reader.set_limit(); reader.set_position(sub1(size)); BOOST_REQUIRE_EQUAL(reader.read_byte(), 0x42u); BOOST_REQUIRE(reader.is_exhausted()); } // set_position back tests both set_position and rewind. BOOST_AUTO_TEST_CASE(byte_reader__set_limit__set_position_back__limited) { std::istringstream stream{ "abcde" }; read::bytes::istream reader(stream); // Read to position 1. BOOST_REQUIRE_EQUAL(reader.get_read_position(), 0u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'a'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 1u); // Position is 1, set limit +2 (to absolute 3). reader.set_limit(2); // Read to limit and verify. BOOST_REQUIRE_EQUAL(reader.get_read_position(), 1u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'b'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 2u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'c'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 3u); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); // Peek past limit invalidates. BOOST_REQUIRE_EQUAL(reader.peek_byte(), 0x00u); BOOST_REQUIRE(!reader); // Reset absolute position to 1 and clear invalid state. reader.set_position(1); BOOST_REQUIRE(!reader.is_exhausted()); BOOST_REQUIRE(reader); // Read to limit and verify. BOOST_REQUIRE_EQUAL(reader.get_read_position(), 1u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'b'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 2u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'c'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 3u); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); // Read past limit invalidates. BOOST_REQUIRE_EQUAL(reader.read_byte(), 0x00u); BOOST_REQUIRE(!reader); } // set_position forward tests both set_position and skip. BOOST_AUTO_TEST_CASE(byte_reader__set_limit__set_position_forward_peek__limited) { std::istringstream stream{ "abcde" }; read::bytes::istream reader(stream); // Read to position 1. BOOST_REQUIRE_EQUAL(reader.get_read_position(), 0u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'a'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 1u); // Position is 1, set limit +3 (to absolute 4). reader.set_limit(3); // Reset absolute position to 3. reader.set_position(3); BOOST_REQUIRE(!reader.is_exhausted()); // Peek does not consume limit (as verified by subsequent reads). BOOST_REQUIRE_EQUAL(reader.peek_byte(), 'd'); BOOST_REQUIRE_EQUAL(reader.peek_byte(), 'd'); BOOST_REQUIRE_EQUAL(reader.peek_byte(), 'd'); // Read to limit and verify. BOOST_REQUIRE_EQUAL(reader.get_read_position(), 3u); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'd'); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 4u); BOOST_REQUIRE(reader.is_exhausted()); BOOST_REQUIRE(reader); // Peek past limit invalidates. BOOST_REQUIRE_EQUAL(reader.peek_byte(), 0x00); BOOST_REQUIRE(!reader); } #endif // BYTE_READER_CONTEXT #ifdef BYTE_READER_BIG_ENDIAN // read_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_big_endian(), 0x0807060504030201u); BOOST_REQUIRE(reader); } // read_2_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_2_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_2_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_2_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_2_bytes_big_endian(), 0x0807u); BOOST_REQUIRE(reader); } // read_3_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_3_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_3_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_3_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_3_bytes_big_endian(), 0x00080706u); BOOST_REQUIRE(reader); } // read_4_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_4_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_4_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_4_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_4_bytes_big_endian(), 0x08070605u); BOOST_REQUIRE(reader); } // read_5_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_5_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_5_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_5_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_5_bytes_big_endian(), 0x0000000807060504u); BOOST_REQUIRE(reader); } // read_6_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_6_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_6_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_6_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_6_bytes_big_endian(), 0x0000080706050403u); BOOST_REQUIRE(reader); } // read_7_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_7_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_7_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_7_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_7_bytes_big_endian(), 0x0008070605040302u); BOOST_REQUIRE(reader); } // read_8_bytes_big_endian BOOST_AUTO_TEST_CASE(byte_reader__read_8_bytes_big_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_8_bytes_big_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_8_bytes_big_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_8_bytes_big_endian(), 0x0807060504030201u); BOOST_REQUIRE(reader); } #endif // BYTE_READER_BIG_ENDIAN #ifdef BYTE_READER_LITTLE_ENDIAN // read_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_little_endian(), 0x0102030405060708u); BOOST_REQUIRE(reader); } // read_2_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_2_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_2_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_2_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_2_bytes_little_endian(), 0x0708u); BOOST_REQUIRE(reader); } // read_3_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_3_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_3_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_3_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_3_bytes_little_endian(), 0x00060708u); BOOST_REQUIRE(reader); } // read_4_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_4_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_4_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_4_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_4_bytes_little_endian(), 0x05060708u); BOOST_REQUIRE(reader); } // read_5_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_5_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_5_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_5_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_5_bytes_little_endian(), 0x0000000405060708u); BOOST_REQUIRE(reader); } // read_6_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_6_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_6_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_6_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_6_bytes_little_endian(), 0x0000030405060708u); BOOST_REQUIRE(reader); } // read_7_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_7_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_7_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_7_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_7_bytes_little_endian(), 0x0002030405060708u); BOOST_REQUIRE(reader); } // read_8_bytes_little_endian BOOST_AUTO_TEST_CASE(byte_reader__read_8_bytes_little_endian__empty__zero) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_8_bytes_little_endian(), 0u); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_8_bytes_little_endian__full__expected) { const std::string value{ 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_8_bytes_little_endian(), 0x0102030405060708u); BOOST_REQUIRE(reader); } // read_size/read_variable BOOST_AUTO_TEST_CASE(byte_reader__read_variable_size__one_byte__expected) { const std::string value{ 0x08 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_size(), 0x08u); reader.rewind_bytes(1); BOOST_REQUIRE_EQUAL(reader.read_variable(), 0x08u); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_variable_size__two_bytes__expected) { const std::string value{ static_cast(varint_two_bytes), 0x08, 0x07 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_size(), 0x0708u); reader.rewind_bytes(3); BOOST_REQUIRE_EQUAL(reader.read_variable(), 0x0708u); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_variable_size__four_bytes__expected) { const std::string value{ static_cast(varint_four_bytes), 0x08, 0x07, 0x06, 0x05 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_size(), 0x05060708u); reader.rewind_bytes(5); BOOST_REQUIRE_EQUAL(reader.read_variable(), 0x05060708u); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_variable_size__eight_bytes__expected) { const std::string value{ static_cast(varint_eight_bytes), 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_variable(), 0x0102030405060708u); reader.rewind_bytes(9); if constexpr (sizeof(size_t) < sizeof(uint64_t)) { BOOST_REQUIRE_EQUAL(reader.read_size(), 0u); BOOST_REQUIRE(!reader); } else { BOOST_REQUIRE_EQUAL(reader.read_size(), 0x0102030405060708u); BOOST_REQUIRE(reader); } } // non-canonical read_size BOOST_AUTO_TEST_CASE(byte_reader__read_size__non_canonical_two_bytes__zero_invalid) { const std::string value{ static_cast(varint_two_bytes), 0x08, 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_zero(reader.read_size())); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_size__non_canonical_four_bytes__zero_invalid) { const std::string value{ static_cast(varint_four_bytes), 0x08, 0x00, 0x00, 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_zero(reader.read_size())); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_size__non_canonical_eight_bytes__zero_invalid) { const std::string value{ static_cast(varint_eight_bytes), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_zero(reader.read_size())); BOOST_REQUIRE(!reader); } // non-canonical read_variable BOOST_AUTO_TEST_CASE(byte_reader__read_variable__non_canonical_two_bytes__zero_invalid) { const std::string value{ static_cast(varint_two_bytes), 0x08, 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_zero(reader.read_variable())); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_variable__non_canonical_four_bytes__zero_invalid) { const std::string value{ static_cast(varint_four_bytes), 0x08, 0x00, 0x00, 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_zero(reader.read_variable())); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_variable__non_canonical_eight_bytes__zero_invalid) { const std::string value{ static_cast(varint_eight_bytes), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_zero(reader.read_variable())); BOOST_REQUIRE(!reader); } // read_error_code BOOST_AUTO_TEST_CASE(byte_reader__read_error_code__empty__default_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_error_code(), error::success); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_error_code__value__expected) { const std::string value{ static_cast(error::double_spend), 0x00, 0x00, 0x00, '*' }; std::stringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_error_code().value(), error::double_spend); BOOST_REQUIRE(reader); } #endif // BYTE_READER_LITTLE_ENDIAN #ifdef BYTE_READER_BYTES // read_forward BOOST_AUTO_TEST_CASE(byte_reader__read_forward__empty__pad_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_forward<1>()[0], pad); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_forward__not_empty__expected) { const data_array<4> expected{ 0x01, 0x02, 0x03, 0x04 }; std::istringstream stream{ "*" + to_string(expected) + "*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(reader.read_forward<4>(), expected); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_forward__past_end__padded_invalid) { const data_array<4> expected{ 0x01, 0x02, pad, pad }; std::istringstream stream{ to_string(expected).substr(0, 2) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_forward<4>(), expected); BOOST_REQUIRE(!reader); } // read_forward_cptr BOOST_AUTO_TEST_CASE(byte_reader__read_forward_cptr__empty__nullptr_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(!reader.read_forward_cptr<1>()); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_forward_cptr__not_empty__expected) { const data_array<4> expected{ 0x01, 0x02, 0x03, 0x04 }; std::istringstream stream{ "*" + to_string(expected) + "*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(*reader.read_forward_cptr<4>(), expected); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_forward_cptr__past_end__nullptr_invalid) { const data_array<4> expected{ 0x01, 0x02, pad, pad }; std::istringstream stream{ to_string(expected).substr(0, 2) }; read::bytes::istream reader(stream); BOOST_REQUIRE(!reader.read_forward_cptr<4>()); BOOST_REQUIRE(!reader); } // read_reverse BOOST_AUTO_TEST_CASE(byte_reader__read_reverse__empty__pad_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_reverse<1>()[0], pad); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_reverse__not_empty__expected) { const data_array<4> value{ 0x01, 0x02, 0x03, 0x04 }; const data_array<4> expected{ 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ "*" + to_string(value) + "*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(reader.read_reverse<4>(), expected); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_reverse__past_end__padded_invalid) { const data_array<2> value{ 0x01, 0x02 }; const data_array<4> expected{ pad, pad, 0x02, 0x01 }; std::istringstream stream{ to_string(value) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_reverse<4>(), expected); BOOST_REQUIRE(!reader); } // read_reverse_cptr BOOST_AUTO_TEST_CASE(byte_reader__read_reverse_cptr__empty__nullptr_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(!reader.read_reverse_cptr<1>()); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_reverse_cptr__not_empty__expected) { const data_array<4> value{ 0x01, 0x02, 0x03, 0x04 }; const data_array<4> expected{ 0x04, 0x03, 0x02, 0x01 }; std::istringstream stream{ "*" + to_string(value) + "*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(*reader.read_reverse_cptr<4>(), expected); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_reverse_cptr__past_end__nullptr_invalid) { const data_array<2> value{ 0x01, 0x02 }; std::istringstream stream{ to_string(value) }; read::bytes::istream reader(stream); BOOST_REQUIRE(!reader.read_reverse_cptr<4>()); BOOST_REQUIRE(!reader); } // read BOOST_AUTO_TEST_CASE(byte_reader__read__empty__empty) { std::istringstream in; std::ostringstream out; read::bytes::istream reader(in); BOOST_REQUIRE(reader.read(out)); BOOST_REQUIRE(out.str().empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read__value__expected) { const std::string expected{ "abcdefghijklmnopqrstuvwxyz" }; std::istringstream in{ expected }; std::ostringstream out; read::bytes::istream reader(in); BOOST_REQUIRE(reader.read(out)); BOOST_REQUIRE_EQUAL(out.str(), expected); BOOST_REQUIRE(reader); } // read_mini_hash BOOST_AUTO_TEST_CASE(byte_reader__read_mini_hash__null_hash__null_mini_hash) { std::istringstream stream{ to_string(null_hash) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_mini_hash(), null_mini_hash); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_mini_hash__value__expected) { const mini_hash expected{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_mini_hash(), expected); BOOST_REQUIRE(reader); } // read_mini_hash_cptr BOOST_AUTO_TEST_CASE(byte_reader__read_mini_hash_cptr__null_hash__null_mini_hash) { std::istringstream stream{ to_string(null_hash) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(*reader.read_mini_hash_cptr(), null_mini_hash); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_mini_hash_cptr__value__expected) { const mini_hash expected{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(*reader.read_mini_hash_cptr(), expected); BOOST_REQUIRE(reader); } // read_short_hash BOOST_AUTO_TEST_CASE(byte_reader__read_short_hash__value__expected) { const short_hash expected { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_short_hash(), expected); BOOST_REQUIRE(reader); } // read_short_hash_cptr BOOST_AUTO_TEST_CASE(byte_reader__read_short_hash_cptr__value__expected) { const short_hash expected { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(*reader.read_short_hash_cptr(), expected); BOOST_REQUIRE(reader); } // read_hash BOOST_AUTO_TEST_CASE(byte_reader__read_hash__value__expected) { const hash_digest expected { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02 }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_hash(), expected); BOOST_REQUIRE(reader); } // read_hash_cptr BOOST_AUTO_TEST_CASE(byte_reader__read_hash_cptr__value__expected) { const hash_digest expected { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02 }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(*reader.read_hash_cptr(), expected); BOOST_REQUIRE(reader); } // read_long_hash BOOST_AUTO_TEST_CASE(byte_reader__read_long_hash__value__expected) { const long_hash expected { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04 }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_long_hash(), expected); BOOST_REQUIRE(reader); } // read_long_hash_cptr BOOST_AUTO_TEST_CASE(byte_reader__read_long_hash_cptr__value__expected) { const long_hash expected { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01, 0x02, 0x03, 0x04 }; std::istringstream stream{ to_string(expected) }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(*reader.read_long_hash_cptr(), expected); BOOST_REQUIRE(reader); } // peek_byte BOOST_AUTO_TEST_CASE(byte_reader__peek_byte__empty__pad_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.peek_byte(), pad); BOOST_REQUIRE_EQUAL(reader.peek_byte(), pad); BOOST_REQUIRE_EQUAL(reader.peek_byte(), pad); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__peek_byte__end__pad_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); BOOST_REQUIRE_EQUAL(reader.peek_byte(), pad); BOOST_REQUIRE_EQUAL(reader.peek_byte(), pad); BOOST_REQUIRE_EQUAL(reader.peek_byte(), pad); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__peek_byte__not_empty__expected_not_advanced) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.peek_byte(), 'a'); BOOST_REQUIRE_EQUAL(reader.peek_byte(), 'a'); BOOST_REQUIRE_EQUAL(reader.peek_byte(), 'a'); BOOST_REQUIRE(reader); } // read_byte BOOST_AUTO_TEST_CASE(byte_reader__read_byte__empty__pad_invalid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_byte(), pad); BOOST_REQUIRE_EQUAL(reader.read_byte(), pad); BOOST_REQUIRE_EQUAL(reader.read_byte(), pad); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_byte__end__pad_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); BOOST_REQUIRE_EQUAL(reader.read_byte(), pad); BOOST_REQUIRE_EQUAL(reader.read_byte(), pad); BOOST_REQUIRE_EQUAL(reader.read_byte(), pad); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_byte__not_empty__expected_advanced) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'a'); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'b'); BOOST_REQUIRE_EQUAL(reader.read_byte(), 'c'); BOOST_REQUIRE(reader); } // read_bytes0 BOOST_AUTO_TEST_CASE(byte_reader__read_bytes0__invalid__empty_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(reader.read_bytes().empty()); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes0__empty__empty_valid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader.read_bytes().empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes0__end__empty_valid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); BOOST_REQUIRE(reader.read_bytes().empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes0__not_empty__expected) { std::istringstream stream{ "*abc" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(reader.read_bytes(), to_chunk("abc")); BOOST_REQUIRE(reader); } // read_bytes_cptr0 BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr0__invalid__nullptr_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(!reader.read_bytes_cptr()); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr0__empty__empty_valid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader.read_bytes_cptr()->empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr0__end__empty_valid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); BOOST_REQUIRE(reader.read_bytes_cptr()->empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr0__not_empty__expected) { std::istringstream stream{ "*abc" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(*reader.read_bytes_cptr(), to_chunk("abc")); BOOST_REQUIRE(reader); } // read_bytes1 BOOST_AUTO_TEST_CASE(byte_reader__read_bytes1__invalid__empty_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(reader.read_bytes(0).empty()); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes1__empty_zero__empty_valid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader.read_bytes(0).empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes1__end_zero__empty_valid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); BOOST_REQUIRE(reader.read_bytes(0).empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes1__to_end__expected) { std::istringstream stream{ "*abc" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(reader.read_bytes(3), to_chunk("abc")); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes1__middle__expected) { std::istringstream stream{ "*abc*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(reader.read_bytes(3), to_chunk("abc")); BOOST_REQUIRE_EQUAL(stream.get(), '*'); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes1__past_end__expected_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_bytes(6), to_chunk("abc\0\0\0")); BOOST_REQUIRE(!reader); } // read_bytes_cptr1 BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr1__invalid__nullptr_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(!reader.read_bytes_cptr(0)); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr1__empty_zero__empty_valid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader.read_bytes_cptr(0)->empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr1__end_zero__empty_valid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); BOOST_REQUIRE(reader.read_bytes_cptr(0)->empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr1__to_end__expected) { std::istringstream stream{ "*abc" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(*reader.read_bytes_cptr(3), to_chunk("abc")); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr1__middle__expected) { std::istringstream stream{ "*abc*" }; read::bytes::istream reader(stream); reader.skip_byte(); BOOST_REQUIRE_EQUAL(*reader.read_bytes_cptr(3), to_chunk("abc")); BOOST_REQUIRE_EQUAL(stream.get(), '*'); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_cptr1__past_end__expected_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); BOOST_REQUIRE(!reader.read_bytes_cptr(6)); BOOST_REQUIRE(!reader); } // read_bytes_raw1 BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw1__invalid__nullptr_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.invalidate(); BOOST_REQUIRE(is_null(reader.read_bytes_raw(0))); BOOST_REQUIRE(!reader); } // A pointer is returned, undefined behavior to dereference it, must destroy. BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw1__empty_zero__not_null_valid) { std::istringstream stream; read::bytes::istream reader(stream); const auto ptr = reader.read_bytes_raw(0); BOOST_REQUIRE(ptr != nullptr); BOOST_REQUIRE(reader); allocator<>::deleter(reader.get_arena())(ptr); } // A pointer is returned, undefined behavior to dereference it, must destroy. BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw1__end_zero__not_null_valid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); const auto ptr = reader.read_bytes_raw(0); BOOST_REQUIRE(ptr != nullptr); BOOST_REQUIRE(reader); reader.get_allocator().deleter(reader.get_arena())(ptr); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw1__to_end__expected) { std::istringstream stream{ "*abc" }; read::bytes::istream reader(stream); reader.skip_byte(); const auto ptr = reader.read_bytes_raw(3); BOOST_REQUIRE(ptr != nullptr); BOOST_REQUIRE_EQUAL(*ptr, to_chunk("abc")); BOOST_REQUIRE(reader); reader.get_allocator().deleter()(ptr); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw1__middle__expected) { std::istringstream stream{ "*abc*" }; read::bytes::istream reader(stream); reader.skip_byte(); const auto ptr = reader.read_bytes_raw(3); BOOST_REQUIRE(ptr != nullptr); BOOST_REQUIRE_EQUAL(*ptr, to_chunk("abc")); BOOST_REQUIRE_EQUAL(stream.get(), '*'); BOOST_REQUIRE(reader); reader.get_allocator().deleter()(ptr); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw1__past_end__nullptr_invalid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); BOOST_REQUIRE(is_null(reader.read_bytes_raw(6))); BOOST_REQUIRE(!reader); } // read_bytes2 BOOST_AUTO_TEST_CASE(byte_reader__read_bytes2__empty_zero__empty_valid) { data_chunk sink; std::istringstream stream; read::bytes::istream reader(stream); reader.read_bytes(sink.data(), 0); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes2__end_zero__empty_valid) { data_chunk sink; std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.skip_bytes(3); reader.read_bytes(sink.data(), 0); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes2__to_end__expected) { data_chunk sink(3, 0x00); std::istringstream stream{ "*abc" }; read::bytes::istream reader(stream); reader.skip_byte(); reader.read_bytes(sink.data(), sink.size()); BOOST_REQUIRE_EQUAL(sink, to_chunk("abc")); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes2__middle__expected) { data_chunk sink(3, 0x00); std::istringstream stream{ "*abc*" }; read::bytes::istream reader(stream); reader.skip_byte(); reader.read_bytes(sink.data(), sink.size()); BOOST_REQUIRE_EQUAL(sink, to_chunk("abc")); BOOST_REQUIRE_EQUAL(stream.get(), '*'); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_bytes2__past_end__expected_invalid) { data_chunk sink(6, 0x00); std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); reader.read_bytes(sink.data(), sink.size()); BOOST_REQUIRE_EQUAL(sink, to_chunk("abc\0\0\0")); BOOST_REQUIRE(!reader); } #endif // BYTE_READER_BYTES #ifdef BYTE_READER_STRINGS // read_string BOOST_AUTO_TEST_CASE(byte_reader__read_string__one_byte__expected) { const std::string value{ 0x03, 'a', 'b', 'c' }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string(), "abc"); } BOOST_AUTO_TEST_CASE(byte_reader__read_string__two_bytes__expected) { const std::string payload(253, 'a'); std::string value{ static_cast(varint_two_bytes), static_cast(0xfd), 0x00 }; value += payload; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string(), payload); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_string__four_bytes__expected) { const std::string payload(65536, 'a'); std::string value{ static_cast(varint_four_bytes), 0x00, 0x00, 0x01, 0x00 }; value += payload; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string(), payload); BOOST_REQUIRE(reader); } // read_string_buffer BOOST_AUTO_TEST_CASE(byte_reader__read_string_buffer__zero__empty_valid) { std::istringstream stream; read::bytes::istream reader(stream); BOOST_REQUIRE(reader.read_string_buffer(0).empty()); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_string_buffer__partial__expected_valid) { const std::string value{ "abcdefghij" }; const auto length = to_half(value.length()); std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string_buffer(length), value.substr(0, length)); BOOST_REQUIRE(reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_string_buffer__full__expected_valid) { const std::string value{ "abcdefghij" }; const auto length = value.length(); std::istringstream stream{ value + "*" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string_buffer(length), value); BOOST_REQUIRE_EQUAL(stream.get(), '*'); BOOST_REQUIRE(reader); } // The full number of bytes are read, but not past end. BOOST_AUTO_TEST_CASE(byte_reader__read_string_buffer__past_end__truncated_valid) { const std::string value{ "abcdefghij" }; const auto length = value.length(); std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string_buffer(add1(length)), value); BOOST_REQUIRE(reader); } // The full number of bytes are read, and the string is terminated at null. BOOST_AUTO_TEST_CASE(byte_reader__read_string_buffer__full_embedded_null__truncated_exhausted) { const std::string value{ "abcdef\0hij" }; const auto length = value.length(); std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string_buffer(length), "abcdef"); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); } // The full number of bytes are read, and the string is terminated at null. BOOST_AUTO_TEST_CASE(byte_reader__read_string_buffer__partial_embedded_null__truncated_not_exhausted) { const std::string value{ "abcdef\0hij" }; const auto length = value.length(); std::istringstream stream{ value + "*" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_string_buffer(length), "abcdef"); BOOST_REQUIRE(reader); BOOST_REQUIRE(!reader.is_exhausted()); BOOST_REQUIRE_EQUAL(stream.get(), '*'); } // read_line BOOST_AUTO_TEST_CASE(byte_reader__read_line__no_terminator__invalidates) { const std::string value{ "hello" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line(), ""); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_line__custom_terminator__expected) { const std::string value{ "test|done" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line("|"), "test"); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 5u); } BOOST_AUTO_TEST_CASE(byte_reader__read_line__terminator_only__expected_position_empty) { const std::string value{ "\r\n" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line(), ""); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 2u); } BOOST_AUTO_TEST_CASE(byte_reader__read_line__multiple_terminators__expected_positions_empty) { const std::string value{ "\r\n\r\n" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line(), ""); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 2u); BOOST_REQUIRE_EQUAL(reader.read_line(), ""); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 4u); } BOOST_AUTO_TEST_CASE(byte_reader__read_line__text_before_terminator__returns_text) { const std::string value{ "hello\r\n" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line(), "hello"); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 7u); } BOOST_AUTO_TEST_CASE(byte_reader__read_line__partial_match__handles_correctly) { const std::string value{ "\rabc\r\n" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line(), "\rabc"); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 6u); } BOOST_AUTO_TEST_CASE(byte_reader__read_line__multiple_lines__returns_sequential) { const std::string value{ "line1\r\nline2\r\n" }; std::istringstream stream{ value }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_line(), "line1"); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 7u); BOOST_REQUIRE_EQUAL(reader.read_line(), "line2"); BOOST_REQUIRE(reader); BOOST_REQUIRE_EQUAL(reader.get_read_position(), 14u); } #endif // BYTE_READER_STRINGS BC_POP_WARNING() BOOST_AUTO_TEST_CASE(byte_reader__read_size__exceeds_limit__zero_invalid) { std::istringstream stream{ "\x2a" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_size(41), zero); BOOST_REQUIRE(!reader); } BOOST_AUTO_TEST_CASE(byte_reader__read_size__within_limit__expected) { std::istringstream stream{ "\x2a" }; read::bytes::istream reader(stream); BOOST_REQUIRE_EQUAL(reader.read_size(42), 42u); BOOST_REQUIRE(reader); } // A pointer is returned, undefined behavior to dereference it, must destroy. BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw0__to_end__not_null_valid) { std::istringstream stream{ "abc" }; read::bytes::istream reader(stream); const auto ptr = reader.read_bytes_raw(); BOOST_REQUIRE(ptr != nullptr); BOOST_REQUIRE(reader); BOOST_REQUIRE(reader.is_exhausted()); allocator<>::deleter(reader.get_arena())(ptr); } // A pointer is returned, undefined behavior to dereference it, must destroy. BOOST_AUTO_TEST_CASE(byte_reader__read_bytes_raw0__empty__not_null_valid) { std::istringstream stream; read::bytes::istream reader(stream); const auto ptr = reader.read_bytes_raw(); BOOST_REQUIRE(ptr != nullptr); BOOST_REQUIRE(reader); allocator<>::deleter(reader.get_arena())(ptr); } // Deleting a derived reader through its base invokes the virtual destructor. BOOST_AUTO_TEST_CASE(byte_reader__destruct__through_base_pointer__expected) { std::istringstream stream{ "*" }; auto reader = std::make_unique>(stream); std::unique_ptr> base{ std::move(reader) }; BOOST_REQUIRE(*base); base.reset(); BOOST_REQUIRE(!base); } BOOST_AUTO_TEST_SUITE_END() 12:["$","$L29",null,{"project":{"id":"cmuidb72x000001s1932ifphv","owner":"libbitcoin","repo":"libbitcoin-system","displayName":"libbitcoin/libbitcoin-system","defaultBranch":"master"},"commit":{"sha":"4f070c1f2115f81ad59206694fd75c772ddc1319","message":"Replace ecdsa capture parameter with unbatched verification method.","authorLogin":"evoskuil","authorName":"Eric Voskuil","date":"2026-09-26T16:28:24.000Z","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/commit/4f070c1f2115f81ad59206694fd75c772ddc1319","isHead":false,"headSha":"83147c18e3a80ab2949c2c8a7e3486950d7cfeff"},"gitRef":"4f070c1f2115f81ad59206694fd75c772ddc1319","path":"test/stream/streamers/byte_reader.cpp","target":{"kind":"file","file":{"path":"test/stream/streamers/byte_reader.cpp","size":57924,"content":"$2a","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/4f070c1f2115f81ad59206694fd75c772ddc1319/test/stream/streamers/byte_reader.cpp","mutants":[],"mutantsAtOtherRevisions":0}},"treeCache":{"":[{"name":".github","path":".github","type":"dir","size":null},{"name":".vscode","path":".vscode","type":"dir","size":null},{"name":"builds","path":"builds","type":"dir","size":null},{"name":"doc","path":"doc","type":"dir","size":null},{"name":"examples","path":"examples","type":"dir","size":null},{"name":"include","path":"include","type":"dir","size":null},{"name":"src","path":"src","type":"dir","size":null},{"name":"test","path":"test","type":"dir","size":null},{"name":"tools","path":"tools","type":"dir","size":null},{"name":".gitignore","path":".gitignore","type":"file","size":1043},{"name":"COPYING","path":"COPYING","type":"file","size":33899},{"name":"README.md","path":"README.md","type":"file","size":13027}],"test":[{"name":"chain","path":"test/chain","type":"dir","size":null},{"name":"config","path":"test/config","type":"dir","size":null},{"name":"crypto","path":"test/crypto","type":"dir","size":null},{"name":"data","path":"test/data","type":"dir","size":null},{"name":"endian","path":"test/endian","type":"dir","size":null},{"name":"error","path":"test/error","type":"dir","size":null},{"name":"filter","path":"test/filter","type":"dir","size":null},{"name":"hash","path":"test/hash","type":"dir","size":null},{"name":"intrinsics","path":"test/intrinsics","type":"dir","size":null},{"name":"machine","path":"test/machine","type":"dir","size":null},{"name":"math","path":"test/math","type":"dir","size":null},{"name":"mocks","path":"test/mocks","type":"dir","size":null},{"name":"radix","path":"test/radix","type":"dir","size":null},{"name":"serial","path":"test/serial","type":"dir","size":null},{"name":"stream","path":"test/stream","type":"dir","size":null},{"name":"unicode","path":"test/unicode","type":"dir","size":null},{"name":"wallet","path":"test/wallet","type":"dir","size":null},{"name":"words","path":"test/words","type":"dir","size":null},{"name":".gitignore","path":"test/.gitignore","type":"file","size":16},{"name":"allocator.cpp","path":"test/allocator.cpp","type":"file","size":20791},{"name":"arena.cpp","path":"test/arena.cpp","type":"file","size":4856},{"name":"constants.cpp","path":"test/constants.cpp","type":"file","size":2567},{"name":"constraints.cpp","path":"test/constraints.cpp","type":"file","size":36099},{"name":"define.cpp","path":"test/define.cpp","type":"file","size":1686},{"name":"funclets.cpp","path":"test/funclets.cpp","type":"file","size":6873},{"name":"hacks.cpp","path":"test/hacks.cpp","type":"file","size":10602},{"name":"literals.cpp","path":"test/literals.cpp","type":"file","size":24343},{"name":"main.cpp","path":"test/main.cpp","type":"file","size":1211},{"name":"settings.cpp","path":"test/settings.cpp","type":"file","size":22428},{"name":"test.cpp","path":"test/test.cpp","type":"file","size":2507},{"name":"test.hpp","path":"test/test.hpp","type":"file","size":6452},{"name":"typelets.cpp","path":"test/typelets.cpp","type":"file","size":24076},{"name":"types.cpp","path":"test/types.cpp","type":"file","size":13119}],"test/stream":[{"name":"devices","path":"test/stream/devices","type":"dir","size":null},{"name":"iostream","path":"test/stream/iostream","type":"dir","size":null},{"name":"streamers","path":"test/stream/streamers","type":"dir","size":null},{"name":"binary.cpp","path":"test/stream/binary.cpp","type":"file","size":10252},{"name":"device.cpp","path":"test/stream/device.cpp","type":"file","size":4325},{"name":"stream.cpp","path":"test/stream/stream.cpp","type":"file","size":34468},{"name":"streamers.cpp","path":"test/stream/streamers.cpp","type":"file","size":8435}],"test/stream/streamers":[{"name":"bit_flipper.cpp","path":"test/stream/streamers/bit_flipper.cpp","type":"file","size":48230},{"name":"bit_reader.cpp","path":"test/stream/streamers/bit_reader.cpp","type":"file","size":33179},{"name":"bit_writer.cpp","path":"test/stream/streamers/bit_writer.cpp","type":"file","size":15586},{"name":"byte_flipper.cpp","path":"test/stream/streamers/byte_flipper.cpp","type":"file","size":48345},{"name":"byte_reader.cpp","path":"test/stream/streamers/byte_reader.cpp","type":"file","size":57924},{"name":"byte_writer.cpp","path":"test/stream/streamers/byte_writer.cpp","type":"file","size":18885},{"name":"hex_reader.cpp","path":"test/stream/streamers/hex_reader.cpp","type":"file","size":5544},{"name":"hex_writer.cpp","path":"test/stream/streamers/hex_writer.cpp","type":"file","size":2931},{"name":"sha256_writer.cpp","path":"test/stream/streamers/sha256_writer.cpp","type":"file","size":2481},{"name":"sha256t_writer.cpp","path":"test/stream/streamers/sha256t_writer.cpp","type":"file","size":2763},{"name":"sha256x2_writer.cpp","path":"test/stream/streamers/sha256x2_writer.cpp","type":"file","size":2468}]},"revisions":[{"commitSha":"9fa0f9a07f31c5cc9ebe5efa05e6d4a6d12ba183","branch":null,"commitMessage":"Test script pattern length guards and the sixteen key multisig builder boundary.","commitDate":"2026-09-29T18:05:00.000Z","mutantCount":129},{"commitSha":"98db5bfd7c7b65532e42309c7b71419d82ec5ea8","branch":null,"commitMessage":"Merge pull request #2017 from evoskuil/master","commitDate":"2026-09-28T17:24:16.000Z","mutantCount":230},{"commitSha":"827fb29d0fecbdf7a157e05b1bea59bc916787aa","branch":null,"commitMessage":"Test multisig sighash cache reset across distinct subscripts","commitDate":"2026-09-26T12:24:47.000Z","mutantCount":1},{"commitSha":"8e7a9fdcb4ca72bc5bfe9961815aaa9bc33b64a0","branch":null,"commitMessage":"Remove dead include.","commitDate":"2026-09-25T06:52:28.000Z","mutantCount":90}],"signedIn":false,"pullRequest":{"id":"cmulblepm000001p96ixnpvs2","number":2012,"title":"Replace ecdsa capture parameter with unbatched verification method.","headSha":"4f070c1f2115f81ad59206694fd75c772ddc1319","state":"MERGED","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/pull/2012","ranges":[],"fileInDiff":false,"atHead":true}}]