ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-11-27 07:05:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add compiler flags (#850)

Browse Source 
Fixes #435
This commit is contained in:
Sergey Kuznetsov
2023-10-02 16:45:48 +01:00
committed by GitHub
parent d1c41a8bb7
commit 69f5025a29
53 changed files with 383 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
CMake/Settings.cmake
View File

@@ -1,7 +1,39 @@
target_compile_options (clio PUBLIC set(COMPILER_FLAGS
-Wall -Wall
-Wcast-align
-Wdouble-promotion
-Wextra
-Werror -Werror
-Wformat=2
-Wimplicit-fallthrough
-Wmisleading-indentation
-Wno-narrowing -Wno-narrowing
-Wno-deprecated-declarations -Wno-deprecated-declarations
-Wno-dangling-else -Wno-dangling-else
-Wno-unused-but-set-variable) -Wno-unused-but-set-variable
-Wnon-virtual-dtor
-Wnull-dereference
-Wold-style-cast
-pedantic
-Wpedantic
-Wunused
)
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
list(APPEND COMPILER_FLAGS
-Wshadow # gcc is to aggressive with shadowing https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78147
)
endif ()
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
list(APPEND COMPILER_FLAGS
-Wduplicated-branches
-Wduplicated-cond
-Wlogical-op
-Wuseless-cast
)
endif ()
# See https://github.com/cpp-best-practices/cppbestpractices/blob/master/02-Use_the_Tools_Available.md#gcc--clang for the flags description
target_compile_options (clio PUBLIC ${COMPILER_FLAGS})

6
src/data/CassandraBackend.h
View File

@@ -649,11 +649,11 @@ public:
return {}; return {};
} }
std::vector<ripple::uint256> keys; std::vector<ripple::uint256> resultKeys;
for (auto [key] : extract<ripple::uint256>(results)) for (auto [key] : extract<ripple::uint256>(results))
keys.push_back(key); resultKeys.push_back(key);
return keys; return resultKeys;
}); });
// one of the above errors must have happened // one of the above errors must have happened

2
src/data/DBHelpers.h
View File

@@ -40,7 +40,7 @@ struct AccountTransactionsData
std::uint32_t transactionIndex; std::uint32_t transactionIndex;
ripple::uint256 txHash; ripple::uint256 txHash;
AccountTransactionsData(ripple::TxMeta& meta, ripple::uint256 const& txHash, beast::Journal& j) AccountTransactionsData(ripple::TxMeta& meta, ripple::uint256 const& txHash)
: accounts(meta.getAffectedAccounts()) : accounts(meta.getAffectedAccounts())
, ledgerSequence(meta.getLgrSeq()) , ledgerSequence(meta.getLgrSeq())
, transactionIndex(meta.getIndex()) , transactionIndex(meta.getIndex())

4
src/data/LedgerCache.cpp
View File

@@ -146,7 +146,7 @@ LedgerCache::getObjectHitRate() const
{ {
if (!objectReqCounter_) if (!objectReqCounter_)
return 1; return 1;
return ((float)objectHitCounter_) / objectReqCounter_; return static_cast<float>(objectHitCounter_) / objectReqCounter_;
} }
float float
@@ -154,7 +154,7 @@ LedgerCache::getSuccessorHitRate() const
{ {
if (!successorReqCounter_) if (!successorReqCounter_)
return 1; return 1;
return ((float)successorHitCounter_) / successorReqCounter_; return static_cast<float>(successorHitCounter_) / successorReqCounter_;
} }
} // namespace data } // namespace data

2
src/data/Types.h
View File

@@ -118,6 +118,8 @@ struct TransactionsCursor
{ {
} }
TransactionsCursor(TransactionsCursor const&) = default;
TransactionsCursor& TransactionsCursor&
operator=(TransactionsCursor const&) = default; operator=(TransactionsCursor const&) = default;

2
src/data/cassandra/impl/Cluster.h
View File

