From 503585f4885cff87cb008698450f986c205bff3c Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Fri, 21 Feb 2025 17:42:25 +0800 Subject: [PATCH 1/7] refactor: adapt to new qtils, scale, soralog Signed-off-by: Dmitriy Khaustov aka xDimon # Conflicts: # test/acceptance/p2p/host/peer/test_peer.cpp --- cmake/Hunter/config.cmake | 31 +++++++++++ test/acceptance/p2p/host/basic_host_test.cpp | 2 +- test/acceptance/p2p/host/peer/test_peer.cpp | 8 +-- test/acceptance/p2p/muxer.cpp | 26 +++++----- .../loopback_stream/loopback_stream_test.cpp | 8 +-- .../plaintext_connection_test.cpp | 12 ++--- test/libp2p/crypto/chachapoly_test.cpp | 8 +-- test/libp2p/crypto/ecdsa_provider_test.cpp | 28 +++++----- test/libp2p/crypto/key_generator_test.cpp | 13 ++--- test/libp2p/crypto/key_validator_test.cpp | 28 +++++----- test/libp2p/crypto/rsa_provider_test.cpp | 12 +++-- test/libp2p/crypto/secp256k1_test.cpp | 35 ++++++++----- test/libp2p/crypto/x25519_provider_test.cpp | 10 ++-- test/libp2p/multi/cid_test.cpp | 48 +++++++++-------- test/libp2p/multi/multiaddress_test.cpp | 8 +-- .../multi/utils/address_converter_test.cpp | 32 ++++++------ .../multi/utils/string_from_to_bytes_test.cpp | 52 ++++++++++--------- test/libp2p/network/dialer_test.cpp | 16 +++--- test/libp2p/network/listener_manager_test.cpp | 8 +-- .../inmem_address_repository_test.cpp | 44 ++++++++-------- .../key_book/inmem_key_repository_test.cpp | 20 +++---- test/libp2p/peer/peer_address_test.cpp | 9 ++-- test/libp2p/peer/peer_id_test.cpp | 16 +++--- .../inmem_protocol_repository_test.cpp | 47 ++++++++--------- test/libp2p/protocol/echo_test.cpp | 2 +- .../kademlia/peer_routing_table_test.cpp | 50 +++++++++--------- .../security/plaintext_adaptor_test.cpp | 20 +++---- ...ntext_exchange_message_marshaller_test.cpp | 16 +++--- ...secio_exchange_message_marshaller_test.cpp | 4 +- .../secio_propose_message_marshaller_test.cpp | 4 +- .../transport/tcp/tcp_integration_test.cpp | 38 ++++++++------ .../transport/tcp/tcp_listener_test.cpp | 26 ++++++---- test/libp2p/transport/upgrader_test.cpp | 6 +-- 33 files changed, 376 insertions(+), 311 deletions(-) diff --git a/cmake/Hunter/config.cmake b/cmake/Hunter/config.cmake index c871529d4..ac04a8e97 100644 --- a/cmake/Hunter/config.cmake +++ b/cmake/Hunter/config.cmake @@ -14,3 +14,34 @@ # SHA1 1234567890abcdef1234567890abcdef12345678 # CMAKE_ARGS "CMAKE_VARIABLE=value" # ) + +hunter_config( + soralog + URL https://github.com/xDimon/soralog/archive/35634db3126d7dc1784c883713c8e31ebb07d051.tar.gz + SHA1 ee64d0982cffe0a3856c4e786161518e55a6ffd4 + # VERSION 0.2.4 + KEEP_PACKAGE_SOURCES +) + +hunter_config( + ZLIB + VERSION 1.3.0-p0 + URL https://github.com/cpp-pm/zlib/archive/refs/tags/v1.3.0-p0.tar.gz + SHA1 311ca59e20cbbfe9d9e05196c12c6ae109093987 +) + +hunter_config( + scale + URL https://github.com/qdrvm/scale-codec-cpp/archive/24fbd767c8975647a733b45f9c3df92380110fb2.tar.gz + SHA1 c8570702805cdbacd31bd5caacead82c746ba901 + KEEP_PACKAGE_SOURCES +) + +hunter_config( + qtils + URL https://github.com/qdrvm/qtils/archive/9a64dfd6ed0226dec29805aa89d4c713a6f81d9f.tar.gz + SHA1 16c0269175018e88c33090f9fbdaa230c8fdb911 + CMAKE_ARGS + FORMAT_ERROR_WITH_FULLTYPE=ON + KEEP_PACKAGE_SOURCES +) diff --git a/test/acceptance/p2p/host/basic_host_test.cpp b/test/acceptance/p2p/host/basic_host_test.cpp index ac17e4212..9a0ed7884 100644 --- a/test/acceptance/p2p/host/basic_host_test.cpp +++ b/test/acceptance/p2p/host/basic_host_test.cpp @@ -156,7 +156,7 @@ TEST_F(BasicHostTest, NewStream) { bool executed = false; host->newStream(pinfo, {protocol}, [&](auto &&result) { - auto stream = EXPECT_OK(result); + ASSERT_OUTCOME_SUCCESS(stream, result); (void)stream; executed = true; }); diff --git a/test/acceptance/p2p/host/peer/test_peer.cpp b/test/acceptance/p2p/host/peer/test_peer.cpp index 7caa31a26..6c694f357 100644 --- a/test/acceptance/p2p/host/peer/test_peer.cpp +++ b/test/acceptance/p2p/host/peer/test_peer.cpp @@ -54,7 +54,7 @@ Peer::Peer(Peer::Duration timeout, bool secure) basic::Scheduler::Config{})}, secure_{secure} { auto keys = - EXPECT_OK(crypto_provider_->generateKeys(crypto::Key::Type::Ed25519)); + crypto_provider_->generateKeys(crypto::Key::Type::Ed25519).value(); host_ = makeHost(keys); auto handler = [this](StreamAndProtocol stream) { echo_->handle(stream); }; @@ -64,7 +64,7 @@ Peer::Peer(Peer::Duration timeout, bool secure) void Peer::startServer(const multi::Multiaddress &address, std::shared_ptr> promise) { post(*context_, [this, address, p = std::move(promise)] { - EXPECT_OK(host_->listen(address)); + ASSERT_OUTCOME_SUCCESS(host_->listen(address)); host_->start(); p->set_value(host_->getPeerInfo()); }); @@ -89,7 +89,7 @@ void Peer::startClient(const peer::PeerInfo &pinfo, counter = std::move(counter)]( StreamAndProtocolOrError rstream) mutable { // get stream - auto stream = EXPECT_OK(rstream); + ASSERT_OUTCOME_SUCCESS(stream, rstream); // make client session auto client = std::make_shared( stream.stream, ping_times); @@ -102,7 +102,7 @@ void Peer::startClient(const peer::PeerInfo &pinfo, // count message exchange counter->tick(); // ensure message returned - auto vec = EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(vec, res); // ensure message is correct ASSERT_EQ(vec.size(), client->bufferSize()); // NOLINT }); diff --git a/test/acceptance/p2p/muxer.cpp b/test/acceptance/p2p/muxer.cpp index f5db077d9..89f5d1107 100644 --- a/test/acceptance/p2p/muxer.cpp +++ b/test/acceptance/p2p/muxer.cpp @@ -91,7 +91,7 @@ struct UpgraderSemiMock : public Upgrader { void upgradeToMuxed(SecSPtr conn, OnMuxedCallbackFunc cb) override { mux->muxConnection(std::move(conn), [cb = std::move(cb)](auto &&conn_res) { - auto conn = EXPECT_OK(conn_res); + ASSERT_OUTCOME_SUCCESS(conn, conn_res); cb(std::move(conn)); }); } @@ -111,7 +111,7 @@ struct Server : public std::enable_shared_from_this { conn->onStream( [this, conn](outcome::result> rstream) { - auto stream = EXPECT_OK(rstream); + ASSERT_OUTCOME_SUCCESS(stream, rstream); this->println("new stream created"); this->streamsCreated++; auto buf = std::make_shared>(); @@ -136,7 +136,7 @@ struct Server : public std::enable_shared_from_this { this->println(fmt::format("readSome error: {}", rread.error())); } - auto read = EXPECT_OK(rread); + ASSERT_OUTCOME_SUCCESS(read, rread); this->println("readSome ", read, " bytes"); if (read == 0) { @@ -150,7 +150,7 @@ struct Server : public std::enable_shared_from_this { stream, *buf, [buf, read, stream, this](outcome::result rwrite) { - auto write = EXPECT_OK(rwrite); + ASSERT_OUTCOME_SUCCESS(write, rwrite); this->println("write ", write, " bytes"); this->streamWrites++; ASSERT_EQ(write, read); @@ -163,12 +163,12 @@ struct Server : public std::enable_shared_from_this { void listen(const Multiaddress &ma) { listener_ = transport_->createListener( [this](outcome::result> rconn) { - auto conn = EXPECT_OK(rconn); + ASSERT_OUTCOME_SUCCESS(conn, rconn); this->println("new connection received"); this->onConnection(conn); }); - EXPECT_OK(this->listener_->listen(ma)); + ASSERT_OUTCOME_SUCCESS(this->listener_->listen(ma)); } size_t clientsConnected = 0; @@ -210,7 +210,7 @@ struct Client : public std::enable_shared_from_this { p, server, [this](outcome::result> rconn) { - auto conn = EXPECT_OK(rconn); + ASSERT_OUTCOME_SUCCESS(conn, rconn); conn->start(); this->println("connected"); this->onConnection(conn); @@ -222,7 +222,7 @@ struct Client : public std::enable_shared_from_this { boost::asio::post(*context_, [i, conn, this]() { conn->newStream( [i, conn, this](outcome::result> rstream) { - auto stream = EXPECT_OK(rstream); + ASSERT_OUTCOME_SUCCESS(stream, rstream); this->println("new stream number ", i, " created"); this->onStream(i, this->rounds_, stream); }); @@ -248,7 +248,7 @@ struct Client : public std::enable_shared_from_this { stream, *buf, [round, streamId, buf, stream, this](outcome::result rwrite) { - auto write = EXPECT_OK(rwrite); + ASSERT_OUTCOME_SUCCESS(write, rwrite); this->println(streamId, " write ", write, " bytes"); this->streamWrites++; @@ -259,7 +259,7 @@ struct Client : public std::enable_shared_from_this { readbuf->size(), [round, streamId, write, buf, readbuf, stream, this]( outcome::result rread) { - auto read = EXPECT_OK(rread); + ASSERT_OUTCOME_SUCCESS(read, rread); this->println(streamId, " readSome ", read, " bytes"); this->streamReads++; @@ -437,9 +437,9 @@ TEST_P(MuxerAcceptanceTest, ParallelEcho) { auto client = std::make_shared( transport, localSeed, context, streams, rounds); - auto marshalled_key = - EXPECT_OK(key_marshaller->marshal(serverKeyPair.publicKey)); - auto p = EXPECT_OK(PeerId::fromPublicKey(marshalled_key)); + ASSERT_OUTCOME_SUCCESS( + marshalled_key, key_marshaller->marshal(serverKeyPair.publicKey)); + ASSERT_OUTCOME_SUCCESS(p, PeerId::fromPublicKey(marshalled_key)); client->connect(p, serverAddr); context->run_for(10000ms); diff --git a/test/libp2p/connection/loopback_stream/loopback_stream_test.cpp b/test/libp2p/connection/loopback_stream/loopback_stream_test.cpp index 6ac7f3ef3..6fa75ae2f 100644 --- a/test/libp2p/connection/loopback_stream/loopback_stream_test.cpp +++ b/test/libp2p/connection/loopback_stream/loopback_stream_test.cpp @@ -42,15 +42,15 @@ class LoopbackStreamTest : public testing::Test { * @then exactly the same data can be read from the stream */ TEST_F(LoopbackStreamTest, Basic) { - auto hash = EXPECT_OK(Multihash::create(libp2p::multi::sha256, kBuffer)); - auto peer_id = EXPECT_OK(PeerId::fromBase58(encodeBase58(hash.toBuffer()))); + ASSERT_OUTCOME_SUCCESS(hash, Multihash::create(libp2p::multi::sha256, kBuffer)); + ASSERT_OUTCOME_SUCCESS(peer_id, PeerId::fromBase58(encodeBase58(hash.toBuffer()))); std::shared_ptr stream = std::make_shared(PeerInfo{peer_id, {}}, context); bool all_executed{false}; libp2p::writeReturnSize( stream, kBuffer, [stream, buf = kBuffer, &all_executed](auto result) { - auto bytes = EXPECT_OK(result); + ASSERT_OUTCOME_SUCCESS(bytes, result); ASSERT_EQ(bytes, kBufferSize); auto read_buf = std::make_shared(kBufferSize, 0); ASSERT_EQ(read_buf->size(), kBufferSize); @@ -59,7 +59,7 @@ TEST_F(LoopbackStreamTest, Basic) { *read_buf, kBufferSize, [buf = read_buf, source_buf = buf, &all_executed](auto result) { - auto bytes = EXPECT_OK(result); + ASSERT_OUTCOME_SUCCESS(bytes, result); ASSERT_EQ(bytes, kBufferSize); ASSERT_EQ(*buf, source_buf); all_executed = true; diff --git a/test/libp2p/connection/security_conn/plaintext_connection_test.cpp b/test/libp2p/connection/security_conn/plaintext_connection_test.cpp index 99b916fc8..2b7b3007d 100644 --- a/test/libp2p/connection/security_conn/plaintext_connection_test.cpp +++ b/test/libp2p/connection/security_conn/plaintext_connection_test.cpp @@ -95,7 +95,7 @@ TEST_F(PlaintextConnectionTest, LocalMultiaddr) { EXPECT_CALL(*connection_, localMultiaddr()) .WillOnce(Return(kDefaultMultiaddr)); - auto ma = EXPECT_OK(secure_connection_->localMultiaddr()); + ASSERT_OUTCOME_SUCCESS(ma, secure_connection_->localMultiaddr()); ASSERT_EQ(ma.getStringAddress(), kDefaultMultiaddr.getStringAddress()); } @@ -109,7 +109,7 @@ TEST_F(PlaintextConnectionTest, RemoteMultiaddr) { EXPECT_CALL(*connection_, remoteMultiaddr()) .WillOnce(Return(kDefaultMultiaddr)); - auto ma = EXPECT_OK(secure_connection_->remoteMultiaddr()); + ASSERT_OUTCOME_SUCCESS(ma, secure_connection_->remoteMultiaddr()); ASSERT_EQ(ma.getStringAddress(), kDefaultMultiaddr.getStringAddress()); } @@ -123,7 +123,7 @@ TEST_F(PlaintextConnectionTest, Read) { EXPECT_CALL(*connection_, read(_, _, _)).WillOnce(AsioSuccess(size)); auto buf = std::make_shared>(size, 0); secure_connection_->read(*buf, size, [size, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), size); }); } @@ -140,7 +140,7 @@ TEST_F(PlaintextConnectionTest, ReadSome) { .WillOnce(AsioSuccess(smaller /* less than 100 */)); auto buf = std::make_shared>(size, 0); secure_connection_->readSome(*buf, smaller, [smaller, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), smaller); }); } @@ -155,7 +155,7 @@ TEST_F(PlaintextConnectionTest, Write) { EXPECT_CALL(*connection_, writeSome(_, _, _)).WillOnce(AsioSuccess(size)); auto buf = std::make_shared>(size, 0); libp2p::writeReturnSize(secure_connection_, *buf, [size, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), size); }); } @@ -172,7 +172,7 @@ TEST_F(PlaintextConnectionTest, WriteSome) { .WillOnce(AsioSuccess(smaller /* less than 100 */)); auto buf = std::make_shared>(size, 0); secure_connection_->writeSome(*buf, smaller, [smaller, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), smaller); }); } diff --git a/test/libp2p/crypto/chachapoly_test.cpp b/test/libp2p/crypto/chachapoly_test.cpp index aabdaf156..406ed3def 100644 --- a/test/libp2p/crypto/chachapoly_test.cpp +++ b/test/libp2p/crypto/chachapoly_test.cpp @@ -130,8 +130,8 @@ class ChaChaPolyTest : public testing::Test { TEST_F(ChaChaPolyTest, Basic) { ChaCha20Poly1305Impl codec(key); Bytes data = "afafafdeadbeef"_unhex; - auto ciphertext = EXPECT_OK(codec.encrypt(nonce, data, aad)); - auto plaintext = EXPECT_OK(codec.decrypt(nonce, ciphertext, aad)); + ASSERT_OUTCOME_SUCCESS(ciphertext, codec.encrypt(nonce, data, aad)); + ASSERT_OUTCOME_SUCCESS(plaintext, codec.decrypt(nonce, ciphertext, aad)); ASSERT_EQ(data, plaintext); } @@ -143,7 +143,7 @@ TEST_F(ChaChaPolyTest, Basic) { TEST_F(ChaChaPolyTest, Encrypt) { ChaCha20Poly1305Impl codec(key); - auto result = EXPECT_OK(codec.encrypt(nonce, plaintext, aad)); + ASSERT_OUTCOME_SUCCESS(result, codec.encrypt(nonce, plaintext, aad)); ASSERT_EQ(result, ciphertext); } @@ -155,6 +155,6 @@ TEST_F(ChaChaPolyTest, Encrypt) { TEST_F(ChaChaPolyTest, Decrypt) { ChaCha20Poly1305Impl codec(key); - auto result = EXPECT_OK(codec.decrypt(nonce, ciphertext, aad)); + ASSERT_OUTCOME_SUCCESS(result, codec.decrypt(nonce, ciphertext, aad)); ASSERT_EQ(result, plaintext); } diff --git a/test/libp2p/crypto/ecdsa_provider_test.cpp b/test/libp2p/crypto/ecdsa_provider_test.cpp index ec5eef18d..2d99c8c3c 100644 --- a/test/libp2p/crypto/ecdsa_provider_test.cpp +++ b/test/libp2p/crypto/ecdsa_provider_test.cpp @@ -69,7 +69,7 @@ class EcdsaProviderTest : public ::testing::Test { * @then Derived public must be the same as the pre-generated */ TEST_F(EcdsaProviderTest, DerivePublicKeySuccess) { - auto derived_key = EXPECT_OK(provider_.derive(private_key_)); + ASSERT_OUTCOME_SUCCESS(derived_key, provider_.derive(private_key_)); ASSERT_EQ(public_key_, derived_key); } @@ -79,10 +79,12 @@ TEST_F(EcdsaProviderTest, DerivePublicKeySuccess) { * @then Signature verification must be successful and signature must be valid */ TEST_F(EcdsaProviderTest, SignVerifySuccess) { - auto key_pair = EXPECT_OK(provider_.generate()); - auto signature = EXPECT_OK(provider_.sign(message_, key_pair.private_key)); - auto verify_result = - EXPECT_OK(provider_.verify(message_, signature, key_pair.public_key)); + ASSERT_OUTCOME_SUCCESS(key_pair, provider_.generate()); + ASSERT_OUTCOME_SUCCESS(signature, + provider_.sign(message_, key_pair.private_key)); + ASSERT_OUTCOME_SUCCESS( + verify_result, + provider_.verify(message_, signature, key_pair.public_key)); ASSERT_TRUE(verify_result); } @@ -92,8 +94,8 @@ TEST_F(EcdsaProviderTest, SignVerifySuccess) { * @then Pre-generated signature must be valid */ TEST_F(EcdsaProviderTest, SampleSignVerifySuccess) { - auto verify_result = - EXPECT_OK(provider_.verify(message_, signature_, public_key_)); + ASSERT_OUTCOME_SUCCESS(verify_result, + provider_.verify(message_, signature_, public_key_)); ASSERT_TRUE(verify_result); } @@ -103,9 +105,10 @@ TEST_F(EcdsaProviderTest, SampleSignVerifySuccess) { * @then Signature must be invalid */ TEST_F(EcdsaProviderTest, VerifyInvalidPubKeyFailure) { - auto key_pair = EXPECT_OK(provider_.generate()); - auto verify_result = - EXPECT_OK(provider_.verify(message_, signature_, key_pair.public_key)); + ASSERT_OUTCOME_SUCCESS(key_pair, provider_.generate()); + ASSERT_OUTCOME_SUCCESS( + verify_result, + provider_.verify(message_, signature_, key_pair.public_key)); ASSERT_FALSE(verify_result); } @@ -116,7 +119,8 @@ TEST_F(EcdsaProviderTest, VerifyInvalidPubKeyFailure) { */ TEST_F(EcdsaProviderTest, VerifyInvalidMessageFailure) { std::array different_message{}; - auto verify_result = - EXPECT_OK(provider_.verify(different_message, signature_, public_key_)); + ASSERT_OUTCOME_SUCCESS( + verify_result, + provider_.verify(different_message, signature_, public_key_)); ASSERT_FALSE(verify_result); } diff --git a/test/libp2p/crypto/key_generator_test.cpp b/test/libp2p/crypto/key_generator_test.cpp index 11d3832d2..90b933f0f 100644 --- a/test/libp2p/crypto/key_generator_test.cpp +++ b/test/libp2p/crypto/key_generator_test.cpp @@ -76,7 +76,7 @@ class KeyGeneratorTest : public KeyGenTest, */ TEST_P(KeyGeneratorTest, GenerateKeyPairSuccess) { auto key_type = GetParam(); - auto val = EXPECT_OK(crypto_provider_->generateKeys(key_type)); + ASSERT_OUTCOME_SUCCESS(val, crypto_provider_->generateKeys(key_type)); ASSERT_EQ(val.privateKey.type, key_type); ASSERT_EQ(val.publicKey.type, key_type); } @@ -88,8 +88,8 @@ TEST_P(KeyGeneratorTest, GenerateKeyPairSuccess) { */ TEST_P(KeyGeneratorTest, TwoKeysAreDifferent) { auto key_type = GetParam(); - auto val1 = EXPECT_OK(crypto_provider_->generateKeys(key_type)); - auto val2 = EXPECT_OK(crypto_provider_->generateKeys(key_type)); + ASSERT_OUTCOME_SUCCESS(val1, crypto_provider_->generateKeys(key_type)); + ASSERT_OUTCOME_SUCCESS(val2, crypto_provider_->generateKeys(key_type)); ASSERT_NE(val1.privateKey.data, val2.privateKey.data); ASSERT_NE(val1.publicKey.data, val2.privateKey.data); } @@ -104,8 +104,9 @@ TEST_P(KeyGeneratorTest, TwoKeysAreDifferent) { TEST_P(KeyGeneratorTest, DerivePublicKeySuccess) { auto key_type = GetParam(); - auto keys = EXPECT_OK(crypto_provider_->generateKeys(key_type)); - auto derived = EXPECT_OK(crypto_provider_->derivePublicKey(keys.privateKey)); + ASSERT_OUTCOME_SUCCESS(keys, crypto_provider_->generateKeys(key_type)); + ASSERT_OUTCOME_SUCCESS(derived, + crypto_provider_->derivePublicKey(keys.privateKey)); ASSERT_EQ(derived.type, key_type); ASSERT_EQ(keys.publicKey.data, derived.data); } @@ -138,7 +139,7 @@ INSTANTIATE_TEST_SUITE_P( TEST_P(KeyLengthTest, KeyLengthCorrect) { auto [key_type, private_key_length, public_key_length] = GetParam(); - auto val = EXPECT_OK(crypto_provider_->generateKeys(key_type)); + ASSERT_OUTCOME_SUCCESS(val, crypto_provider_->generateKeys(key_type)); ASSERT_EQ(val.privateKey.data.size(), private_key_length); } diff --git a/test/libp2p/crypto/key_validator_test.cpp b/test/libp2p/crypto/key_validator_test.cpp index 874c918e7..989fb296f 100644 --- a/test/libp2p/crypto/key_validator_test.cpp +++ b/test/libp2p/crypto/key_validator_test.cpp @@ -75,10 +75,10 @@ class GeneratedKeysTest : public BaseKeyTest, */ TEST_P(GeneratedKeysTest, GeneratedKeysAreValid) { Key::Type key_type = GetParam(); - auto key_pair = EXPECT_OK(crypto_provider->generateKeys(key_type)); - EXPECT_OK(validator->validate(key_pair.publicKey)); - EXPECT_OK(validator->validate(key_pair.privateKey)); - EXPECT_OK(validator->validate(key_pair)); + ASSERT_OUTCOME_SUCCESS(key_pair, crypto_provider->generateKeys(key_type)); + EXPECT_OUTCOME_SUCCESS(validator->validate(key_pair.publicKey)); + EXPECT_OUTCOME_SUCCESS(validator->validate(key_pair.privateKey)); + EXPECT_OUTCOME_SUCCESS(validator->validate(key_pair)); } /** @@ -95,10 +95,10 @@ TEST_P(GeneratedKeysTest, GeneratedKeysAreValid) { TEST_P(GeneratedKeysTest, ArbitraryKeyInvalid) { Key::Type key_type = GetParam(); auto public_key = PublicKey{{key_type, random->randomBytes(64)}}; - EXPECT_HAS_ERROR(validator->validate(public_key)); + ASSERT_OUTCOME_ERROR(validator->validate(public_key)); auto private_key = PrivateKey{{key_type, random->randomBytes(64)}}; - EXPECT_HAS_ERROR(validator->validate(private_key)); + ASSERT_OUTCOME_ERROR(validator->validate(private_key)); } /** @@ -115,11 +115,11 @@ TEST_P(GeneratedKeysTest, ArbitraryKeyInvalid) { TEST_P(GeneratedKeysTest, InvalidPublicKeyInvalidatesPair) { Key::Type key_type = GetParam(); - auto key_pair = EXPECT_OK(crypto_provider->generateKeys(key_type)); + ASSERT_OUTCOME_SUCCESS(key_pair, crypto_provider->generateKeys(key_type)); auto public_key = PublicKey{{key_type, random->randomBytes(64)}}; - EXPECT_HAS_ERROR(validator->validate(public_key)); + ASSERT_OUTCOME_ERROR(validator->validate(public_key)); auto invalid_pair = KeyPair{public_key, key_pair.privateKey}; - EXPECT_HAS_ERROR(validator->validate(invalid_pair)); + ASSERT_OUTCOME_ERROR(validator->validate(invalid_pair)); } INSTANTIATE_TEST_SUITE_P(GeneratedValidKeysCases, @@ -145,8 +145,8 @@ TEST_P(RandomKeyTest, Every32byteIsValidPrivateKey) { auto key_type = GetParam(); auto sequence = random->randomBytes(32); auto private_key = PrivateKey{{key_type, sequence}}; - EXPECT_OK(validator->validate(private_key)); - EXPECT_OK(crypto_provider->derivePublicKey(private_key)); + EXPECT_OUTCOME_SUCCESS(validator->validate(private_key)); + EXPECT_OUTCOME_SUCCESS(crypto_provider->derivePublicKey(private_key)); } INSTANTIATE_TEST_SUITE_P(RandomSequencesCases, @@ -165,9 +165,9 @@ class UnspecifiedKeyTest : public BaseKeyTest, public ::testing::Test {}; TEST_F(UnspecifiedKeyTest, UnspecifiedAlwaysValid) { auto private_key = PrivateKey{{Key::Type::UNSPECIFIED, random->randomBytes(64)}}; - EXPECT_OK(validator->validate(private_key)); + EXPECT_OUTCOME_SUCCESS(validator->validate(private_key)); auto public_key = PublicKey{{Key::Type::UNSPECIFIED, random->randomBytes(64)}}; - EXPECT_OK(validator->validate(public_key)); - EXPECT_OK(validator->validate(KeyPair{public_key, private_key})); + EXPECT_OUTCOME_SUCCESS(validator->validate(public_key)); + EXPECT_OUTCOME_SUCCESS(validator->validate(KeyPair{public_key, private_key})); } diff --git a/test/libp2p/crypto/rsa_provider_test.cpp b/test/libp2p/crypto/rsa_provider_test.cpp index 2c9efe579..ce563f76d 100644 --- a/test/libp2p/crypto/rsa_provider_test.cpp +++ b/test/libp2p/crypto/rsa_provider_test.cpp @@ -213,7 +213,8 @@ class RsaProviderTest : public ::testing::Test { * @then Pre-generated signature must be valid */ TEST_F(RsaProviderTest, SignatureVerificationSuccess) { - auto result = EXPECT_OK(provider_.verify(message_, signature_, public_key_)); + ASSERT_OUTCOME_SUCCESS(result, + provider_.verify(message_, signature_, public_key_)); ASSERT_TRUE(result); } @@ -225,8 +226,8 @@ TEST_F(RsaProviderTest, SignatureVerificationSuccess) { */ TEST_F(RsaProviderTest, InvalidSignatureVerificationFailure) { Signature different_signature{SAMPLE_RSA_INVALID_SIGNATURE_BYTES}; - auto result = - EXPECT_OK(provider_.verify(message_, different_signature, public_key_)); + ASSERT_OUTCOME_SUCCESS( + result, provider_.verify(message_, different_signature, public_key_)); ASSERT_FALSE(result); } @@ -239,7 +240,8 @@ TEST_F(RsaProviderTest, InvalidSignatureVerificationFailure) { TEST_F(RsaProviderTest, InvalidPublicKeySignatureVerificationFailure) { PublicKey invalid_key = public_key_; invalid_key[32] ^= 8; - auto result = EXPECT_OK(provider_.verify(message_, signature_, invalid_key)); + ASSERT_OUTCOME_SUCCESS(result, + provider_.verify(message_, signature_, invalid_key)); ASSERT_FALSE(result); } @@ -249,6 +251,6 @@ TEST_F(RsaProviderTest, InvalidPublicKeySignatureVerificationFailure) { * @then Generated signature matches pre-generated */ TEST_F(RsaProviderTest, SigningSample) { - auto signature = EXPECT_OK(provider_.sign(message_, private_key_)); + ASSERT_OUTCOME_SUCCESS(signature, provider_.sign(message_, private_key_)); EXPECT_EQ(signature, signature_); } diff --git a/test/libp2p/crypto/secp256k1_test.cpp b/test/libp2p/crypto/secp256k1_test.cpp index 0d97d248e..636087e6b 100644 --- a/test/libp2p/crypto/secp256k1_test.cpp +++ b/test/libp2p/crypto/secp256k1_test.cpp @@ -64,7 +64,8 @@ class Secp256k1ProviderTest : public ::testing::Test { * @then Derived public key must be the same as pre-generated */ TEST_F(Secp256k1ProviderTest, PublicKeyDerivationSuccess) { - auto derivedPublicKey = EXPECT_OK(provider_.derive(sample_private_key_)); + ASSERT_OUTCOME_SUCCESS(derivedPublicKey, + provider_.derive(sample_private_key_)); ASSERT_EQ(derivedPublicKey, sample_public_key_); }; @@ -74,7 +75,8 @@ TEST_F(Secp256k1ProviderTest, PublicKeyDerivationSuccess) { * @then Verification of the pre-generated signature must be successful */ TEST_F(Secp256k1ProviderTest, PreGeneratedSignatureVerificationSuccess) { - auto verificationResult = EXPECT_OK( + ASSERT_OUTCOME_SUCCESS( + verificationResult, provider_.verify(message_, sample_signature_, sample_public_key_)); ASSERT_TRUE(verificationResult); } @@ -85,10 +87,12 @@ TEST_F(Secp256k1ProviderTest, PreGeneratedSignatureVerificationSuccess) { * @then Generating key pair, signature and it's verification must be successful */ TEST_F(Secp256k1ProviderTest, GenerateSignatureSuccess) { - auto keyPair = EXPECT_OK(provider_.generate()); - auto signature = EXPECT_OK(provider_.sign(message_, keyPair.private_key)); - auto verificationResult = - EXPECT_OK(provider_.verify(message_, signature, keyPair.public_key)); + ASSERT_OUTCOME_SUCCESS(keyPair, provider_.generate()); + ASSERT_OUTCOME_SUCCESS(signature, + provider_.sign(message_, keyPair.private_key)); + ASSERT_OUTCOME_SUCCESS( + verificationResult, + provider_.verify(message_, signature, keyPair.public_key)); ASSERT_TRUE(verificationResult); } @@ -98,11 +102,12 @@ TEST_F(Secp256k1ProviderTest, GenerateSignatureSuccess) { * @then Signature for different public key must be invalid */ TEST_F(Secp256k1ProviderTest, VerifySignatureInvalidKeyFailure) { - auto firstKeyPair = EXPECT_OK(provider_.generate()); - auto secondKeyPair = EXPECT_OK(provider_.generate()); - auto signature = - EXPECT_OK(provider_.sign(message_, firstKeyPair.private_key)); - auto verificationResult = EXPECT_OK( + ASSERT_OUTCOME_SUCCESS(firstKeyPair, provider_.generate()); + ASSERT_OUTCOME_SUCCESS(secondKeyPair, provider_.generate()); + ASSERT_OUTCOME_SUCCESS(signature, + provider_.sign(message_, firstKeyPair.private_key)); + ASSERT_OUTCOME_SUCCESS( + verificationResult, provider_.verify(message_, signature, secondKeyPair.public_key)); ASSERT_FALSE(verificationResult); } @@ -113,9 +118,11 @@ TEST_F(Secp256k1ProviderTest, VerifySignatureInvalidKeyFailure) { * @then Invalid signature verification must be unsuccessful */ TEST_F(Secp256k1ProviderTest, VerifyInvalidSignaturFailure) { - auto signature = EXPECT_OK(provider_.sign(message_, sample_private_key_)); + ASSERT_OUTCOME_SUCCESS(signature, + provider_.sign(message_, sample_private_key_)); message_[0] = 0; // Modify sample message - auto verificationResult = - EXPECT_OK(provider_.verify(message_, signature, sample_public_key_)); + ASSERT_OUTCOME_SUCCESS( + verificationResult, + provider_.verify(message_, signature, sample_public_key_)); ASSERT_FALSE(verificationResult); } diff --git a/test/libp2p/crypto/x25519_provider_test.cpp b/test/libp2p/crypto/x25519_provider_test.cpp index 177e9f3a7..2aa4cee33 100644 --- a/test/libp2p/crypto/x25519_provider_test.cpp +++ b/test/libp2p/crypto/x25519_provider_test.cpp @@ -39,7 +39,7 @@ class X25519Fixture : public ::testing::Test { * @then the public key bytes are equal to expected */ TEST_F(X25519Fixture, GoKeyCompatibility) { - auto public_key = EXPECT_OK(provider.derive(privkey)); + ASSERT_OUTCOME_SUCCESS(public_key, provider.derive(privkey)); ASSERT_EQ(public_key, pubkey); } @@ -49,7 +49,7 @@ TEST_F(X25519Fixture, GoKeyCompatibility) { * @then the result equals to the expected */ TEST_F(X25519Fixture, GoDiffieHellmanCompatibility) { - auto shared_secret = EXPECT_OK(provider.dh(privkey, pubkey)); + ASSERT_OUTCOME_SUCCESS(shared_secret, provider.dh(privkey, pubkey)); ASSERT_EQ(shared_secret, secret); } @@ -59,8 +59,8 @@ TEST_F(X25519Fixture, GoDiffieHellmanCompatibility) { * @then the shared secrets are the same */ TEST_F(X25519Fixture, SharedSecret) { - auto peer = EXPECT_OK(provider.generate()); - auto secret1 = EXPECT_OK(provider.dh(privkey, peer.public_key)); - auto secret2 = EXPECT_OK(provider.dh(peer.private_key, pubkey)); + ASSERT_OUTCOME_SUCCESS(peer, provider.generate()); + ASSERT_OUTCOME_SUCCESS(secret1, provider.dh(privkey, peer.public_key)); + ASSERT_OUTCOME_SUCCESS(secret2, provider.dh(peer.private_key, pubkey)); ASSERT_EQ(secret1, secret2); } diff --git a/test/libp2p/multi/cid_test.cpp b/test/libp2p/multi/cid_test.cpp index bf5ce6f8f..8ef97bf62 100644 --- a/test/libp2p/multi/cid_test.cpp +++ b/test/libp2p/multi/cid_test.cpp @@ -41,7 +41,7 @@ TEST(CidTest, MultibaseStringSuccess) { ContentIdentifier cid(ContentIdentifier::Version::V0, MulticodecType::Code::DAG_PB, reference_multihash); - auto cid_string = EXPECT_OK(ContentIdentifierCodec::toString(cid)); + ASSERT_OUTCOME_SUCCESS(cid_string, ContentIdentifierCodec::toString(cid)); ASSERT_EQ(cid_string, "QmYTYMTdkVyB8we45bdXfZuDu5vCjRVX8QNTFLhC7K8C7t"); } @@ -57,7 +57,7 @@ TEST(CidTest, MultibaseStringSuccessCIDV1) { ContentIdentifier cid(ContentIdentifier::Version::V1, MulticodecType::Code::RAW, reference_multihash); - auto cid_string = EXPECT_OK(ContentIdentifierCodec::toString(cid)); + ASSERT_OUTCOME_SUCCESS(cid_string, ContentIdentifierCodec::toString(cid)); ASSERT_EQ(cid_string, "bafkreibnlo34hl56ndafxtiqtweq3sriz2ybaw7vfhvbcepz56fujmqxxe"); } @@ -74,8 +74,9 @@ TEST(CidTest, MultibaseStringOfBaseSuccessCIDV1) { ContentIdentifier cid(ContentIdentifier::Version::V1, MulticodecType::Code::RAW, reference_multihash); - auto cid_string = EXPECT_OK(ContentIdentifierCodec::toStringOfBase( - cid, MultibaseCodec::Encoding::BASE58)); + ASSERT_OUTCOME_SUCCESS(cid_string, + ContentIdentifierCodec::toStringOfBase( + cid, MultibaseCodec::Encoding::BASE58)); ASSERT_EQ(cid_string, "zb2rhZhLextyrUiNJUcVUR143SaKDPvHxgpGyeB1N1nqdPzfi"); } @@ -91,8 +92,9 @@ TEST(CidTest, MultibaseStringOfBaseSuccessCIDV0) { ContentIdentifier cid(ContentIdentifier::Version::V0, MulticodecType::Code::DAG_PB, reference_multihash); - auto cid_string = EXPECT_OK(ContentIdentifierCodec::toStringOfBase( - cid, MultibaseCodec::Encoding::BASE58)); + ASSERT_OUTCOME_SUCCESS(cid_string, + ContentIdentifierCodec::toStringOfBase( + cid, MultibaseCodec::Encoding::BASE58)); ASSERT_EQ(cid_string, "QmYTYMTdkVyB8we45bdXfZuDu5vCjRVX8QNTFLhC7K8C7t"); } @@ -108,9 +110,10 @@ TEST(CidTest, MultibaseStringOfBaseCIDV0InvalidBase) { ContentIdentifier cid(ContentIdentifier::Version::V0, MulticodecType::Code::DAG_PB, reference_multihash); - EXPECT_EC(ContentIdentifierCodec::toStringOfBase( - cid, MultibaseCodec::Encoding::BASE32_LOWER), - ContentIdentifierCodec::EncodeError::INVALID_BASE_ENCODING); + ASSERT_OUTCOME_ERROR( + ContentIdentifierCodec::toStringOfBase( + cid, MultibaseCodec::Encoding::BASE32_LOWER), + ContentIdentifierCodec::EncodeError::INVALID_BASE_ENCODING); } /** @@ -127,8 +130,8 @@ TEST(CidTest, MultibaseFromStringSuccessCIDV1) { reference_multihash); const std::string reference_string_cid = "bafkreibnlo34hl56ndafxtiqtweq3sriz2ybaw7vfhvbcepz56fujmqxxe"; - auto cid = - EXPECT_OK(ContentIdentifierCodec::fromString(reference_string_cid)); + ASSERT_OUTCOME_SUCCESS( + cid, ContentIdentifierCodec::fromString(reference_string_cid)); ASSERT_EQ(cid, reference_cid); } @@ -147,8 +150,8 @@ TEST(CidTest, MultibaseFromStringSuccessCIDV0) { const std::string reference_string_cid = "QmYTYMTdkVyB8we45bdXfZuDu5vCjRVX8QNTFLhC7K8C7t"; - auto cid = - EXPECT_OK(ContentIdentifierCodec::fromString(reference_string_cid)); + ASSERT_OUTCOME_SUCCESS( + cid, ContentIdentifierCodec::fromString(reference_string_cid)); ASSERT_EQ(cid, reference_cid); } @@ -160,8 +163,8 @@ TEST(CidTest, MultibaseFromStringSuccessCIDV0) { TEST(CidTest, MultibaseFromStringShortCid) { const std::string short_string = "*"; - EXPECT_EC(ContentIdentifierCodec::fromString(short_string), - ContentIdentifierCodec::DecodeError::CID_TOO_SHORT); + ASSERT_OUTCOME_ERROR(ContentIdentifierCodec::fromString(short_string), + ContentIdentifierCodec::DecodeError::CID_TOO_SHORT); } /** @@ -236,11 +239,12 @@ TEST(CidTest, Create) { } TEST(CidEncodeTest, Encode) { - EXPECT_EC(ContentIdentifierCodec::encode( - ContentIdentifier(ContentIdentifier::Version::V0, - MulticodecType::Code::SHA1, - ZERO_MULTIHASH)), - ContentIdentifierCodec::EncodeError::INVALID_CONTENT_TYPE); + ASSERT_OUTCOME_ERROR( + ContentIdentifierCodec::encode( + ContentIdentifier(ContentIdentifier::Version::V0, + MulticodecType::Code::SHA1, + ZERO_MULTIHASH)), + ContentIdentifierCodec::EncodeError::INVALID_CONTENT_TYPE); EXPECT_EQ(ContentIdentifierCodec::encode( ContentIdentifier(ContentIdentifier::Version::V0, @@ -270,8 +274,8 @@ class CidEncodeDecodeTest : public testing::TestWithParam {}; TEST_P(CidEncodeDecodeTest, DecodedMatchesOriginal) { auto cid = GetParam(); - auto bytes = EXPECT_OK(ContentIdentifierCodec::encode(cid)); - auto dec_cid = EXPECT_OK(ContentIdentifierCodec::decode(bytes)); + ASSERT_OUTCOME_SUCCESS(bytes, ContentIdentifierCodec::encode(cid)); + ASSERT_OUTCOME_SUCCESS(dec_cid, ContentIdentifierCodec::decode(bytes)); ASSERT_EQ(cid, dec_cid); } diff --git a/test/libp2p/multi/multiaddress_test.cpp b/test/libp2p/multi/multiaddress_test.cpp index 1f2fcee13..98f7a9916 100644 --- a/test/libp2p/multi/multiaddress_test.cpp +++ b/test/libp2p/multi/multiaddress_test.cpp @@ -37,7 +37,7 @@ class MultiaddressTest : public ::testing::Test { * @then creation succeeds */ TEST_F(MultiaddressTest, CreateFromStringValid) { - auto address = EXPECT_OK(Multiaddress::create(valid_ip_udp)); + ASSERT_OUTCOME_SUCCESS(address, Multiaddress::create(valid_ip_udp)); ASSERT_EQ(address.getStringAddress(), valid_ip_udp); ASSERT_EQ(address.getBytesAddress(), valid_ip_udp_bytes); } @@ -145,7 +145,7 @@ TEST_F(MultiaddressTest, GetString) { * @then result is equal to the expected one */ TEST_F(MultiaddressTest, GetBytes) { - auto address = EXPECT_OK(Multiaddress::create(valid_ip_udp)); + ASSERT_OUTCOME_SUCCESS(address, Multiaddress::create(valid_ip_udp)); ASSERT_EQ(address.getBytesAddress(), valid_ip_udp_bytes); } @@ -251,7 +251,7 @@ TEST_F(MultiaddressTest, GetProtocolsWithValues) { TEST_F(MultiaddressTest, DnsAndIpfs) { auto addr = "/dns4/p2p.cc3-0.kusama.network/tcp/30100/p2p/12D3KooWDgtynm4S9M3m6ZZhXYu2RrWKdvkCSScc25xKDVSg1Sjd"s; - auto address = EXPECT_OK(Multiaddress::create(addr)); + ASSERT_OUTCOME_SUCCESS(address, Multiaddress::create(addr)); ASSERT_EQ(address.getStringAddress(), addr); auto peer_id_opt = address.getPeerId(); ASSERT_TRUE(peer_id_opt); @@ -266,6 +266,6 @@ TEST_F(MultiaddressTest, DnsAndIpfs) { */ TEST_F(MultiaddressTest, ParityWss) { auto addr = "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F"s; - auto address = EXPECT_OK(Multiaddress::create(addr)); + ASSERT_OUTCOME_SUCCESS(address, Multiaddress::create(addr)); ASSERT_EQ(address.getStringAddress(), addr); } diff --git a/test/libp2p/multi/utils/address_converter_test.cpp b/test/libp2p/multi/utils/address_converter_test.cpp index 534c86da4..c37626df4 100644 --- a/test/libp2p/multi/utils/address_converter_test.cpp +++ b/test/libp2p/multi/utils/address_converter_test.cpp @@ -17,24 +17,24 @@ using libp2p::multi::ProtocolList; using libp2p::multi::converters::addressToBytes; using libp2p::multi::converters::ConversionError; -#define EXAMINE_STR_TO_BYTES(str_addr, hex_bytes, should_be_success) \ - do { \ - if (should_be_success) { \ - auto actual = EXPECT_OK(addressToBytes(protocol, str_addr)); \ - auto expected = EXPECT_OK(qtils::unhex(hex_bytes)); \ - ASSERT_EQ(actual, expected); \ - } else { \ - EXPECT_EC(addressToBytes(protocol, str_addr), \ - ConversionError::INVALID_ADDRESS); \ - } \ +#define EXAMINE_STR_TO_BYTES(str_addr, hex_bytes, should_be_success) \ + do { \ + if (should_be_success) { \ + ASSERT_OUTCOME_SUCCESS(actual, addressToBytes(protocol, str_addr)); \ + ASSERT_OUTCOME_SUCCESS(expected, qtils::unhex(hex_bytes)); \ + ASSERT_EQ(actual, expected); \ + } else { \ + ASSERT_OUTCOME_ERROR(addressToBytes(protocol, str_addr), \ + ConversionError::INVALID_ADDRESS); \ + } \ } while (false) -#define EXAMINE_BYTES_TO_STR(str_addr, hex_bytes) \ - do { \ - auto &expected = str_addr; \ - auto bytes = EXPECT_OK(qtils::unhex(hex_bytes)); \ - auto actual = EXPECT_OK(bytesToMultiaddrString(bytes)); \ - ASSERT_EQ(actual, expected); \ +#define EXAMINE_BYTES_TO_STR(str_addr, hex_bytes) \ + do { \ + auto &expected = str_addr; \ + ASSERT_OUTCOME_SUCCESS(bytes, qtils::unhex(hex_bytes)); \ + ASSERT_OUTCOME_SUCCESS(actual, bytesToMultiaddrString(bytes)); \ + ASSERT_EQ(actual, expected); \ } while (false) /** diff --git a/test/libp2p/multi/utils/string_from_to_bytes_test.cpp b/test/libp2p/multi/utils/string_from_to_bytes_test.cpp index 42fada802..3d00aad32 100644 --- a/test/libp2p/multi/utils/string_from_to_bytes_test.cpp +++ b/test/libp2p/multi/utils/string_from_to_bytes_test.cpp @@ -16,19 +16,19 @@ using libp2p::multi::converters::bytesToMultiaddrString; using libp2p::multi::converters::ConversionError; using libp2p::multi::converters::multiaddrToBytes; -#define EXAMINE_STR_TO_BYTES(str_addr, hex_bytes) \ - do { \ - auto actual = EXPECT_OK(multiaddrToBytes(str_addr)); \ - auto expected = EXPECT_OK(qtils::unhex(hex_bytes)); \ - ASSERT_EQ(actual, expected); \ +#define EXAMINE_STR_TO_BYTES(str_addr, hex_bytes) \ + do { \ + ASSERT_OUTCOME_SUCCESS(actual, multiaddrToBytes(str_addr)); \ + ASSERT_OUTCOME_SUCCESS(expected, qtils::unhex(hex_bytes)); \ + ASSERT_EQ(actual, expected); \ } while (false) -#define EXAMINE_BYTES_TO_STR(str_addr, hex_bytes) \ - do { \ - auto &expected = str_addr; \ - auto bytes = EXPECT_OK(qtils::unhex(hex_bytes)); \ - auto actual = EXPECT_OK(bytesToMultiaddrString(bytes)); \ - ASSERT_EQ(actual, expected); \ +#define EXAMINE_BYTES_TO_STR(str_addr, hex_bytes) \ + do { \ + auto &expected = str_addr; \ + ASSERT_OUTCOME_SUCCESS(bytes, qtils::unhex(hex_bytes)); \ + ASSERT_OUTCOME_SUCCESS(actual, bytesToMultiaddrString(bytes)); \ + ASSERT_EQ(actual, expected); \ } while (false) /** @@ -123,17 +123,21 @@ TEST(AddressConverter, BytesToString) { } TEST(AddressConverter, InvalidAddresses) { - EXPECT_EC(multiaddrToBytes("ip4/127.0.0.1"), - ConversionError::ADDRESS_DOES_NOT_BEGIN_WITH_SLASH); - EXPECT_EC(multiaddrToBytes("/"), ConversionError::EMPTY_PROTOCOL); - EXPECT_EC(multiaddrToBytes("/ip4/8.8.8.8//"), - ConversionError::EMPTY_PROTOCOL); - EXPECT_EC(multiaddrToBytes("/fake"), ConversionError::NO_SUCH_PROTOCOL); - EXPECT_EC(multiaddrToBytes("/80/tcp"), ConversionError::NO_SUCH_PROTOCOL); - EXPECT_EC(multiaddrToBytes("/ip4/127.0.0.1/tcp"), - ConversionError::EMPTY_ADDRESS); - EXPECT_EC(multiaddrToBytes("/ip4/254.255.256.257/"), - ConversionError::INVALID_ADDRESS); - EXPECT_EC(multiaddrToBytes("/tcp/77777"), ConversionError::INVALID_ADDRESS); - EXPECT_EC(multiaddrToBytes("/tcp/udp"), ConversionError::INVALID_ADDRESS); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("ip4/127.0.0.1"), + ConversionError::ADDRESS_DOES_NOT_BEGIN_WITH_SLASH); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/"), ConversionError::EMPTY_PROTOCOL); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/ip4/8.8.8.8//"), + ConversionError::EMPTY_PROTOCOL); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/fake"), + ConversionError::NO_SUCH_PROTOCOL); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/80/tcp"), + ConversionError::NO_SUCH_PROTOCOL); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/ip4/127.0.0.1/tcp"), + ConversionError::EMPTY_ADDRESS); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/ip4/254.255.256.257/"), + ConversionError::INVALID_ADDRESS); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/tcp/77777"), + ConversionError::INVALID_ADDRESS); + ASSERT_OUTCOME_ERROR(multiaddrToBytes("/tcp/udp"), + ConversionError::INVALID_ADDRESS); } diff --git a/test/libp2p/network/dialer_test.cpp b/test/libp2p/network/dialer_test.cpp index aaf6144ad..5bb77f0fb 100644 --- a/test/libp2p/network/dialer_test.cpp +++ b/test/libp2p/network/dialer_test.cpp @@ -112,7 +112,7 @@ TEST_F(DialerTest, DialAllTheAddresses) { bool executed = false; dialer->dial(pinfo_two_addrs, [&](auto &&rconn) { - auto conn = EXPECT_OK(rconn); + ASSERT_OUTCOME_SUCCESS(conn, rconn); (void)conn; executed = true; }); @@ -144,7 +144,7 @@ TEST_F(DialerTest, DialNewConnection) { bool executed = false; dialer->dial(pinfo, [&](auto &&rconn) { - auto conn = EXPECT_OK(rconn); + ASSERT_OUTCOME_SUCCESS(conn, rconn); (void)conn; executed = true; }); @@ -168,7 +168,7 @@ TEST_F(DialerTest, DialNoAddresses) { peer::PeerInfo pinfo = {pid, {}}; bool executed = false; dialer->dial(pinfo, [&](auto &&rconn) { - EXPECT_EC(rconn, std::errc::destination_address_required); + ASSERT_OUTCOME_ERROR(rconn, std::errc::destination_address_required); executed = true; }); @@ -193,7 +193,7 @@ TEST_F(DialerTest, DialNoTransports) { bool executed = false; dialer->dial(pinfo, [&](auto &&rconn) { - EXPECT_EC(rconn, std::errc::address_family_not_supported); + ASSERT_OUTCOME_ERROR(rconn, std::errc::address_family_not_supported); executed = true; }); @@ -214,7 +214,7 @@ TEST_F(DialerTest, DialExistingConnection) { bool executed = false; dialer->dial(pinfo, [&](auto &&rconn) { - auto conn = EXPECT_OK(rconn); + ASSERT_OUTCOME_SUCCESS(conn, rconn); (void)conn; executed = true; }); @@ -246,7 +246,7 @@ TEST_F(DialerTest, NewStreamFailed) { bool executed = false; dialer->newStream(pinfo, protocols, [&](auto &&rstream) { - EXPECT_EC(rstream, std::errc::io_error); + ASSERT_OUTCOME_ERROR(rstream, std::errc::io_error); executed = true; }); @@ -281,7 +281,7 @@ TEST_F(DialerTest, NewStreamNegotiationFailed) { bool executed = false; dialer->newStream(pinfo, protocols, [&](auto &&rstream) { - EXPECT_EC(rstream, r); + ASSERT_OUTCOME_ERROR(rstream, r); executed = true; }); @@ -314,7 +314,7 @@ TEST_F(DialerTest, NewStreamSuccess) { bool executed = false; dialer->newStream(pinfo, protocols, [&](auto &&rstream) { - auto s = EXPECT_OK(rstream); + ASSERT_OUTCOME_SUCCESS(s, rstream); (void)s; executed = true; }); diff --git a/test/libp2p/network/listener_manager_test.cpp b/test/libp2p/network/listener_manager_test.cpp index bd73fcc71..ff419dabc 100644 --- a/test/libp2p/network/listener_manager_test.cpp +++ b/test/libp2p/network/listener_manager_test.cpp @@ -70,7 +70,7 @@ TEST_F(ListenerManagerTest, ListenValidAddr) { .WillOnce(Return(transport_listener)); auto supported = "/ip4/127.0.0.1/tcp/0"_multiaddr; - EXPECT_OK(listener->listen(supported)); + ASSERT_OUTCOME_SUCCESS(listener->listen(supported)); EXPECT_EQ(listener->getListenAddresses(), std::vector{supported}); @@ -84,7 +84,7 @@ TEST_F(ListenerManagerTest, ListenValidAddr) { std::vector{random_port_resolved}); // do listen on the same addr - EXPECT_HAS_ERROR(listener->listen(supported)); + ASSERT_OUTCOME_ERROR(listener->listen(supported)); } /** @@ -96,7 +96,7 @@ TEST_F(ListenerManagerTest, ListenInvalidAddr) { EXPECT_CALL(*tmgr, findBest(_)).WillOnce(Return(nullptr)); auto unsupported = "/ip4/127.0.0.1/udp/0"_multiaddr; - EXPECT_HAS_ERROR(listener->listen(unsupported)); + ASSERT_OUTCOME_ERROR(listener->listen(unsupported)); EXPECT_TRUE(listener->getListenAddresses().empty()); @@ -120,7 +120,7 @@ TEST_F(ListenerManagerTest, StartStop) { // given 1 listener auto supported = "/ip4/127.0.0.1/tcp/0"_multiaddr; - EXPECT_OK(listener->listen(supported)); + ASSERT_OUTCOME_SUCCESS(listener->listen(supported)); // when start ASSERT_NO_FATAL_FAILURE(listener->start()); diff --git a/test/libp2p/peer/address_repository/inmem_address_repository_test.cpp b/test/libp2p/peer/address_repository/inmem_address_repository_test.cpp index 0c15922ba..0faa9cc75 100644 --- a/test/libp2p/peer/address_repository/inmem_address_repository_test.cpp +++ b/test/libp2p/peer/address_repository/inmem_address_repository_test.cpp @@ -59,14 +59,14 @@ struct InmemAddressRepository_Test : public ::testing::Test { TEST_F(InmemAddressRepository_Test, GarbageCollection) { // @given address repository that has 2 peers, and some addresses - EXPECT_OK(db->addAddresses(p1, std::vector{ma1, ma2}, 10ms)); - EXPECT_OK(db->addAddresses(p1, std::vector{ma3, ma4}, 1000ms)); - EXPECT_OK(db->upsertAddresses(p2, std::vector{ma4}, 10ms)); + ASSERT_OUTCOME_SUCCESS(db->addAddresses(p1, std::vector{ma1, ma2}, 10ms)); + ASSERT_OUTCOME_SUCCESS(db->addAddresses(p1, std::vector{ma3, ma4}, 1000ms)); + ASSERT_OUTCOME_SUCCESS(db->upsertAddresses(p2, std::vector{ma4}, 10ms)); // @when no collectGarbage is called { - auto v1 = EXPECT_OK(db->getAddresses(p1)); - auto v2 = EXPECT_OK(db->getAddresses(p2)); + ASSERT_OUTCOME_SUCCESS(v1, db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v2, db->getAddresses(p2)); // @then initial state is initial EXPECT_EQ(v1.size(), 4); @@ -77,8 +77,8 @@ TEST_F(InmemAddressRepository_Test, GarbageCollection) { collectGarbage(); { - auto v1 = EXPECT_OK(db->getAddresses(p1)); - auto v2 = EXPECT_OK(db->getAddresses(p2)); + ASSERT_OUTCOME_SUCCESS(v1, db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v2, db->getAddresses(p2)); // @then no addresses are evicted EXPECT_EQ(v1.size(), 4); @@ -92,13 +92,13 @@ TEST_F(InmemAddressRepository_Test, GarbageCollection) { { // @then p1 has evicted 2 addresses - auto v1 = EXPECT_OK(db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v1, db->getAddresses(p1)); EXPECT_EQ(v1.size(), 2); // @and p2 has been evicted completely auto v2 = db->getAddresses(p2); // peers without addresses are removed... so we can't find this peer - EXPECT_EC(v2, PeerError::NOT_FOUND); + ASSERT_OUTCOME_ERROR(v2, PeerError::NOT_FOUND); } // @when clear p1 addresses @@ -108,12 +108,12 @@ TEST_F(InmemAddressRepository_Test, GarbageCollection) { // @then p1 is not evicted, but all its addresses are // since we intentionally cleared addresses of this peer, we do not evict // this peer from the list of known peers up to the next garbage collection - auto v1 = EXPECT_OK(db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v1, db->getAddresses(p1)); EXPECT_EQ(v1.size(), 0); // @and p2 is still evicted auto v2 = db->getAddresses(p2); - EXPECT_EC(v2, PeerError::NOT_FOUND); + ASSERT_OUTCOME_ERROR(v2, PeerError::NOT_FOUND); } // @when third collect garbage is called @@ -124,7 +124,7 @@ TEST_F(InmemAddressRepository_Test, GarbageCollection) { // last garbage collection removed all peers that do not have addresses for (const auto &it : {p1, p2}) { auto v = db->getAddresses(it); - EXPECT_EC(v, PeerError::NOT_FOUND); + ASSERT_OUTCOME_ERROR(v, PeerError::NOT_FOUND); } } } @@ -135,11 +135,11 @@ TEST_F(InmemAddressRepository_Test, GarbageCollection) { * @then ttl is updated, ma1 is not evicted */ TEST_F(InmemAddressRepository_Test, UpdateAddress) { - EXPECT_OK(db->addAddresses(p1, std::vector{ma1}, 10ms)); - EXPECT_OK(db->upsertAddresses(p1, std::vector{ma1}, 1000ms)); + ASSERT_OUTCOME_SUCCESS(db->addAddresses(p1, std::vector{ma1}, 10ms)); + ASSERT_OUTCOME_SUCCESS(db->upsertAddresses(p1, std::vector{ma1}, 1000ms)); { - auto v = EXPECT_OK(db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v, db->getAddresses(p1)); EXPECT_EQ(v.size(), 1); } @@ -147,7 +147,7 @@ TEST_F(InmemAddressRepository_Test, UpdateAddress) { collectGarbage(); // ma1 is updated - auto v = EXPECT_OK(db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v, db->getAddresses(p1)); EXPECT_EQ(v.size(), 1); } @@ -157,11 +157,11 @@ TEST_F(InmemAddressRepository_Test, UpdateAddress) { * @then ttl of ma1 is not updated, ma1 is evicted. ma2 is inserted. */ TEST_F(InmemAddressRepository_Test, InsertAddress) { - EXPECT_OK(db->addAddresses(p1, std::vector{ma1}, 10ms)); - EXPECT_OK(db->upsertAddresses(p1, std::vector{ma2}, 1000ms)); + ASSERT_OUTCOME_SUCCESS(db->addAddresses(p1, std::vector{ma1}, 10ms)); + ASSERT_OUTCOME_SUCCESS(db->upsertAddresses(p1, std::vector{ma2}, 1000ms)); { - auto v = EXPECT_OK(db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v, db->getAddresses(p1)); EXPECT_EQ(v.size(), 2); } @@ -169,7 +169,7 @@ TEST_F(InmemAddressRepository_Test, InsertAddress) { collectGarbage(); // ma1 is evicted, ma2 is not - auto v = EXPECT_OK(db->getAddresses(p1)); + ASSERT_OUTCOME_SUCCESS(v, db->getAddresses(p1)); EXPECT_EQ(v.size(), 1); EXPECT_EQ(v.front(), ma2); } @@ -180,8 +180,8 @@ TEST_F(InmemAddressRepository_Test, InsertAddress) { * @then 2 peers returned */ TEST_F(InmemAddressRepository_Test, GetPeers) { - EXPECT_OK(db->upsertAddresses(p1, {}, 1000ms)); - EXPECT_OK(db->upsertAddresses(p2, {}, 1000ms)); + ASSERT_OUTCOME_SUCCESS(db->upsertAddresses(p1, {}, 1000ms)); + ASSERT_OUTCOME_SUCCESS(db->upsertAddresses(p2, {}, 1000ms)); auto s = db->getPeers(); EXPECT_EQ(s.size(), 2); diff --git a/test/libp2p/peer/key_book/inmem_key_repository_test.cpp b/test/libp2p/peer/key_book/inmem_key_repository_test.cpp index 534b489b8..fca565f93 100644 --- a/test/libp2p/peer/key_book/inmem_key_repository_test.cpp +++ b/test/libp2p/peer/key_book/inmem_key_repository_test.cpp @@ -29,16 +29,16 @@ struct InmemKeyRepositoryTest : ::testing::Test { }; TEST_F(InmemKeyRepositoryTest, PubkeyStore) { - EXPECT_OK(db_->addPublicKey(p1_, {{Key::Type::Ed25519, {'a'}}})); - EXPECT_OK(db_->addPublicKey(p1_, {{Key::Type::Ed25519, {'b'}}})); + ASSERT_OUTCOME_SUCCESS(db_->addPublicKey(p1_, {{Key::Type::Ed25519, {'a'}}})); + ASSERT_OUTCOME_SUCCESS(db_->addPublicKey(p1_, {{Key::Type::Ed25519, {'b'}}})); // insert same pubkey. it should not be inserted - EXPECT_OK(db_->addPublicKey(p1_, {{Key::Type::Ed25519, {'b'}}})); + ASSERT_OUTCOME_SUCCESS(db_->addPublicKey(p1_, {{Key::Type::Ed25519, {'b'}}})); // same pubkey but different type - EXPECT_OK(db_->addPublicKey(p1_, {{Key::Type::RSA, {'b'}}})); + ASSERT_OUTCOME_SUCCESS(db_->addPublicKey(p1_, {{Key::Type::RSA, {'b'}}})); // put pubkey to different peer - EXPECT_OK(db_->addPublicKey(p2_, {{Key::Type::RSA, {'c'}}})); + ASSERT_OUTCOME_SUCCESS(db_->addPublicKey(p2_, {{Key::Type::RSA, {'c'}}})); - auto v = EXPECT_OK(db_->getPublicKeys(p1_)); + ASSERT_OUTCOME_SUCCESS(v, db_->getPublicKeys(p1_)); EXPECT_EQ(v->size(), 3); db_->clear(p1_); @@ -50,9 +50,9 @@ TEST_F(InmemKeyRepositoryTest, KeyPairStore) { PublicKey pub = {{Key::Type::RSA, {'a'}}}; PrivateKey priv = {{Key::Type::RSA, {'b'}}}; KeyPair kp{pub, priv}; - EXPECT_OK(db_->addKeyPair({pub, priv})); + ASSERT_OUTCOME_SUCCESS(db_->addKeyPair({pub, priv})); - auto v = EXPECT_OK(db_->getKeyPairs()); + ASSERT_OUTCOME_SUCCESS(v, db_->getKeyPairs()); EXPECT_EQ(v->size(), 1); EXPECT_EQ(*v, std::unordered_set{kp}); @@ -67,8 +67,8 @@ TEST_F(InmemKeyRepositoryTest, GetPeers) { PublicKey z{}; KeyPair kp{}; - EXPECT_OK(db_->addPublicKey(p1_, z)); - EXPECT_OK(db_->addKeyPair(kp)); + ASSERT_OUTCOME_SUCCESS(db_->addPublicKey(p1_, z)); + ASSERT_OUTCOME_SUCCESS(db_->addKeyPair(kp)); auto s = db_->getPeers(); EXPECT_EQ(s.size(), 1); diff --git a/test/libp2p/peer/peer_address_test.cpp b/test/libp2p/peer/peer_address_test.cpp index d2a2fd557..e65c13eb8 100644 --- a/test/libp2p/peer/peer_address_test.cpp +++ b/test/libp2p/peer/peer_address_test.cpp @@ -49,7 +49,7 @@ class PeerAddressTest : public ::testing::Test { * @then creation is successful */ TEST_F(PeerAddressTest, FromStringSuccess) { - auto address = EXPECT_OK(PeerAddress::create(kAddressString)); + ASSERT_OUTCOME_SUCCESS(address, PeerAddress::create(kAddressString)); EXPECT_EQ(address.toString(), kAddressString); EXPECT_EQ(address.getId(), kDefaultPeerId); EXPECT_EQ(address.getAddress(), kDefaultAddress); @@ -103,7 +103,8 @@ TEST_F(PeerAddressTest, FromStringIdNotSha256) { * @then creation is successful */ TEST_F(PeerAddressTest, FromInfoSuccess) { - auto address = EXPECT_OK( + ASSERT_OUTCOME_SUCCESS( + address, PeerAddress::create(PeerInfo{kDefaultPeerId, {kDefaultAddress}})); EXPECT_EQ(address.toString(), kAddressString); EXPECT_EQ(address.getId(), kDefaultPeerId); @@ -125,8 +126,8 @@ TEST_F(PeerAddressTest, FromInfoNoAddresses) { * @then creation is successful */ TEST_F(PeerAddressTest, FromDistinctSuccess) { - auto address = - EXPECT_OK(PeerAddress::create(kDefaultPeerId, kDefaultAddress)); + ASSERT_OUTCOME_SUCCESS(address, + PeerAddress::create(kDefaultPeerId, kDefaultAddress)); EXPECT_EQ(address.toString(), kAddressString); EXPECT_EQ(address.getId(), kDefaultPeerId); EXPECT_EQ(address.getAddress(), kDefaultAddress); diff --git a/test/libp2p/peer/peer_id_test.cpp b/test/libp2p/peer/peer_id_test.cpp index c933e6312..6163992ec 100644 --- a/test/libp2p/peer/peer_id_test.cpp +++ b/test/libp2p/peer/peer_id_test.cpp @@ -33,10 +33,10 @@ TEST_F(PeerIdTest, FromPubkeySuccess) { pubkey.data = kBuffer; auto hash = libp2p::crypto::sha256(pubkey.data).value(); - auto multihash = EXPECT_OK(Multihash::create( + ASSERT_OUTCOME_SUCCESS(multihash, Multihash::create( libp2p::multi::sha256, Buffer{hash.begin(), hash.end()})); - auto peer_id = EXPECT_OK(PeerId::fromPublicKey(ProtobufKey{pubkey.data})); + ASSERT_OUTCOME_SUCCESS(peer_id, PeerId::fromPublicKey(ProtobufKey{pubkey.data})); EXPECT_EQ(peer_id.toBase58(), encodeBase58(multihash.toBuffer())); EXPECT_EQ(peer_id.toMultihash(), multihash); } @@ -47,10 +47,10 @@ TEST_F(PeerIdTest, FromPubkeySuccess) { * @then creation is successful */ TEST_F(PeerIdTest, FromBase58Success) { - auto hash = EXPECT_OK(Multihash::create(libp2p::multi::sha256, kBuffer)); + ASSERT_OUTCOME_SUCCESS(hash, Multihash::create(libp2p::multi::sha256, kBuffer)); auto hash_b58 = encodeBase58(hash.toBuffer()); - auto peer_id = EXPECT_OK(PeerId::fromBase58(hash_b58)); + ASSERT_OUTCOME_SUCCESS(peer_id, PeerId::fromBase58(hash_b58)); EXPECT_EQ(peer_id.toBase58(), hash_b58); EXPECT_EQ(peer_id.toMultihash(), hash); } @@ -81,7 +81,7 @@ TEST_F(PeerIdTest, FromBase58IcorrectHash) { * @then creation fails */ TEST_F(PeerIdTest, FromBase58NotSha256) { - auto hash = EXPECT_OK(Multihash::create(libp2p::multi::sha512, kBuffer)); + ASSERT_OUTCOME_SUCCESS(hash, Multihash::create(libp2p::multi::sha512, kBuffer)); auto hash_b58 = encodeBase58(hash.toBuffer()); EXPECT_FALSE(PeerId::fromBase58(hash_b58)); @@ -93,10 +93,10 @@ TEST_F(PeerIdTest, FromBase58NotSha256) { * @then creation is successful */ TEST_F(PeerIdTest, FromHashSuccess) { - auto hash = EXPECT_OK(Multihash::create(libp2p::multi::sha256, kBuffer)); + ASSERT_OUTCOME_SUCCESS(hash, Multihash::create(libp2p::multi::sha256, kBuffer)); auto hash_b58 = encodeBase58(hash.toBuffer()); - auto peer_id = EXPECT_OK(PeerId::fromHash(hash)); + ASSERT_OUTCOME_SUCCESS(peer_id, PeerId::fromHash(hash)); EXPECT_EQ(peer_id.toBase58(), hash_b58); EXPECT_EQ(peer_id.toMultihash(), hash); } @@ -107,7 +107,7 @@ TEST_F(PeerIdTest, FromHashSuccess) { * @then creation fails */ TEST_F(PeerIdTest, FromHashNotSha256) { - auto hash = EXPECT_OK(Multihash::create(libp2p::multi::sha512, kBuffer)); + ASSERT_OUTCOME_SUCCESS(hash, Multihash::create(libp2p::multi::sha512, kBuffer)); EXPECT_FALSE(PeerId::fromHash(hash)); } diff --git a/test/libp2p/peer/protocol_repository/inmem_protocol_repository_test.cpp b/test/libp2p/peer/protocol_repository/inmem_protocol_repository_test.cpp index e256fe97f..18a9620d5 100644 --- a/test/libp2p/peer/protocol_repository/inmem_protocol_repository_test.cpp +++ b/test/libp2p/peer/protocol_repository/inmem_protocol_repository_test.cpp @@ -46,13 +46,12 @@ struct InmemProtocolRepository_Test : public ::testing::Test { * @then two protocols added */ TEST_F(InmemProtocolRepository_Test, Add) { - EXPECT_OK(db->addProtocols(p1, vec(s1, s2))); + EXPECT_OUTCOME_SUCCESS(db->addProtocols(p1, vec(s1, s2))); { - auto v = EXPECT_OK(db->getProtocols(p1)); + ASSERT_OUTCOME_SUCCESS(v, db->getProtocols(p1)); EXPECT_EQ(v.size(), 2); - auto r = db->getProtocols(p2); - EXPECT_EC(r, PeerError::NOT_FOUND); + ASSERT_OUTCOME_ERROR(db->getProtocols(p2), PeerError::NOT_FOUND); } } @@ -62,18 +61,17 @@ TEST_F(InmemProtocolRepository_Test, Add) { * @then they are evicted */ TEST_F(InmemProtocolRepository_Test, CollectGarbage) { - EXPECT_OK(db->addProtocols(p1, vec(s1, s2))); - EXPECT_OK(db->addProtocols(p2, vec())); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p1, vec(s1, s2))); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p2, vec())); // no effect db->collectGarbage(); { - auto v = EXPECT_OK(db->getProtocols(p1)); + ASSERT_OUTCOME_SUCCESS(v, db->getProtocols(p1)); EXPECT_EQ(v.size(), 2); - auto r = db->getProtocols(p2); - EXPECT_EC(r, PeerError::NOT_FOUND); + ASSERT_OUTCOME_ERROR(db->getProtocols(p2), PeerError::NOT_FOUND); } // clear p1. now p1 has 0 protocols @@ -84,8 +82,7 @@ TEST_F(InmemProtocolRepository_Test, CollectGarbage) { { for (const auto &it : {p1, p2}) { - auto r = db->getProtocols(it); - EXPECT_EC(r, PeerError::NOT_FOUND); + ASSERT_OUTCOME_ERROR(db->getProtocols(it), PeerError::NOT_FOUND); } } } @@ -96,30 +93,30 @@ TEST_F(InmemProtocolRepository_Test, CollectGarbage) { * @then expected protocols are returned */ TEST_F(InmemProtocolRepository_Test, Supports) { - EXPECT_OK(db->addProtocols(p1, vec(s1, s2))); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p1, vec(s1, s2))); // one of { - auto v = EXPECT_OK(db->supportsProtocols(p1, set(s1))); + ASSERT_OUTCOME_SUCCESS(v, db->supportsProtocols(p1, set(s1))); EXPECT_EQ(v, vec(s1)); } // forward order { - auto v = EXPECT_OK(db->supportsProtocols(p1, set(s1, s2))); + ASSERT_OUTCOME_SUCCESS(v, db->supportsProtocols(p1, set(s1, s2))); EXPECT_EQ(v, vec(s1, s2)); } // reverse order { - auto v = EXPECT_OK(db->supportsProtocols(p1, set(s2, s1))); + ASSERT_OUTCOME_SUCCESS(v, db->supportsProtocols(p1, set(s2, s1))); EXPECT_EQ(v, vec(s1, s2)); } // non existing { - EXPECT_OK(db->removeProtocols(p1, vec(s1))); - auto v = EXPECT_OK(db->supportsProtocols(p1, set(s1, s2))); + ASSERT_OUTCOME_SUCCESS(db->removeProtocols(p1, vec(s1))); + ASSERT_OUTCOME_SUCCESS(v, db->supportsProtocols(p1, set(s1, s2))); EXPECT_EQ(v, vec(s2)); } } @@ -130,9 +127,9 @@ TEST_F(InmemProtocolRepository_Test, Supports) { * @then protocol s1 is removed */ TEST_F(InmemProtocolRepository_Test, Remove) { - EXPECT_OK(db->addProtocols(p1, vec(s1, s2))); - EXPECT_OK(db->removeProtocols(p1, vec(s1))); - auto v = EXPECT_OK(db->getProtocols(p1)); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p1, vec(s1, s2))); + ASSERT_OUTCOME_SUCCESS(db->removeProtocols(p1, vec(s1))); + ASSERT_OUTCOME_SUCCESS(v, db->getProtocols(p1)); EXPECT_EQ(v, vec(s2)); } @@ -142,9 +139,9 @@ TEST_F(InmemProtocolRepository_Test, Remove) { * @then get no error */ TEST_F(InmemProtocolRepository_Test, RemoveNonExisting) { - EXPECT_OK(db->addProtocols(p1, vec(s2))); - EXPECT_OK(db->removeProtocols(p1, vec(s1))); - auto v = EXPECT_OK(db->getProtocols(p1)); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p1, vec(s2))); + ASSERT_OUTCOME_SUCCESS(db->removeProtocols(p1, vec(s1))); + ASSERT_OUTCOME_SUCCESS(v, db->getProtocols(p1)); EXPECT_EQ(v.size(), 1); } @@ -154,11 +151,11 @@ TEST_F(InmemProtocolRepository_Test, RemoveNonExisting) { * @then 2 peers returned */ TEST_F(InmemProtocolRepository_Test, GetPeers) { - EXPECT_OK(db->addProtocols(p1, {})); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p1, {})); auto s1 = db->getPeers(); EXPECT_EQ(s1.size(), 1); - EXPECT_OK(db->addProtocols(p2, {})); + ASSERT_OUTCOME_SUCCESS(db->addProtocols(p2, {})); auto s = db->getPeers(); EXPECT_EQ(s.size(), 2); } diff --git a/test/libp2p/protocol/echo_test.cpp b/test/libp2p/protocol/echo_test.cpp index c0eb27769..6fbcbf919 100644 --- a/test/libp2p/protocol/echo_test.cpp +++ b/test/libp2p/protocol/echo_test.cpp @@ -88,7 +88,7 @@ TEST(EchoTest, DISABLED_Client) { auto client = echo.createClient(stream); client->sendAnd(msg, [&](outcome::result rm) { - auto m = EXPECT_OK(rm); + ASSERT_OUTCOME_SUCCESS(m, rm); ASSERT_EQ(m, msg); executed = true; }); diff --git a/test/libp2p/protocol/kademlia/peer_routing_table_test.cpp b/test/libp2p/protocol/kademlia/peer_routing_table_test.cpp index 22c3e00d6..b0f0675e6 100644 --- a/test/libp2p/protocol/kademlia/peer_routing_table_test.cpp +++ b/test/libp2p/protocol/kademlia/peer_routing_table_test.cpp @@ -71,7 +71,7 @@ TEST_F(PeerRoutingTableTest, BusWorks) { std::generate_n(std::back_inserter(peers), 1, testutil::randomPeerId); // table does not contain peer[0] - EXPECT_OK(table_->update(peers[0], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[0], false)); ASSERT_TRUE(hasPeer(peerset, peers[0])) << "should have this peer"; table_->remove(peers[0]); @@ -91,7 +91,7 @@ TEST_F(PeerRoutingTableTest, FindMultiple) { std::generate_n(std::back_inserter(peers), 18, testutil::randomPeerId); for (const auto &peer : peers) { - EXPECT_OK(table_->update(peer, false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peer, false)); } auto found = table_->getNearestPeers(NodeId(peers[2]), 15); @@ -133,31 +133,31 @@ TEST_F(PeerRoutingTableTest, RecyclingTest) { } } - EXPECT_OK(table_->update(peers[0], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[0], false)); ASSERT_TRUE(hasPeer(peerset, peers[0])) << "should have this peer"; - EXPECT_OK(table_->update(peers[1], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[1], false)); ASSERT_FALSE(hasPeer(peerset, peers[0])) << "should have recycled peer"; ASSERT_TRUE(hasPeer(peerset, peers[1])) << "should have this peer"; - EXPECT_OK(table_->update(peers[2], true)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[2], true)); ASSERT_FALSE(hasPeer(peerset, peers[0])) << "should have recycled peer"; ASSERT_FALSE(hasPeer(peerset, peers[1])) << "should have recycled peer"; ASSERT_TRUE(hasPeer(peerset, peers[2])) << "should have this peer"; // if bucket is full of permanent peers addition of peers into same bucket // should fail - EXPECT_EC(table_->update(peers[0], false), - PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); - EXPECT_EC(table_->update(peers[1], true), - PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); + ASSERT_OUTCOME_ERROR(table_->update(peers[0], false), + PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); + ASSERT_OUTCOME_ERROR(table_->update(peers[1], true), + PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); // re-adding an existent peer should return false regardless of is permanent auto updateVal = table_->update(peers[2], true); - EXPECT_OK(updateVal); + ASSERT_OUTCOME_SUCCESS(updateVal); ASSERT_FALSE(updateVal.value()); updateVal = table_->update(peers[2], false); - EXPECT_OK(updateVal); + ASSERT_OUTCOME_SUCCESS(updateVal); ASSERT_FALSE(updateVal.value()); } @@ -190,18 +190,18 @@ TEST_F(PeerRoutingTableTest, PreferLongLivedPeers) { } } // recycle FIFO; known peers but not connected dont get boost - EXPECT_OK(table_->update(peers[0], false)); - EXPECT_OK(table_->update(peers[1], false)); - EXPECT_OK(table_->update(peers[0], false)); - EXPECT_OK(table_->update(peers[2], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[0], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[1], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[0], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[2], false)); ASSERT_FALSE(hasPeer(peerset, peers[0])); ASSERT_TRUE(hasPeer(peerset, peers[1])); ASSERT_TRUE(hasPeer(peerset, peers[2])); // if connected; peer gets a boost - EXPECT_OK(table_->update(peers[1], false, true)); - EXPECT_OK(table_->update(peers[0], false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[1], false, true)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[0], false)); ASSERT_TRUE(hasPeer(peerset, peers[0])); ASSERT_TRUE(hasPeer(peerset, peers[1])); @@ -227,11 +227,12 @@ TEST_F(PeerRoutingTableTest, EldestRecycledIfNotPermanent) { for (size_t i = 0; i < peers.size(); i++) { if (i < config_->maxBucketSize) { // peers added till bucket filled are accepted - EXPECT_OK(table_->update(peers[i], true)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[i], true)); } else { // Remained are rejected - EXPECT_EC(table_->update(peers[i], true), - PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); + ASSERT_OUTCOME_ERROR( + table_->update(peers[i], true), + PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); } } } @@ -255,11 +256,12 @@ TEST_F(PeerRoutingTableTest, EldestPrefferedIfPermanent) { for (size_t i = 0; i < peers.size(); i++) { if (i < config_->maxBucketSize) { // peers added till bucket filled are accepted - EXPECT_OK(table_->update(peers[i], true)); + ASSERT_OUTCOME_SUCCESS(table_->update(peers[i], true)); } else { // Remained are rejected - EXPECT_EC(table_->update(peers[i], true), - PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); + ASSERT_OUTCOME_ERROR( + table_->update(peers[i], true), + PeerRoutingTableImpl::Error::PEER_REJECTED_NO_CAPACITY); } } } @@ -306,7 +308,7 @@ TEST_F(PeerRoutingTableTest, Find) { std::generate_n(std::back_inserter(peers), nPeers, testutil::randomPeerId); for (const auto &peer : peers) { - EXPECT_OK(table_->update(peer, false)); + ASSERT_OUTCOME_SUCCESS(table_->update(peer, false)); } ASSERT_EQ(table_->size(), nPeers); diff --git a/test/libp2p/security/plaintext_adaptor_test.cpp b/test/libp2p/security/plaintext_adaptor_test.cpp index eafe3edb6..ec34f7e36 100644 --- a/test/libp2p/security/plaintext_adaptor_test.cpp +++ b/test/libp2p/security/plaintext_adaptor_test.cpp @@ -104,16 +104,16 @@ TEST_F(PlaintextAdaptorTest, DISABLED_SecureInbound) { adaptor->secureInbound( conn, [this](outcome::result> rc) { - auto sec = EXPECT_OK(rc); + ASSERT_OUTCOME_SUCCESS(sec, rc); - auto sec_remote_pubkey = EXPECT_OK(sec->remotePublicKey()); + ASSERT_OUTCOME_SUCCESS(sec_remote_pubkey, sec->remotePublicKey()); EXPECT_EQ(sec_remote_pubkey, remote_pubkey); EXPECT_CALL(*key_marshaller, marshal(sec_remote_pubkey)) .WillOnce(Return(ProtobufKey{remote_pubkey.data})); - auto remote_id = EXPECT_OK(sec->remotePeer()); - auto calculated = - EXPECT_OK(PeerId::fromPublicKey(ProtobufKey{remote_pubkey.data})); + ASSERT_OUTCOME_SUCCESS(remote_id, sec->remotePeer()); + ASSERT_OUTCOME_SUCCESS( + calculated, PeerId::fromPublicKey(ProtobufKey{remote_pubkey.data})); EXPECT_EQ(remote_id, calculated); }); } @@ -149,16 +149,16 @@ TEST_F(PlaintextAdaptorTest, DISABLED_SecureOutbound) { conn, pid, [pid, this](outcome::result> rc) { - auto sec = EXPECT_OK(rc); + ASSERT_OUTCOME_SUCCESS(sec, rc); - auto sec_remote_pubkey = EXPECT_OK(sec->remotePublicKey()); + ASSERT_OUTCOME_SUCCESS(sec_remote_pubkey, sec->remotePublicKey()); EXPECT_EQ(sec_remote_pubkey, remote_pubkey); EXPECT_CALL(*key_marshaller, marshal(sec_remote_pubkey)) .WillOnce(Return(ProtobufKey{remote_pubkey.data})); - auto remote_id = EXPECT_OK(sec->remotePeer()); - auto calculated = - EXPECT_OK(PeerId::fromPublicKey(ProtobufKey{remote_pubkey.data})); + ASSERT_OUTCOME_SUCCESS(remote_id, sec->remotePeer()); + ASSERT_OUTCOME_SUCCESS( + calculated, PeerId::fromPublicKey(ProtobufKey{remote_pubkey.data})); EXPECT_EQ(remote_id, calculated); EXPECT_EQ(remote_id, pid); }); diff --git a/test/libp2p/security/plaintext_exchange_message_marshaller_test.cpp b/test/libp2p/security/plaintext_exchange_message_marshaller_test.cpp index 0ba884554..426e813f3 100644 --- a/test/libp2p/security/plaintext_exchange_message_marshaller_test.cpp +++ b/test/libp2p/security/plaintext_exchange_message_marshaller_test.cpp @@ -53,10 +53,10 @@ TEST_F(ExchangeMessageMarshallerTest, ToProtobufAndBack) { EXPECT_CALL(*key_marshaller, marshal(pk)) .WillOnce(Return(ProtobufKey{pubkey_bytes})); EXPECT_CALL(*key_marshaller, unmarshalPublicKey(_)).WillOnce(Return(pk)); - auto pid = EXPECT_OK(PeerId::fromPublicKey(ProtobufKey{pk.data})); + ASSERT_OUTCOME_SUCCESS(pid, PeerId::fromPublicKey(ProtobufKey{pk.data})); ExchangeMessage msg{.pubkey = pk, .peer_id = pid}; - auto bytes = EXPECT_OK(marshaller->marshal(msg)); - auto dec_msg = EXPECT_OK(marshaller->unmarshal(bytes)); + ASSERT_OUTCOME_SUCCESS(bytes, marshaller->marshal(msg)); + ASSERT_OUTCOME_SUCCESS(dec_msg, marshaller->unmarshal(bytes)); ASSERT_EQ(msg.peer_id, dec_msg.first.peer_id); ASSERT_EQ(msg.pubkey, dec_msg.first.pubkey); } @@ -70,9 +70,9 @@ TEST_F(ExchangeMessageMarshallerTest, ToProtobufAndBack) { TEST_F(ExchangeMessageMarshallerTest, MarshalError) { EXPECT_CALL(*key_marshaller, marshal(pk)) .WillOnce(Return(ProtobufKey{std::vector(32, 1)})); - auto pid = EXPECT_OK(PeerId::fromPublicKey(ProtobufKey{pk.data})); + ASSERT_OUTCOME_SUCCESS(pid, PeerId::fromPublicKey(ProtobufKey{pk.data})); ExchangeMessage msg{.pubkey = pk, .peer_id = pid}; - EXPECT_HAS_ERROR(marshaller->marshal(msg)); + EXPECT_OUTCOME_ERROR(marshaller->marshal(msg)); } /** @@ -87,8 +87,8 @@ TEST_F(ExchangeMessageMarshallerTest, UnmarshalError) { EXPECT_CALL(*key_marshaller, unmarshalPublicKey(_)) .WillOnce( Return(libp2p::crypto::CryptoProviderError::FAILED_UNMARSHAL_DATA)); - auto pid = EXPECT_OK(PeerId::fromPublicKey(ProtobufKey{pk.data})); + ASSERT_OUTCOME_SUCCESS(pid, PeerId::fromPublicKey(ProtobufKey{pk.data})); ExchangeMessage msg{.pubkey = pk, .peer_id = pid}; - auto bytes = EXPECT_OK(marshaller->marshal(msg)); - EXPECT_HAS_ERROR(marshaller->unmarshal(bytes)); + ASSERT_OUTCOME_SUCCESS(bytes, marshaller->marshal(msg)); + EXPECT_OUTCOME_ERROR(marshaller->unmarshal(bytes)); } diff --git a/test/libp2p/security/secio_exchange_message_marshaller_test.cpp b/test/libp2p/security/secio_exchange_message_marshaller_test.cpp index 10623ae3a..edd80bebb 100644 --- a/test/libp2p/security/secio_exchange_message_marshaller_test.cpp +++ b/test/libp2p/security/secio_exchange_message_marshaller_test.cpp @@ -23,8 +23,8 @@ class ExchangeMessageMarshallerTest : public ::testing::Test { TEST_F(ExchangeMessageMarshallerTest, BasicCase) { ExchangeMessage source{.epubkey = {1, 2, 3, 4, 5}, .signature = {6, 7, 8, 9, 10}}; - auto bytes = EXPECT_OK(marshaller.marshal(source)); - auto derived = EXPECT_OK(marshaller.unmarshal(bytes)); + ASSERT_OUTCOME_SUCCESS(bytes, marshaller.marshal(source)); + ASSERT_OUTCOME_SUCCESS(derived, marshaller.unmarshal(bytes)); ASSERT_EQ(source.epubkey, derived.epubkey); ASSERT_EQ(source.signature, derived.signature); } diff --git a/test/libp2p/security/secio_propose_message_marshaller_test.cpp b/test/libp2p/security/secio_propose_message_marshaller_test.cpp index 74c75999b..9134a5f32 100644 --- a/test/libp2p/security/secio_propose_message_marshaller_test.cpp +++ b/test/libp2p/security/secio_propose_message_marshaller_test.cpp @@ -26,8 +26,8 @@ TEST_F(ProposeMessageMarshallerTest, BasicCase) { .exchanges = "think", .ciphers = "of the", .hashes = "rapture"}; - auto bytes = EXPECT_OK(marshaller.marshal(source)); - auto derived = EXPECT_OK(marshaller.unmarshal(bytes)); + ASSERT_OUTCOME_SUCCESS(bytes, marshaller.marshal(source)); + ASSERT_OUTCOME_SUCCESS(derived, marshaller.unmarshal(bytes)); ASSERT_EQ(source.rand, derived.rand); ASSERT_EQ(source.pubkey, derived.pubkey); ASSERT_EQ(source.exchanges, derived.exchanges); diff --git a/test/libp2p/transport/tcp/tcp_integration_test.cpp b/test/libp2p/transport/tcp/tcp_integration_test.cpp index b5d295cb8..cb967a4fa 100644 --- a/test/libp2p/transport/tcp/tcp_integration_test.cpp +++ b/test/libp2p/transport/tcp/tcp_integration_test.cpp @@ -38,13 +38,13 @@ libp2p::muxer::MuxedConnectionConfig mux_config; namespace { std::shared_ptr expectConnectionValid( outcome::result> rconn) { - EXPECT_OK(rconn); + EXPECT_OUTCOME_SUCCESS(rconn); auto conn = rconn.value(); - auto mar = EXPECT_OK(conn->remoteMultiaddr()); - auto mal = EXPECT_OK(conn->localMultiaddr()); + EXPECT_OUTCOME_SUCCESS(mar, conn->remoteMultiaddr()); + EXPECT_OUTCOME_SUCCESS(mal, conn->localMultiaddr()); std::ostringstream s; - s << mar.getStringAddress() << " -> " << mal.getStringAddress(); + s << mar.value().getStringAddress() << " -> " << mal.value().getStringAddress(); std::cout << s.str() << '\n'; return conn; @@ -113,7 +113,11 @@ TEST(TCP, TwoListenersCantBindOnSamePort) { std::cout << "listener 2 starting...\n"; auto r = listener2->listen(ma); - EXPECT_EC(r, boost::asio::error::address_in_use); + if (!r) { + ASSERT_EQ(r.error().value(), (int)boost::asio::error::address_in_use); + } else { + ADD_FAILURE(); + } using std::chrono_literals::operator""ms; context->run_for(50ms); @@ -142,11 +146,11 @@ TEST(TCP, SingleListenerCanAcceptManyClients) { auto buf = std::make_shared>(kSize, 0); conn->readSome( *buf, buf->size(), [&counter, conn, buf, context](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); libp2p::writeReturnSize( conn, *buf, [&counter, conn, buf, context](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); EXPECT_EQ(res.value(), buf->size()); counter++; if (counter >= kClients) { @@ -179,13 +183,13 @@ TEST(TCP, SingleListenerCanAcceptManyClients) { libp2p::writeReturnSize( conn, *buf, [conn, readback, buf, context](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), buf->size()); conn->read(*readback, readback->size(), [conn, readback, buf, context](auto &&res) { context->stop(); - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), readback->size()); ASSERT_EQ(*buf, *readback); }); @@ -217,7 +221,7 @@ TEST(TCP, DialToNoServer) { auto ma = "/ip4/127.0.0.1/tcp/40003"_multiaddr; transport->dial(testutil::randomPeerId(), ma, [](auto &&rc) { - EXPECT_EC(rc, boost::asio::error::connection_refused); + ASSERT_OUTCOME_ERROR(rc, boost::asio::error::connection_refused); }); using std::chrono_literals::operator""ms; @@ -240,7 +244,7 @@ TEST(TCP, ClientClosesConnection) { auto buf = std::make_shared>(100, 0); conn->readSome(*buf, buf->size(), [conn, buf](auto &&res) { - EXPECT_EC(res, boost::asio::error::eof); + ASSERT_OUTCOME_ERROR(res, boost::asio::error::eof); }); }); @@ -270,7 +274,7 @@ TEST(TCP, ServerClosesConnection) { auto listener = transport->createListener([&](auto &&rconn) { auto conn = expectConnectionValid(rconn); EXPECT_FALSE(conn->isInitiator()); - EXPECT_OK(conn->close()); + ASSERT_OUTCOME_SUCCESS(conn->close()); }); ASSERT_TRUE(listener); @@ -282,7 +286,7 @@ TEST(TCP, ServerClosesConnection) { EXPECT_TRUE(conn->isInitiator()); auto buf = std::make_shared>(100, 0); conn->readSome(*buf, buf->size(), [conn, buf](auto &&res) { - EXPECT_EC(res, boost::asio::error::eof); + ASSERT_OUTCOME_ERROR(res, boost::asio::error::eof); }); }); @@ -308,10 +312,10 @@ TEST(TCP, OneTransportServerHandlesManyClients) { auto buf = std::make_shared>(kSize, 0); conn->readSome(*buf, kSize, [&counter, conn, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); libp2p::writeReturnSize(conn, *buf, [&counter, buf, conn](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); EXPECT_EQ(res.value(), buf->size()); counter++; }); @@ -338,10 +342,10 @@ TEST(TCP, OneTransportServerHandlesManyClients) { libp2p::writeReturnSize( conn, *buf, [conn, kSize, readback, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), buf->size()); conn->read(*readback, kSize, [conn, readback, buf](auto &&res) { - EXPECT_OK(res); + ASSERT_OUTCOME_SUCCESS(res); ASSERT_EQ(res.value(), readback->size()); ASSERT_EQ(*buf, *readback); }); diff --git a/test/libp2p/transport/tcp/tcp_listener_test.cpp b/test/libp2p/transport/tcp/tcp_listener_test.cpp index d9bda6419..c96a9b585 100644 --- a/test/libp2p/transport/tcp/tcp_listener_test.cpp +++ b/test/libp2p/transport/tcp/tcp_listener_test.cpp @@ -54,17 +54,21 @@ struct TcpListenerTest : public ::testing::Test { */ TEST_F(TcpListenerTest, ListenCloseListen) { EXPECT_CALL(cb, Call(_)).WillRepeatedly(Invoke([](CapConnResult c) { - EXPECT_EC(c, boost::asio::error::operation_aborted); + if (!c) { + ASSERT_EQ(c.error().value(), (int)boost::asio::error::operation_aborted); + } else { + ADD_FAILURE(); + } })); - EXPECT_OK(listener->listen(ma)); + ASSERT_OUTCOME_SUCCESS(listener->listen(ma)); ASSERT_FALSE(listener->isClosed()); - EXPECT_OK(listener->close()); + ASSERT_OUTCOME_SUCCESS(listener->close()); ASSERT_TRUE(listener->isClosed()); - EXPECT_OK(listener->listen(ma)); + ASSERT_OUTCOME_SUCCESS(listener->listen(ma)); ASSERT_FALSE(listener->isClosed()); - EXPECT_OK(listener->close()); + ASSERT_OUTCOME_SUCCESS(listener->close()); ASSERT_TRUE(listener->isClosed()); context->run_for(50ms); @@ -78,14 +82,18 @@ TEST_F(TcpListenerTest, ListenCloseListen) { TEST_F(TcpListenerTest, DoubleClose) { EXPECT_CALL(cb, Call(_)).WillOnce(Invoke([](CapConnResult c) { if (!c) { - EXPECT_EC(c, boost::asio::error::operation_aborted); + if (!c) { + ASSERT_EQ(c.error().value(), (int)boost::asio::error::operation_aborted); + } else { + ADD_FAILURE(); + } } })); - EXPECT_OK(listener->listen(ma)); + ASSERT_OUTCOME_SUCCESS(listener->listen(ma)); ASSERT_FALSE(listener->isClosed()); - EXPECT_OK(listener->close()); - EXPECT_OK(listener->close()); + ASSERT_OUTCOME_SUCCESS(listener->close()); + ASSERT_OUTCOME_SUCCESS(listener->close()); ASSERT_TRUE(listener->isClosed()); context->run_for(50ms); } diff --git a/test/libp2p/transport/upgrader_test.cpp b/test/libp2p/transport/upgrader_test.cpp index d4f9029ac..9dda85d92 100644 --- a/test/libp2p/transport/upgrader_test.cpp +++ b/test/libp2p/transport/upgrader_test.cpp @@ -122,7 +122,7 @@ class UpgraderTest : public testing::Test { TEST_F(UpgraderTest, UpgradeLayersInitiator) { setAllOutbound(); - auto address = EXPECT_OK(libp2p::multi::Multiaddress::create( + ASSERT_OUTCOME_SUCCESS(address, libp2p::multi::Multiaddress::create( "/ip4/127.0.0.1/tcp/1234/_dummy_proto_1/_dummy_proto_2" "/p2p/12D3KooWEgUjBV5FJAuBSoNMRYFRHjV7PjZwRQ7b43EKX9g7D6xV")); auto layers = detail::asTcp(address).value().second; @@ -140,7 +140,7 @@ TEST_F(UpgraderTest, UpgradeLayersInitiator) { upgrader_->upgradeLayersOutbound( address, raw_conn_, layers, [this](auto &&upgraded_conn_res) { - auto upgraded_conn = EXPECT_OK(upgraded_conn_res); + ASSERT_OUTCOME_SUCCESS(upgraded_conn, upgraded_conn_res); ASSERT_EQ(upgraded_conn, layer2_conn_); }); } @@ -148,7 +148,7 @@ TEST_F(UpgraderTest, UpgradeLayersInitiator) { TEST_F(UpgraderTest, UpgradeLayersNotInitiator) { setAllInbound(); - auto address = EXPECT_OK(libp2p::multi::Multiaddress::create( + ASSERT_OUTCOME_SUCCESS(address, libp2p::multi::Multiaddress::create( "/ip4/127.0.0.1/tcp/1234/_dummy_proto_1/_dummy_proto_2" "/p2p/12D3KooWEgUjBV5FJAuBSoNMRYFRHjV7PjZwRQ7b43EKX9g7D6xV")); auto layers = detail::asTcp(address).value().second; From 7adcc20eab4cf605f30b7622a35f037376bacc7d Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Mon, 24 Feb 2025 16:23:46 +0800 Subject: [PATCH 2/7] feature: vcpkg compatibility Signed-off-by: Dmitriy Khaustov aka xDimon --- CMakeLists.txt | 36 +++++++-- cmake/Hunter/config.cmake | 8 +- cmake/dependencies.cmake | 24 ++++-- src/crypto/rsa_provider/rsa_provider_impl.cpp | 2 +- .../multiselect/multiselect_instance.cpp | 2 +- src/storage/CMakeLists.txt | 12 +-- src/transport/quic/CMakeLists.txt | 1 + test/libp2p/storage/CMakeLists.txt | 16 ++-- vcpkg-configuration.json | 17 ++++ vcpkg-overlay/boost-di/portfile.cmake | 14 ++++ vcpkg-overlay/boost-di/vcpkg.json | 8 ++ vcpkg-overlay/liblsquic/disable-asan.patch | 23 ++++++ .../liblsquic/fix-found-boringssl.patch | 53 ++++++++++++ vcpkg-overlay/liblsquic/lsquic_conn_ssl.patch | 80 +++++++++++++++++++ vcpkg-overlay/liblsquic/portfile.cmake | 78 ++++++++++++++++++ vcpkg-overlay/liblsquic/vcpkg.json | 25 ++++++ vcpkg-overlay/libsecp256k1/portfile.cmake | 11 +++ vcpkg-overlay/libsecp256k1/vcpkg.json | 8 ++ vcpkg-overlay/qtils/portfile.cmake | 11 +++ vcpkg-overlay/qtils/vcpkg.json | 19 +++++ vcpkg-overlay/scale/portfile.cmake | 11 +++ vcpkg-overlay/scale/vcpkg.json | 19 +++++ vcpkg-overlay/soralog/portfile.cmake | 11 +++ vcpkg-overlay/soralog/vcpkg.json | 18 +++++ vcpkg-overlay/tsl-hat-trie/portfile.cmake | 11 +++ vcpkg-overlay/tsl-hat-trie/vcpkg.json | 8 ++ vcpkg.json | 40 ++++++++++ 27 files changed, 535 insertions(+), 31 deletions(-) create mode 100644 vcpkg-configuration.json create mode 100644 vcpkg-overlay/boost-di/portfile.cmake create mode 100644 vcpkg-overlay/boost-di/vcpkg.json create mode 100644 vcpkg-overlay/liblsquic/disable-asan.patch create mode 100644 vcpkg-overlay/liblsquic/fix-found-boringssl.patch create mode 100644 vcpkg-overlay/liblsquic/lsquic_conn_ssl.patch create mode 100644 vcpkg-overlay/liblsquic/portfile.cmake create mode 100644 vcpkg-overlay/liblsquic/vcpkg.json create mode 100644 vcpkg-overlay/libsecp256k1/portfile.cmake create mode 100644 vcpkg-overlay/libsecp256k1/vcpkg.json create mode 100644 vcpkg-overlay/qtils/portfile.cmake create mode 100644 vcpkg-overlay/qtils/vcpkg.json create mode 100644 vcpkg-overlay/scale/portfile.cmake create mode 100644 vcpkg-overlay/scale/vcpkg.json create mode 100644 vcpkg-overlay/soralog/portfile.cmake create mode 100644 vcpkg-overlay/soralog/vcpkg.json create mode 100644 vcpkg-overlay/tsl-hat-trie/portfile.cmake create mode 100644 vcpkg-overlay/tsl-hat-trie/vcpkg.json create mode 100644 vcpkg.json diff --git a/CMakeLists.txt b/CMakeLists.txt index 052617ff8..a94a5665a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,21 @@ cmake_minimum_required(VERSION 3.12) +if (PACKAGE_MANAGER) + if(PACKAGE_MANAGER NOT MATCHES "^(hunter|vcpkg)$") + message(FATAL_ERROR "PACKAGE_MANAGER must be set to 'hunter', 'vcpkg' or isn't set") + endif () +else () + set(PACKAGE_MANAGER "hunter") + if (CMAKE_TOOLCHAIN_FILE) + get_filename_component(ACTUAL_NAME ${CMAKE_TOOLCHAIN_FILE} NAME) + if(ACTUAL_NAME STREQUAL "vcpkg.cmake") + message(STATUS "vcpkg will be used because vcpkg.cmake has found") + set(PACKAGE_MANAGER "vcpkg") + endif () + endif () +endif () +message(STATUS "Selected package manager: ${PACKAGE_MANAGER}") + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.27") cmake_policy(SET CMP0144 NEW) endif() @@ -20,7 +36,9 @@ set(CMAKE_TOOLCHAIN_FILE cmake_policy(SET CMP0048 NEW) cmake_policy(SET CMP0135 NEW) -include("cmake/Hunter/init.cmake") +if (PACKAGE_MANAGER STREQUAL "hunter") + include("cmake/Hunter/init.cmake") +endif () project(libp2p VERSION 0.1.17 LANGUAGES C CXX) @@ -39,6 +57,7 @@ option(TSAN "Enable thread sanitizer" OFF) option(UBSAN "Enable UB sanitizer" OFF) option(EXPOSE_MOCKS "Make mocks header files visible for child projects" ON) option(METRICS_ENABLED "Enable libp2p metrics" OFF) +option(SQLITE_ENABLED "Enable sqlite based libp2p storage" OFF) include(cmake/print.cmake) print("C flags: ${CMAKE_C_FLAGS}") @@ -114,6 +133,9 @@ if(EXAMPLES) add_subdirectory(example) endif() if(TESTING OR COVERAGE) + if (PACKAGE_MANAGER STREQUAL "vcpkg") + list(APPEND VCPKG_MANIFEST_FEATURES libp2p-tests) + endif() enable_testing() add_subdirectory(test) endif() @@ -126,11 +148,11 @@ include(CMakePackageConfigHelpers) set(CONFIG_INCLUDE_DIRS ${CMAKE_INSTALL_FULL_INCLUDEDIR}/libp2p) configure_package_config_file(${CMAKE_CURRENT_LIST_DIR}/cmake/libp2pConfig.cmake.in - ${CMAKE_CURRENT_BINARY_DIR}/libp2pConfig.cmake - INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libp2p - ) + ${CMAKE_CURRENT_BINARY_DIR}/libp2pConfig.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libp2p +) install(FILES - ${CMAKE_CURRENT_BINARY_DIR}/libp2pConfig.cmake - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libp2p - ) + ${CMAKE_CURRENT_BINARY_DIR}/libp2pConfig.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libp2p +) diff --git a/cmake/Hunter/config.cmake b/cmake/Hunter/config.cmake index ac04a8e97..f7ddb2ae2 100644 --- a/cmake/Hunter/config.cmake +++ b/cmake/Hunter/config.cmake @@ -17,8 +17,8 @@ hunter_config( soralog - URL https://github.com/xDimon/soralog/archive/35634db3126d7dc1784c883713c8e31ebb07d051.tar.gz - SHA1 ee64d0982cffe0a3856c4e786161518e55a6ffd4 + URL https://github.com/xDimon/soralog/archive/4dfffd3d949b1c16a04db2e5756555a4031732f7.tar.gz + SHA1 60e3dcaab2d8e43f0ed4fd22087677663c618716 # VERSION 0.2.4 KEEP_PACKAGE_SOURCES ) @@ -32,8 +32,8 @@ hunter_config( hunter_config( scale - URL https://github.com/qdrvm/scale-codec-cpp/archive/24fbd767c8975647a733b45f9c3df92380110fb2.tar.gz - SHA1 c8570702805cdbacd31bd5caacead82c746ba901 + URL https://github.com/qdrvm/scale-codec-cpp/archive/156433264c90770c9eda2a2417852fd8e14a024e.tar.gz + SHA1 d2b9edf1d67f48c1916caeae119df3065ef14062 KEEP_PACKAGE_SOURCES ) diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake index d8ad42c71..9eab5cea2 100644 --- a/cmake/dependencies.cmake +++ b/cmake/dependencies.cmake @@ -4,15 +4,23 @@ # SPDX-License-Identifier: Apache-2.0 # +if (NOT PACKAGE_MANAGER STREQUAL "hunter") + function(hunter_add_package) + endfunction() +endif () + if (TESTING) # https://docs.hunter.sh/en/latest/packages/pkg/GTest.html hunter_add_package(GTest) find_package(GTest CONFIG REQUIRED) endif() -# https://docs.hunter.sh/en/latest/packages/pkg/Boost.html -hunter_add_package(Boost COMPONENTS random filesystem program_options) -find_package(Boost CONFIG REQUIRED random filesystem program_options) +if (PACKAGE_MANAGER STREQUAL "hunter") + hunter_add_package(Boost COMPONENTS random filesystem program_options) + find_package(Boost CONFIG REQUIRED filesystem random program_options) +else () + find_package(Boost CONFIG REQUIRED filesystem random beast program_options) +endif () # https://www.openssl.org/ hunter_add_package(BoringSSL) @@ -53,6 +61,10 @@ find_package(tsl_hat_trie CONFIG REQUIRED) hunter_add_package(Boost.DI) find_package(Boost.DI CONFIG REQUIRED) -# https://github.com/qdrvm/libp2p-sqlite-modern-cpp/tree/hunter -hunter_add_package(SQLiteModernCpp) -find_package(SQLiteModernCpp CONFIG REQUIRED) +if (SQLITE_ENABLED) + # https://github.com/qdrvm/libp2p-sqlite-modern-cpp/tree/hunter + hunter_add_package(SQLiteModernCpp) + find_package(SQLiteModernCpp CONFIG REQUIRED) +endif () + +find_package(ZLIB REQUIRED) diff --git a/src/crypto/rsa_provider/rsa_provider_impl.cpp b/src/crypto/rsa_provider/rsa_provider_impl.cpp index ceafda188..1616086fa 100644 --- a/src/crypto/rsa_provider/rsa_provider_impl.cpp +++ b/src/crypto/rsa_provider/rsa_provider_impl.cpp @@ -157,7 +157,7 @@ namespace libp2p::crypto::rsa { const Signature &signature, const PublicKey &public_key) const { OUTCOME_TRY(x509_key, RsaProviderImpl::getPublicKeyFromBytes(public_key)); - EVP_PKEY *key = X509_PUBKEY_get0(x509_key.get()); + EVP_PKEY *key = X509_PUBKEY_get(x509_key.get()); std::unique_ptr rsa{EVP_PKEY_get1_RSA(key), RSA_free}; OUTCOME_TRY(digest, sha256(message)); int result = RSA_verify(NID_sha256, diff --git a/src/protocol_muxer/multiselect/multiselect_instance.cpp b/src/protocol_muxer/multiselect/multiselect_instance.cpp index 316b8e538..abb657bf0 100644 --- a/src/protocol_muxer/multiselect/multiselect_instance.cpp +++ b/src/protocol_muxer/multiselect/multiselect_instance.cpp @@ -328,7 +328,7 @@ namespace libp2p::protocol_muxer::multiselect { SL_DEBUG(log(), "Failed to negotiate protocols: {}", - fmt::join(protocols_.begin(), protocols_.end(), ", ")); + fmt::join(protocols_, ", ")); return MaybeResult(ProtocolMuxer::Error::NEGOTIATION_FAILED); } diff --git a/src/storage/CMakeLists.txt b/src/storage/CMakeLists.txt index a048325a3..520d87829 100644 --- a/src/storage/CMakeLists.txt +++ b/src/storage/CMakeLists.txt @@ -4,8 +4,10 @@ # SPDX-License-Identifier: Apache-2.0 # -libp2p_add_library(p2p_sqlite sqlite.cpp) -target_link_libraries(p2p_sqlite - SQLiteModernCpp::SQLiteModernCpp - p2p_logger - ) +if (SQLITE_ENABLED) + libp2p_add_library(p2p_sqlite sqlite.cpp) + target_link_libraries(p2p_sqlite + SQLiteModernCpp::SQLiteModernCpp + p2p_logger + ) +endif () \ No newline at end of file diff --git a/src/transport/quic/CMakeLists.txt b/src/transport/quic/CMakeLists.txt index 1812280ed..4dc7e594a 100644 --- a/src/transport/quic/CMakeLists.txt +++ b/src/transport/quic/CMakeLists.txt @@ -14,4 +14,5 @@ libp2p_add_library(p2p_quic target_link_libraries(p2p_quic lsquic::lsquic p2p_tls + ZLIB::ZLIB ) diff --git a/test/libp2p/storage/CMakeLists.txt b/test/libp2p/storage/CMakeLists.txt index 30b480c6f..093d09151 100644 --- a/test/libp2p/storage/CMakeLists.txt +++ b/test/libp2p/storage/CMakeLists.txt @@ -4,10 +4,12 @@ # SPDX-License-Identifier: Apache-2.0 # -addtest(libp2p_sqlite_test - sqlite_test.cpp - ) -target_link_libraries(libp2p_sqlite_test - Boost::filesystem - p2p_sqlite - ) +if (SQLITE_ENABLED) + addtest(libp2p_sqlite_test + sqlite_test.cpp + ) + target_link_libraries(libp2p_sqlite_test + Boost::filesystem + p2p_sqlite + ) +endif () \ No newline at end of file diff --git a/vcpkg-configuration.json b/vcpkg-configuration.json new file mode 100644 index 000000000..1ad42d251 --- /dev/null +++ b/vcpkg-configuration.json @@ -0,0 +1,17 @@ +{ + "default-registry": { + "kind": "git", + "baseline": "fe1cde61e971d53c9687cf9a46308f8f55da19fa", + "repository": "https://github.com/microsoft/vcpkg" + }, + "registries": [ + { + "kind": "artifact", + "location": "https://github.com/microsoft/vcpkg-ce-catalog/archive/refs/heads/main.zip", + "name": "microsoft" + } + ], + "overlay-ports": [ + "vcpkg-overlay" + ] +} diff --git a/vcpkg-overlay/boost-di/portfile.cmake b/vcpkg-overlay/boost-di/portfile.cmake new file mode 100644 index 000000000..1b7254447 --- /dev/null +++ b/vcpkg-overlay/boost-di/portfile.cmake @@ -0,0 +1,14 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO qdrvm/boost-di + REF d5de6c9840c7fc2e44bf37134b4a14b88151ecc4 + SHA512 98e924d02bde23940ab59330730de6d4198d1e98cbb303ef713e3ee06f88e90707a952e6aa9a0372213b46d6c9d3478e86ed5cd64d74899861984e786e21c319 +) +vcpkg_cmake_configure( + SOURCE_PATH "${SOURCE_PATH}" + OPTIONS + -DBOOST_DI_OPT_BUILD_TESTS=OFF + -DBOOST_DI_OPT_BUILD_EXAMPLES=OFF +) +vcpkg_cmake_install() diff --git a/vcpkg-overlay/boost-di/vcpkg.json b/vcpkg-overlay/boost-di/vcpkg.json new file mode 100644 index 000000000..8090168d0 --- /dev/null +++ b/vcpkg-overlay/boost-di/vcpkg.json @@ -0,0 +1,8 @@ +{ + "name": "boost-di", + "version": "1.1.0.1", + "dependencies": [ + { "name": "vcpkg-cmake", "host": true }, + { "name": "vcpkg-cmake-config", "host": true } + ] +} diff --git a/vcpkg-overlay/liblsquic/disable-asan.patch b/vcpkg-overlay/liblsquic/disable-asan.patch new file mode 100644 index 000000000..2b05d0ee3 --- /dev/null +++ b/vcpkg-overlay/liblsquic/disable-asan.patch @@ -0,0 +1,23 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 65c4776..5d4086a 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -60,12 +60,12 @@ ENDIF() + + IF(CMAKE_BUILD_TYPE STREQUAL "Debug") + SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -O0 -g3") +- IF(CMAKE_C_COMPILER MATCHES "clang" AND +- NOT "$ENV{TRAVIS}" MATCHES "^true$" AND +- NOT "$ENV{EXTRA_CFLAGS}" MATCHES "-fsanitize") +- SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -fsanitize=address") +- SET(LIBS ${LIBS} -fsanitize=address) +- ENDIF() ++ # IF(CMAKE_C_COMPILER MATCHES "clang" AND ++ # NOT "$ENV{TRAVIS}" MATCHES "^true$" AND ++ # NOT "$ENV{EXTRA_CFLAGS}" MATCHES "-fsanitize") ++ # SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -fsanitize=address") ++ # SET(LIBS ${LIBS} -fsanitize=address) ++ # ENDIF() + # Uncomment to enable cleartext protocol mode (no crypto): + #SET (MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DLSQUIC_ENABLE_HANDSHAKE_DISABLE=1") + ELSE() diff --git a/vcpkg-overlay/liblsquic/fix-found-boringssl.patch b/vcpkg-overlay/liblsquic/fix-found-boringssl.patch new file mode 100644 index 000000000..a3a632c5e --- /dev/null +++ b/vcpkg-overlay/liblsquic/fix-found-boringssl.patch @@ -0,0 +1,53 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 5d4086a..e085a83 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -120,10 +120,12 @@ IF(CMAKE_BUILD_TYPE STREQUAL "Debug") + SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -Od") + #SET (MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DFIU_ENABLE=1") + #SET(LIBS ${LIBS} fiu) ++ SET(LIB_NAME ssld cryptod) + ELSE() + SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -Ox") + # Comment out the following line to compile out debug messages: + #SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DLSQUIC_LOWEST_LOG_LEVEL=LSQ_LOG_INFO") ++ SET(LIB_NAME ssl crypto) + ENDIF() + + ENDIF() #MSVC +@@ -191,7 +193,7 @@ IF (NOT DEFINED BORINGSSL_LIB AND DEFINED BORINGSSL_DIR) + ELSE() + + +- FOREACH(LIB_NAME ssl crypto) ++ FOREACH(LIB ${LIB_NAME}) + # If BORINGSSL_LIB is defined, try find each lib. Otherwise, user should define BORINGSSL_LIB_ssl, + # BORINGSSL_LIB_crypto and so on explicitly. For example, including boringssl and lsquic both via + # add_subdirectory: +@@ -201,20 +203,20 @@ ELSE() + # add_subdirectory(third_party/lsquic) + IF (DEFINED BORINGSSL_LIB) + IF (CMAKE_SYSTEM_NAME STREQUAL Windows) +- FIND_LIBRARY(BORINGSSL_LIB_${LIB_NAME} +- NAMES ${LIB_NAME} ++ FIND_LIBRARY(BORINGSSL_LIB_${LIB} ++ NAMES ${LIB} + PATHS ${BORINGSSL_LIB} + PATH_SUFFIXES Debug Release MinSizeRel RelWithDebInfo + NO_DEFAULT_PATH) + ELSE() +- FIND_LIBRARY(BORINGSSL_LIB_${LIB_NAME} +- NAMES lib${LIB_NAME}${LIB_SUFFIX} ++ FIND_LIBRARY(BORINGSSL_LIB_${LIB} ++ NAMES lib${LI}${LIB_SUFFIX} + PATHS ${BORINGSSL_LIB} +- PATH_SUFFIXES ${LIB_NAME} ++ PATH_SUFFIXES ${LIB} + NO_DEFAULT_PATH) + ENDIF() + ENDIF() +- IF(BORINGSSL_LIB_${LIB_NAME}) ++ IF(BORINGSSL_LIB_${LIB}) + MESSAGE(STATUS "Found ${LIB_NAME} library: ${BORINGSSL_LIB_${LIB_NAME}}") + ELSE() + MESSAGE(FATAL_ERROR "BORINGSSL_LIB_${LIB_NAME} library not found") diff --git a/vcpkg-overlay/liblsquic/lsquic_conn_ssl.patch b/vcpkg-overlay/liblsquic/lsquic_conn_ssl.patch new file mode 100644 index 000000000..ae7be541d --- /dev/null +++ b/vcpkg-overlay/liblsquic/lsquic_conn_ssl.patch @@ -0,0 +1,80 @@ +diff --git a/include/lsquic.h b/include/lsquic.h +index 389fbcc..c38d027 100644 +--- a/include/lsquic.h ++++ b/include/lsquic.h +@@ -1671,6 +1671,10 @@ int lsquic_stream_close(lsquic_stream_t *s); + int + lsquic_stream_has_unacked_data (lsquic_stream_t *s); + ++/* Return SSL object associated with this connection */ ++struct ssl_st * ++lsquic_conn_ssl(struct lsquic_conn *conn); ++ + /** + * Get certificate chain returned by the server. This can be used for + * server certificate verification. +diff --git a/src/liblsquic/lsquic_conn.c b/src/liblsquic/lsquic_conn.c +index f76550d..31e5285 100644 +--- a/src/liblsquic/lsquic_conn.c ++++ b/src/liblsquic/lsquic_conn.c +@@ -128,6 +128,12 @@ lsquic_conn_crypto_alg_keysize (const lsquic_conn_t *lconn) + } + + ++struct ssl_st * ++lsquic_conn_ssl(struct lsquic_conn *lconn) { ++ return lconn->cn_esf_c->esf_get_ssl(lconn->cn_enc_session); ++} ++ ++ + struct stack_st_X509 * + lsquic_conn_get_server_cert_chain (struct lsquic_conn *lconn) + { +diff --git a/src/liblsquic/lsquic_enc_sess.h b/src/liblsquic/lsquic_enc_sess.h +index f45c15f..3505fbd 100644 +--- a/src/liblsquic/lsquic_enc_sess.h ++++ b/src/liblsquic/lsquic_enc_sess.h +@@ -115,6 +115,9 @@ struct enc_session_funcs_common + (*esf_decrypt_packet)(enc_session_t *, struct lsquic_engine_public *, + const struct lsquic_conn *, struct lsquic_packet_in *); + ++ struct ssl_st * ++ (*esf_get_ssl)(enc_session_t *); ++ + struct stack_st_X509 * + (*esf_get_server_cert_chain) (enc_session_t *); + +diff --git a/src/liblsquic/lsquic_enc_sess_ietf.c b/src/liblsquic/lsquic_enc_sess_ietf.c +index 66329c1..076c4c5 100644 +--- a/src/liblsquic/lsquic_enc_sess_ietf.c ++++ b/src/liblsquic/lsquic_enc_sess_ietf.c +@@ -2519,6 +2519,13 @@ iquic_esf_global_cleanup (void) + } + + ++static struct ssl_st * ++iquic_esf_get_ssl(enc_session_t *enc_session_p) { ++ struct enc_sess_iquic *const enc_sess = enc_session_p; ++ return enc_sess->esi_ssl; ++} ++ ++ + static struct stack_st_X509 * + iquic_esf_get_server_cert_chain (enc_session_t *enc_session_p) + { +@@ -2744,6 +2751,7 @@ const struct enc_session_funcs_common lsquic_enc_session_common_ietf_v1 = + .esf_global_cleanup = iquic_esf_global_cleanup, + .esf_global_init = iquic_esf_global_init, + .esf_tag_len = IQUIC_TAG_LEN, ++ .esf_get_ssl = iquic_esf_get_ssl, + .esf_get_server_cert_chain + = iquic_esf_get_server_cert_chain, + .esf_get_sni = iquic_esf_get_sni, +@@ -2763,6 +2771,7 @@ const struct enc_session_funcs_common lsquic_enc_session_common_ietf_v1_no_flush + .esf_global_cleanup = iquic_esf_global_cleanup, + .esf_global_init = iquic_esf_global_init, + .esf_tag_len = IQUIC_TAG_LEN, ++ .esf_get_ssl = iquic_esf_get_ssl, + .esf_get_server_cert_chain + = iquic_esf_get_server_cert_chain, + .esf_get_sni = iquic_esf_get_sni, diff --git a/vcpkg-overlay/liblsquic/portfile.cmake b/vcpkg-overlay/liblsquic/portfile.cmake new file mode 100644 index 000000000..3602c5953 --- /dev/null +++ b/vcpkg-overlay/liblsquic/portfile.cmake @@ -0,0 +1,78 @@ +if(VCPKG_TARGET_IS_WINDOWS) + # The lib uses CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS, at least until + # https://github.com/litespeedtech/lsquic/pull/371 or similar is merged + vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +endif() + +vcpkg_from_github(OUT_SOURCE_PATH SOURCE_PATH + REPO litespeedtech/lsquic + REF v${VERSION} + SHA512 40d742779bfa2dc6fdaf0ee8e9349498d373dcffcc6dd27867c18d87309a288ea6811d693043b5d98364d816b818b49445214497475844201241193c0f37b349 + HEAD_REF master + PATCHES + disable-asan.patch + fix-found-boringssl.patch + lsquic_conn_ssl.patch +) + +# Submodules +vcpkg_from_github(OUT_SOURCE_PATH LSQPACK_SOURCE_PATH + REPO litespeedtech/ls-qpack + REF v2.5.3 + HEAD_REF master + SHA512 f90502c763abc84532f33d1b8f952aea7869e4e0c5f6bd344532ddd51c4a180958de4086d88b9ec96673a059c806eec9e70007651d4d4e1a73395919dee47ce0 +) +if(NOT EXISTS "${SOURCE_PATH}/src/ls-hpack/CMakeLists.txt") + file(REMOVE_RECURSE "${SOURCE_PATH}/src/liblsquic/ls-qpack") + file(RENAME "${LSQPACK_SOURCE_PATH}" "${SOURCE_PATH}/src/liblsquic/ls-qpack") +endif() + +vcpkg_from_github(OUT_SOURCE_PATH LSHPACK_SOURCE_PATH + REPO litespeedtech/ls-hpack + REF v2.3.2 + HEAD_REF master + SHA512 45d6c8296e8eee511e6a083f89460d5333fc9a49bc078dac55fdec6c46db199de9f150379f02e054571f954a5e3c79af3864dbc53dc57d10a8d2ed26a92d4278 +) +if(NOT EXISTS "${SOURCE_PATH}/src/lshpack/CMakeLists.txt") + file(REMOVE_RECURSE "${SOURCE_PATH}/src/lshpack") + file(RENAME "${LSHPACK_SOURCE_PATH}" "${SOURCE_PATH}/src/lshpack") +endif() + +# Configuration +vcpkg_find_acquire_program(PERL) + +string(COMPARE EQUAL "${VCPKG_LIBRARY_LINKAGE}" "dynamic" LSQUIC_SHARED_LIB) + +vcpkg_cmake_configure( + SOURCE_PATH "${SOURCE_PATH}" + OPTIONS + "-DPERL=${PERL}" + "-DPERL_EXECUTABLE=${PERL}" + "-DLSQUIC_SHARED_LIB=${LSQUIC_SHARED_LIB}" + "-DBORINGSSL_INCLUDE=${CURRENT_INSTALLED_DIR}/include" + -DLSQUIC_BIN=OFF + -DLSQUIC_TESTS=OFF + OPTIONS_RELEASE + "-DBORINGSSL_LIB=${CURRENT_INSTALLED_DIR}/lib" + OPTIONS_DEBUG + "-DBORINGSSL_LIB=${CURRENT_INSTALLED_DIR}/debug/lib" + -DLSQUIC_DEVEL=ON +) + +vcpkg_cmake_install() +if(VCPKG_TARGET_IS_WINDOWS) + # Upstream removed installation of this header after merging changes + file(INSTALL "${SOURCE_PATH}/wincompat/vc_compat.h" DESTINATION "${CURRENT_INSTALLED_DIR}/include/lsquic") +endif() + +vcpkg_cmake_config_fixup(PACKAGE_NAME lsquic) + +# Concatenate license files and install +vcpkg_install_copyright(FILE_LIST + "${SOURCE_PATH}/LICENSE" + "${SOURCE_PATH}/LICENSE.chrome" +) + +# Remove duplicated include directory +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") + diff --git a/vcpkg-overlay/liblsquic/vcpkg.json b/vcpkg-overlay/liblsquic/vcpkg.json new file mode 100644 index 000000000..ec900322b --- /dev/null +++ b/vcpkg-overlay/liblsquic/vcpkg.json @@ -0,0 +1,25 @@ +{ + "name": "liblsquic", + "version": "3.3.2", + "port-version": 1, + "description": "An implementation of the QUIC and HTTP/3 protocols.", + "homepage": "https://github.com/litespeedtech/lsquic", + "license": "MIT AND BSD-3-Clause", + "supports": "!x86", + "dependencies": [ + "boringssl", + { + "name": "getopt", + "platform": "windows" + }, + { + "name": "vcpkg-cmake", + "host": true + }, + { + "name": "vcpkg-cmake-config", + "host": true + }, + "zlib" + ] +} diff --git a/vcpkg-overlay/libsecp256k1/portfile.cmake b/vcpkg-overlay/libsecp256k1/portfile.cmake new file mode 100644 index 000000000..bfbc93c07 --- /dev/null +++ b/vcpkg-overlay/libsecp256k1/portfile.cmake @@ -0,0 +1,11 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO qdrvm/libsecp256k1 + REF 4370b9c336f86457c0b7bb97cd1ac6a281d951fa + SHA512 ed4660a66d8d74d5d5a27e54a247fe89d0fab4a5618ace27fe384690eebe296b89ababb7eb8a0184d64c339a27c7882306ecefb3fc8bf8c554ca3e244df627e5 +) +vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}") +vcpkg_cmake_install() +#vcpkg_cmake_config_fixup(PACKAGE_NAME "libsecp256k1") +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") diff --git a/vcpkg-overlay/libsecp256k1/vcpkg.json b/vcpkg-overlay/libsecp256k1/vcpkg.json new file mode 100644 index 000000000..8143946f9 --- /dev/null +++ b/vcpkg-overlay/libsecp256k1/vcpkg.json @@ -0,0 +1,8 @@ +{ + "name": "libsecp256k1", + "version": "0.5.1", + "dependencies": [ + { "name": "vcpkg-cmake", "host": true }, + { "name": "vcpkg-cmake-config", "host": true } + ] +} diff --git a/vcpkg-overlay/qtils/portfile.cmake b/vcpkg-overlay/qtils/portfile.cmake new file mode 100644 index 000000000..cc367ce3f --- /dev/null +++ b/vcpkg-overlay/qtils/portfile.cmake @@ -0,0 +1,11 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO qdrvm/qtils + REF 9a64dfd6ed0226dec29805aa89d4c713a6f81d9f + SHA512 bab32974f6926054ea11b0e6d8549d2b62e1def75cb4464ca47895bdd32d624ff6b9e25d10d7075581c4310c872b71560dfce76e92a60e83949b4af0276768ec +) +vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}") +vcpkg_cmake_install() +vcpkg_cmake_config_fixup(PACKAGE_NAME "qtils") +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") diff --git a/vcpkg-overlay/qtils/vcpkg.json b/vcpkg-overlay/qtils/vcpkg.json new file mode 100644 index 000000000..a6f24b66e --- /dev/null +++ b/vcpkg-overlay/qtils/vcpkg.json @@ -0,0 +1,19 @@ +{ + "name": "qtils", + "version": "0.0.3", + "dependencies": [ + { "name": "vcpkg-cmake", "host": true }, + { "name": "vcpkg-cmake-config", "host": true }, + "boost-algorithm", + "boost-outcome", + "fmt" + ], + "features": { + "qtils-tests": { + "description": "Test compilable of qtils", + "dependencies": [ + "gtest" + ] + } + } +} diff --git a/vcpkg-overlay/scale/portfile.cmake b/vcpkg-overlay/scale/portfile.cmake new file mode 100644 index 000000000..bfc72eb6d --- /dev/null +++ b/vcpkg-overlay/scale/portfile.cmake @@ -0,0 +1,11 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO qdrvm/scale-codec-cpp + REF 34e980bb539af19d5d1c28319f5618f40e9ec503 + SHA512 50c3984d2f7dd90b3918d8a88165ac5b2533b7e16fccd865280f36048d8386f3a0831799905d23e6275c89f1d82135d0655effae7c6c43c78f823e6d359e6685 +) +vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}") +vcpkg_cmake_install() +vcpkg_cmake_config_fixup(PACKAGE_NAME "scale") +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") diff --git a/vcpkg-overlay/scale/vcpkg.json b/vcpkg-overlay/scale/vcpkg.json new file mode 100644 index 000000000..73942f4ca --- /dev/null +++ b/vcpkg-overlay/scale/vcpkg.json @@ -0,0 +1,19 @@ +{ + "name": "scale", + "version": "1.1.3", + "dependencies": [ + { "name": "vcpkg-cmake", "host": true }, + { "name": "vcpkg-cmake-config", "host": true }, + "boost-endian", + "boost-multiprecision", + "qtils" + ], + "features": { + "scale-tests": { + "description": "Test of scale encoding/decoding", + "dependencies": [ + "gtest" + ] + } + } +} diff --git a/vcpkg-overlay/soralog/portfile.cmake b/vcpkg-overlay/soralog/portfile.cmake new file mode 100644 index 000000000..53fd8938a --- /dev/null +++ b/vcpkg-overlay/soralog/portfile.cmake @@ -0,0 +1,11 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO xDimon/soralog + REF 4dfffd3d949b1c16a04db2e5756555a4031732f7 + SHA512 4a8f6066433e6bde504454ea256915e8e6975c060eabdaebd031df409d348b8c22ccd716ec11c4466b0f4322b1f2524350dcc77c3615a8511cba9886f88e7260 +) +vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}") +vcpkg_cmake_install() +#vcpkg_cmake_config_fixup(PACKAGE_NAME "soralog") +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") diff --git a/vcpkg-overlay/soralog/vcpkg.json b/vcpkg-overlay/soralog/vcpkg.json new file mode 100644 index 000000000..f375fea90 --- /dev/null +++ b/vcpkg-overlay/soralog/vcpkg.json @@ -0,0 +1,18 @@ +{ + "name": "soralog", + "version": "0.2.5", + "dependencies": [ + { "name": "vcpkg-cmake", "host": true }, + { "name": "vcpkg-cmake-config", "host": true }, + "fmt", + "yaml-cpp" + ], + "features": { + "soralog-tests": { + "description": "Test of soralog's mechanisms", + "dependencies": [ + "gtest" + ] + } + } +} diff --git a/vcpkg-overlay/tsl-hat-trie/portfile.cmake b/vcpkg-overlay/tsl-hat-trie/portfile.cmake new file mode 100644 index 000000000..597fada15 --- /dev/null +++ b/vcpkg-overlay/tsl-hat-trie/portfile.cmake @@ -0,0 +1,11 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO masterjedy/hat-trie + REF 4fdfc75e75276185eed4b748ea09671601101b8e + SHA512 1f8e216037d06909a80dc89550a667cb1a8c64270c91b0ea5585c98f318fdbfe863a9766c9fadfb3da581b248fcd6b6b13576a2f855c61b7587516c38947c457 +) +vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}") +vcpkg_cmake_install() +#vcpkg_cmake_config_fixup(PACKAGE_NAME "tsl-hat-trie") +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") diff --git a/vcpkg-overlay/tsl-hat-trie/vcpkg.json b/vcpkg-overlay/tsl-hat-trie/vcpkg.json new file mode 100644 index 000000000..0ad4d7be2 --- /dev/null +++ b/vcpkg-overlay/tsl-hat-trie/vcpkg.json @@ -0,0 +1,8 @@ +{ + "name": "tsl-hat-trie", + "version": "1.0.0", + "dependencies": [ + { "name": "vcpkg-cmake", "host": true }, + { "name": "vcpkg-cmake-config", "host": true } + ] +} diff --git a/vcpkg.json b/vcpkg.json new file mode 100644 index 000000000..c7c4e07f1 --- /dev/null +++ b/vcpkg.json @@ -0,0 +1,40 @@ +{ + "name": "libp2p", + "version": "0.1.17", + "dependencies": [ + "boost-filesystem", + "boost-random", + "boost-program-options", + "qtils", + "boringssl", + "boost-signals2", + "boost-asio", + "soralog", + "fmt", + "gtest", + "boost-beast", + "protobuf", + "liblsquic", + "zlib", + "boost-di", + "sqlite-modern-cpp", + "libsecp256k1", + "tsl-hat-trie", + "boost-multi-index", + "c-ares" + ], + "overrides": [ + { + "name": "fmt", + "version": "10.1.1" + } + ], + "features": { + "libp2p-tests": { + "description": "Test of scale encoding/decoding", + "dependencies": [ + "gtest" + ] + } + } +} From cfcde87dea7bf5fe8457f43d2d88772e1dcfa950 Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Mon, 24 Feb 2025 22:38:33 +0800 Subject: [PATCH 3/7] fix: CI Signed-off-by: Dmitriy Khaustov aka xDimon --- .github/workflows/coverage.yml | 3 +-- cmake/Hunter/config.cmake | 5 +++-- vcpkg-overlay/scale/portfile.cmake | 11 ----------- vcpkg-overlay/scale/vcpkg.json | 19 ------------------- 4 files changed, 4 insertions(+), 34 deletions(-) delete mode 100644 vcpkg-overlay/scale/portfile.cmake delete mode 100644 vcpkg-overlay/scale/vcpkg.json diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 4b4007967..a291e1624 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -23,8 +23,7 @@ jobs: run: | set -e sudo apt-get update || true - sudo apt-get install -y ninja-build - sudo python3 -m pip install --upgrade pip + sudo apt-get install -y ninja-build python3-pip sudo pip3 install scikit-build sudo pip3 install cmake requests gitpython gcovr pyyaml - name: "cmake" diff --git a/cmake/Hunter/config.cmake b/cmake/Hunter/config.cmake index f7ddb2ae2..6e980b803 100644 --- a/cmake/Hunter/config.cmake +++ b/cmake/Hunter/config.cmake @@ -32,8 +32,9 @@ hunter_config( hunter_config( scale - URL https://github.com/qdrvm/scale-codec-cpp/archive/156433264c90770c9eda2a2417852fd8e14a024e.tar.gz - SHA1 d2b9edf1d67f48c1916caeae119df3065ef14062 +# VERSION 2.0.0 + URL https://github.com/qdrvm/scale-codec-cpp/archive/refs/tags/v2.0.0.tar.gz + SHA1 a83f0a034693809b948451ff774aeb58462a0f96 KEEP_PACKAGE_SOURCES ) diff --git a/vcpkg-overlay/scale/portfile.cmake b/vcpkg-overlay/scale/portfile.cmake deleted file mode 100644 index bfc72eb6d..000000000 --- a/vcpkg-overlay/scale/portfile.cmake +++ /dev/null @@ -1,11 +0,0 @@ -vcpkg_check_linkage(ONLY_STATIC_LIBRARY) -vcpkg_from_github( - OUT_SOURCE_PATH SOURCE_PATH - REPO qdrvm/scale-codec-cpp - REF 34e980bb539af19d5d1c28319f5618f40e9ec503 - SHA512 50c3984d2f7dd90b3918d8a88165ac5b2533b7e16fccd865280f36048d8386f3a0831799905d23e6275c89f1d82135d0655effae7c6c43c78f823e6d359e6685 -) -vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}") -vcpkg_cmake_install() -vcpkg_cmake_config_fixup(PACKAGE_NAME "scale") -file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") diff --git a/vcpkg-overlay/scale/vcpkg.json b/vcpkg-overlay/scale/vcpkg.json deleted file mode 100644 index 73942f4ca..000000000 --- a/vcpkg-overlay/scale/vcpkg.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "name": "scale", - "version": "1.1.3", - "dependencies": [ - { "name": "vcpkg-cmake", "host": true }, - { "name": "vcpkg-cmake-config", "host": true }, - "boost-endian", - "boost-multiprecision", - "qtils" - ], - "features": { - "scale-tests": { - "description": "Test of scale encoding/decoding", - "dependencies": [ - "gtest" - ] - } - } -} From ceddd9d9cfbe39dd6f01832caed298599dd0101f Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Mon, 24 Feb 2025 23:05:35 +0800 Subject: [PATCH 4/7] fix: CI Signed-off-by: Dmitriy Khaustov aka xDimon --- include/libp2p/multi/multiaddress_protocol_list.hpp | 1 + test/libp2p/multi/utils/protocol_list_test.cpp | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/include/libp2p/multi/multiaddress_protocol_list.hpp b/include/libp2p/multi/multiaddress_protocol_list.hpp index 08445d2f3..1b547615b 100644 --- a/include/libp2p/multi/multiaddress_protocol_list.hpp +++ b/include/libp2p/multi/multiaddress_protocol_list.hpp @@ -10,6 +10,7 @@ #include #include #include +#include namespace libp2p::multi { diff --git a/test/libp2p/multi/utils/protocol_list_test.cpp b/test/libp2p/multi/utils/protocol_list_test.cpp index 66ae68885..216d9dbb9 100644 --- a/test/libp2p/multi/utils/protocol_list_test.cpp +++ b/test/libp2p/multi/utils/protocol_list_test.cpp @@ -8,6 +8,8 @@ #include +#include + using libp2p::multi::Protocol; using libp2p::multi::ProtocolList; @@ -44,7 +46,7 @@ TEST(ProtocolList, getByCode) { TEST(ProtocolList, getProtocols) { auto &protocols = ProtocolList::getProtocols(); static_assert(protocols.size() == ProtocolList::kProtocolsNum); - auto it = std::find_if(protocols.begin(), protocols.end(), [](auto &p) { + auto it = std::ranges::find_if(protocols, [](auto &p) { return p.name == "ip4"; }); ASSERT_NE(it, protocols.end()); From ebcc24e3c4f11ac80d68b082dab4a5a5543b8df4 Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Tue, 25 Feb 2025 00:54:02 +0800 Subject: [PATCH 5/7] clean: remove mentions of SCALE update: qtils Signed-off-by: Dmitriy Khaustov aka xDimon --- cmake/Hunter/config.cmake | 14 +++----------- vcpkg.json | 2 +- 2 files changed, 4 insertions(+), 12 deletions(-) diff --git a/cmake/Hunter/config.cmake b/cmake/Hunter/config.cmake index 6e980b803..d8f5b2f52 100644 --- a/cmake/Hunter/config.cmake +++ b/cmake/Hunter/config.cmake @@ -30,19 +30,11 @@ hunter_config( SHA1 311ca59e20cbbfe9d9e05196c12c6ae109093987 ) -hunter_config( - scale -# VERSION 2.0.0 - URL https://github.com/qdrvm/scale-codec-cpp/archive/refs/tags/v2.0.0.tar.gz - SHA1 a83f0a034693809b948451ff774aeb58462a0f96 - KEEP_PACKAGE_SOURCES -) - hunter_config( qtils - URL https://github.com/qdrvm/qtils/archive/9a64dfd6ed0226dec29805aa89d4c713a6f81d9f.tar.gz - SHA1 16c0269175018e88c33090f9fbdaa230c8fdb911 + URL https://github.com/qdrvm/qtils/archive/1e492cf09a3640570cae59a951502614320c0797.tar.gz + SHA1 033dd907e2566c95ce2ccf1fa6dd9766bc896894 CMAKE_ARGS - FORMAT_ERROR_WITH_FULLTYPE=ON + FORMAT_ERROR_WITH_FULLTYPE=ON KEEP_PACKAGE_SOURCES ) diff --git a/vcpkg.json b/vcpkg.json index c7c4e07f1..216339c97 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -31,7 +31,7 @@ ], "features": { "libp2p-tests": { - "description": "Test of scale encoding/decoding", + "description": "Tests of libp2p", "dependencies": [ "gtest" ] From 5d0013db9850a1c23dfe9ef6673077959b2d784f Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Tue, 25 Feb 2025 01:11:21 +0800 Subject: [PATCH 6/7] fix: libp2pConfig.cmake Signed-off-by: Dmitriy Khaustov aka xDimon --- CMakeLists.txt | 4 ++++ cmake/libp2pConfig.cmake.in | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a94a5665a..2d732bd5c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -78,6 +78,10 @@ if (METRICS_ENABLED) add_compile_definitions("LIBP2P_METRICS_ENABLED") endif () +if(SQLITE_ENABLED) + set(SQLITE_FIND_DEP "find_dependency(SQLiteModernCpp CONFIG REQUIRED)") +endif() + ## setup compilation flags if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "^(AppleClang|Clang|GNU)$") # enable those flags diff --git a/cmake/libp2pConfig.cmake.in b/cmake/libp2pConfig.cmake.in index 0b1a97ebe..7cb13f7bc 100644 --- a/cmake/libp2pConfig.cmake.in +++ b/cmake/libp2pConfig.cmake.in @@ -13,7 +13,7 @@ find_dependency(yaml-cpp CONFIG REQUIRED) find_dependency(soralog CONFIG REQUIRED) find_dependency(tsl_hat_trie CONFIG REQUIRED) find_dependency(Boost.DI CONFIG REQUIRED) -find_dependency(SQLiteModernCpp CONFIG REQUIRED) +@SQLITE_FIND_DEP@ include("${CMAKE_CURRENT_LIST_DIR}/libp2pTargets.cmake") From 5f0235955a5de9c48ea51ccb0a4a8f779d8da940 Mon Sep 17 00:00:00 2001 From: Dmitriy Khaustov aka xDimon Date: Thu, 27 Feb 2025 16:28:19 +0800 Subject: [PATCH 7/7] fix: possible mem-leaks at X509_PUBKEY_get Signed-off-by: Dmitriy Khaustov aka xDimon --- src/crypto/rsa_provider/rsa_provider_impl.cpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/crypto/rsa_provider/rsa_provider_impl.cpp b/src/crypto/rsa_provider/rsa_provider_impl.cpp index 1616086fa..cbc492658 100644 --- a/src/crypto/rsa_provider/rsa_provider_impl.cpp +++ b/src/crypto/rsa_provider/rsa_provider_impl.cpp @@ -157,8 +157,19 @@ namespace libp2p::crypto::rsa { const Signature &signature, const PublicKey &public_key) const { OUTCOME_TRY(x509_key, RsaProviderImpl::getPublicKeyFromBytes(public_key)); + EVP_PKEY *key = X509_PUBKEY_get(x509_key.get()); - std::unique_ptr rsa{EVP_PKEY_get1_RSA(key), RSA_free}; + if (!key) { + return CryptoProviderError::SIGNATURE_VERIFICATION_FAILED; + } + std::unique_ptr key_ptr{key, + EVP_PKEY_free}; + std::unique_ptr rsa{ + EVP_PKEY_get1_RSA(key_ptr.get()), RSA_free}; + if (!rsa) { + return CryptoProviderError::SIGNATURE_VERIFICATION_FAILED; + } + OUTCOME_TRY(digest, sha256(message)); int result = RSA_verify(NID_sha256, digest.data(),