Differential D6357 Diff 26255 src/seeder/test/message_writer_tests.cpp

Changeset View

Standalone View

src/seeder/test/message_writer_tests.cpp

This file was added.

				// Copyright (c) 2020 The Bitcoin developers
				// Distributed under the MIT software license, see the accompanying
				// file COPYING or http://www.opensource.org/licenses/mit-license.php.

				#include <hash.h>
				#include <primitives/block.h>
				#include <protocol.h>
				#include <seeder/messagewriter.h>
				#include <streams.h>
				#include <version.h>

				#include <boost/test/unit_test.hpp>

				#include <string>
				#include <vector>

				BOOST_AUTO_TEST_SUITE(message_writer_tests)

				template <typename... Args>
				static void CheckMessage(CDataStream expectedMessage, int version,
				std::string command, Args &&... args) {
				CDataStream message = MessageWriter::WriteMessage(
				version, command, std::forward<Args>(args)...);
				BOOST_CHECK_EQUAL(message.size(), expectedMessage.size());
				for (size_t i = 0; i < message.size(); i++) {
				BOOST_CHECK_EQUAL(message[i], expectedMessage[i]);
				}
				}

				BOOST_AUTO_TEST_CASE(simple_header_and_payload_message_writer_test) {
				SelectParams(CBaseChainParams::MAIN);
				int nVersion = PROTOCOL_VERSION;
				uint64_t now = time(nullptr);
				uint64_t nonce = 0;
				uint64_t serviceFlags = uint64_t(ServiceFlags(NODE_NETWORK));
				CService service;
				CAddress addrTo(service, ServiceFlags(NODE_NETWORK));
				CAddress addrFrom(service, ServiceFlags(NODE_NETWORK));
				std::string user_agent = "/bitcoin-cash-seeder:0.15/";
				int start_height = 1;

				CDataStream versionPayload(SER_NETWORK, nVersion);
				versionPayload << nVersion << serviceFlags << now << addrTo << addrFrom
				<< nonce << user_agent << start_height;

				CMessageHeader versionhdr(Params().NetMagic(), NetMsgType::VERSION,
				versionPayload.size());
				uint256 hash = Hash(versionPayload.data(),
				versionPayload.data() + versionPayload.size());
				memcpy(versionhdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);

				CDataStream expectedVersion(SER_NETWORK, nVersion);
				expectedVersion << versionhdr;
				expectedVersion += versionPayload;

				CheckMessage(expectedVersion, nVersion, NetMsgType::VERSION, nVersion,
				serviceFlags, now, addrTo, addrFrom, nonce, user_agent,
				start_height);
				}

				BOOST_AUTO_TEST_CASE(header_empty_payload_message_writer_test) {
				SelectParams(CBaseChainParams::MAIN);
				int nVersion = PROTOCOL_VERSION;
				CMessageHeader verackHeader(Params().NetMagic(), NetMsgType::VERACK, 0);
				CDataStream expectedVerack(SER_NETWORK, nVersion);
				// This is an empty payload, but is still necessary for the checksum
				std::vector<uint8_t> payload;
				uint256 hash = Hash(payload.data(), payload.data() + payload.size());
				memcpy(verackHeader.pchChecksum, hash.begin(),
				CMessageHeader::CHECKSUM_SIZE);
				expectedVerack << verackHeader;

				CheckMessage(expectedVerack, nVersion, NetMsgType::VERACK);
				}

				BOOST_AUTO_TEST_CASE(write_getheaders_message_test) {
				SelectParams(CBaseChainParams::MAIN);
				int nVersion = PROTOCOL_VERSION;
				CDataStream payload(SER_NETWORK, nVersion);
				BlockHash bhash(uint256S(
				"0000000099f5509b5f36b1926bcf82b21d936ebeadee811030dfbbb7fae915d7"));
				std::vector<BlockHash> vlocator(1, bhash);
				CBlockLocator locatorhash(vlocator);
				payload << locatorhash << uint256();
				uint256 hash = Hash(payload.data(), payload.data() + payload.size());

				CMessageHeader msgHeader(Params().NetMagic(), NetMsgType::GETHEADERS,
				payload.size());
				memcpy(msgHeader.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);

				CDataStream expectedMsg(SER_NETWORK, nVersion);
				expectedMsg << msgHeader;
				expectedMsg += payload;

				CheckMessage(expectedMsg, nVersion, NetMsgType::GETHEADERS, locatorhash,
				uint256());
				}

				BOOST_AUTO_TEST_SUITE_END()