@@ -46,7 +46,7 @@ struct Settings
struct ContactPoints struct ContactPoints
{ {
std::string contactPoints = "127.0.0.1"; // defaults to localhost std::string contactPoints = "127.0.0.1"; // defaults to localhost
std::optional<uint16_t> port; std::optional<uint16_t> port = {};
}; };
/** /**

2
src/data/cassandra/impl/ManagedObject.h
View File

@@ -38,7 +38,7 @@ public:
} }
ManagedObject(ManagedObject&&) = default; ManagedObject(ManagedObject&&) = default;
operator Managed* const() const operator Managed*() const
{ {
return ptr_.get(); return ptr_.get();
} }

101
src/etl/ETLService.cpp
View File

@@ -142,43 +142,50 @@ ETLService::monitor()
while (true) while (true)
{ {
if (auto rng = backend_->hardFetchLedgerRangeNoThrow(); rng && rng->maxSequence >= nextSequence) nextSequence = publishNextSequence(nextSequence);
}
}
uint32_t
ETLService::publishNextSequence(uint32_t nextSequence)
{
if (auto rng = backend_->hardFetchLedgerRangeNoThrow(); rng && rng->maxSequence >= nextSequence)
{
ledgerPublisher_.publish(nextSequence, {});
++nextSequence;
}
else if (networkValidatedLedgers_->waitUntilValidatedByNetwork(nextSequence, 1000))
{
LOG(log_.info()) << "Ledger with sequence = " << nextSequence << " has been validated by the network. "
<< "Attempting to find in database and publish";
// Attempt to take over responsibility of ETL writer after 10 failed
// attempts to publish the ledger. publishLedger() fails if the
// ledger that has been validated by the network is not found in the
// database after the specified number of attempts. publishLedger()
// waits one second between each attempt to read the ledger from the
// database
constexpr size_t timeoutSeconds = 10;
bool success = ledgerPublisher_.publish(nextSequence, timeoutSeconds);
if (!success)
{
LOG(log_.warn()) << "Failed to publish ledger with sequence = " << nextSequence << " . Beginning ETL";
// returns the most recent sequence published empty optional if no sequence was published
std::optional<uint32_t> lastPublished = runETLPipeline(nextSequence, extractorThreads_);
LOG(log_.info()) << "Aborting ETL. Falling back to publishing";
// if no ledger was published, don't increment nextSequence
if (lastPublished)
nextSequence = *lastPublished + 1;
}
else
{ {
ledgerPublisher_.publish(nextSequence, {});
++nextSequence; ++nextSequence;
} }
else if (networkValidatedLedgers_->waitUntilValidatedByNetwork(nextSequence, 1000))
{
LOG(log_.info()) << "Ledger with sequence = " << nextSequence << " has been validated by the network. "
<< "Attempting to find in database and publish";
// Attempt to take over responsibility of ETL writer after 10 failed
// attempts to publish the ledger. publishLedger() fails if the
// ledger that has been validated by the network is not found in the
// database after the specified number of attempts. publishLedger()
// waits one second between each attempt to read the ledger from the
// database
constexpr size_t timeoutSeconds = 10;
bool success = ledgerPublisher_.publish(nextSequence, timeoutSeconds);
if (!success)
{
LOG(log_.warn()) << "Failed to publish ledger with sequence = " << nextSequence << " . Beginning ETL";
// returns the most recent sequence published empty optional if no sequence was published
std::optional<uint32_t> lastPublished = runETLPipeline(nextSequence, extractorThreads_);
LOG(log_.info()) << "Aborting ETL. Falling back to publishing";
// if no ledger was published, don't increment nextSequence
if (lastPublished)
nextSequence = *lastPublished + 1;
}
else
{
++nextSequence;
}
}
} }
return nextSequence;
} }
void void
@@ -186,21 +193,29 @@ ETLService::monitorReadOnly()
{ {
LOG(log_.debug()) << "Starting reporting in strict read only mode"; LOG(log_.debug()) << "Starting reporting in strict read only mode";
auto rng = backend_->hardFetchLedgerRangeNoThrow(); const auto latestSequenceOpt = [this]() -> std::optional<uint32_t> {
uint32_t latestSequence; auto rng = backend_->hardFetchLedgerRangeNoThrow();
if (!rng) if (!rng)
{ {
if (auto net = networkValidatedLedgers_->getMostRecent()) if (auto net = networkValidatedLedgers_->getMostRecent())
latestSequence = *net; return *net;
else
return std::nullopt;
}
else else
return; {
} return rng->maxSequence;
else }
}();
if (!latestSequenceOpt.has_value())
{ {
latestSequence = rng->maxSequence; return;
} }
uint32_t latestSequence = *latestSequenceOpt;
cacheLoader_.load(latestSequence); cacheLoader_.load(latestSequence);
latestSequence++; latestSequence++;

9
src/etl/ETLService.h
View File

@@ -230,6 +230,15 @@ private:
void void
monitor(); monitor();
/**
* @brief Monitor the network for newly validated ledgers and publish them to the ledgers stream
*
* @param nextSequence the ledger sequence to publish
* @return the next ledger sequence to publish
*/
uint32_t
publishNextSequence(uint32_t nextSequence);
/** /**
* @brief Monitor the database for newly written ledgers. * @brief Monitor the database for newly written ledgers.
* *

4
src/etl/LoadBalancer.cpp
View File

@@ -147,7 +147,7 @@ LoadBalancer::forwardToRippled(
std::string const& clientIp, std::string const& clientIp,
boost::asio::yield_context yield) const boost::asio::yield_context yield) const
{ {
srand((unsigned)time(0)); srand(static_cast<unsigned>(time(0)));
auto sourceIdx = rand() % sources_.size(); auto sourceIdx = rand() % sources_.size();
auto numAttempts = 0u; auto numAttempts = 0u;
@@ -193,7 +193,7 @@ template <class Func>
bool bool
LoadBalancer::execute(Func f, uint32_t ledgerSequence) LoadBalancer::execute(Func f, uint32_t ledgerSequence)
{ {
srand((unsigned)time(0)); srand(static_cast<unsigned>(time(0)));
auto sourceIdx = rand() % sources_.size(); auto sourceIdx = rand() % sources_.size();
auto numAttempts = 0; auto numAttempts = 0;

4
src/etl/ProbingSource.cpp
View File

@@ -160,7 +160,7 @@ ProbingSource::make_SSLHooks() noexcept
return SourceHooks::Action::PROCEED; return SourceHooks::Action::PROCEED;
}, },
// onDisconnected // onDisconnected
[this](auto ec) { [this](auto /* ec */) {
std::lock_guard lck(mtx_); std::lock_guard lck(mtx_);
if (currentSrc_) if (currentSrc_)
{ {
@@ -189,7 +189,7 @@ ProbingSource::make_PlainHooks() noexcept
return SourceHooks::Action::PROCEED; return SourceHooks::Action::PROCEED;
}, },
// onDisconnected // onDisconnected
[this](auto ec) { [this](auto /* ec */) {
std::lock_guard lck(mtx_); std::lock_guard lck(mtx_);
if (currentSrc_) if (currentSrc_)
{ {

2
src/etl/impl/AsyncData.h
View File

@@ -128,7 +128,7 @@ public:
auto& obj = *(cur_->mutable_ledger_objects()->mutable_objects(i)); auto& obj = *(cur_->mutable_ledger_objects()->mutable_objects(i));
if (!more && nextPrefix_ != 0x00) if (!more && nextPrefix_ != 0x00)
{ {
if (((unsigned char)obj.key()[0]) >= nextPrefix_) if (static_cast<unsigned char>(obj.key()[0]) >= nextPrefix_)
continue; continue;
} }
cacheUpdates.push_back( cacheUpdates.push_back(

5
src/etl/impl/LedgerLoader.h
View File

@@ -107,9 +107,8 @@ public:
if (maybeNFT) if (maybeNFT)
result.nfTokensData.push_back(*maybeNFT); result.nfTokensData.push_back(*maybeNFT);
auto journal = ripple::debugLog(); result.accountTxData.emplace_back(txMeta, sttx.getTransactionID());
result.accountTxData.emplace_back(txMeta, sttx.getTransactionID(), journal); std::string keyStr{reinterpret_cast<const char*>(sttx.getTransactionID().data()), 32};
std::string keyStr{(const char*)sttx.getTransactionID().data(), 32};
backend_->writeTransaction( backend_->writeTransaction(
std::move(keyStr), std::move(keyStr),
ledger.seq, ledger.seq,

2
src/main/Main.cpp
View File

@@ -206,7 +206,7 @@ try
auto const handlerProvider = std::make_shared<rpc::detail::ProductionHandlerProvider const>( auto const handlerProvider = std::make_shared<rpc::detail::ProductionHandlerProvider const>(
config, backend, subscriptions, balancer, etl, counters); config, backend, subscriptions, balancer, etl, counters);
auto const rpcEngine = rpc::RPCEngine::make_RPCEngine( auto const rpcEngine = rpc::RPCEngine::make_RPCEngine(
config, backend, subscriptions, balancer, etl, dosGuard, workQueue, counters, handlerProvider); backend, subscriptions, balancer, dosGuard, workQueue, counters, handlerProvider);
// Init the web server // Init the web server
auto handler = std::make_shared<web::RPCServerHandler<rpc::RPCEngine, etl::ETLService>>( auto handler = std::make_shared<web::RPCServerHandler<rpc::RPCEngine, etl::ETLService>>(

1
src/rpc/BookChangesHelper.h
View File

@@ -199,6 +199,7 @@ private:
case ripple::ttOFFER_CREATE: case ripple::ttOFFER_CREATE:
if (tx->isFieldPresent(ripple::sfOfferSequence)) if (tx->isFieldPresent(ripple::sfOfferSequence))
return tx->getFieldU32(ripple::sfOfferSequence); return tx->getFieldU32(ripple::sfOfferSequence);
[[fallthrough]];
default: default:
return std::nullopt; return std::nullopt;
} }

4
src/rpc/Factories.cpp
View File

@@ -35,8 +35,6 @@ make_WsContext(
string const& clientIp, string const& clientIp,
std::reference_wrapper<APIVersionParser const> apiVersionParser) std::reference_wrapper<APIVersionParser const> apiVersionParser)
{ {
using Error = Unexpected<Status>;
boost::json::value commandValue = nullptr; boost::json::value commandValue = nullptr;
if (!request.contains("command") && request.contains("method")) if (!request.contains("command") && request.contains("method"))
commandValue = request.at("method"); commandValue = request.at("method");
@@ -63,8 +61,6 @@ make_HttpContext(
string const& clientIp, string const& clientIp,
std::reference_wrapper<APIVersionParser const> apiVersionParser) std::reference_wrapper<APIVersionParser const> apiVersionParser)
{ {
using Error = Unexpected<Status>;
if (!request.contains("method")) if (!request.contains("method"))
return Error{{ClioError::rpcCOMMAND_IS_MISSING}}; return Error{{ClioError::rpcCOMMAND_IS_MISSING}};

5
src/rpc/RPCEngine.h
View File

@@ -83,7 +83,6 @@ public:
std::shared_ptr<BackendInterface> const& backend, std::shared_ptr<BackendInterface> const& backend,
std::shared_ptr<feed::SubscriptionManager> const& subscriptions, std::shared_ptr<feed::SubscriptionManager> const& subscriptions,
std::shared_ptr<etl::LoadBalancer> const& balancer, std::shared_ptr<etl::LoadBalancer> const& balancer,
std::shared_ptr<etl::ETLService> const& etl,
web::DOSGuard const& dosGuard, web::DOSGuard const& dosGuard,
WorkQueue& workQueue, WorkQueue& workQueue,
Counters& counters, Counters& counters,
@@ -101,18 +100,16 @@ public:
static std::shared_ptr<RPCEngineBase> static std::shared_ptr<RPCEngineBase>
make_RPCEngine( make_RPCEngine(
util::Config const& config,
std::shared_ptr<BackendInterface> const& backend, std::shared_ptr<BackendInterface> const& backend,
std::shared_ptr<feed::SubscriptionManager> const& subscriptions, std::shared_ptr<feed::SubscriptionManager> const& subscriptions,
std::shared_ptr<etl::LoadBalancer> const& balancer, std::shared_ptr<etl::LoadBalancer> const& balancer,
std::shared_ptr<etl::ETLService> const& etl,
web::DOSGuard const& dosGuard, web::DOSGuard const& dosGuard,
WorkQueue& workQueue, WorkQueue& workQueue,
Counters& counters, Counters& counters,
std::shared_ptr<HandlerProvider const> const& handlerProvider) std::shared_ptr<HandlerProvider const> const& handlerProvider)
{ {
return std::make_shared<RPCEngineBase>( return std::make_shared<RPCEngineBase>(
backend, subscriptions, balancer, etl, dosGuard, workQueue, counters, handlerProvider); backend, subscriptions, balancer, dosGuard, workQueue, counters, handlerProvider);
} }
/** /**

23
src/rpc/RPCHelpers.cpp
View File

@@ -33,6 +33,7 @@
// local to compilation unit loggers // local to compilation unit loggers
namespace { namespace {
util::Logger gLog{"RPC"}; util::Logger gLog{"RPC"};
} // namespace } // namespace
namespace rpc { namespace rpc {
@@ -565,10 +566,10 @@ traverseOwnedNodes(
if (!hintDir) if (!hintDir)
return Status(ripple::rpcINVALID_PARAMS, "Invalid marker."); return Status(ripple::rpcINVALID_PARAMS, "Invalid marker.");
ripple::SerialIter it{hintDir->data(), hintDir->size()}; ripple::SerialIter hintDirIt{hintDir->data(), hintDir->size()};
ripple::SLE sle{it, hintIndex.key}; ripple::SLE hintDirSle{hintDirIt, hintIndex.key};
if (auto const& indexes = sle.getFieldV256(ripple::sfIndexes); if (auto const& indexes = hintDirSle.getFieldV256(ripple::sfIndexes);
std::find(std::begin(indexes), std::end(indexes), hexMarker) == std::end(indexes)) std::find(std::begin(indexes), std::end(indexes), hexMarker) == std::end(indexes))
{ {
// the index specified by marker is not in the page specified by marker // the index specified by marker is not in the page specified by marker
@@ -584,10 +585,10 @@ traverseOwnedNodes(
if (!ownerDir) if (!ownerDir)
return Status(ripple::rpcINVALID_PARAMS, "Owner directory not found."); return Status(ripple::rpcINVALID_PARAMS, "Owner directory not found.");
ripple::SerialIter it{ownerDir->data(), ownerDir->size()}; ripple::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()};
ripple::SLE sle{it, currentIndex.key}; ripple::SLE ownedDirSle{ownedDirIt, currentIndex.key};
for (auto const& key : sle.getFieldV256(ripple::sfIndexes)) for (auto const& key : ownedDirSle.getFieldV256(ripple::sfIndexes))
{ {
if (!found) if (!found)
{ {
@@ -611,7 +612,7 @@ traverseOwnedNodes(
break; break;
} }
// the next page // the next page
auto const uNodeNext = sle.getFieldU64(ripple::sfIndexNext); auto const uNodeNext = ownedDirSle.getFieldU64(ripple::sfIndexNext);
if (uNodeNext == 0) if (uNodeNext == 0)
break; break;
@@ -628,10 +629,10 @@ traverseOwnedNodes(
if (!ownerDir) if (!ownerDir)
break; break;
ripple::SerialIter it{ownerDir->data(), ownerDir->size()}; ripple::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()};
ripple::SLE sle{it, currentIndex.key}; ripple::SLE ownedDirSle{ownedDirIt, currentIndex.key};
for (auto const& key : sle.getFieldV256(ripple::sfIndexes)) for (auto const& key : ownedDirSle.getFieldV256(ripple::sfIndexes))
{ {
keys.push_back(key); keys.push_back(key);
@@ -645,7 +646,7 @@ traverseOwnedNodes(
break; break;
} }
auto const uNodeNext = sle.getFieldU64(ripple::sfIndexNext); auto const uNodeNext = ownedDirSle.getFieldU64(ripple::sfIndexNext);
if (uNodeNext == 0) if (uNodeNext == 0)
break; break;

4
src/rpc/common/Types.h
View File

@@ -83,9 +83,9 @@ struct VoidOutput
struct Context struct Context
{ {
boost::asio::yield_context yield; boost::asio::yield_context yield;
std::shared_ptr<web::ConnectionBase> session; std::shared_ptr<web::ConnectionBase> session = {};
bool isAdmin = false; bool isAdmin = false;
std::string clientIp; std::string clientIp = {};
uint32_t apiVersion = 0u; // invalid by default uint32_t apiVersion = 0u; // invalid by default
}; };

2
src/rpc/common/Validators.cpp
View File

@@ -68,7 +68,7 @@ CustomValidator Uint256HexStringValidator =
}}; }};
CustomValidator LedgerIndexValidator = CustomValidator LedgerIndexValidator =
CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { CustomValidator{[](boost::json::value const& value, std::string_view /* key */) -> MaybeError {
auto err = Error{Status{RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"}}; auto err = Error{Status{RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"}};
if (!value.is_string() && !(value.is_uint64() || value.is_int64())) if (!value.is_string() && !(value.is_uint64() || value.is_int64()))

2
src/rpc/handlers/LedgerEntry.h
View File

@@ -81,7 +81,7 @@ public:
// The accounts array must have two different elements // The accounts array must have two different elements
// Each element must be a valid address // Each element must be a valid address
static auto const rippleStateAccountsCheck = static auto const rippleStateAccountsCheck =
validation::CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { validation::CustomValidator{[](boost::json::value const& value, std::string_view /* key */) -> MaybeError {
if (!value.is_array() || value.as_array().size() != 2 || !value.as_array()[0].is_string() || if (!value.is_array() || value.as_array().size() != 2 || !value.as_array()[0].is_string() ||
!value.as_array()[1].is_string() || !value.as_array()[1].is_string() ||
value.as_array()[0].as_string() == value.as_array()[1].as_string()) value.as_array()[0].as_string() == value.as_array()[1].as_string())

2
src/rpc/handlers/NFTOffersCommon.cpp
View File

@@ -132,7 +132,7 @@ NFTOffersHandlerBase::iterateOfferDirectory(
std::move(std::begin(offers), std::end(offers), std::back_inserter(output.offers)); std::move(std::begin(offers), std::end(offers), std::back_inserter(output.offers));
return std::move(output); return output;
} }
void void

8
src/rpc/handlers/NFTOffersCommon.h
View File

@@ -38,13 +38,13 @@ public:
struct Output struct Output
{ {
std::string nftID; std::string nftID = {};
std::vector<ripple::SLE> offers; std::vector<ripple::SLE> offers = {};
// validated should be sent via framework // validated should be sent via framework
bool validated = true; bool validated = true;
std::optional<uint32_t> limit; std::optional<uint32_t> limit = {};
std::optional<std::string> marker; std::optional<std::string> marker = {};
}; };
struct Input struct Input

16
src/web/RPCServerHandler.h
View File

@@ -190,13 +190,13 @@ private:
return web::detail::ErrorHelper(connection, request).sendError(err); return web::detail::ErrorHelper(connection, request).sendError(err);
} }
auto [v, timeDiff] = util::timed([&]() { return rpcEngine_->buildResponse(*context); }); auto [result, timeDiff] = util::timed([&]() { return rpcEngine_->buildResponse(*context); });
auto us = std::chrono::duration<int, std::milli>(timeDiff); auto us = std::chrono::duration<int, std::milli>(timeDiff);
rpc::logDuration(*context, us); rpc::logDuration(*context, us);
boost::json::object response; boost::json::object response;
if (auto const status = std::get_if<rpc::Status>(&v)) if (auto const status = std::get_if<rpc::Status>(&result))
{ {
// note: error statuses are counted/notified in buildResponse itself // note: error statuses are counted/notified in buildResponse itself
response = web::detail::ErrorHelper(connection, request).composeError(*status); response = web::detail::ErrorHelper(connection, request).composeError(*status);
@@ -210,20 +210,20 @@ private:
// This can still technically be an error. Clio counts forwarded requests as successful. // This can still technically be an error. Clio counts forwarded requests as successful.
rpcEngine_->notifyComplete(context->method, us); rpcEngine_->notifyComplete(context->method, us);
auto& result = std::get<boost::json::object>(v); auto& json = std::get<boost::json::object>(result);
auto const isForwarded = result.contains("forwarded") && result.at("forwarded").is_bool() && auto const isForwarded =
result.at("forwarded").as_bool(); json.contains("forwarded") && json.at("forwarded").is_bool() && json.at("forwarded").as_bool();
// if the result is forwarded - just use it as is // if the result is forwarded - just use it as is
// if forwarded request has error, for http, error should be in "result"; for ws, error should be at top // if forwarded request has error, for http, error should be in "result"; for ws, error should be at top
if (isForwarded && (result.contains("result") || connection->upgraded)) if (isForwarded && (json.contains("result") || connection->upgraded))
{ {
for (auto const& [k, v] : result) for (auto const& [k, v] : json)
response.insert_or_assign(k, v); response.insert_or_assign(k, v);
} }
else else
{ {
response["result"] = result; response["result"] = json;
} }
// for ws there is an additional field "status" in the response, // for ws there is an additional field "status" in the response,

2
src/web/impl/WsBase.h
View File

@@ -150,7 +150,7 @@ public:
* If the DOSGuard is triggered, the message will be modified to include a warning * If the DOSGuard is triggered, the message will be modified to include a warning
*/ */
void void
send(std::string&& msg, http::status _ = http::status::ok) override send(std::string&& msg, http::status = http::status::ok) override
{ {
if (!dosGuard_.get().add(clientIp, msg.size())) if (!dosGuard_.get().add(clientIp, msg.size()))
{ {

3
src/web/interface/ConnectionBase.h
View File

@@ -68,8 +68,7 @@ public:
* @param msg The message to send * @param msg The message to send
* @throws Not supported unless implemented in child classes. Will always throw std::logic_error. * @throws Not supported unless implemented in child classes. Will always throw std::logic_error.
*/ */
virtual void virtual void send(std::shared_ptr<std::string> /* msg */)
send(std::shared_ptr<std::string> msg)
{ {
throw std::logic_error("web server can not send the shared payload"); throw std::logic_error("web server can not send the shared payload");
} }

2
unittests/SubscriptionManagerTests.cpp
View File

@@ -270,7 +270,7 @@ TEST_F(SubscriptionManagerSimpleBackendTest, SubscriptionManagerAccountProposedT
})"; })";
subManagerPtr->forwardProposedTransaction(json::parse(dummyTransaction).get_object()); subManagerPtr->forwardProposedTransaction(json::parse(dummyTransaction).get_object());
CheckSubscriberMessage(dummyTransaction, session); CheckSubscriberMessage(dummyTransaction, session);
auto rawIdle = (MockSession*)(sessionIdle.get()); auto rawIdle = static_cast<MockSession*>(sessionIdle.get());
EXPECT_EQ("", rawIdle->message); EXPECT_EQ("", rawIdle->message);
} }

13
unittests/SubscriptionTests.cpp
View File

@@ -25,7 +25,6 @@
#include <boost/json/parse.hpp> #include <boost/json/parse.hpp>
#include <gmock/gmock.h> #include <gmock/gmock.h>
namespace json = boost::json;
using namespace feed; using namespace feed;
// io_context // io_context
@@ -83,9 +82,9 @@ TEST_F(SubscriptionTest, SubscriptionPublish)
sub.publish(std::make_shared<std::string>("message")); sub.publish(std::make_shared<std::string>("message"));
ctx.restart(); ctx.restart();
ctx.run(); ctx.run();
MockSession* p1 = (MockSession*)(session1.get()); MockSession* p1 = static_cast<MockSession*>(session1.get());
EXPECT_EQ(p1->message, "message"); EXPECT_EQ(p1->message, "message");
MockSession* p2 = (MockSession*)(session2.get()); MockSession* p2 = static_cast<MockSession*>(session2.get());
EXPECT_EQ(p2->message, "message"); EXPECT_EQ(p2->message, "message");
sub.unsubscribe(session1); sub.unsubscribe(session1);
ctx.restart(); ctx.restart();
@@ -166,9 +165,9 @@ TEST_F(SubscriptionMapTest, SubscriptionMapPublish)
subMap.publish(std::make_shared<std::string>(topic2Message.data()), topic2); // rvalue subMap.publish(std::make_shared<std::string>(topic2Message.data()), topic2); // rvalue
ctx.restart(); ctx.restart();
ctx.run(); ctx.run();
MockSession* p1 = (MockSession*)(session1.get()); MockSession* p1 = static_cast<MockSession*>(session1.get());
EXPECT_EQ(p1->message, topic1Message); EXPECT_EQ(p1->message, topic1Message);
MockSession* p2 = (MockSession*)(session2.get()); MockSession* p2 = static_cast<MockSession*>(session2.get());
EXPECT_EQ(p2->message, topic2Message); EXPECT_EQ(p2->message, topic2Message);
} }
@@ -190,9 +189,9 @@ TEST_F(SubscriptionMapTest, SubscriptionMapDeadRemoveSubscriber)
subMap.publish(std::make_shared<std::string>(topic2Message), topic2); // rvalue subMap.publish(std::make_shared<std::string>(topic2Message), topic2); // rvalue
ctx.restart(); ctx.restart();
ctx.run(); ctx.run();
MockDeadSession* p1 = (MockDeadSession*)(session1.get()); MockDeadSession* p1 = static_cast<MockDeadSession*>(session1.get());
EXPECT_EQ(p1->dead(), true); EXPECT_EQ(p1->dead(), true);
MockSession* p2 = (MockSession*)(session2.get()); MockSession* p2 = static_cast<MockSession*>(session2.get());
EXPECT_EQ(p2->message, topic2Message); EXPECT_EQ(p2->message, topic2Message);
subMap.publish(message1, topic1); subMap.publish(message1, topic1);
ctx.restart(); ctx.restart();

98
unittests/data/cassandra/BackendTests.cpp
View File

@@ -122,9 +122,9 @@ TEST_F(BackendCassandraTest, Basic)
lgrInfoNext.hash++; lgrInfoNext.hash++;
lgrInfoNext.accountHash = ~lgrInfo.accountHash; lgrInfoNext.accountHash = ~lgrInfo.accountHash;
{ {
std::string rawHeaderBlob = ledgerInfoToBinaryString(lgrInfoNext); std::string infoBlob = ledgerInfoToBinaryString(lgrInfoNext);
backend->writeLedger(lgrInfoNext, std::move(rawHeaderBlob)); backend->writeLedger(lgrInfoNext, std::move(infoBlob));
ASSERT_TRUE(backend->finishWrites(lgrInfoNext.seq)); ASSERT_TRUE(backend->finishWrites(lgrInfoNext.seq));
} }
{ {
@@ -349,14 +349,13 @@ TEST_F(BackendCassandraTest, Basic)
ripple::uint256 hash256; ripple::uint256 hash256;
EXPECT_TRUE(hash256.parseHex(hashHex)); EXPECT_TRUE(hash256.parseHex(hashHex));
ripple::TxMeta txMeta{hash256, lgrInfoNext.seq, metaBlob}; ripple::TxMeta txMeta{hash256, lgrInfoNext.seq, metaBlob};
auto journal = ripple::debugLog();
auto accountsSet = txMeta.getAffectedAccounts(); auto accountsSet = txMeta.getAffectedAccounts();
for (auto& a : accountsSet) for (auto& a : accountsSet)
{ {
affectedAccounts.push_back(a); affectedAccounts.push_back(a);
} }
std::vector<AccountTransactionsData> accountTxData; std::vector<AccountTransactionsData> accountTxData;
accountTxData.emplace_back(txMeta, hash256, journal); accountTxData.emplace_back(txMeta, hash256);
ripple::uint256 nftHash256; ripple::uint256 nftHash256;
EXPECT_TRUE(nftHash256.parseHex(nftTxnHashHex)); EXPECT_TRUE(nftHash256.parseHex(nftTxnHashHex));
@@ -399,18 +398,22 @@ TEST_F(BackendCassandraTest, Basic)
auto retLgr = backend->fetchLedgerBySequence(lgrInfoNext.seq, yield); auto retLgr = backend->fetchLedgerBySequence(lgrInfoNext.seq, yield);
EXPECT_TRUE(retLgr); EXPECT_TRUE(retLgr);
EXPECT_EQ(ledgerInfoToBlob(*retLgr), ledgerInfoToBlob(lgrInfoNext)); EXPECT_EQ(ledgerInfoToBlob(*retLgr), ledgerInfoToBlob(lgrInfoNext));
auto txns = backend->fetchAllTransactionsInLedger(lgrInfoNext.seq, yield); auto allTransactions = backend->fetchAllTransactionsInLedger(lgrInfoNext.seq, yield);
ASSERT_EQ(txns.size(), 1); ASSERT_EQ(allTransactions.size(), 1);
EXPECT_STREQ((const char*)txns[0].transaction.data(), (const char*)txnBlob.data()); EXPECT_STREQ(
EXPECT_STREQ((const char*)txns[0].metadata.data(), (const char*)metaBlob.data()); reinterpret_cast<const char*>(allTransactions[0].transaction.data()),
static_cast<const char*>(txnBlob.data()));
EXPECT_STREQ(
reinterpret_cast<const char*>(allTransactions[0].metadata.data()),
static_cast<const char*>(metaBlob.data()));
auto hashes = backend->fetchAllTransactionHashesInLedger(lgrInfoNext.seq, yield); auto hashes = backend->fetchAllTransactionHashesInLedger(lgrInfoNext.seq, yield);
EXPECT_EQ(hashes.size(), 1); EXPECT_EQ(hashes.size(), 1);
EXPECT_EQ(ripple::strHex(hashes[0]), hashHex); EXPECT_EQ(ripple::strHex(hashes[0]), hashHex);
for (auto& a : affectedAccounts) for (auto& a : affectedAccounts)
{ {
auto [txns, cursor] = backend->fetchAccountTransactions(a, 100, true, {}, yield); auto [accountTransactions, cursor] = backend->fetchAccountTransactions(a, 100, true, {}, yield);
EXPECT_EQ(txns.size(), 1); EXPECT_EQ(accountTransactions.size(), 1);
EXPECT_EQ(txns[0], txns[0]); EXPECT_EQ(accountTransactions[0], accountTransactions[0]);
EXPECT_FALSE(cursor); EXPECT_FALSE(cursor);
} }
auto nft = backend->fetchNFT(nftID, lgrInfoNext.seq, yield); auto nft = backend->fetchNFT(nftID, lgrInfoNext.seq, yield);
@@ -424,10 +427,10 @@ TEST_F(BackendCassandraTest, Basic)
EXPECT_TRUE(key256.parseHex(accountIndexHex)); EXPECT_TRUE(key256.parseHex(accountIndexHex));
auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield); auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield);
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
} }
@@ -463,13 +466,13 @@ TEST_F(BackendCassandraTest, Basic)
EXPECT_TRUE(key256.parseHex(accountIndexHex)); EXPECT_TRUE(key256.parseHex(accountIndexHex));
auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield); auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 1, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlobOld.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlobOld.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield);
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
} }
@@ -505,7 +508,7 @@ TEST_F(BackendCassandraTest, Basic)
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 2, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 2, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlobOld.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlobOld.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield);
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
} }
@@ -518,7 +521,7 @@ TEST_F(BackendCassandraTest, Basic)
for (auto& blob : res) for (auto& blob : res)
{ {
++key; ++key;
std::string keyStr{(const char*)key.data(), key.size()}; std::string keyStr{reinterpret_cast<const char*>(key.data()), key.size()};
blob.first = keyStr; blob.first = keyStr;
blob.second = std::to_string(ledgerSequence) + keyStr; blob.second = std::to_string(ledgerSequence) + keyStr;
} }
@@ -538,7 +541,7 @@ TEST_F(BackendCassandraTest, Basic)
for (auto& blob : res) for (auto& blob : res)
{ {
++base; ++base;
std::string hashStr{(const char*)base.data(), base.size()}; std::string hashStr{reinterpret_cast<const char*>(base.data()), base.size()};
std::string txnStr = "tx" + std::to_string(ledgerSequence) + hashStr; std::string txnStr = "tx" + std::to_string(ledgerSequence) + hashStr;
std::string metaStr = "meta" + std::to_string(ledgerSequence) + hashStr; std::string metaStr = "meta" + std::to_string(ledgerSequence) + hashStr;
blob = std::make_tuple(hashStr, txnStr, metaStr); blob = std::make_tuple(hashStr, txnStr, metaStr);
@@ -642,8 +645,14 @@ TEST_F(BackendCassandraTest, Basic)
bool found = false; bool found = false;
for (auto [retTxn, retMeta, retSeq, retDate] : retTxns) for (auto [retTxn, retMeta, retSeq, retDate] : retTxns)
{ {
if (std::strncmp((const char*)retTxn.data(), (const char*)txn.data(), txn.size()) == 0 && if (std::strncmp(
std::strncmp((const char*)retMeta.data(), (const char*)meta.data(), meta.size()) == 0) reinterpret_cast<const char*>(retTxn.data()),
static_cast<const char*>(txn.data()),
txn.size()) == 0 &&
std::strncmp(
reinterpret_cast<const char*>(retMeta.data()),
static_cast<const char*>(meta.data()),
meta.size()) == 0)
found = true; found = true;
} }
ASSERT_TRUE(found); ASSERT_TRUE(found);
@@ -655,19 +664,20 @@ TEST_F(BackendCassandraTest, Basic)
do do
{ {
uint32_t limit = 10; uint32_t limit = 10;
auto [txns, retCursor] = backend->fetchAccountTransactions(account, limit, false, cursor, yield); auto [accountTransactions, retCursor] =
backend->fetchAccountTransactions(account, limit, false, cursor, yield);
if (retCursor) if (retCursor)
EXPECT_EQ(txns.size(), limit); EXPECT_EQ(accountTransactions.size(), limit);
retData.insert(retData.end(), txns.begin(), txns.end()); retData.insert(retData.end(), accountTransactions.begin(), accountTransactions.end());
cursor = retCursor; cursor = retCursor;
} while (cursor); } while (cursor);
EXPECT_EQ(retData.size(), data.size()); EXPECT_EQ(retData.size(), data.size());
for (size_t i = 0; i < retData.size(); ++i) for (size_t i = 0; i < retData.size(); ++i)
{ {
auto [txn, meta, seq, date] = retData[i]; auto [txn, meta, _, __] = retData[i];
auto [hash, expTxn, expMeta] = data[i]; auto [___, expTxn, expMeta] = data[i];
EXPECT_STREQ((const char*)txn.data(), (const char*)expTxn.data()); EXPECT_STREQ(reinterpret_cast<const char*>(txn.data()), static_cast<const char*>(expTxn.data()));
EXPECT_STREQ((const char*)meta.data(), (const char*)expMeta.data()); EXPECT_STREQ(reinterpret_cast<const char*>(meta.data()), static_cast<const char*>(expMeta.data()));
} }
} }
std::vector<ripple::uint256> keys; std::vector<ripple::uint256> keys;
@@ -677,7 +687,7 @@ TEST_F(BackendCassandraTest, Basic)
if (obj.size()) if (obj.size())
{ {
ASSERT_TRUE(retObj.has_value()); ASSERT_TRUE(retObj.has_value());
EXPECT_STREQ((const char*)obj.data(), (const char*)retObj->data()); EXPECT_STREQ(static_cast<const char*>(obj.data()), reinterpret_cast<const char*>(retObj->data()));
} }
else else
{ {
@@ -697,7 +707,8 @@ TEST_F(BackendCassandraTest, Basic)
if (obj.size()) if (obj.size())
{ {
ASSERT_TRUE(retObj.size()); ASSERT_TRUE(retObj.size());
EXPECT_STREQ((const char*)obj.data(), (const char*)retObj.data()); EXPECT_STREQ(
static_cast<const char*>(obj.data()), reinterpret_cast<const char*>(retObj.data()));
} }
else else
{ {
@@ -747,7 +758,7 @@ TEST_F(BackendCassandraTest, Basic)
for (auto account : rec.accounts) for (auto account : rec.accounts)
{ {
allAccountTx[lgrInfoNext.seq][account].push_back( allAccountTx[lgrInfoNext.seq][account].push_back(
std::string{(const char*)rec.txHash.data(), rec.txHash.size()}); std::string{reinterpret_cast<const char*>(rec.txHash.data()), rec.txHash.size()});
} }
} }
EXPECT_EQ(objs.size(), 25); EXPECT_EQ(objs.size(), 25);
@@ -780,7 +791,7 @@ TEST_F(BackendCassandraTest, Basic)
for (auto account : rec.accounts) for (auto account : rec.accounts)
{ {
allAccountTx[lgrInfoNext.seq][account].push_back( allAccountTx[lgrInfoNext.seq][account].push_back(
std::string{(const char*)rec.txHash.data(), rec.txHash.size()}); std::string{reinterpret_cast<const char*>(rec.txHash.data()), rec.txHash.size()});
} }
} }
EXPECT_EQ(objs.size(), 25); EXPECT_EQ(objs.size(), 25);
@@ -916,10 +927,10 @@ TEST_F(BackendCassandraTest, CacheIntegration)
lgrInfoNext.hash++; lgrInfoNext.hash++;
lgrInfoNext.accountHash = ~lgrInfo.accountHash; lgrInfoNext.accountHash = ~lgrInfo.accountHash;
{ {
std::string rawHeaderBlob = ledgerInfoToBinaryString(lgrInfoNext); std::string infoBlob = ledgerInfoToBinaryString(lgrInfoNext);
backend->startWrites(); backend->startWrites();
backend->writeLedger(lgrInfoNext, std::move(rawHeaderBlob)); backend->writeLedger(lgrInfoNext, std::move(infoBlob));
ASSERT_TRUE(backend->finishWrites(lgrInfoNext.seq)); ASSERT_TRUE(backend->finishWrites(lgrInfoNext.seq));
} }
{ {
@@ -979,10 +990,10 @@ TEST_F(BackendCassandraTest, CacheIntegration)
EXPECT_TRUE(key256.parseHex(accountIndexHex)); EXPECT_TRUE(key256.parseHex(accountIndexHex));
auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield); auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield);
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
} }
@@ -1017,13 +1028,13 @@ TEST_F(BackendCassandraTest, CacheIntegration)
EXPECT_TRUE(key256.parseHex(accountIndexHex)); EXPECT_TRUE(key256.parseHex(accountIndexHex));
auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield); auto obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq + 1, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlob.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlob.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 1, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlobOld.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlobOld.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield);
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
} }
@@ -1059,7 +1070,7 @@ TEST_F(BackendCassandraTest, CacheIntegration)
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 2, yield); obj = backend->fetchLedgerObject(key256, lgrInfoNext.seq - 2, yield);
EXPECT_TRUE(obj); EXPECT_TRUE(obj);
EXPECT_STREQ((const char*)obj->data(), (const char*)accountBlobOld.data()); EXPECT_STREQ(reinterpret_cast<const char*>(obj->data()), static_cast<const char*>(accountBlobOld.data()));
obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield); obj = backend->fetchLedgerObject(key256, lgrInfoOld.seq - 1, yield);
EXPECT_FALSE(obj); EXPECT_FALSE(obj);
} }
@@ -1072,7 +1083,7 @@ TEST_F(BackendCassandraTest, CacheIntegration)
for (auto& blob : res) for (auto& blob : res)
{ {
++key; ++key;
std::string keyStr{(const char*)key.data(), key.size()}; std::string keyStr{reinterpret_cast<const char*>(key.data()), key.size()};
blob.first = keyStr; blob.first = keyStr;
blob.second = std::to_string(ledgerSequence) + keyStr; blob.second = std::to_string(ledgerSequence) + keyStr;
} }
@@ -1154,7 +1165,7 @@ TEST_F(BackendCassandraTest, CacheIntegration)
if (obj.size()) if (obj.size())
{ {
ASSERT_TRUE(retObj.has_value()); ASSERT_TRUE(retObj.has_value());
EXPECT_STREQ((const char*)obj.data(), (const char*)retObj->data()); EXPECT_STREQ(static_cast<const char*>(obj.data()), reinterpret_cast<const char*>(retObj->data()));
} }
else else
{ {
@@ -1174,7 +1185,8 @@ TEST_F(BackendCassandraTest, CacheIntegration)
if (obj.size()) if (obj.size())
{ {
ASSERT_TRUE(retObj.size()); ASSERT_TRUE(retObj.size());
EXPECT_STREQ((const char*)obj.data(), (const char*)retObj.data()); EXPECT_STREQ(
static_cast<const char*>(obj.data()), reinterpret_cast<const char*>(retObj.data()));
} }
else else
{ {

29
unittests/data/cassandra/BaseTests.cpp
View File

@@ -30,8 +30,6 @@ using namespace std;
using namespace data::cassandra; using namespace data::cassandra;
namespace json = boost::json;
class BackendCassandraBaseTest : public NoLoggerFixture class BackendCassandraBaseTest : public NoLoggerFixture
{ {
protected: protected:
@@ -88,7 +86,7 @@ protected:
int64_t idx = 1000; int64_t idx = 1000;
for (auto const& entry : entries) for (auto const& entry : entries)
statements.push_back(insert.bind(entry, static_cast<int64_t>(idx++))); statements.push_back(insert.bind(entry, idx++));
EXPECT_EQ(statements.size(), entries.size()); EXPECT_EQ(statements.size(), entries.size());
EXPECT_TRUE(handle.execute(statements)); EXPECT_TRUE(handle.execute(statements));
@@ -241,9 +239,11 @@ TEST_F(BackendCassandraBaseTest, CreateTableWithStrings)
)", )",
5000); 5000);
auto const f1 = handle.asyncExecute(q1); {
auto const rc = f1.await(); auto const f1 = handle.asyncExecute(q1);
ASSERT_TRUE(rc) << rc.error(); auto const rc = f1.await();
ASSERT_TRUE(rc) << rc.error();
}
std::string q2 = "INSERT INTO strings (hash, sequence) VALUES (?, ?)"; std::string q2 = "INSERT INTO strings (hash, sequence) VALUES (?, ?)";
auto insert = handle.prepare(q2); auto insert = handle.prepare(q2);
@@ -254,7 +254,7 @@ TEST_F(BackendCassandraBaseTest, CreateTableWithStrings)
int64_t idx = 1000; int64_t idx = 1000;
for (auto const& entry : entries) for (auto const& entry : entries)
futures.push_back(handle.asyncExecute(insert, entry, static_cast<int64_t>(idx++))); futures.push_back(handle.asyncExecute(insert, entry, idx++));
ASSERT_EQ(futures.size(), entries.size()); ASSERT_EQ(futures.size(), entries.size());
for (auto const& f : futures) for (auto const& f : futures)
@@ -302,9 +302,11 @@ TEST_F(BackendCassandraBaseTest, BatchInsert)
WITH default_time_to_live = {} WITH default_time_to_live = {}
)", )",
5000); 5000);
auto const f1 = handle.asyncExecute(q1); {
auto const rc = f1.await(); auto const f1 = handle.asyncExecute(q1);
ASSERT_TRUE(rc) << rc.error(); auto const rc = f1.await();
ASSERT_TRUE(rc) << rc.error();
}
std::string q2 = "INSERT INTO strings (hash, sequence) VALUES (?, ?)"; std::string q2 = "INSERT INTO strings (hash, sequence) VALUES (?, ?)";
auto const insert = handle.prepare(q2); auto const insert = handle.prepare(q2);
@@ -315,7 +317,7 @@ TEST_F(BackendCassandraBaseTest, BatchInsert)
int64_t idx = 1000; int64_t idx = 1000;
for (auto const& entry : entries) for (auto const& entry : entries)
statements.push_back(insert.bind(entry, static_cast<int64_t>(idx++))); statements.push_back(insert.bind(entry, idx++));
ASSERT_EQ(statements.size(), entries.size()); ASSERT_EQ(statements.size(), entries.size());
@@ -374,7 +376,7 @@ TEST_F(BackendCassandraBaseTest, BatchInsertAsync)
int64_t idx = 1000; int64_t idx = 1000;
for (auto const& entry : entries) for (auto const& entry : entries)
statements.push_back(insert.bind(entry, static_cast<int64_t>(idx++))); statements.push_back(insert.bind(entry, idx++));
ASSERT_EQ(statements.size(), entries.size()); ASSERT_EQ(statements.size(), entries.size());
fut.emplace(handle.asyncExecute(statements, [&](auto const res) { fut.emplace(handle.asyncExecute(statements, [&](auto const res) {
@@ -434,8 +436,7 @@ TEST_F(BackendCassandraBaseTest, AlterTableMoveToNewTable)
{ {
static_assert(std::is_same_v<decltype(hash), std::string>); static_assert(std::is_same_v<decltype(hash), std::string>);
static_assert(std::is_same_v<decltype(seq), int64_t>); static_assert(std::is_same_v<decltype(seq), int64_t>);
migrationStatements.push_back( migrationStatements.push_back(migrationInsert.bind(hash, seq, seq + 1u));
migrationInsert.bind(hash, static_cast<int64_t>(seq), static_cast<int64_t>(seq + 1u)));
} }
EXPECT_TRUE(handle.execute(migrationStatements)); EXPECT_TRUE(handle.execute(migrationStatements));

2
unittests/data/cassandra/ExecutionStrategyTests.cpp
View File

@@ -38,7 +38,7 @@ TEST_F(BackendCassandraExecutionStrategyTest, ReadOneInCoroutineSuccessful)
auto strat = DefaultExecutionStrategy{Settings{}, handle}; auto strat = DefaultExecutionStrategy{Settings{}, handle};
ON_CALL(handle, asyncExecute(An<FakeStatement const&>(), An<std::function<void(FakeResultOrError)>&&>())) ON_CALL(handle, asyncExecute(An<FakeStatement const&>(), An<std::function<void(FakeResultOrError)>&&>()))
.WillByDefault([](auto const& statement, auto&& cb) { .WillByDefault([](auto const& /* statement */, auto&& cb) {
cb({}); // pretend we got data cb({}); // pretend we got data
return FakeFutureWithCallback{}; return FakeFutureWithCallback{};
}); });

3
unittests/data/cassandra/impl/FakesAndMocks.h
View File

@@ -115,8 +115,7 @@ struct FakeRetryPolicy
{ {
FakeRetryPolicy(boost::asio::io_context&){}; // required by concept FakeRetryPolicy(boost::asio::io_context&){}; // required by concept
std::chrono::milliseconds std::chrono::milliseconds calculateDelay(uint32_t /* attempt */)
calculateDelay(uint32_t attempt)
{ {
return std::chrono::milliseconds{1}; return std::chrono::milliseconds{1};
} }

12
unittests/etl/ExtractorTests.cpp
View File

@@ -68,8 +68,7 @@ public:
TEST_F(ETLExtractorTest, StopsWhenCurrentSequenceExceedsFinishSequence) TEST_F(ETLExtractorTest, StopsWhenCurrentSequenceExceedsFinishSequence)
{ {
auto const rawNetworkValidatedLedgersPtr = auto const rawNetworkValidatedLedgersPtr = networkValidatedLedgers_.get();
static_cast<MockNetworkValidatedLedgers*>(networkValidatedLedgers_.get());
ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(true)); ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(true));
EXPECT_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).Times(3); EXPECT_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).Times(3);
@@ -107,8 +106,7 @@ TEST_F(ETLExtractorTest, StopsOnServerShutdown)
// stop extractor thread if fetcheResponse is empty // stop extractor thread if fetcheResponse is empty
TEST_F(ETLExtractorTest, StopsIfFetchIsUnsuccessful) TEST_F(ETLExtractorTest, StopsIfFetchIsUnsuccessful)
{ {
auto const rawNetworkValidatedLedgersPtr = auto const rawNetworkValidatedLedgersPtr = networkValidatedLedgers_.get();
static_cast<MockNetworkValidatedLedgers*>(networkValidatedLedgers_.get());
ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(true)); ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(true));
EXPECT_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).Times(1); EXPECT_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).Times(1);
@@ -123,8 +121,7 @@ TEST_F(ETLExtractorTest, StopsIfFetchIsUnsuccessful)
TEST_F(ETLExtractorTest, StopsIfWaitingUntilValidatedByNetworkTimesOut) TEST_F(ETLExtractorTest, StopsIfWaitingUntilValidatedByNetworkTimesOut)
{ {
auto const rawNetworkValidatedLedgersPtr = auto const rawNetworkValidatedLedgersPtr = networkValidatedLedgers_.get();
static_cast<MockNetworkValidatedLedgers*>(networkValidatedLedgers_.get());
// note that in actual clio code we don't return false unless a timeout is specified and exceeded // note that in actual clio code we don't return false unless a timeout is specified and exceeded
ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(false)); ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(false));
@@ -137,8 +134,7 @@ TEST_F(ETLExtractorTest, StopsIfWaitingUntilValidatedByNetworkTimesOut)
TEST_F(ETLExtractorTest, SendsCorrectResponseToDataPipe) TEST_F(ETLExtractorTest, SendsCorrectResponseToDataPipe)
{ {
auto const rawNetworkValidatedLedgersPtr = auto const rawNetworkValidatedLedgersPtr = networkValidatedLedgers_.get();
static_cast<MockNetworkValidatedLedgers*>(networkValidatedLedgers_.get());
ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(true)); ON_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).WillByDefault(Return(true));
EXPECT_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).Times(1); EXPECT_CALL(*rawNetworkValidatedLedgersPtr, waitUntilValidatedByNetwork).Times(1);

2
unittests/rpc/BaseTests.cpp
View File

@@ -346,7 +346,7 @@ TEST_F(RPCBaseTest, CustomValidator)
{ {
// clang-format off // clang-format off
auto customFormatCheck = CustomValidator{ auto customFormatCheck = CustomValidator{
[](json::value const& value, std::string_view key) -> MaybeError { [](json::value const& value, std::string_view /* key */) -> MaybeError {
return value.as_string().size() == 34 ? return value.as_string().size() == 34 ?
MaybeError{} : Error{rpc::Status{"Uh oh"}}; MaybeError{} : Error{rpc::Status{"Uh oh"}};
} }

36
unittests/rpc/ForwardingProxyTests.cpp
View File

@@ -52,7 +52,7 @@ protected:
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfClioOnly) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfClioOnly)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "test"; auto const method = "test";
auto const params = json::parse("{}"); auto const params = json::parse("{}");
@@ -72,7 +72,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfClioOnly)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfProxied) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfProxied)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "submit"; auto const method = "submit";
auto const params = json::parse("{}"); auto const params = json::parse("{}");
@@ -92,7 +92,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfProxied)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfCurrentLedgerSpecified) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfCurrentLedgerSpecified)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "anymethod"; auto const method = "anymethod";
auto const params = json::parse(R"({"ledger_index": "current"})"); auto const params = json::parse(R"({"ledger_index": "current"})");
@@ -112,7 +112,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfCurrentLedgerSpecified)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfClosedLedgerSpecified) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfClosedLedgerSpecified)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "anymethod"; auto const method = "anymethod";
auto const params = json::parse(R"({"ledger_index": "closed"})"); auto const params = json::parse(R"({"ledger_index": "closed"})");
@@ -132,7 +132,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfClosedLedgerSpecified)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfAccountInfoWithQueueSpecified) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfAccountInfoWithQueueSpecified)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "account_info"; auto const method = "account_info";
auto const params = json::parse(R"({"queue": true})"); auto const params = json::parse(R"({"queue": true})");
@@ -152,7 +152,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfAccountInfoWithQueueSpe
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithQueueSpecified) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithQueueSpecified)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "ledger"; auto const method = "ledger";
auto const params = json::parse(R"({"queue": true})"); auto const params = json::parse(R"({"queue": true})");
@@ -172,7 +172,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithQueueSpecifie
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithFullSpecified) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithFullSpecified)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "ledger"; auto const method = "ledger";
auto const params = json::parse(R"({"full": true})"); auto const params = json::parse(R"({"full": true})");
@@ -192,7 +192,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithFullSpecified
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithAccountsSpecified) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithAccountsSpecified)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "ledger"; auto const method = "ledger";
auto const params = json::parse(R"({"accounts": true})"); auto const params = json::parse(R"({"accounts": true})");
@@ -212,7 +212,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsTrueIfLedgerWithAccountsSpeci
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfAccountInfoQueueIsFalse) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfAccountInfoQueueIsFalse)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "account_info"; auto const method = "account_info";
auto const params = json::parse(R"({"queue": false})"); auto const params = json::parse(R"({"queue": false})");
@@ -232,7 +232,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfAccountInfoQueueIsFals
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerQueueIsFalse) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerQueueIsFalse)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "ledger"; auto const method = "ledger";
auto const params = json::parse(R"({"queue": false})"); auto const params = json::parse(R"({"queue": false})");
@@ -252,7 +252,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerQueueIsFalse)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerFullIsFalse) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerFullIsFalse)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "ledger"; auto const method = "ledger";
auto const params = json::parse(R"({"full": false})"); auto const params = json::parse(R"({"full": false})");
@@ -272,7 +272,7 @@ TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerFullIsFalse)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerAccountsIsFalse) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfLedgerAccountsIsFalse)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "ledger"; auto const method = "ledger";
auto const params = json::parse(R"({"accounts": false})"); auto const params = json::parse(R"({"accounts": false})");
@@ -296,7 +296,7 @@ TEST_F(RPCForwardingProxyTest, ShouldNotForwardReturnsTrueIfAPIVersionIsV1)
auto const method = "api_version_check"; auto const method = "api_version_check";
auto const params = json::parse("{}"); auto const params = json::parse("{}");
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
ON_CALL(*rawHandlerProviderPtr, isClioOnly(_)).WillByDefault(Return(false)); ON_CALL(*rawHandlerProviderPtr, isClioOnly(_)).WillByDefault(Return(false));
EXPECT_CALL(*rawHandlerProviderPtr, isClioOnly(method)).Times(1); EXPECT_CALL(*rawHandlerProviderPtr, isClioOnly(method)).Times(1);
@@ -312,7 +312,7 @@ TEST_F(RPCForwardingProxyTest, ShouldNotForwardReturnsTrueIfAPIVersionIsV1)
TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfAPIVersionIsV2) TEST_F(RPCForwardingProxyTest, ShouldForwardReturnsFalseIfAPIVersionIsV2)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "api_version_check"; auto const method = "api_version_check";
auto const params = json::parse("{}"); auto const params = json::parse("{}");
@@ -364,8 +364,8 @@ TEST_F(RPCForwardingProxyTest, ShouldNeverForwardUnsubscribe)
TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams) TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const rawBalancerPtr = static_cast<MockLoadBalancer*>(loadBalancer.get()); auto const rawBalancerPtr = loadBalancer.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "submit"; auto const method = "submit";
auto const params = json::parse(R"({"test": true})"); auto const params = json::parse(R"({"test": true})");
@@ -394,8 +394,8 @@ TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams)
TEST_F(RPCForwardingProxyTest, ForwardingFailYieldsErrorStatus) TEST_F(RPCForwardingProxyTest, ForwardingFailYieldsErrorStatus)
{ {
auto const rawHandlerProviderPtr = static_cast<MockHandlerProvider*>(handlerProvider.get()); auto const rawHandlerProviderPtr = handlerProvider.get();
auto const rawBalancerPtr = static_cast<MockLoadBalancer*>(loadBalancer.get()); auto const rawBalancerPtr = loadBalancer.get();
auto const apiVersion = 2u; auto const apiVersion = 2u;
auto const method = "submit"; auto const method = "submit";
auto const params = json::parse(R"({"test": true})"); auto const params = json::parse(R"({"test": true})");

4
unittests/rpc/WorkQueueTests.cpp
View File

@@ -55,7 +55,7 @@ TEST_F(RPCWorkQueueTest, WhitelistedExecutionCountAddsUp)
for (auto i = 0u; i < TOTAL; ++i) for (auto i = 0u; i < TOTAL; ++i)
{ {
queue.postCoro( queue.postCoro(
[&executeCount, &sem, &mtx](auto yield) { [&executeCount, &sem, &mtx](auto /* yield */) {
std::lock_guard lk(mtx); std::lock_guard lk(mtx);
if (++executeCount; executeCount == TOTAL) if (++executeCount; executeCount == TOTAL)
sem.release(); // 1) note we are still in user function sem.release(); // 1) note we are still in user function
@@ -91,7 +91,7 @@ TEST_F(RPCWorkQueueTest, NonWhitelistedPreventSchedulingAtQueueLimitExceeded)
for (auto i = 0u; i < TOTAL; ++i) for (auto i = 0u; i < TOTAL; ++i)
{ {
auto res = queue.postCoro( auto res = queue.postCoro(
[&](auto yield) { [&](auto /* yield */) {
std::unique_lock lk{mtx}; std::unique_lock lk{mtx};
cv.wait(lk, [&] { return unblocked == true; }); cv.wait(lk, [&] { return unblocked == true; });

15
unittests/rpc/handlers/AccountCurrenciesTests.cpp
View File

@@ -180,16 +180,13 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter)
// ACCOUNT can receive USD 10 from ACCOUNT2 and send USD 20 to ACCOUNT2, now // ACCOUNT can receive USD 10 from ACCOUNT2 and send USD 20 to ACCOUNT2, now
// the balance is 100, ACCOUNT can only send USD to ACCOUNT2 // the balance is 100, ACCOUNT can only send USD to ACCOUNT2
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
// ACCOUNT2 can receive JPY 10 from ACCOUNT and send JPY 20 to ACCOUNT, now // ACCOUNT2 can receive JPY 10 from ACCOUNT and send JPY 20 to ACCOUNT, now
// the balance is 100, ACCOUNT2 can only send JPY to ACCOUNT // the balance is 100, ACCOUNT2 can only send JPY to ACCOUNT
auto const line2 = auto const line2 = CreateRippleStateLedgerObject("JPY", ISSUER, 100, ACCOUNT2, 10, ACCOUNT, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, 100, ACCOUNT2, 10, ACCOUNT, 20, TXNID, 123, 0);
// ACCOUNT can receive EUR 10 from ACCOUNT and send EUR 20 to ACCOUNT2, now // ACCOUNT can receive EUR 10 from ACCOUNT and send EUR 20 to ACCOUNT2, now
// the balance is 8, ACCOUNT can receive/send EUR to/from ACCOUNT2 // the balance is 8, ACCOUNT can receive/send EUR to/from ACCOUNT2
auto const line3 = auto const line3 = CreateRippleStateLedgerObject("EUR", ISSUER, 8, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "EUR", ISSUER, 8, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
bbs.push_back(line2.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData());
@@ -229,8 +226,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderHash)
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -270,8 +266,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderSeq)
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));

36
unittests/rpc/handlers/AccountLinesTests.cpp
View File

@@ -465,10 +465,8 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest)
// return two trust lines // return two trust lines
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123); auto const line2 = CreateRippleStateLedgerObject("USD", ACCOUNT, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123);
auto const line2 =
CreateRippleStateLedgerObject(ACCOUNT2, "USD", ACCOUNT, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
bbs.push_back(line2.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -545,8 +543,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit)
while (repetitions--) while (repetitions--)
{ {
indexes.push_back(ripple::uint256{INDEX1}); indexes.push_back(ripple::uint256{INDEX1});
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(indexes, INDEX1); ripple::STObject ownerDir = CreateOwnerDirLedgerObject(indexes, INDEX1);
@@ -625,8 +622,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination)
while (repetitions--) while (repetitions--)
{ {
indexes.push_back(ripple::uint256{INDEX1}); indexes.push_back(ripple::uint256{INDEX1});
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -635,8 +631,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination)
while (repetitions--) while (repetitions--)
{ {
indexes.push_back(ripple::uint256{INDEX1}); indexes.push_back(ripple::uint256{INDEX1});
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT3, 10, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT3, 10, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -761,13 +756,13 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseField)
// return few trust lines // return few trust lines
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto line1 = CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 0); auto line1 = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 0);
line1.setFlag(ripple::lsfHighAuth); line1.setFlag(ripple::lsfHighAuth);
line1.setFlag(ripple::lsfHighNoRipple); line1.setFlag(ripple::lsfHighNoRipple);
line1.setFlag(ripple::lsfHighFreeze); line1.setFlag(ripple::lsfHighFreeze);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
auto line2 = CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 20, ACCOUNT, 200, ACCOUNT2, 400, TXNID, 0); auto line2 = CreateRippleStateLedgerObject("USD", ACCOUNT2, 20, ACCOUNT, 200, ACCOUNT2, 400, TXNID, 0);
line2.setFlag(ripple::lsfLowAuth); line2.setFlag(ripple::lsfLowAuth);
line2.setFlag(ripple::lsfLowNoRipple); line2.setFlag(ripple::lsfLowNoRipple);
line2.setFlag(ripple::lsfLowFreeze); line2.setFlag(ripple::lsfLowFreeze);
@@ -809,7 +804,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto line = CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 0); auto line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 0);
// owner dir contains 10 indexes // owner dir contains 10 indexes
int objectsCount = 10; int objectsCount = 10;
@@ -878,8 +873,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 0);
int objectsCount = limit; int objectsCount = limit;
std::vector<ripple::uint256> indexes; std::vector<ripple::uint256> indexes;
while (objectsCount != 0) while (objectsCount != 0)
@@ -944,10 +938,8 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin)
// return two trust lines // return two trust lines
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123); auto const line2 = CreateRippleStateLedgerObject("USD", ACCOUNT, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123);
auto const line2 =
CreateRippleStateLedgerObject(ACCOUNT2, "USD", ACCOUNT, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
bbs.push_back(line2.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -1027,10 +1019,8 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax)
// return two trust lines // return two trust lines
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123); auto const line2 = CreateRippleStateLedgerObject("USD", ACCOUNT, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123);
auto const line2 =
CreateRippleStateLedgerObject(ACCOUNT2, "USD", ACCOUNT, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
bbs.push_back(line2.getSerializer().peekData()); bbs.push_back(line2.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));

48
unittests/rpc/handlers/AccountObjectsTests.cpp
View File

@@ -327,8 +327,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -378,8 +377,7 @@ TEST_F(RPCAccountObjectsHandlerTest, Limit)
std::vector<Blob> bbs; std::vector<Blob> bbs;
while (count-- != 0) while (count-- != 0)
{ {
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
} }
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -427,8 +425,7 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker)
std::vector<Blob> bbs; std::vector<Blob> bbs;
while (count-- != 0) while (count-- != 0)
{ {
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
} }
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -489,8 +486,7 @@ TEST_F(RPCAccountObjectsHandlerTest, MultipleDirNoNFT)
cc = count * 2; cc = count * 2;
while (cc-- != 0) while (cc-- != 0)
{ {
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
} }
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -538,8 +534,7 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter)
std::vector<Blob> bbs; std::vector<Blob> bbs;
// put 1 state and 1 offer // put 1 state and 1 offer
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const offer = CreateOfferLedgerObject( auto const offer = CreateOfferLedgerObject(
ACCOUNT, ACCOUNT,
10, 10,
@@ -594,8 +589,7 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty)
ON_CALL(*rawBackendPtr, doFetchLedgerObject(nftMaxKK, 30, _)).WillByDefault(Return(std::nullopt)); ON_CALL(*rawBackendPtr, doFetchLedgerObject(nftMaxKK, 30, _)).WillByDefault(Return(std::nullopt));
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const offer = CreateOfferLedgerObject( auto const offer = CreateOfferLedgerObject(
ACCOUNT, ACCOUNT,
10, 10,
@@ -653,8 +647,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28); auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
auto const offer = CreateOfferLedgerObject( auto const offer = CreateOfferLedgerObject(
ACCOUNT, ACCOUNT,
@@ -714,8 +707,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter)
auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; auto const nftMaxKK = ripple::keylet::nftpage_max(account).key;
ON_CALL(*rawBackendPtr, doFetchLedgerObject(nftMaxKK, 30, _)).WillByDefault(Return(std::nullopt)); ON_CALL(*rawBackendPtr, doFetchLedgerObject(nftMaxKK, 30, _)).WillByDefault(Return(std::nullopt));
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28); auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
std::vector<Blob> bbs; std::vector<Blob> bbs;
@@ -971,8 +963,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(4); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(4);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -1134,8 +1125,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker)
ON_CALL(*rawBackendPtr, doFetchLedgerObject(ownerDirKk, 30, _)) ON_CALL(*rawBackendPtr, doFetchLedgerObject(ownerDirKk, 30, _))
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28); auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
auto const offer = CreateOfferLedgerObject( auto const offer = CreateOfferLedgerObject(
ACCOUNT, ACCOUNT,
@@ -1195,8 +1185,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT)
ON_CALL(*rawBackendPtr, doFetchLedgerObject(ownerDirKk, 30, _)) ON_CALL(*rawBackendPtr, doFetchLedgerObject(ownerDirKk, 30, _))
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28); auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
auto const offer = CreateOfferLedgerObject( auto const offer = CreateOfferLedgerObject(
ACCOUNT, ACCOUNT,
@@ -1344,8 +1333,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust)
ON_CALL(*rawBackendPtr, doFetchLedgerObject(ownerDirKk, 30, _)) ON_CALL(*rawBackendPtr, doFetchLedgerObject(ownerDirKk, 30, _))
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28); auto const channel = CreatePaymentChannelLedgerObject(ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
auto const offer = CreateOfferLedgerObject( auto const offer = CreateOfferLedgerObject(
ACCOUNT, ACCOUNT,
@@ -1462,8 +1450,7 @@ TEST_F(RPCAccountObjectsHandlerTest, FilterNFT)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(4); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(4);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -1510,8 +1497,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker)
std::vector<Blob> bbs; std::vector<Blob> bbs;
while (count-- != 0) while (count-- != 0)
{ {
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
} }
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -1595,8 +1581,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -1676,8 +1661,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs; std::vector<Blob> bbs;
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));

6
unittests/rpc/handlers/BookOffersTests.cpp
View File

@@ -531,7 +531,7 @@ generateNormalPathBookOffersTestBundles()
auto const account2 = GetAccountIDWithString(ACCOUNT2); auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const frozenTrustLine = CreateRippleStateLedgerObject( auto const frozenTrustLine = CreateRippleStateLedgerObject(
ACCOUNT2, "USD", ACCOUNT, -8, ACCOUNT2, 1000, ACCOUNT, 2000, INDEX1, 2, ripple::lsfLowFreeze); "USD", ACCOUNT, -8, ACCOUNT2, 1000, ACCOUNT, 2000, INDEX1, 2, ripple::lsfLowFreeze);
auto const gets10USDPays20XRPOffer = CreateOfferLedgerObject( auto const gets10USDPays20XRPOffer = CreateOfferLedgerObject(
ACCOUNT2, ACCOUNT2,
@@ -599,10 +599,10 @@ generateNormalPathBookOffersTestBundles()
auto const feeLedgerObject = CreateFeeSettingBlob(1, 2, 3, 4, 0); auto const feeLedgerObject = CreateFeeSettingBlob(1, 2, 3, 4, 0);
auto const trustline30Balance = auto const trustline30Balance =
CreateRippleStateLedgerObject(ACCOUNT2, "USD", ACCOUNT, -30, ACCOUNT2, 1000, ACCOUNT, 2000, INDEX1, 2, 0); CreateRippleStateLedgerObject("USD", ACCOUNT, -30, ACCOUNT2, 1000, ACCOUNT, 2000, INDEX1, 2, 0);
auto const trustline8Balance = auto const trustline8Balance =
CreateRippleStateLedgerObject(ACCOUNT2, "USD", ACCOUNT, -8, ACCOUNT2, 1000, ACCOUNT, 2000, INDEX1, 2, 0); CreateRippleStateLedgerObject("USD", ACCOUNT, -8, ACCOUNT2, 1000, ACCOUNT, 2000, INDEX1, 2, 0);
return std::vector<BookOffersNormalTestBundle>{ return std::vector<BookOffersNormalTestBundle>{
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{

53
unittests/rpc/handlers/GatewayBalancesTests.cpp
View File

@@ -318,7 +318,7 @@ TEST_F(RPCGatewayBalancesHandlerTest, InvalidHotWallet)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
// create a valid line, balance is 0 // create a valid line, balance is 0
auto const line1 = CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 0, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123); auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 0, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -415,12 +415,10 @@ TEST_P(NormalPathTest, CheckOutput)
auto auto
generateNormalPathTestBundles() generateNormalPathTestBundles()
{ {
auto frozenState = auto frozenState = CreateRippleStateLedgerObject("JPY", ISSUER, -50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, -50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123);
frozenState.setFieldU32(ripple::sfFlags, ripple::lsfLowFreeze); frozenState.setFieldU32(ripple::sfFlags, ripple::lsfLowFreeze);
auto overflowState = auto overflowState = CreateRippleStateLedgerObject("JPY", ISSUER, 50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, 50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123);
int64_t min64 = -9922966390934554; int64_t min64 = -9922966390934554;
overflowState.setFieldAmount(ripple::sfBalance, ripple::STAmount(GetIssue("JPY", ISSUER), min64, 80)); overflowState.setFieldAmount(ripple::sfBalance, ripple::STAmount(GetIssue("JPY", ISSUER), min64, 80));
return std::vector<NormalTestBundle>{ return std::vector<NormalTestBundle>{
@@ -434,18 +432,17 @@ generateNormalPathTestBundles()
ripple::uint256{INDEX2}, ripple::uint256{INDEX2},
ripple::uint256{INDEX2}}, ripple::uint256{INDEX2}},
INDEX1), INDEX1),
std::vector{ std::vector{// hotwallet
// hotwallet CreateRippleStateLedgerObject("USD", ISSUER, -10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, -10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123), // hotwallet
// hotwallet CreateRippleStateLedgerObject("CNY", ISSUER, -20, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "CNY", ISSUER, -20, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123), // positive balance -> asset
// positive balance -> asset CreateRippleStateLedgerObject("EUR", ISSUER, 30, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "EUR", ISSUER, 30, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123), // positive balance -> asset
// positive balance -> asset CreateRippleStateLedgerObject("JPY", ISSUER, 40, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, 40, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123), // obligation
// obligation CreateRippleStateLedgerObject("JPY", ISSUER, -50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, -50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123), frozenState
frozenState
}, },
fmt::format( fmt::format(
@@ -497,8 +494,7 @@ generateNormalPathTestBundles()
NormalTestBundle{ NormalTestBundle{
"NoHotwallet", "NoHotwallet",
CreateOwnerDirLedgerObject({ripple::uint256{INDEX2}}, INDEX1), CreateOwnerDirLedgerObject({ripple::uint256{INDEX2}}, INDEX1),
std::vector{ std::vector{CreateRippleStateLedgerObject("JPY", ISSUER, -50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123)},
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, -50, ACCOUNT, 10, ACCOUNT3, 20, TXNID, 123)},
fmt::format( fmt::format(
R"({{ R"({{
"obligations":{{ "obligations":{{
@@ -530,13 +526,12 @@ generateNormalPathTestBundles()
CreateOwnerDirLedgerObject( CreateOwnerDirLedgerObject(
{ripple::uint256{INDEX2}, ripple::uint256{INDEX2}, ripple::uint256{INDEX2}, ripple::uint256{INDEX2}}, {ripple::uint256{INDEX2}, ripple::uint256{INDEX2}, ripple::uint256{INDEX2}, ripple::uint256{INDEX2}},
INDEX1), INDEX1),
std::vector{ std::vector{// hotwallet
// hotwallet CreateRippleStateLedgerObject("USD", ISSUER, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 10, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123), // hotwallet
// hotwallet CreateRippleStateLedgerObject("CNY", ISSUER, 20, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "CNY", ISSUER, 20, ACCOUNT2, 100, ACCOUNT, 200, TXNID, 123), CreateRippleStateLedgerObject("EUR", ISSUER, 30, ACCOUNT3, 100, ACCOUNT, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "EUR", ISSUER, 30, ACCOUNT3, 100, ACCOUNT, 200, TXNID, 123), CreateRippleStateLedgerObject("JPY", ISSUER, -50, ACCOUNT3, 10, ACCOUNT, 20, TXNID, 123)},
CreateRippleStateLedgerObject(ACCOUNT, "JPY", ISSUER, -50, ACCOUNT3, 10, ACCOUNT, 20, TXNID, 123)},
fmt::format( fmt::format(
R"({{ R"({{
"obligations":{{ "obligations":{{
@@ -575,9 +570,9 @@ generateNormalPathTestBundles()
CreateOwnerDirLedgerObject( CreateOwnerDirLedgerObject(
{ripple::uint256{INDEX2}, ripple::uint256{INDEX2}, ripple::uint256{INDEX2}}, INDEX1), {ripple::uint256{INDEX2}, ripple::uint256{INDEX2}, ripple::uint256{INDEX2}}, INDEX1),
std::vector{ std::vector{
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, -10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123), CreateRippleStateLedgerObject("USD", ISSUER, -10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "CNY", ISSUER, -20, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123), CreateRippleStateLedgerObject("CNY", ISSUER, -20, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123),
CreateRippleStateLedgerObject(ACCOUNT, "EUR", ISSUER, -30, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123) CreateRippleStateLedgerObject("EUR", ISSUER, -30, ACCOUNT, 100, ACCOUNT3, 200, TXNID, 123)
}, },
fmt::format( fmt::format(

26
unittests/rpc/handlers/LedgerDataTests.cpp
View File

@@ -252,8 +252,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker)
while (limitLine--) while (limitLine--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -315,8 +314,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter)
while (limitLine--) while (limitLine--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -381,8 +379,7 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder)
ON_CALL(*rawBackendPtr, doFetchSuccessorKey(ripple::uint256{INDEX2}, RANGEMAX, _)) ON_CALL(*rawBackendPtr, doFetchSuccessorKey(ripple::uint256{INDEX2}, RANGEMAX, _))
.WillByDefault(Return(std::nullopt)); .WillByDefault(Return(std::nullopt));
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs)); ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
@@ -416,7 +413,7 @@ TEST_F(RPCLedgerDataHandlerTest, Marker)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(1); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(1);
ON_CALL(*rawBackendPtr, doFetchLedgerObject(ripple::uint256{INDEX1}, RANGEMAX, _)) ON_CALL(*rawBackendPtr, doFetchLedgerObject(ripple::uint256{INDEX1}, RANGEMAX, _))
.WillByDefault( .WillByDefault(
Return(CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123) Return(CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123)
.getSerializer() .getSerializer()
.peekData())); .peekData()));
@@ -430,8 +427,7 @@ TEST_F(RPCLedgerDataHandlerTest, Marker)
while (limit--) while (limit--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -474,8 +470,7 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker)
while (limit--) while (limit--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
los.push_back(LedgerObject{ripple::uint256{INDEX2}, Blob{}}); los.push_back(LedgerObject{ripple::uint256{INDEX2}, Blob{}});
} }
@@ -521,8 +516,7 @@ TEST_F(RPCLedgerDataHandlerTest, Binary)
while (limit--) while (limit--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -565,8 +559,7 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax)
while (limit--) while (limit--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }
@@ -610,8 +603,7 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax)
while (limit--) while (limit--)
{ {
auto const line = auto const line = CreateRippleStateLedgerObject("USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 10, ACCOUNT, 100, ACCOUNT2, 200, TXNID, 123);
bbs.push_back(line.getSerializer().peekData()); bbs.push_back(line.getSerializer().peekData());
} }

2
unittests/rpc/handlers/LedgerEntryTests.cpp
View File

@@ -861,7 +861,7 @@ generateTestValuesForNormalPathTest()
ACCOUNT, ACCOUNT,
ACCOUNT2), ACCOUNT2),
ripple::keylet::line(account1, account2, currency).key, ripple::keylet::line(account1, account2, currency).key,
CreateRippleStateLedgerObject(ACCOUNT, "USD", ACCOUNT2, 100, ACCOUNT, 10, ACCOUNT2, 20, INDEX1, 123, 0)}, CreateRippleStateLedgerObject("USD", ACCOUNT2, 100, ACCOUNT, 10, ACCOUNT2, 20, INDEX1, 123, 0)},
NormalPathTestBundle{ NormalPathTestBundle{
"Ticket", "Ticket",
fmt::format( fmt::format(

5
unittests/rpc/handlers/LedgerTests.cpp
View File

@@ -1035,8 +1035,8 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotXRP)
ON_CALL(*rawBackendPtr, fetchLedgerBySequence(RANGEMAX, _)).WillByDefault(Return(ledgerinfo)); ON_CALL(*rawBackendPtr, fetchLedgerBySequence(RANGEMAX, _)).WillByDefault(Return(ledgerinfo));
// mock line // mock line
auto const line = CreateRippleStateLedgerObject( auto const line =
ACCOUNT, CURRENCY, ACCOUNT2, 50 /*balance*/, ACCOUNT, 10, ACCOUNT2, 20, INDEX1, 123); CreateRippleStateLedgerObject(CURRENCY, ACCOUNT2, 50 /*balance*/, ACCOUNT, 10, ACCOUNT2, 20, INDEX1, 123);
auto lineKey = ripple::keylet::line( auto lineKey = ripple::keylet::line(
GetAccountIDWithString(ACCOUNT), GetAccountIDWithString(ACCOUNT),
GetAccountIDWithString(ACCOUNT2), GetAccountIDWithString(ACCOUNT2),
@@ -1090,7 +1090,6 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsIgnoreFreezeLine)
// mock line freeze // mock line freeze
auto const line = CreateRippleStateLedgerObject( auto const line = CreateRippleStateLedgerObject(
ACCOUNT,
CURRENCY, CURRENCY,
ACCOUNT2, ACCOUNT2,
50 /*balance*/, 50 /*balance*/,

36
unittests/rpc/handlers/NoRippleCheckTests.cpp
View File

@@ -332,10 +332,10 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const line1 = CreateRippleStateLedgerObject( auto const line1 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
auto const line2 = CreateRippleStateLedgerObject( auto const line2 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -389,11 +389,9 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const line2 = auto const line2 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -451,10 +449,10 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const line1 = CreateRippleStateLedgerObject( auto const line1 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
auto const line2 = CreateRippleStateLedgerObject( auto const line2 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -508,11 +506,9 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR
.WillByDefault(Return(ownerDir.getSerializer().peekData())); .WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
auto const line2 = auto const line2 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, 0);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -558,11 +554,9 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR
.WillByDefault(Return(CreateFeeSettingBlob(1, 2, 3, 4, 0))); .WillByDefault(Return(CreateFeeSettingBlob(1, 2, 3, 4, 0)));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
auto const line1 = auto const line1 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT2, 10, ACCOUNT, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT2, 10, ACCOUNT, 20, TXNID, 123, 0);
auto const line2 = auto const line2 = CreateRippleStateLedgerObject("USD", ISSUER, 100, ACCOUNT2, 10, ACCOUNT, 20, TXNID, 123, 0);
CreateRippleStateLedgerObject(ACCOUNT, "USD", ISSUER, 100, ACCOUNT2, 10, ACCOUNT, 20, TXNID, 123, 0);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -611,10 +605,10 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const line1 = CreateRippleStateLedgerObject( auto const line1 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
auto const line2 = CreateRippleStateLedgerObject( auto const line2 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -713,10 +707,10 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
auto const line1 = CreateRippleStateLedgerObject( auto const line1 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
auto const line2 = CreateRippleStateLedgerObject( auto const line2 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
std::vector<Blob> bbs; std::vector<Blob> bbs;
bbs.push_back(line1.getSerializer().peekData()); bbs.push_back(line1.getSerializer().peekData());
@@ -765,7 +759,7 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax)
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2); EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const line1 = CreateRippleStateLedgerObject( auto const line1 = CreateRippleStateLedgerObject(
ACCOUNT, "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple); "USD", ISSUER, 100, ACCOUNT, 10, ACCOUNT2, 20, TXNID, 123, ripple::lsfLowNoRipple);
std::vector<Blob> bbs; std::vector<Blob> bbs;
for (auto i = 0; i < NoRippleCheckHandler::LIMIT_MAX + 1; i++) for (auto i = 0; i < NoRippleCheckHandler::LIMIT_MAX + 1; i++)

39
unittests/rpc/handlers/ServerInfoTests.cpp
View File

@@ -190,9 +190,9 @@ TEST_F(RPCServerInfoHandlerTest, NoFeesErrorsOutWithInternal)
TEST_F(RPCServerInfoHandlerTest, DefaultOutputIsPresent) TEST_F(RPCServerInfoHandlerTest, DefaultOutputIsPresent)
{ {
MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get()); MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
MockLoadBalancer* rawBalancerPtr = static_cast<MockLoadBalancer*>(mockLoadBalancerPtr.get()); MockLoadBalancer* rawBalancerPtr = mockLoadBalancerPtr.get();
MockCounters* rawCountersPtr = static_cast<MockCounters*>(mockCountersPtr.get()); MockCounters* rawCountersPtr = mockCountersPtr.get();
MockETLService* rawETLServicePtr = static_cast<MockETLService*>(mockETLServicePtr.get()); MockETLService* rawETLServicePtr = mockETLServicePtr.get();
mockBackendPtr->updateRange(10); // min mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max mockBackendPtr->updateRange(30); // max
@@ -234,9 +234,9 @@ TEST_F(RPCServerInfoHandlerTest, DefaultOutputIsPresent)
TEST_F(RPCServerInfoHandlerTest, AmendmentBlockedIsPresentIfSet) TEST_F(RPCServerInfoHandlerTest, AmendmentBlockedIsPresentIfSet)
{ {
MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get()); MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
MockLoadBalancer* rawBalancerPtr = static_cast<MockLoadBalancer*>(mockLoadBalancerPtr.get()); MockLoadBalancer* rawBalancerPtr = mockLoadBalancerPtr.get();
MockCounters* rawCountersPtr = static_cast<MockCounters*>(mockCountersPtr.get()); MockCounters* rawCountersPtr = mockCountersPtr.get();
MockETLService* rawETLServicePtr = static_cast<MockETLService*>(mockETLServicePtr.get()); MockETLService* rawETLServicePtr = mockETLServicePtr.get();
mockBackendPtr->updateRange(10); // min mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max mockBackendPtr->updateRange(30); // max
@@ -276,11 +276,10 @@ TEST_F(RPCServerInfoHandlerTest, AmendmentBlockedIsPresentIfSet)
TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet) TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet)
{ {
MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get()); MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
MockLoadBalancer* rawBalancerPtr = static_cast<MockLoadBalancer*>(mockLoadBalancerPtr.get()); MockLoadBalancer* rawBalancerPtr = mockLoadBalancerPtr.get();
MockCounters* rawCountersPtr = static_cast<MockCounters*>(mockCountersPtr.get()); MockCounters* rawCountersPtr = mockCountersPtr.get();
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get()); MockETLService* rawETLServicePtr = mockETLServicePtr.get();
MockETLService* rawETLServicePtr = static_cast<MockETLService*>(mockETLServicePtr.get());
mockBackendPtr->updateRange(10); // min mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max mockBackendPtr->updateRange(30); // max
@@ -328,11 +327,10 @@ TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet)
TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent) TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent)
{ {
MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get()); MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
MockLoadBalancer* rawBalancerPtr = static_cast<MockLoadBalancer*>(mockLoadBalancerPtr.get()); MockLoadBalancer* rawBalancerPtr = mockLoadBalancerPtr.get();
MockCounters* rawCountersPtr = static_cast<MockCounters*>(mockCountersPtr.get()); MockCounters* rawCountersPtr = mockCountersPtr.get();
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get()); MockETLService* rawETLServicePtr = mockETLServicePtr.get();
MockETLService* rawETLServicePtr = static_cast<MockETLService*>(mockETLServicePtr.get());
mockBackendPtr->updateRange(10); // min mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max mockBackendPtr->updateRange(30); // max
@@ -391,11 +389,10 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent)
TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown) TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown)
{ {
MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get()); MockBackend* rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
MockLoadBalancer* rawBalancerPtr = static_cast<MockLoadBalancer*>(mockLoadBalancerPtr.get()); MockLoadBalancer* rawBalancerPtr = mockLoadBalancerPtr.get();
MockCounters* rawCountersPtr = static_cast<MockCounters*>(mockCountersPtr.get()); MockCounters* rawCountersPtr = mockCountersPtr.get();
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get()); MockETLService* rawETLServicePtr = mockETLServicePtr.get();
MockETLService* rawETLServicePtr = static_cast<MockETLService*>(mockETLServicePtr.get());
mockBackendPtr->updateRange(10); // min mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max mockBackendPtr->updateRange(30); // max

15
unittests/rpc/handlers/UnsubscribeTests.cpp
View File

@@ -521,8 +521,7 @@ TEST_F(RPCUnsubscribeTest, Streams)
"streams": ["transactions_proposed","transactions","validations","manifests","book_changes","ledger"] "streams": ["transactions_proposed","transactions","validations","manifests","book_changes","ledger"]
})"); })");
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get());
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubLedger).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubLedger).Times(1);
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubTransactions).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubTransactions).Times(1);
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubValidation).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubValidation).Times(1);
@@ -547,8 +546,7 @@ TEST_F(RPCUnsubscribeTest, Accounts)
ACCOUNT, ACCOUNT,
ACCOUNT2)); ACCOUNT2));
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get());
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubAccount(rpc::accountFromStringStrict(ACCOUNT).value(), _)).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubAccount(rpc::accountFromStringStrict(ACCOUNT).value(), _)).Times(1);
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubAccount(rpc::accountFromStringStrict(ACCOUNT2).value(), _)).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubAccount(rpc::accountFromStringStrict(ACCOUNT2).value(), _)).Times(1);
@@ -569,8 +567,7 @@ TEST_F(RPCUnsubscribeTest, AccountsProposed)
ACCOUNT, ACCOUNT,
ACCOUNT2)); ACCOUNT2));
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get());
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubProposedAccount(rpc::accountFromStringStrict(ACCOUNT).value(), _)) EXPECT_CALL(*rawSubscriptionManagerPtr, unsubProposedAccount(rpc::accountFromStringStrict(ACCOUNT).value(), _))
.Times(1); .Times(1);
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubProposedAccount(rpc::accountFromStringStrict(ACCOUNT2).value(), _)) EXPECT_CALL(*rawSubscriptionManagerPtr, unsubProposedAccount(rpc::accountFromStringStrict(ACCOUNT2).value(), _))
@@ -606,8 +603,7 @@ TEST_F(RPCUnsubscribeTest, Books)
auto const parsedBookMaybe = rpc::parseBook(input.as_object().at("books").as_array()[0].as_object()); auto const parsedBookMaybe = rpc::parseBook(input.as_object().at("books").as_array()[0].as_object());
auto const book = std::get<ripple::Book>(parsedBookMaybe); auto const book = std::get<ripple::Book>(parsedBookMaybe);
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get());
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubBook(book, _)).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubBook(book, _)).Times(1);
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubBook(ripple::reversed(book), _)).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubBook(ripple::reversed(book), _)).Times(1);
@@ -640,8 +636,7 @@ TEST_F(RPCUnsubscribeTest, SingleBooks)
auto const parsedBookMaybe = rpc::parseBook(input.as_object().at("books").as_array()[0].as_object()); auto const parsedBookMaybe = rpc::parseBook(input.as_object().at("books").as_array()[0].as_object());
auto const book = std::get<ripple::Book>(parsedBookMaybe); auto const book = std::get<ripple::Book>(parsedBookMaybe);
MockSubscriptionManager* rawSubscriptionManagerPtr = MockSubscriptionManager* rawSubscriptionManagerPtr = mockSubscriptionManagerPtr.get();
static_cast<MockSubscriptionManager*>(mockSubscriptionManagerPtr.get());
EXPECT_CALL(*rawSubscriptionManagerPtr, unsubBook(book, _)).Times(1); EXPECT_CALL(*rawSubscriptionManagerPtr, unsubBook(book, _)).Times(1);
runSpawn([&, this](auto yield) { runSpawn([&, this](auto yield) {

7
unittests/util/MockWsBase.h
View File

@@ -31,7 +31,7 @@ struct MockSession : public web::ConnectionBase
} }
void void
send(std::string&& msg, boost::beast::http::status status = boost::beast::http::status::ok) override send(std::string&& msg, boost::beast::http::status = boost::beast::http::status::ok) override
{ {
message += msg; message += msg;
} }
@@ -43,15 +43,14 @@ struct MockSession : public web::ConnectionBase
struct MockDeadSession : public web::ConnectionBase struct MockDeadSession : public web::ConnectionBase
{ {
void void send(std::shared_ptr<std::string>) override
send(std::shared_ptr<std::string> _) override
{ {
// err happen, the session should remove from subscribers // err happen, the session should remove from subscribers
ec_.assign(2, boost::system::system_category()); ec_.assign(2, boost::system::system_category());
} }
void void
send(std::string&& _, boost::beast::http::status __ = boost::beast::http::status::ok) override send(std::string&&, boost::beast::http::status = boost::beast::http::status::ok) override
{ {
} }

2
unittests/util/StringUtils.cpp
View File

@@ -37,7 +37,7 @@ ripple::uint256
binaryStringToUint256(std::string const& bin) binaryStringToUint256(std::string const& bin)
{ {
ripple::uint256 uint; ripple::uint256 uint;
return uint.fromVoid((void const*)bin.data()); return uint.fromVoid(static_cast<void const*>(bin.data()));
} }
std::string std::string

11
unittests/util/TestHttpSyncClient.h
View File

@@ -22,6 +22,7 @@
#include <boost/asio.hpp> #include <boost/asio.hpp>
#include <boost/beast.hpp> #include <boost/beast.hpp>
#include <boost/beast/http.hpp> #include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
#include <string> #include <string>
@@ -57,7 +58,7 @@ struct HttpSyncClient
boost::beast::error_code ec; boost::beast::error_code ec;
stream.socket().shutdown(tcp::socket::shutdown_both, ec); stream.socket().shutdown(tcp::socket::shutdown_both, ec);
return std::string(res.body()); return res.body();
} }
}; };
@@ -107,7 +108,7 @@ public:
struct HttpsSyncClient struct HttpsSyncClient
{ {
static bool static bool
verify_certificate(bool preverified, boost::asio::ssl::verify_context& ctx) verify_certificate(bool /* preverified */, boost::asio::ssl::verify_context& /* ctx */)
{ {
return true; return true;
} }
@@ -123,7 +124,11 @@ struct HttpsSyncClient
tcp::resolver resolver(ioc); tcp::resolver resolver(ioc);
boost::beast::ssl_stream<boost::beast::tcp_stream> stream(ioc, ctx); boost::beast::ssl_stream<boost::beast::tcp_stream> stream(ioc, ctx);
// We can't fix this so have to ignore
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
if (!SSL_set_tlsext_host_name(stream.native_handle(), host.c_str())) if (!SSL_set_tlsext_host_name(stream.native_handle(), host.c_str()))
#pragma GCC diagnostic pop
{ {
boost::beast::error_code ec{static_cast<int>(::ERR_get_error()), net::error::get_ssl_category()}; boost::beast::error_code ec{static_cast<int>(::ERR_get_error()), net::error::get_ssl_category()};
throw boost::beast::system_error{ec}; throw boost::beast::system_error{ec};
@@ -147,7 +152,7 @@ struct HttpsSyncClient
boost::beast::error_code ec; boost::beast::error_code ec;
stream.shutdown(ec); stream.shutdown(ec);
return std::string(res.body()); return res.body();
} }
}; };

