ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format first-party source according to .clang-format

Browse Source
This commit is contained in:
Pretty Printer
2020-04-17 09:56:34 -05:00
committed by manojsdoshi
parent 65dfc5d19e
commit 50760c6935
1076 changed files with 86161 additions and 77449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
src/test/jtx/impl/Env.cpp
View File

@@ -17,23 +17,12 @@
*/
//==============================================================================
#include <test/jtx/balance.h>
#include <test/jtx/Env.h>
#include <test/jtx/fee.h>
#include <test/jtx/flags.h>
#include <test/jtx/pay.h>
#include <test/jtx/trust.h>
#include <test/jtx/require.h>
#include <test/jtx/seq.h>
#include <test/jtx/sig.h>
#include <test/jtx/utility.h>
#include <test/jtx/JSONRPCClient.h>
#include <ripple/app/ledger/LedgerMaster.h>
#include <ripple/consensus/LedgerTiming.h>
#include <ripple/app/misc/NetworkOPs.h>
#include <ripple/app/misc/TxQ.h>
#include <ripple/basics/contract.h>
#include <ripple/basics/Slice.h>
#include <ripple/basics/contract.h>
#include <ripple/consensus/LedgerTiming.h>
#include <ripple/json/to_string.h>
#include <ripple/net/HTTPClient.h>
#include <ripple/net/RPCCall.h>
@@ -41,14 +30,25 @@
#include <ripple/protocol/Feature.h>
#include <ripple/protocol/HashPrefix.h>
#include <ripple/protocol/Indexes.h>
#include <ripple/protocol/jss.h>
#include <ripple/protocol/LedgerFormats.h>
#include <ripple/protocol/Serializer.h>
#include <ripple/protocol/SystemParameters.h>
#include <ripple/protocol/TER.h>
#include <ripple/protocol/TxFlags.h>
#include <ripple/protocol/UintTypes.h>
#include <ripple/protocol/jss.h>
#include <memory>
#include <test/jtx/Env.h>
#include <test/jtx/JSONRPCClient.h>
#include <test/jtx/balance.h>
#include <test/jtx/fee.h>
#include <test/jtx/flags.h>
#include <test/jtx/pay.h>
#include <test/jtx/require.h>
#include <test/jtx/seq.h>
#include <test/jtx/sig.h>
#include <test/jtx/trust.h>
#include <test/jtx/utility.h>
namespace ripple {
namespace test {
@@ -56,31 +56,28 @@ namespace jtx {
//------------------------------------------------------------------------------
Env::AppBundle::AppBundle(beast::unit_test::suite& suite,
Env::AppBundle::AppBundle(
beast::unit_test::suite& suite,
std::unique_ptr<Config> config,
std::unique_ptr<Logs> logs)
: AppBundle()
{
using namespace beast::severities;
// Use kFatal threshold to reduce noise from STObject.
setDebugLogSink (std::make_unique<SuiteJournalSink>(
"Debug", kFatal, suite));
auto timeKeeper_ =
std::make_unique<ManualTimeKeeper>();
setDebugLogSink(std::make_unique<SuiteJournalSink>("Debug", kFatal, suite));
auto timeKeeper_ = std::make_unique<ManualTimeKeeper>();
timeKeeper = timeKeeper_.get();
// Hack so we don't have to call Config::setup
HTTPClient::initializeSSLContext(*config, debugLog());
owned = make_Application(std::move(config),
std::move(logs), std::move(timeKeeper_));
owned = make_Application(
std::move(config), std::move(logs), std::move(timeKeeper_));
app = owned.get();
app->logs().threshold(kError);
if(! app->setup())
Throw<std::runtime_error> ("Env::AppBundle: setup failed");
timeKeeper->set(
app->getLedgerMaster().getClosedLedger()->info().closeTime);
if (!app->setup())
Throw<std::runtime_error>("Env::AppBundle: setup failed");
timeKeeper->set(app->getLedgerMaster().getClosedLedger()->info().closeTime);
app->doStart(false /*don't start timers*/);
thread = std::thread(
[&](){ app->run(); });
thread = std::thread([&]() { app->run(); });
client = makeJSONRPCClient(app->config());
}
@@ -99,7 +96,7 @@ Env::AppBundle::~AppBundle()
thread.join();
// Remove the debugLogSink before the suite goes out of scope.
setDebugLogSink (nullptr);
setDebugLogSink(nullptr);
}
//------------------------------------------------------------------------------
@@ -111,7 +108,8 @@ Env::closed()
}
void
Env::close(NetClock::time_point closeTime,
Env::close(
NetClock::time_point closeTime,
boost::optional<std::chrono::milliseconds> consensusDelay)
{
// Round up to next distinguishable value
@@ -127,134 +125,123 @@ Env::close(NetClock::time_point closeTime,
rpc("ledger_accept");
// VFALCO No error check?
}
timeKeeper().set(
closed()->info().closeTime);
timeKeeper().set(closed()->info().closeTime);
}
void
Env::memoize (Account const& account)
Env::memoize(Account const& account)
{
map_.emplace(account.id(), account);
}
Account const&
Env::lookup (AccountID const& id) const
Env::lookup(AccountID const& id) const
{
auto const iter = map_.find(id);
if (iter == map_.end())
Throw<std::runtime_error> (
"Env::lookup:: unknown account ID");
Throw<std::runtime_error>("Env::lookup:: unknown account ID");
return iter->second;
}
Account const&
Env::lookup (std::string const& base58ID) const
Env::lookup(std::string const& base58ID) const
{
auto const account =
parseBase58<AccountID>(base58ID);
if (! account)
Throw<std::runtime_error>(
"Env::lookup: invalid account ID");
auto const account = parseBase58<AccountID>(base58ID);
if (!account)
Throw<std::runtime_error>("Env::lookup: invalid account ID");
return lookup(*account);
}
PrettyAmount
Env::balance (Account const& account) const
Env::balance(Account const& account) const
{
auto const sle = le(account);
if (! sle)
if (!sle)
return XRP(0);
return {
sle->getFieldAmount(sfBalance),
"" };
return {sle->getFieldAmount(sfBalance), ""};
}
PrettyAmount
Env::balance (Account const& account,
Issue const& issue) const
Env::balance(Account const& account, Issue const& issue) const
{
if (isXRP(issue.currency))
return balance(account);
auto const sle = le(keylet::line(
account.id(), issue));
if (! sle)
return { STAmount( issue, 0 ),
account.name() };
auto const sle = le(keylet::line(account.id(), issue));
if (!sle)
return {STAmount(issue, 0), account.name()};
auto amount = sle->getFieldAmount(sfBalance);
amount.setIssuer(issue.account);
if (account.id() > issue.account)
amount.negate();
return { amount,
lookup(issue.account).name() };
return {amount, lookup(issue.account).name()};
}
std::uint32_t
Env::seq (Account const& account) const
Env::seq(Account const& account) const
{
auto const sle = le(account);
if (! sle)
Throw<std::runtime_error> (
"missing account root");
if (!sle)
Throw<std::runtime_error>("missing account root");
return sle->getFieldU32(sfSequence);
}
std::shared_ptr<SLE const>
Env::le (Account const& account) const
Env::le(Account const& account) const
{
return le(keylet::account(account.id()));
}
std::shared_ptr<SLE const>
Env::le (Keylet const& k) const
Env::le(Keylet const& k) const
{
return current()->read(k);
}
void
Env::fund (bool setDefaultRipple,
STAmount const& amount,
Account const& account)
Env::fund(bool setDefaultRipple, STAmount const& amount, Account const& account)
{
memoize(account);
if (setDefaultRipple)
{
// VFALCO NOTE Is the fee formula correct?
apply(pay(master, account, amount +
drops(current()->fees().base)),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
apply(fset(account, asfDefaultRipple),
apply(
pay(master, account, amount + drops(current()->fees().base)),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
fee(jtx::autofill),
sig(jtx::autofill));
apply(
fset(account, asfDefaultRipple),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
require(flags(account, asfDefaultRipple));
}
else
{
apply(pay(master, account, amount),
apply(
pay(master, account, amount),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
fee(jtx::autofill),
sig(jtx::autofill));
require(nflags(account, asfDefaultRipple));
}
require(jtx::balance(account, amount));
}
void
Env::trust (STAmount const& amount,
Account const& account)
Env::trust(STAmount const& amount, Account const& account)
{
auto const start = balance(account);
apply(jtx::trust(account, amount),
apply(
jtx::trust(account, amount),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
apply(pay(master, account,
drops(current()->fees().base)),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
fee(jtx::autofill),
sig(jtx::autofill));
apply(
pay(master, account, drops(current()->fees().base)),
jtx::seq(jtx::autofill),
fee(jtx::autofill),
sig(jtx::autofill));
test.expect(balance(account) == start);
}
@@ -264,15 +251,14 @@ Env::parseResult(Json::Value const& jr)
TER ter;
if (jr.isObject() && jr.isMember(jss::result) &&
jr[jss::result].isMember(jss::engine_result_code))
ter = TER::fromInt (jr[jss::result][jss::engine_result_code].asInt());
ter = TER::fromInt(jr[jss::result][jss::engine_result_code].asInt());
else
ter = temINVALID;
return std::make_pair(ter,
isTesSuccess(ter) || isTecClaim(ter));
return std::make_pair(ter, isTesSuccess(ter) || isTecClaim(ter));
}
void
Env::submit (JTx const& jt)
Env::submit(JTx const& jt)
{
bool didApply;
if (jt.stx)
@@ -299,8 +285,7 @@ Env::sign_and_submit(JTx const& jt, Json::Value params)
{
bool didApply;
auto const account =
lookup(jt.jv[jss::Account].asString());
auto const account = lookup(jt.jv[jss::Account].asString());
auto const& passphrase = account.name();
Json::Value jr;
@@ -315,10 +300,8 @@ Env::sign_and_submit(JTx const& jt, Json::Value params)
// Use the provided parameters, and go straight
// to the (RPC) client.
assert(params.isObject());
if (!params.isMember(jss::secret) &&
!params.isMember(jss::key_type) &&
!params.isMember(jss::seed) &&
!params.isMember(jss::seed_hex) &&
if (!params.isMember(jss::secret) && !params.isMember(jss::key_type) &&
!params.isMember(jss::seed) && !params.isMember(jss::seed_hex) &&
!params.isMember(jss::passphrase))
{
params[jss::secret] = passphrase;
@@ -326,8 +309,7 @@ Env::sign_and_submit(JTx const& jt, Json::Value params)
params[jss::tx_json] = jt.jv;
jr = client().invoke("submit", params);
}
txid_.SetHex(
jr[jss::result][jss::tx_json][jss::hash].asString());
txid_.SetHex(jr[jss::result][jss::tx_json][jss::hash].asString());
std::tie(ter_, didApply) = parseResult(jr);
@@ -337,11 +319,11 @@ Env::sign_and_submit(JTx const& jt, Json::Value params)
void
Env::postconditions(JTx const& jt, TER ter, bool didApply)
{
if (jt.ter && ! test.expect(ter == *jt.ter,
"apply: " + transToken(ter) +
" (" + transHuman(ter) + ") != " +
transToken(*jt.ter) + " (" +
transHuman(*jt.ter) + ")"))
if (jt.ter &&
!test.expect(
ter == *jt.ter,
"apply: " + transToken(ter) + " (" + transHuman(ter) + ") != " +
transToken(*jt.ter) + " (" + transHuman(*jt.ter) + ")"))
{
test.log << pretty(jt.jv) << std::endl;
// Don't check postconditions if
@@ -373,38 +355,35 @@ Env::tx() const
}
void
Env::autofill_sig (JTx& jt)
Env::autofill_sig(JTx& jt)
{
auto& jv = jt.jv;
if (jt.signer)
return jt.signer(*this, jt);
if (! jt.fill_sig)
if (!jt.fill_sig)
return;
auto const account =
lookup(jv[jss::Account].asString());
auto const account = lookup(jv[jss::Account].asString());
if (!app().checkSigs())
{
jv[jss::SigningPubKey] =
strHex(account.pk().slice());
jv[jss::SigningPubKey] = strHex(account.pk().slice());
// dummy sig otherwise STTx is invalid
jv[jss::TxnSignature] = "00";
return;
}
auto const ar = le(account);
if (ar && ar->isFieldPresent(sfRegularKey))
jtx::sign(jv, lookup(
ar->getAccountID(sfRegularKey)));
jtx::sign(jv, lookup(ar->getAccountID(sfRegularKey)));
else
jtx::sign(jv, account);
}
void
Env::autofill (JTx& jt)
Env::autofill(JTx& jt)
{
auto& jv = jt.jv;
if(jt.fill_fee)
if (jt.fill_fee)
jtx::fill_fee(jv, *current());
if(jt.fill_seq)
if (jt.fill_seq)
jtx::fill_seq(jv, *current());
// Must come last
try
@@ -413,14 +392,13 @@ Env::autofill (JTx& jt)
}
catch (parse_error const&)
{
test.log << "parse failed:\n" <<
pretty(jv) << std::endl;
test.log << "parse failed:\n" << pretty(jv) << std::endl;
Rethrow();
}
}
std::shared_ptr<STTx const>
Env::st (JTx const& jt)
Env::st(JTx const& jt)
{
// The parse must succeed, since we
// generated the JSON ourselves.
@@ -429,10 +407,9 @@ Env::st (JTx const& jt)
{
obj = jtx::parse(jt.jv);
}
catch(jtx::parse_error const&)
catch (jtx::parse_error const&)
{
test.log << "Exception: parse_error\n" <<
pretty(jt.jv) << std::endl;
test.log << "Exception: parse_error\n" << pretty(jt.jv) << std::endl;
Rethrow();
}
@@ -440,14 +417,15 @@ Env::st (JTx const& jt)
{
return sterilize(STTx{std::move(*obj)});
}
catch(std::exception const&)
catch (std::exception const&)
{
}
return nullptr;
}
Json::Value
Env::do_rpc(std::vector<std::string> const& args,
Env::do_rpc(
std::vector<std::string> const& args,
std::unordered_map<std::string, std::string> const& headers)
{
return rpcClient(args, app().config(), app().logs(), headers).second;
@@ -461,7 +439,7 @@ Env::enableFeature(uint256 const feature)
app().config().features.insert(feature);
}
} // jtx
} // namespace jtx
} // test
} // ripple
} // namespace test
} // namespace ripple