ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-03 00:36:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: Set ColumnLimit to 120 in clang-format (#6288)

Browse Source 
This change updates the ColumnLimit from 80 to 120, and applies clang-format to reformat the code.
This commit is contained in:
Ayaz Salikhov
2026-01-28 18:09:50 +00:00
committed by GitHub
parent 92046785d1
commit 5f638f5553
1016 changed files with 26918 additions and 66660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

485
src/test/rpc/Simulate_test.cpp
View File

@@ -31,8 +31,7 @@ class Simulate_test : public beast::unit_test::suite
BEAST_EXPECT(result.isMember(jss::engine_result));
BEAST_EXPECT(result.isMember(jss::engine_result_code));
BEAST_EXPECT(result.isMember(jss::engine_result_message));
BEAST_EXPECT(
result.isMember(jss::tx_json) || result.isMember(jss::tx_blob));
BEAST_EXPECT(result.isMember(jss::tx_json) || result.isMember(jss::tx_blob));
Json::Value tx_json;
if (result.isMember(jss::tx_json))
@@ -43,18 +42,14 @@ class Simulate_test : public beast::unit_test::suite
{
auto const unHexed = strUnHex(result[jss::tx_blob].asString());
SerialIter sitTrans(makeSlice(*unHexed));
tx_json = STObject(std::ref(sitTrans), sfGeneric)
.getJson(JsonOptions::none);
tx_json = STObject(std::ref(sitTrans), sfGeneric).getJson(JsonOptions::none);
}
BEAST_EXPECT(tx_json[jss::TransactionType] == tx[jss::TransactionType]);
BEAST_EXPECT(tx_json[jss::Account] == tx[jss::Account]);
BEAST_EXPECT(
tx_json[jss::SigningPubKey] == tx.get(jss::SigningPubKey, ""));
BEAST_EXPECT(
tx_json[jss::TxnSignature] == tx.get(jss::TxnSignature, ""));
BEAST_EXPECT(tx_json[jss::SigningPubKey] == tx.get(jss::SigningPubKey, ""));
BEAST_EXPECT(tx_json[jss::TxnSignature] == tx.get(jss::TxnSignature, ""));
BEAST_EXPECT(tx_json[jss::Fee] == tx.get(jss::Fee, expectedFee));
BEAST_EXPECT(
tx_json[jss::Sequence] == tx.get(jss::Sequence, expectedSequence));
BEAST_EXPECT(tx_json[jss::Sequence] == tx.get(jss::Sequence, expectedSequence));
}
void
@@ -64,16 +59,14 @@ class Simulate_test : public beast::unit_test::suite
int const expectedSequence,
XRPAmount const& expectedFee)
{
return checkBasicReturnValidity(
result, tx, expectedSequence, expectedFee.jsonClipped().asString());
return checkBasicReturnValidity(result, tx, expectedSequence, expectedFee.jsonClipped().asString());
}
void
testTx(
jtx::Env& env,
Json::Value const& tx,
std::function<void(Json::Value const&, Json::Value const&)> const&
validate,
std::function<void(Json::Value const&, Json::Value const&)> const& validate,
bool testSerialized = true)
{
env.close();
@@ -93,8 +86,7 @@ class Simulate_test : public beast::unit_test::suite
// It is technically not a valid STObject, so the following line
// will crash
STParsedJSONObject const parsed(std::string(jss::tx_json), tx);
auto const tx_blob =
strHex(parsed.object->getSerializer().peekData());
auto const tx_blob = strHex(parsed.object->getSerializer().peekData());
if (BEAST_EXPECT(parsed.object.has_value()))
{
Json::Value params;
@@ -107,20 +99,15 @@ class Simulate_test : public beast::unit_test::suite
validate(env.rpc("simulate", tx_blob, "binary"), tx);
}
BEAST_EXPECTS(
env.current()->txCount() == 0,
std::to_string(env.current()->txCount()));
BEAST_EXPECTS(env.current()->txCount() == 0, std::to_string(env.current()->txCount()));
}
void
testTxJsonMetadataField(
jtx::Env& env,
Json::Value const& tx,
std::function<void(
Json::Value const&,
Json::Value const&,
Json::Value const&,
Json::Value const&)> const& validate,
std::function<void(Json::Value const&, Json::Value const&, Json::Value const&, Json::Value const&)> const&
validate,
Json::Value const& expectedMetadataKey,
Json::Value const& expectedMetadataValue)
{
@@ -128,20 +115,10 @@ class Simulate_test : public beast::unit_test::suite
Json::Value params;
params[jss::tx_json] = tx;
validate(
env.rpc("json", "simulate", to_string(params)),
tx,
expectedMetadataKey,
expectedMetadataValue);
validate(
env.rpc("simulate", to_string(tx)),
tx,
expectedMetadataKey,
expectedMetadataValue);
validate(env.rpc("json", "simulate", to_string(params)), tx, expectedMetadataKey, expectedMetadataValue);
validate(env.rpc("simulate", to_string(tx)), tx, expectedMetadataKey, expectedMetadataValue);
BEAST_EXPECTS(
env.current()->txCount() == 0,
std::to_string(env.current()->txCount()));
BEAST_EXPECTS(env.current()->txCount() == 0, std::to_string(env.current()->txCount()));
}
Json::Value
@@ -151,8 +128,7 @@ class Simulate_test : public beast::unit_test::suite
{
auto unHexed = strUnHex(txResult[jss::meta_blob].asString());
SerialIter sitTrans(makeSlice(*unHexed));
return STObject(std::ref(sitTrans), sfGeneric)
.getJson(JsonOptions::none);
return STObject(std::ref(sitTrans), sfGeneric).getJson(JsonOptions::none);
}
return txResult[jss::meta];
@@ -171,9 +147,7 @@ class Simulate_test : public beast::unit_test::suite
// No params
Json::Value const params = Json::objectValue;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Neither `tx_blob` nor `tx_json` included.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Neither `tx_blob` nor `tx_json` included.");
}
{
// Providing both `tx_json` and `tx_blob`
@@ -182,9 +156,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_blob] = "1200";
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Can only include one of `tx_blob` and `tx_json`.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Can only include one of `tx_blob` and `tx_json`.");
}
{
// `binary` isn't a boolean
@@ -192,9 +164,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_blob] = "1200";
params[jss::binary] = "100";
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'binary'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'binary'.");
}
{
// Invalid `tx_blob`
@@ -202,9 +172,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_blob] = "12";
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx_blob'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
}
{
// Empty `tx_json`
@@ -212,9 +180,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = Json::objectValue;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Missing field 'tx.TransactionType'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Missing field 'tx.TransactionType'.");
}
{
// No tx.Account
@@ -224,9 +190,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Missing field 'tx.Account'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Missing field 'tx.Account'.");
}
{
// Empty `tx_blob`
@@ -234,9 +198,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_blob] = "";
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx_blob'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
}
{
// Non-string `tx_blob`
@@ -244,9 +206,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_blob] = 1.1;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx_blob'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
}
{
// Non-object `tx_json`
@@ -254,9 +214,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = "";
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx_json', not object.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_json', not object.");
}
{
// `seed` field included
@@ -267,9 +225,7 @@ class Simulate_test : public beast::unit_test::suite
tx_json[jss::Account] = env.master.human();
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'seed'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'seed'.");
}
{
// `secret` field included
@@ -280,9 +236,7 @@ class Simulate_test : public beast::unit_test::suite
tx_json[jss::Account] = env.master.human();
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'secret'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'secret'.");
}
{
// `seed_hex` field included
@@ -293,9 +247,7 @@ class Simulate_test : public beast::unit_test::suite
tx_json[jss::Account] = env.master.human();
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'seed_hex'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'seed_hex'.");
}
{
// `passphrase` field included
@@ -306,9 +258,7 @@ class Simulate_test : public beast::unit_test::suite
tx_json[jss::Account] = env.master.human();
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'passphrase'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'passphrase'.");
}
{
// Invalid transaction
@@ -319,9 +269,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_exception] ==
"Field 'Destination' is required but missing.");
BEAST_EXPECT(resp[jss::result][jss::error_exception] == "Field 'Destination' is required but missing.");
}
{
// Bad account
@@ -333,11 +281,8 @@ class Simulate_test : public beast::unit_test::suite
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECTS(
resp[jss::result][jss::error] == "srcActMalformed",
resp[jss::result][jss::error].toStyledString());
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx.Account'.");
resp[jss::result][jss::error] == "srcActMalformed", resp[jss::result][jss::error].toStyledString());
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Account'.");
}
{
// Account doesn't exist for Sequence autofill
@@ -348,9 +293,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Source account not found.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Source account not found.");
}
{
// Invalid Signers field
@@ -362,9 +305,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx.Signers'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Signers'.");
}
{
// Invalid Signers field
@@ -377,9 +318,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Invalid field 'tx.Signers[0]'.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Signers[0]'.");
}
{
// Invalid transaction
@@ -391,9 +330,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Field 'tx_json.foo' is unknown.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Field 'tx_json.foo' is unknown.");
}
{
// non-`"binary"` second param for CLI
@@ -413,9 +350,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Transaction should not be signed.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Transaction should not be signed.");
}
{
// Signed multisig transaction
@@ -436,9 +371,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = tx_json;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(
resp[jss::result][jss::error_message] ==
"Transaction should not be signed.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Transaction should not be signed.");
}
}
@@ -450,8 +383,7 @@ class Simulate_test : public beast::unit_test::suite
using namespace jtx;
Env env(*this, envconfig([](std::unique_ptr<Config> cfg) {
cfg->section("transaction_queue")
.set("minimum_txn_in_ledger_standalone", "3");
cfg->section("transaction_queue").set("minimum_txn_in_ledger_standalone", "3");
return cfg;
}));
@@ -504,8 +436,7 @@ class Simulate_test : public beast::unit_test::suite
params[jss::tx_json] = jt.jv;
auto const resp = env.rpc("json", "simulate", to_string(params));
BEAST_EXPECT(resp[jss::result][jss::error] == "notImpl");
BEAST_EXPECT(
resp[jss::result][jss::error_message] == "Not implemented.");
BEAST_EXPECT(resp[jss::result][jss::error_message] == "Not implemented.");
}
void
@@ -521,44 +452,33 @@ class Simulate_test : public beast::unit_test::suite
static auto const newDomain = "123ABC";
{
auto validateOutput = [&](Json::Value const& resp,
Json::Value const& tx) {
auto validateOutput = [&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result, tx, 1, env.current()->fees().base);
checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
BEAST_EXPECT(result[jss::engine_result_code] == 0);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"The simulated transaction would have been applied.");
result[jss::engine_result_message] == "The simulated transaction would have been applied.");
if (BEAST_EXPECT(
result.isMember(jss::meta) ||
result.isMember(jss::meta_blob)))
if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
if (BEAST_EXPECT(
metadata.isMember(sfAffectedNodes.jsonName)))
if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
{
BEAST_EXPECT(
metadata[sfAffectedNodes.jsonName].size() == 1);
BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
auto node = metadata[sfAffectedNodes.jsonName][0u];
if (BEAST_EXPECT(
node.isMember(sfModifiedNode.jsonName)))
if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
{
auto modifiedNode = node[sfModifiedNode];
BEAST_EXPECT(
modifiedNode[sfLedgerEntryType] ==
"AccountRoot");
BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
auto finalFields = modifiedNode[sfFinalFields];
BEAST_EXPECT(finalFields[sfDomain] == newDomain);
}
}
BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(
metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
}
};
@@ -591,22 +511,16 @@ class Simulate_test : public beast::unit_test::suite
Account const alice("alice");
{
std::function<void(Json::Value const&, Json::Value const&)> const&
testSimulation = [&](Json::Value const& resp,
Json::Value const& tx) {
std::function<void(Json::Value const&, Json::Value const&)> const& testSimulation =
[&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result, tx, 1, env.current()->fees().base);
checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
BEAST_EXPECT(result[jss::engine_result] == "temBAD_AMOUNT");
BEAST_EXPECT(result[jss::engine_result_code] == -298);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"Malformed: Bad amount.");
BEAST_EXPECT(result[jss::engine_result_message] == "Malformed: Bad amount.");
BEAST_EXPECT(
!result.isMember(jss::meta) &&
!result.isMember(jss::meta_blob));
BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
};
Json::Value tx;
@@ -639,15 +553,12 @@ class Simulate_test : public beast::unit_test::suite
Account const alice("alice");
{
std::function<void(Json::Value const&, Json::Value const&)> const&
testSimulation = [&](Json::Value const& resp,
Json::Value const& tx) {
std::function<void(Json::Value const&, Json::Value const&)> const& testSimulation =
[&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result, tx, 1, env.current()->fees().base);
checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
BEAST_EXPECT(
result[jss::engine_result] == "tecNO_DST_INSUF_XRP");
BEAST_EXPECT(result[jss::engine_result] == "tecNO_DST_INSUF_XRP");
BEAST_EXPECT(result[jss::engine_result_code] == 125);
BEAST_EXPECT(
result[jss::engine_result_message] ==
@@ -655,38 +566,26 @@ class Simulate_test : public beast::unit_test::suite
"create "
"it.");
if (BEAST_EXPECT(
result.isMember(jss::meta) ||
result.isMember(jss::meta_blob)))
if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
if (BEAST_EXPECT(
metadata.isMember(sfAffectedNodes.jsonName)))
if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
{
BEAST_EXPECT(
metadata[sfAffectedNodes.jsonName].size() == 1);
BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
auto node = metadata[sfAffectedNodes.jsonName][0u];
if (BEAST_EXPECT(
node.isMember(sfModifiedNode.jsonName)))
if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
{
auto modifiedNode = node[sfModifiedNode];
BEAST_EXPECT(
modifiedNode[sfLedgerEntryType] ==
"AccountRoot");
BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
auto finalFields = modifiedNode[sfFinalFields];
BEAST_EXPECT(
finalFields[sfBalance] ==
std::to_string(
100'000'000'000'000'000 -
env.current()->fees().base.drops()));
std::to_string(100'000'000'000'000'000 - env.current()->fees().base.drops()));
}
}
BEAST_EXPECT(
metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(
metadata[sfTransactionResult.jsonName] ==
"tecNO_DST_INSUF_XRP");
BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tecNO_DST_INSUF_XRP");
}
};
@@ -729,48 +628,37 @@ class Simulate_test : public beast::unit_test::suite
env.close();
{
auto validateOutput = [&](Json::Value const& resp,
Json::Value const& tx) {
auto validateOutput = [&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result,
tx,
env.seq(alice),
tx.isMember(jss::Signers) ? env.current()->fees().base * 2
: env.current()->fees().base);
tx.isMember(jss::Signers) ? env.current()->fees().base * 2 : env.current()->fees().base);
BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
BEAST_EXPECT(result[jss::engine_result_code] == 0);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"The simulated transaction would have been applied.");
result[jss::engine_result_message] == "The simulated transaction would have been applied.");
if (BEAST_EXPECT(
result.isMember(jss::meta) ||
result.isMember(jss::meta_blob)))
if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
if (BEAST_EXPECT(
metadata.isMember(sfAffectedNodes.jsonName)))
if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
{
BEAST_EXPECT(
metadata[sfAffectedNodes.jsonName].size() == 1);
BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
auto node = metadata[sfAffectedNodes.jsonName][0u];
if (BEAST_EXPECT(
node.isMember(sfModifiedNode.jsonName)))
if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
{
auto modifiedNode = node[sfModifiedNode];
BEAST_EXPECT(
modifiedNode[sfLedgerEntryType] ==
"AccountRoot");
BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
auto finalFields = modifiedNode[sfFinalFields];
BEAST_EXPECT(finalFields[sfDomain] == newDomain);
}
}
BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(
metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
}
};
@@ -799,8 +687,7 @@ class Simulate_test : public beast::unit_test::suite
tx[sfTxnSignature] = "";
tx[sfSequence] = env.seq(alice);
// transaction requires a non-base fee
tx[sfFee] =
(env.current()->fees().base * 2).jsonClipped().asString();
tx[sfFee] = (env.current()->fees().base * 2).jsonClipped().asString();
tx[sfSigners][0u][sfSigner][jss::SigningPubKey] = "";
tx[sfSigners][0u][sfSigner][jss::TxnSignature] = "";
@@ -823,27 +710,17 @@ class Simulate_test : public beast::unit_test::suite
env.close();
{
std::function<void(Json::Value const&, Json::Value const&)> const&
testSimulation =
[&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result,
tx,
env.seq(env.master),
env.current()->fees().base);
std::function<void(Json::Value const&, Json::Value const&)> const& testSimulation =
[&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(result, tx, env.seq(env.master), env.current()->fees().base);
BEAST_EXPECT(
result[jss::engine_result] == "tefMASTER_DISABLED");
BEAST_EXPECT(result[jss::engine_result_code] == -188);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"Master key is disabled.");
BEAST_EXPECT(result[jss::engine_result] == "tefMASTER_DISABLED");
BEAST_EXPECT(result[jss::engine_result_code] == -188);
BEAST_EXPECT(result[jss::engine_result_message] == "Master key is disabled.");
BEAST_EXPECT(
!result.isMember(jss::meta) &&
!result.isMember(jss::meta_blob));
};
BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
};
Json::Value tx;
@@ -886,25 +763,16 @@ class Simulate_test : public beast::unit_test::suite
env.close();
{
std::function<void(Json::Value const&, Json::Value const&)> const&
testSimulation = [&](Json::Value const& resp,
Json::Value const& tx) {
std::function<void(Json::Value const&, Json::Value const&)> const& testSimulation =
[&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result,
tx,
env.seq(env.master),
env.current()->fees().base * 2);
checkBasicReturnValidity(result, tx, env.seq(env.master), env.current()->fees().base * 2);
BEAST_EXPECT(result[jss::engine_result] == "temINVALID");
BEAST_EXPECT(result[jss::engine_result_code] == -277);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"The transaction is ill-formed.");
BEAST_EXPECT(result[jss::engine_result_message] == "The transaction is ill-formed.");
BEAST_EXPECT(
!result.isMember(jss::meta) &&
!result.isMember(jss::meta_blob));
BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
};
Json::Value tx;
@@ -929,8 +797,7 @@ class Simulate_test : public beast::unit_test::suite
tx[sfTxnSignature] = "";
tx[sfSequence] = env.seq(env.master);
tx[sfFee] = env.current()->fees().base.jsonClipped().asString();
tx[sfSigners][0u][sfSigner][jss::SigningPubKey] =
strHex(becky.pk().slice());
tx[sfSigners][0u][sfSigner][jss::SigningPubKey] = strHex(becky.pk().slice());
tx[sfSigners][0u][sfSigner][jss::TxnSignature] = "";
// test without autofill
@@ -957,23 +824,16 @@ class Simulate_test : public beast::unit_test::suite
env(signers(alice, 1, {{becky, 1}, {carol, 1}}));
{
auto validateOutput = [&](Json::Value const& resp,
Json::Value const& tx) {
auto validateOutput = [&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result, tx, env.seq(alice), env.current()->fees().base * 2);
checkBasicReturnValidity(result, tx, env.seq(alice), env.current()->fees().base * 2);
BEAST_EXPECTS(
result[jss::engine_result] == "tefBAD_SIGNATURE",
result[jss::engine_result].toStyledString());
result[jss::engine_result] == "tefBAD_SIGNATURE", result[jss::engine_result].toStyledString());
BEAST_EXPECT(result[jss::engine_result_code] == -186);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"A signature is provided for a non-signer.");
BEAST_EXPECT(result[jss::engine_result_message] == "A signature is provided for a non-signer.");
BEAST_EXPECT(
!result.isMember(jss::meta) &&
!result.isMember(jss::meta_blob));
BEAST_EXPECT(!result.isMember(jss::meta) && !result.isMember(jss::meta_blob));
};
Json::Value tx;
@@ -998,8 +858,7 @@ class Simulate_test : public beast::unit_test::suite
tx[sfTxnSignature] = "";
tx[sfSequence] = env.seq(alice);
// transaction requires a non-base fee
tx[sfFee] =
(env.current()->fees().base * 2).jsonClipped().asString();
tx[sfFee] = (env.current()->fees().base * 2).jsonClipped().asString();
tx[sfSigners][0u][sfSigner][jss::TxnSignature] = "";
// test without autofill
@@ -1026,57 +885,40 @@ class Simulate_test : public beast::unit_test::suite
auto const credType = "123ABC";
auto jv = credentials::create(subject, issuer, credType);
uint32_t const t =
env.current()->header().parentCloseTime.time_since_epoch().count();
uint32_t const t = env.current()->header().parentCloseTime.time_since_epoch().count();
jv[sfExpiration.jsonName] = t;
env(jv);
env.close();
{
auto validateOutput = [&](Json::Value const& resp,
Json::Value const& tx) {
auto validateOutput = [&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result, tx, env.seq(subject), env.current()->fees().base);
checkBasicReturnValidity(result, tx, env.seq(subject), env.current()->fees().base);
BEAST_EXPECT(result[jss::engine_result] == "tecEXPIRED");
BEAST_EXPECT(result[jss::engine_result_code] == 148);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"Expiration time is passed.");
BEAST_EXPECT(result[jss::engine_result_message] == "Expiration time is passed.");
if (BEAST_EXPECT(
result.isMember(jss::meta) ||
result.isMember(jss::meta_blob)))
if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
if (BEAST_EXPECT(
metadata.isMember(sfAffectedNodes.jsonName)))
if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
{
BEAST_EXPECT(
metadata[sfAffectedNodes.jsonName].size() == 5);
BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 5);
try
{
bool found = false;
for (auto const& node :
metadata[sfAffectedNodes.jsonName])
for (auto const& node : metadata[sfAffectedNodes.jsonName])
{
if (node.isMember(sfDeletedNode.jsonName) &&
node[sfDeletedNode.jsonName]
[sfLedgerEntryType.jsonName]
.asString() == "Credential")
node[sfDeletedNode.jsonName][sfLedgerEntryType.jsonName].asString() == "Credential")
{
auto const deleted =
node[sfDeletedNode.jsonName]
[sfFinalFields.jsonName];
found = deleted[jss::Issuer] ==
issuer.human() &&
deleted[jss::Subject] ==
subject.human() &&
deleted["CredentialType"] ==
strHex(std::string_view(credType));
auto const deleted = node[sfDeletedNode.jsonName][sfFinalFields.jsonName];
found = deleted[jss::Issuer] == issuer.human() &&
deleted[jss::Subject] == subject.human() &&
deleted["CredentialType"] == strHex(std::string_view(credType));
break;
}
}
@@ -1088,8 +930,7 @@ class Simulate_test : public beast::unit_test::suite
}
}
BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(
metadata[sfTransactionResult.jsonName] == "tecEXPIRED");
BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tecEXPIRED");
}
};
@@ -1108,18 +949,14 @@ class Simulate_test : public beast::unit_test::suite
}
// check that expired credentials weren't deleted
auto const jle =
credentials::ledgerEntry(env, subject, issuer, credType);
auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
BEAST_EXPECT(
jle.isObject() && jle.isMember(jss::result) &&
!jle[jss::result].isMember(jss::error) &&
jle[jss::result].isMember(jss::node) &&
jle[jss::result][jss::node].isMember("LedgerEntryType") &&
jle.isObject() && jle.isMember(jss::result) && !jle[jss::result].isMember(jss::error) &&
jle[jss::result].isMember(jss::node) && jle[jss::result][jss::node].isMember("LedgerEntryType") &&
jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
jle[jss::result][jss::node][jss::Subject] == subject.human() &&
jle[jss::result][jss::node]["CredentialType"] ==
strHex(std::string_view(credType)));
jle[jss::result][jss::node]["CredentialType"] == strHex(std::string_view(credType)));
BEAST_EXPECT(ownerCount(env, issuer) == 1);
BEAST_EXPECT(ownerCount(env, subject) == 0);
@@ -1138,44 +975,33 @@ class Simulate_test : public beast::unit_test::suite
static auto const newDomain = "123ABC";
{
auto validateOutput = [&](Json::Value const& resp,
Json::Value const& tx) {
auto validateOutput = [&](Json::Value const& resp, Json::Value const& tx) {
auto result = resp[jss::result];
checkBasicReturnValidity(
result, tx, 1, env.current()->fees().base);
checkBasicReturnValidity(result, tx, 1, env.current()->fees().base);
BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
BEAST_EXPECT(result[jss::engine_result_code] == 0);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"The simulated transaction would have been applied.");
result[jss::engine_result_message] == "The simulated transaction would have been applied.");
if (BEAST_EXPECT(
result.isMember(jss::meta) ||
result.isMember(jss::meta_blob)))
if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
if (BEAST_EXPECT(
metadata.isMember(sfAffectedNodes.jsonName)))
if (BEAST_EXPECT(metadata.isMember(sfAffectedNodes.jsonName)))
{
BEAST_EXPECT(
metadata[sfAffectedNodes.jsonName].size() == 1);
BEAST_EXPECT(metadata[sfAffectedNodes.jsonName].size() == 1);
auto node = metadata[sfAffectedNodes.jsonName][0u];
if (BEAST_EXPECT(
node.isMember(sfModifiedNode.jsonName)))
if (BEAST_EXPECT(node.isMember(sfModifiedNode.jsonName)))
{
auto modifiedNode = node[sfModifiedNode];
BEAST_EXPECT(
modifiedNode[sfLedgerEntryType] ==
"AccountRoot");
BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot");
auto finalFields = modifiedNode[sfFinalFields];
BEAST_EXPECT(finalFields[sfDomain] == newDomain);
}
}
BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(
metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
}
};
@@ -1221,37 +1047,27 @@ class Simulate_test : public beast::unit_test::suite
env.close(NetClock::time_point{446000000s});
{
auto validateOutput =
[&](Json::Value const& resp,
Json::Value const& tx,
Json::Value const& expectedMetadataKey,
Json::Value const& expectedMetadataValue) {
auto result = resp[jss::result];
auto validateOutput = [&](Json::Value const& resp,
Json::Value const& tx,
Json::Value const& expectedMetadataKey,
Json::Value const& expectedMetadataValue) {
auto result = resp[jss::result];
BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
BEAST_EXPECT(result[jss::engine_result_code] == 0);
BEAST_EXPECT(
result[jss::engine_result_message] ==
"The simulated transaction would have been applied.");
BEAST_EXPECT(result[jss::engine_result] == "tesSUCCESS");
BEAST_EXPECT(result[jss::engine_result_code] == 0);
BEAST_EXPECT(
result[jss::engine_result_message] == "The simulated transaction would have been applied.");
if (BEAST_EXPECT(
result.isMember(jss::meta) ||
result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
if (BEAST_EXPECT(result.isMember(jss::meta) || result.isMember(jss::meta_blob)))
{
Json::Value const metadata = getJsonMetadata(result);
BEAST_EXPECT(
metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(
metadata[sfTransactionResult.jsonName] ==
"tesSUCCESS");
BEAST_EXPECT(
metadata.isMember(expectedMetadataKey.asString()));
BEAST_EXPECT(
metadata[expectedMetadataKey.asString()] ==
expectedMetadataValue);
}
};
BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0);
BEAST_EXPECT(metadata[sfTransactionResult.jsonName] == "tesSUCCESS");
BEAST_EXPECT(metadata.isMember(expectedMetadataKey.asString()));
BEAST_EXPECT(metadata[expectedMetadataKey.asString()] == expectedMetadataValue);
}
};
{
Json::Value tx;
@@ -1261,8 +1077,7 @@ class Simulate_test : public beast::unit_test::suite
tx[sfAmount] = "100";
// test delivered amount
testTxJsonMetadataField(
env, tx, validateOutput, jss::delivered_amount, "100");
testTxJsonMetadataField(env, tx, validateOutput, jss::delivered_amount, "100");
}
{
@@ -1271,11 +1086,9 @@ class Simulate_test : public beast::unit_test::suite
tx[jss::TransactionType] = jss::NFTokenMint;
tx[sfNFTokenTaxon] = 1;
Json::Value nftokenId =
to_string(token::getNextID(env, alice, 1));
Json::Value nftokenId = to_string(token::getNextID(env, alice, 1));
// test nft synthetic
testTxJsonMetadataField(
env, tx, validateOutput, jss::nftoken_id, nftokenId);
testTxJsonMetadataField(env, tx, validateOutput, jss::nftoken_id, nftokenId);
}
{
@@ -1283,15 +1096,9 @@ class Simulate_test : public beast::unit_test::suite
tx[jss::Account] = alice.human();
tx[jss::TransactionType] = jss::MPTokenIssuanceCreate;
Json::Value mptIssuanceId =
to_string(makeMptID(env.seq(alice), alice));
Json::Value mptIssuanceId = to_string(makeMptID(env.seq(alice), alice));
// test mpt issuance id
testTxJsonMetadataField(
env,
tx,
validateOutput,
jss::mpt_issuance_id,
mptIssuanceId);
testTxJsonMetadataField(env, tx, validateOutput, jss::mpt_issuance_id, mptIssuanceId);
}
}
}