1
unittests/util/TestObject.cpp
View File

@@ -334,7 +334,6 @@ CreatePaymentChannelLedgerObject(
[[nodiscard]] ripple::STObject [[nodiscard]] ripple::STObject
CreateRippleStateLedgerObject( CreateRippleStateLedgerObject(
std::string_view accountId,
std::string_view currency, std::string_view currency,
std::string_view issuerId, std::string_view issuerId,
int balance, int balance,

1
unittests/util/TestObject.h
View File

@@ -172,7 +172,6 @@ CreatePaymentChannelLedgerObject(
[[nodiscard]] ripple::STObject [[nodiscard]] ripple::STObject
CreateRippleStateLedgerObject( CreateRippleStateLedgerObject(
std::string_view accountId,
std::string_view currency, std::string_view currency,
std::string_view issuerId, std::string_view issuerId,
int balance, int balance,

6
unittests/web/ServerTests.cpp
View File

@@ -174,7 +174,7 @@ public:
} }
void void
operator()(boost::beast::error_code ec, std::shared_ptr<web::ConnectionBase> const& ws) operator()(boost::beast::error_code /* ec */, std::shared_ptr<web::ConnectionBase> const& /* ws */)
{ {
} }
}; };
@@ -183,13 +183,13 @@ class ExceptionExecutor
{ {
public: public:
void void
operator()(std::string const& req, std::shared_ptr<web::ConnectionBase> const& ws) operator()(std::string const& /* req */, std::shared_ptr<web::ConnectionBase> const& /* ws */)
{ {
throw std::runtime_error("MyError"); throw std::runtime_error("MyError");
} }
void void
operator()(boost::beast::error_code ec, std::shared_ptr<web::ConnectionBase> const& ws) operator()(boost::beast::error_code /* ec */, std::shared_ptr<web::ConnectionBase> const& /* ws */)
{ {
} }
}; };