ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-08-21 22:30:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: Remove testline JTX helper class (#6539)

Browse Source 
This change removes the JTX helper class `testline`, which adds the line that made the `env` call, as it is no longer necessary.
This commit is contained in:
Mayukha Vadari
2026-03-16 12:28:49 -04:00
committed by GitHub
parent 983816248a
commit e4dbaf5efc
8 changed files with 151 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
src/test/app/LoanBroker_test.cpp
View File

@@ -674,38 +674,28 @@ class LoanBroker_test : public beast::unit_test::suite
// fields that can't be changed
// LoanBrokerID
env(set(alice, vault.vaultID),
loanBrokerID(nextKeylet.key),
ter(tecNO_ENTRY),
THISLINE);
env(set(alice, vault.vaultID), loanBrokerID(nextKeylet.key), ter(tecNO_ENTRY));
// VaultID
env(set(alice, nextKeylet.key),
loanBrokerID(broker->key()),
ter(tecNO_ENTRY),
THISLINE);
env(set(alice, nextKeylet.key), loanBrokerID(broker->key()), ter(tecNO_ENTRY));
// Owner
env(set(evan, vault.vaultID),
loanBrokerID(broker->key()),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
// ManagementFeeRate
env(set(alice, vault.vaultID),
loanBrokerID(broker->key()),
managementFeeRate(maxManagementFeeRate),
ter(temINVALID),
THISLINE);
ter(temINVALID));
// CoverRateMinimum
env(set(alice, vault.vaultID),
loanBrokerID(broker->key()),
coverRateMinimum(maxManagementFeeRate),
ter(temINVALID),
THISLINE);
ter(temINVALID));
// CoverRateLiquidation
env(set(alice, vault.vaultID),
loanBrokerID(broker->key()),
coverRateLiquidation(maxManagementFeeRate),
ter(temINVALID),
THISLINE);
ter(temINVALID));
// fields that can be changed
testData = "Test Data 1234";
@@ -713,15 +703,13 @@ class LoanBroker_test : public beast::unit_test::suite
env(set(alice, vault.vaultID),
loanBrokerID(broker->key()),
data(std::string(maxDataPayloadLength + 1, 'W')),
ter(temINVALID),
THISLINE);
ter(temINVALID));
// Bad debt maximum
env(set(alice, vault.vaultID),
loanBrokerID(broker->key()),
debtMaximum(Number(-175, -1)),
ter(temINVALID),
THISLINE);
ter(temINVALID));
Number debtMax{175, -1};
if (vault.asset.integral())
{
@@ -729,16 +717,14 @@ class LoanBroker_test : public beast::unit_test::suite
loanBrokerID(broker->key()),
data(testData),
debtMaximum(debtMax),
ter(tecPRECISION_LOSS),
THISLINE);
ter(tecPRECISION_LOSS));
roundToAsset(vault.asset, debtMax);
}
// Data & Debt maximum
env(set(alice, vault.vaultID),
loanBrokerID(broker->key()),
data(testData),
debtMaximum(debtMax),
THISLINE);
debtMaximum(debtMax));
},
[&](SLE::const_ref broker) {
// Check the updated fields
@@ -817,16 +803,16 @@ class LoanBroker_test : public beast::unit_test::suite
PrettyAsset const asset = [&]() {
if (getAsset)
return getAsset(env, issuer, alice);
env(trust(alice, issuer["IOU"](1'000'000)), THISLINE);
env(trust(alice, issuer["IOU"](1'000'000)));
env.close();
return PrettyAsset(issuer["IOU"]);
}();
env(pay(issuer, alice, asset(100'000)), THISLINE);
env(pay(issuer, alice, asset(100'000)));
env.close();
auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
env(tx, THISLINE);
env(tx);
env.close();
auto const le = env.le(vaultKeylet);
VaultInfo vaultInfo = [&]() {
@@ -837,12 +823,11 @@ class LoanBroker_test : public beast::unit_test::suite
if (vaultInfo.vaultID == uint256{})
return;
env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}),
THISLINE);
env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
env.close();
auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice));
env(set(alice, vaultInfo.vaultID), THISLINE);
env(set(alice, vaultInfo.vaultID));
env.close();
auto broker = env.le(brokerKeylet);
@@ -853,23 +838,23 @@ class LoanBroker_test : public beast::unit_test::suite
auto jv = getTxJv();
// empty broker ID
jv[sfLoanBrokerID] = "";
env(jv, ter(temINVALID), THISLINE);
env(jv, ter(temINVALID));
// zero broker ID
jv[sfLoanBrokerID] = to_string(uint256{});
// needs a flag to distinguish the parsed STTx from the prior
// test
env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID), THISLINE);
env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID));
};
auto testZeroVaultID = [&](auto&& getTxJv) {
auto jv = getTxJv();
// empty broker ID
jv[sfVaultID] = "";
env(jv, ter(temINVALID), THISLINE);
env(jv, ter(temINVALID));
// zero broker ID
jv[sfVaultID] = to_string(uint256{});
// needs a flag to distinguish the parsed STTx from the prior
// test
env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID), THISLINE);
env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID));
};
if (brokerTest == CoverDeposit)
@@ -878,26 +863,22 @@ class LoanBroker_test : public beast::unit_test::suite
testZeroBrokerID([&]() { return coverDeposit(alice, brokerKeylet.key, asset(10)); });
// preclaim: tecWRONG_ASSET
env(coverDeposit(alice, brokerKeylet.key, issuer["BAD"](10)),
ter(tecWRONG_ASSET),
THISLINE);
env(coverDeposit(alice, brokerKeylet.key, issuer["BAD"](10)), ter(tecWRONG_ASSET));
// preclaim: tecINSUFFICIENT_FUNDS
env(pay(alice, issuer, asset(100'000 - 50)), THISLINE);
env(pay(alice, issuer, asset(100'000 - 50)));
env.close();
env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)),
ter(tecINSUFFICIENT_FUNDS));
// preclaim: tecFROZEN
env(fset(issuer, asfGlobalFreeze), THISLINE);
env(fset(issuer, asfGlobalFreeze));
env.close();
env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)),
ter(tecFROZEN),
THISLINE);
env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)), ter(tecFROZEN));
}
else
// Fund the cover deposit
env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)), THISLINE);
env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)));
env.close();
if (brokerTest == CoverWithdraw)
@@ -906,59 +887,51 @@ class LoanBroker_test : public beast::unit_test::suite
testZeroBrokerID([&]() { return coverWithdraw(alice, brokerKeylet.key, asset(10)); });
// preclaim: tecWRONG_ASSET
env(coverWithdraw(alice, brokerKeylet.key, issuer["BAD"](10)),
ter(tecWRONG_ASSET),
THISLINE);
env(coverWithdraw(alice, brokerKeylet.key, issuer["BAD"](10)), ter(tecWRONG_ASSET));
// preclaim: tecNO_DST
Account const bogus{"bogus"};
env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
destination(bogus),
ter(tecNO_DST),
THISLINE);
ter(tecNO_DST));
// preclaim: tecDST_TAG_NEEDED
Account const dest{"dest"};
env.fund(XRP(1'000), dest);
env(fset(dest, asfRequireDest), THISLINE);
env(fset(dest, asfRequireDest));
env.close();
env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
destination(dest),
ter(tecDST_TAG_NEEDED),
THISLINE);
ter(tecDST_TAG_NEEDED));
// preclaim: tecNO_PERMISSION
env(fclear(dest, asfRequireDest), THISLINE);
env(fset(dest, asfDepositAuth), THISLINE);
env(fclear(dest, asfRequireDest));
env(fset(dest, asfDepositAuth));
env.close();
env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
destination(dest),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
// preclaim: tecFROZEN
env(trust(dest, asset(1'000)), THISLINE);
env(fclear(dest, asfDepositAuth), THISLINE);
env(fset(issuer, asfGlobalFreeze), THISLINE);
env(trust(dest, asset(1'000)));
env(fclear(dest, asfDepositAuth));
env(fset(issuer, asfGlobalFreeze));
env.close();
env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
destination(dest),
ter(tecFROZEN),
THISLINE);
ter(tecFROZEN));
// preclaim:: tecFROZEN (deep frozen)
env(fclear(issuer, asfGlobalFreeze), THISLINE);
env(trust(issuer, asset(1'000), dest, tfSetFreeze | tfSetDeepFreeze), THISLINE);
env(fclear(issuer, asfGlobalFreeze));
env(trust(issuer, asset(1'000), dest, tfSetFreeze | tfSetDeepFreeze));
env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
destination(dest),
ter(tecFROZEN),
THISLINE);
ter(tecFROZEN));
// preclaim: tecPSEUDO_ACCOUNT
env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
destination(vaultInfo.pseudoAccount),
ter(tecPSEUDO_ACCOUNT),
THISLINE);
ter(tecPSEUDO_ACCOUNT));
}
if (brokerTest == CoverClawback)
@@ -977,17 +950,15 @@ class LoanBroker_test : public beast::unit_test::suite
env(coverClawback(issuer),
loanBrokerID(brokerKeylet.key),
amount(vaultInfo.asset(2)),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
// preclaim: NoFreeze is set
env(fset(issuer, asfAllowTrustLineClawback | asfNoFreeze), THISLINE);
env(fset(issuer, asfAllowTrustLineClawback | asfNoFreeze));
env.close();
env(coverClawback(issuer),
loanBrokerID(brokerKeylet.key),
amount(vaultInfo.asset(2)),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
}
else
{
@@ -995,8 +966,7 @@ class LoanBroker_test : public beast::unit_test::suite
env(coverClawback(issuer),
loanBrokerID(brokerKeylet.key),
amount(vaultInfo.asset(2)),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
}
env.close();
}
@@ -1007,30 +977,29 @@ class LoanBroker_test : public beast::unit_test::suite
env.fund(XRP(1'000), borrower);
env(loan::set(borrower, brokerKeylet.key, asset(50).value()),
sig(sfCounterpartySignature, alice),
fee(env.current()->fees().base * 2),
THISLINE);
fee(env.current()->fees().base * 2));
// preflight: temINVALID (empty/zero broker id)
testZeroBrokerID([&]() { return del(alice, brokerKeylet.key); });
// preclaim: tecHAS_OBLIGATIONS
env(del(alice, brokerKeylet.key), ter(tecHAS_OBLIGATIONS), THISLINE);
env(del(alice, brokerKeylet.key), ter(tecHAS_OBLIGATIONS));
// Repay and delete the loan
auto const loanKeylet = keylet::loan(brokerKeylet.key, 1);
env(loan::pay(borrower, loanKeylet.key, asset(50).value()), THISLINE);
env(loan::del(alice, loanKeylet.key), THISLINE);
env(loan::pay(borrower, loanKeylet.key, asset(50).value()));
env(loan::del(alice, loanKeylet.key));
env(trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze), THISLINE);
env(trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
// preclaim: tecFROZEN (deep frozen)
env(del(alice, brokerKeylet.key), ter(tecFROZEN), THISLINE);
env(trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze), THISLINE);
env(del(alice, brokerKeylet.key), ter(tecFROZEN));
env(trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
// successful delete the loan broker object
env(del(alice, brokerKeylet.key), ter(tesSUCCESS), THISLINE);
env(del(alice, brokerKeylet.key), ter(tesSUCCESS));
}
else
env(del(alice, brokerKeylet.key), THISLINE);
env(del(alice, brokerKeylet.key));
if (brokerTest == Set)
{
@@ -1045,21 +1014,21 @@ class LoanBroker_test : public beast::unit_test::suite
if (asset.holds<Issue>())
{
env(fclear(issuer, asfDefaultRipple), THISLINE);
env(fclear(issuer, asfDefaultRipple));
env.close();
// preclaim: DefaultRipple is not set
env(set(alice, vaultInfo.vaultID), ter(terNO_RIPPLE), THISLINE);
env(set(alice, vaultInfo.vaultID), ter(terNO_RIPPLE));
env(fset(issuer, asfDefaultRipple), THISLINE);
env(fset(issuer, asfDefaultRipple));
env.close();
}
auto const amt =
env.balance(alice) - env.current()->fees().accountReserve(env.ownerCount(alice));
env(pay(alice, issuer, amt), THISLINE);
env(pay(alice, issuer, amt));
// preclaim:: tecINSUFFICIENT_RESERVE
env(set(alice, vaultInfo.vaultID), ter(tecINSUFFICIENT_RESERVE), THISLINE);
env(set(alice, vaultInfo.vaultID), ter(tecINSUFFICIENT_RESERVE));
}
}
@@ -1082,7 +1051,7 @@ class LoanBroker_test : public beast::unit_test::suite
auto jtx = env.jt(coverClawback(alice), amount(USD(100)));
// holder == account
env(jtx, ter(temINVALID), THISLINE);
env(jtx, ter(temINVALID));
// holder == beast::zero
STAmount bad(Issue{USD.currency, beast::zero}, 100);
@@ -1356,11 +1325,11 @@ class LoanBroker_test : public beast::unit_test::suite
return mptAsset;
}();
env(pay(issuer, alice, asset(100'000)), THISLINE);
env(pay(issuer, alice, asset(100'000)));
env.close();
auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
env(tx, THISLINE);
env(tx);
env.close();
auto const le = env.le(vaultKeylet);
VaultInfo vaultInfo = [&]() {
@@ -1371,20 +1340,18 @@ class LoanBroker_test : public beast::unit_test::suite
if (vaultInfo.vaultID == uint256{})
return;
env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}),
THISLINE);
env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
env.close();
auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice));
env(set(alice, vaultInfo.vaultID), THISLINE);
env(set(alice, vaultInfo.vaultID));
env.close();
Account const borrower{"borrower"};
env.fund(XRP(1'000), borrower);
env(loan::set(borrower, brokerKeylet.key, asset(50).value()),
sig(sfCounterpartySignature, alice),
fee(env.current()->fees().base * 2),
THISLINE);
fee(env.current()->fees().base * 2));
auto const broker = env.le(brokerKeylet);
if (!BEAST_EXPECT(broker))
return;
@@ -1395,47 +1362,47 @@ class LoanBroker_test : public beast::unit_test::suite
auto tx2 = set(alice, vaultInfo.vaultID);
tx2[sfLoanBrokerID] = to_string(brokerKeylet.key);
tx2[sfDebtMaximum] = debtTotal - 1;
env(tx2, ter(tecLIMIT_EXCEEDED), THISLINE);
env(tx2, ter(tecLIMIT_EXCEEDED));
tx2[sfDebtMaximum] = debtTotal + 1;
env(tx2, ter(tesSUCCESS), THISLINE);
env(tx2, ter(tesSUCCESS));
tx2[sfDebtMaximum] = 0;
env(tx2, ter(tesSUCCESS), THISLINE);
env(tx2, ter(tesSUCCESS));
tx2[sfDebtMaximum] = Json::Value::maxInt;
env(tx2, ter(tesSUCCESS), THISLINE);
env(tx2, ter(tesSUCCESS));
{
auto const dm = power(2, 64) - 1;
BEAST_EXPECT(dm > maxMPTokenAmount);
tx2[sfDebtMaximum] = dm;
env(tx2, ter(temINVALID), THISLINE);
env(tx2, ter(temINVALID));
}
{
auto const dm = power(2, 63) - 1;
BEAST_EXPECTS(dm > maxMPTokenAmount, to_string(dm));
tx2[sfDebtMaximum] = dm;
env(tx2, ter(temINVALID), THISLINE);
env(tx2, ter(temINVALID));
}
{
auto const dm = power(2, 63) - 3;
BEAST_EXPECTS(dm == maxMPTokenAmount, to_string(dm));
tx2[sfDebtMaximum] = dm;
env(tx2, ter(tesSUCCESS), THISLINE);
env(tx2, ter(tesSUCCESS));
}
{
auto const dm = 2 * (power(2, 62) - 1) + 1;
BEAST_EXPECTS(dm == maxMPTokenAmount, to_string(dm));
tx2[sfDebtMaximum] = dm;
env(tx2, ter(tesSUCCESS), THISLINE);
env(tx2, ter(tesSUCCESS));
}
tx2[sfDebtMaximum] = Number{9223372036854775807, 0};
env(tx2, ter(tesSUCCESS), THISLINE);
env(tx2, ter(tesSUCCESS));
}
void

45
src/test/app/Loan_test.cpp
View File

@@ -3303,8 +3303,7 @@ protected:
interestRate(TenthBips32(10'000)),
sig(sfCounterpartySignature, lender),
fee(env.current()->fees().base * 5),
ter(tecLIMIT_EXCEEDED),
THISLINE);
ter(tecLIMIT_EXCEEDED));
},
nullptr);
@@ -3327,8 +3326,7 @@ protected:
fee(env.current()->fees().base * 5),
paymentTotal(2),
paymentInterval(3600 * 24),
ter(tecLIMIT_EXCEEDED),
THISLINE);
ter(tecLIMIT_EXCEEDED));
},
nullptr);
}
@@ -3727,7 +3725,7 @@ protected:
createJson = env.json(createJson, sig(sfCounterpartySignature, lender));
// Fails in preclaim because principal requested can't be
// represented as XRP
env(createJson, ter(tecPRECISION_LOSS), THISLINE);
env(createJson, ter(tecPRECISION_LOSS));
env.close();
BEAST_EXPECT(!env.le(keylet));
@@ -3739,7 +3737,7 @@ protected:
createJson = env.json(createJson, sig(sfCounterpartySignature, lender));
// Fails in doApply because the payment is too small to be
// represented as XRP.
env(createJson, ter(tecPRECISION_LOSS), THISLINE);
env(createJson, ter(tecPRECISION_LOSS));
env.close();
}
@@ -4217,8 +4215,8 @@ protected:
// preclaim
Env env(*this);
env.fund(XRP(1'000), lender, issuer, borrower);
env(trust(lender, IOU(10'000'000)), THISLINE);
env(pay(issuer, lender, IOU(5'000'000)), THISLINE);
env(trust(lender, IOU(10'000'000)));
env(pay(issuer, lender, IOU(5'000'000)));
BrokerInfo brokerInfo{createVaultAndBroker(env, issuer["IOU"], lender)};
auto const loanSetFee = fee(env.current()->fees().base * 2);
@@ -4226,22 +4224,21 @@ protected:
env(set(borrower, brokerInfo.brokerID, debtMaximumRequest),
sig(sfCounterpartySignature, lender),
loanSetFee,
THISLINE);
loanSetFee);
env.close();
std::uint32_t const loanSequence = 1;
auto const loanKeylet = keylet::loan(brokerInfo.brokerID, loanSequence);
env(fset(issuer, asfGlobalFreeze), THISLINE);
env(fset(issuer, asfGlobalFreeze));
env.close();
// preclaim: tecFROZEN
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN), THISLINE);
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN));
env.close();
env(fclear(issuer, asfGlobalFreeze), THISLINE);
env(fclear(issuer, asfGlobalFreeze));
env.close();
auto const pseudoBroker = [&]() -> std::optional<Account> {
@@ -4259,33 +4256,29 @@ protected:
return;
// Lender and pseudoaccount must both be frozen
env(trust(issuer, lender["IOU"](1'000), lender, tfSetFreeze | tfSetDeepFreeze), THISLINE);
env(trust(issuer, lender["IOU"](1'000), lender, tfSetFreeze | tfSetDeepFreeze));
env(trust(
issuer,
(*pseudoBroker)["IOU"](1'000),
*pseudoBroker,
tfSetFreeze | tfSetDeepFreeze),
THISLINE);
issuer, (*pseudoBroker)["IOU"](1'000), *pseudoBroker, tfSetFreeze | tfSetDeepFreeze));
env.close();
// preclaim: tecFROZEN due to deep frozen
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN), THISLINE);
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN));
env.close();
// Only one needs to be unfrozen
env(trust(issuer, lender["IOU"](1'000), tfClearFreeze | tfClearDeepFreeze), THISLINE);
env(trust(issuer, lender["IOU"](1'000), tfClearFreeze | tfClearDeepFreeze));
env.close();
// The payment is late by this point
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecEXPIRED), THISLINE);
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecEXPIRED));
env.close();
env(pay(borrower, loanKeylet.key, debtMaximumRequest, tfLoanLatePayment), THISLINE);
env(pay(borrower, loanKeylet.key, debtMaximumRequest, tfLoanLatePayment));
env.close();
// preclaim: tecKILLED
// note that tecKILLED in loanMakePayment()
// doesn't happen because of the preclaim check.
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecKILLED), THISLINE);
env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecKILLED));
}
void
@@ -4637,12 +4630,12 @@ protected:
auto const keylet = keylet::loan(broker.brokerID, loanSequence);
createJson = env.json(createJson, sig(sfCounterpartySignature, lender));
env(createJson, THISLINE);
env(createJson);
env.close();
auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}}));
loanPayTx["Amount"]["value"] = "0.000281284125490196";
env(loanPayTx, ter(tecINSUFFICIENT_PAYMENT), THISLINE);
env(loanPayTx, ter(tecINSUFFICIENT_PAYMENT));
env.close();
}

136
src/test/app/Vault_test.cpp
View File

@@ -3,7 +3,6 @@
#include <test/jtx/Env.h>
#include <test/jtx/amount.h>
#include <test/jtx/mpt.h>
#include <test/jtx/testline.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/unit_test/suite.h>
@@ -2623,13 +2622,13 @@ class Vault_test : public beast::unit_test::suite
// Turn on noripple on the pseudo account's trust line.
// Charlie's is already set.
env(trust(issuer, vaultAccount(keylet)["IOU"], tfSetNoRipple), THISLINE);
env(trust(issuer, vaultAccount(keylet)["IOU"], tfSetNoRipple));
{
// Charlie cannot deposit
auto tx = vault.deposit(
{.depositor = charlie, .id = keylet.key, .amount = asset(100)});
env(tx, ter{terNO_RIPPLE}, THISLINE);
env(tx, ter{terNO_RIPPLE});
env.close();
}
@@ -2637,14 +2636,14 @@ class Vault_test : public beast::unit_test::suite
PrettyAsset shares = issuanceId(keylet);
auto tx1 =
vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)});
env(tx1, THISLINE);
env(tx1);
env.close();
// Charlie cannot receive funds
auto tx2 = vault.withdraw(
{.depositor = owner, .id = keylet.key, .amount = shares(100)});
tx2[sfDestination] = charlie.human();
env(tx2, ter{terNO_RIPPLE}, THISLINE);
env(tx2, ter{terNO_RIPPLE});
env.close();
{
@@ -2657,7 +2656,7 @@ class Vault_test : public beast::unit_test::suite
env(tx);
env.close();
}
env(pay(owner, charlie, shares(100)), THISLINE);
env(pay(owner, charlie, shares(100)));
env.close();
// Charlie cannot withdraw
@@ -2666,16 +2665,16 @@ class Vault_test : public beast::unit_test::suite
env(tx3, ter{terNO_RIPPLE});
env.close();
env(pay(charlie, owner, shares(100)), THISLINE);
env(pay(charlie, owner, shares(100)));
env.close();
}
tx = vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(100)});
env(tx, THISLINE);
env(tx);
env.close();
// Delete vault with zero balance
env(vault.del({.owner = owner, .id = keylet.key}), THISLINE);
env(vault.del({.owner = owner, .id = keylet.key}));
},
{.charlieRipple = false});
@@ -4531,7 +4530,7 @@ class Vault_test : public beast::unit_test::suite
Vault vault{env};
auto const& [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
env(tx, ter(tesSUCCESS), THISLINE);
env(tx, ter(tesSUCCESS));
env.close();
auto const& vaultSle = env.le(vaultKeylet);
@@ -4541,8 +4540,7 @@ class Vault_test : public beast::unit_test::suite
env(vault.deposit(
{.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
env.close();
auto const& [availablePreDefault, totalPreDefault] = vaultAssetBalance(vaultKeylet);
@@ -4555,14 +4553,13 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = depositor,
.amount = share(0).value()}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
env.close();
auto const& sharesAvailable = vaultShareBalance(vaultKeylet);
auto const& brokerKeylet = keylet::loanbroker(owner.id(), env.seq(owner));
env(set(owner, vaultKeylet.key), THISLINE);
env(set(owner, vaultKeylet.key));
env.close();
auto const& loanKeylet = keylet::loan(brokerKeylet.key, 1);
@@ -4575,8 +4572,7 @@ class Vault_test : public beast::unit_test::suite
paymentTotal(10),
sig(sfCounterpartySignature, owner),
fee(env.current()->fees().base * 2),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
env.close();
// attempt to clawback shares while there assetsAvailable == 0 and
@@ -4586,13 +4582,12 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = depositor,
.amount = share(0).value()}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
env.close();
env.close(std::chrono::seconds{120 + 60});
env(manage(owner, loanKeylet.key, tfLoanDefault), ter(tesSUCCESS), THISLINE);
env(manage(owner, loanKeylet.key, tfLoanDefault), ter(tesSUCCESS));
auto const& [availablePostDefault, totalPostDefault] = vaultAssetBalance(vaultKeylet);
@@ -4621,8 +4616,7 @@ class Vault_test : public beast::unit_test::suite
// empty
asset.native() ? ter(temMALFORMED)
: asset.raw().getIssuer() != owner.id() ? ter(tecNO_PERMISSION)
: ter(tecPRECISION_LOSS),
THISLINE);
: ter(tecPRECISION_LOSS));
env.close();
}
@@ -4641,8 +4635,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = share(1).value(),
}),
ter(tecLIMIT_EXCEEDED),
THISLINE);
ter(tecLIMIT_EXCEEDED));
env.close();
}
@@ -4658,8 +4651,7 @@ class Vault_test : public beast::unit_test::suite
}),
// when owner is issuer implicit clawback fails
asset.native() || asset.raw().getIssuer() != owner.id() ? ter(tesSUCCESS)
: ter(tecWRONG_ASSET),
THISLINE);
: ter(tecWRONG_ASSET));
env.close();
}
@@ -4679,8 +4671,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = share(vaultShareBalance(vaultKeylet)).value(),
}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
env.close();
}
{
@@ -4697,8 +4688,7 @@ class Vault_test : public beast::unit_test::suite
.holder = owner,
.amount = share(vaultShareBalance(vaultKeylet)).value(),
}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
env.close();
}
@@ -4715,8 +4705,7 @@ class Vault_test : public beast::unit_test::suite
.holder = owner,
.amount = share(vaultShareBalance(vaultKeylet)).value(),
}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
// Now the vault is empty, clawback again fails
env(vault.clawback({
@@ -4724,8 +4713,7 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = owner,
}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
env.close();
}
};
@@ -4783,15 +4771,14 @@ class Vault_test : public beast::unit_test::suite
Vault vault{env};
auto const& [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
env(tx, ter(tesSUCCESS), THISLINE);
env(tx, ter(tesSUCCESS));
env.close();
auto const& vaultSle = env.le(vaultKeylet);
BEAST_EXPECT(vaultSle != nullptr);
env(vault.deposit(
{.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
env.close();
return std::make_pair(vault, vaultKeylet);
@@ -4814,16 +4801,14 @@ class Vault_test : public beast::unit_test::suite
.holder = issuer,
.amount = asset(1).value(),
}),
ter(temMALFORMED),
THISLINE);
ter(temMALFORMED));
// When asset is implicit, clawback fails as no permission.
env(vault.clawback({
.issuer = issuer,
.id = vaultKeylet.key,
.holder = issuer,
}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
return;
}
@@ -4840,8 +4825,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = asset2(1).value(),
}),
ter(tecWRONG_ASSET),
THISLINE);
ter(tecWRONG_ASSET));
}
{
@@ -4854,8 +4838,7 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = issuer,
}),
ter(tecWRONG_ASSET),
THISLINE);
ter(tecWRONG_ASSET));
}
{
@@ -4867,8 +4850,7 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = depositor,
}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
env(vault.clawback({
.issuer = owner,
@@ -4876,8 +4858,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = asset(1).value(),
}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
}
{
@@ -4888,8 +4869,7 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = issuer,
}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
}
{
@@ -4907,8 +4887,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = share(1).value(),
}),
ter(tecNO_PERMISSION),
THISLINE);
ter(tecNO_PERMISSION));
}
{
@@ -4923,8 +4902,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = asset(1).value(),
}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
}
{
@@ -4938,8 +4916,7 @@ class Vault_test : public beast::unit_test::suite
.holder = depositor,
.amount = asset(100).value(),
}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
}
{
@@ -4953,8 +4930,7 @@ class Vault_test : public beast::unit_test::suite
.id = vaultKeylet.key,
.holder = depositor,
}),
ter(tesSUCCESS),
THISLINE);
ter(tesSUCCESS));
}
};
@@ -5029,19 +5005,19 @@ class Vault_test : public beast::unit_test::suite
tx[sfData] = "4D65746144617461";
tx[sfAssetsMaximum] = maxInt64;
env(tx, ter(tefEXCEPTION), THISLINE);
env(tx, ter(tefEXCEPTION));
env.close();
tx[sfAssetsMaximum] = initialXRPPlus1;
env(tx, ter(tefEXCEPTION), THISLINE);
env(tx, ter(tefEXCEPTION));
env.close();
tx[sfAssetsMaximum] = initialXRP;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = maxInt64Plus1;
env(tx, ter(tefEXCEPTION), THISLINE);
env(tx, ter(tefEXCEPTION));
env.close();
// This value will be rounded
@@ -5051,7 +5027,7 @@ class Vault_test : public beast::unit_test::suite
BEAST_EXPECT(decimalTest == "9223372036854775.808");
tx[sfAssetsMaximum] = decimalTest;
auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
env(tx, THISLINE);
env(tx);
env.close();
auto const vaultSle = env.le(newKeylet);
@@ -5074,26 +5050,26 @@ class Vault_test : public beast::unit_test::suite
return mptAsset;
}();
env(pay(issuer, owner, mptAsset(100'000)), THISLINE);
env(pay(issuer, owner, mptAsset(100'000)));
env.close();
auto [tx, keylet] = vault.create({.owner = owner, .asset = mptAsset});
tx[sfData] = "4D65746144617461";
tx[sfAssetsMaximum] = maxInt64;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = initialXRPPlus1;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = initialXRP;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = maxInt64Plus1;
env(tx, ter(tefEXCEPTION), THISLINE);
env(tx, ter(tefEXCEPTION));
env.close();
// This value will be rounded
@@ -5103,7 +5079,7 @@ class Vault_test : public beast::unit_test::suite
BEAST_EXPECT(decimalTest == "922337203685477580.8");
tx[sfAssetsMaximum] = decimalTest;
auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
env(tx, THISLINE);
env(tx);
env.close();
auto const vaultSle = env.le(newKeylet);
@@ -5126,19 +5102,19 @@ class Vault_test : public beast::unit_test::suite
tx[sfData] = "4D65746144617461";
tx[sfAssetsMaximum] = maxInt64;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = initialXRPPlus1;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = initialXRP;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = maxInt64Plus1;
env(tx, THISLINE);
env(tx);
env.close();
tx[sfAssetsMaximum] = "1000000000000000e80";
@@ -5155,7 +5131,7 @@ class Vault_test : public beast::unit_test::suite
BEAST_EXPECT(decimalTest == "922337203685477580.8");
tx[sfAssetsMaximum] = decimalTest;
auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
env(tx, THISLINE);
env(tx);
env.close();
auto const vaultSle = env.le(newKeylet);
@@ -5169,7 +5145,7 @@ class Vault_test : public beast::unit_test::suite
{
tx[sfAssetsMaximum] = "9223372036854775807e40"; // max int64 * 10^40
auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
env(tx, THISLINE);
env(tx);
env.close();
auto const vaultSle = env.le(newKeylet);
@@ -5183,7 +5159,7 @@ class Vault_test : public beast::unit_test::suite
{
tx[sfAssetsMaximum] = "9223372036854775807e-40"; // max int64 * 10^-40
auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
env(tx, THISLINE);
env(tx);
env.close();
auto const vaultSle = env.le(newKeylet);
@@ -5197,7 +5173,7 @@ class Vault_test : public beast::unit_test::suite
{
tx[sfAssetsMaximum] = "9223372036854775807e-100"; // max int64 * 10^-100
auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
env(tx, THISLINE);
env(tx);
env.close();
// Field 'AssetsMaximum' may not be explicitly set to default.
@@ -5211,7 +5187,7 @@ class Vault_test : public beast::unit_test::suite
// What _can't_ IOUs do?
// 1. Exceed maximum exponent / offset
tx[sfAssetsMaximum] = "1000000000000000e81";
env(tx, ter(tefEXCEPTION), THISLINE);
env(tx, ter(tefEXCEPTION));
env.close();
// 2. Mantissa larger than uint64 max
@@ -5219,7 +5195,7 @@ class Vault_test : public beast::unit_test::suite
try
{
tx[sfAssetsMaximum] = "18446744073709551617e5"; // uint64 max + 1
env(tx, THISLINE);
env(tx);
BEAST_EXPECTS(false, "Expected parse_error for mantissa larger than uint64 max");
}
catch (parse_error const& e)

1
src/test/jtx.h
View File

@@ -51,7 +51,6 @@
#include <test/jtx/tag.h>
#include <test/jtx/tags.h>
#include <test/jtx/ter.h>
#include <test/jtx/testline.h>
#include <test/jtx/ticket.h>
#include <test/jtx/token.h>
#include <test/jtx/trust.h>

3
src/test/jtx/JTx.h
View File

@@ -38,9 +38,6 @@ struct JTx
// Functions that sign something else after the mainSigners, such as
// sfCounterpartySignature
std::vector<std::function<void(Env&, JTx&)>> postSigners;
// Metadata about the unit test itself
// The line where the JTx was constructed
std::optional<int> testLine = std::nullopt;
JTx() = default;
JTx(JTx const&) = default;

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

@@ -419,16 +419,15 @@ Env::postconditions(
Json::Value const& jr,
std::source_location const& loc)
{
auto const line = jt.testLine ? " (" + to_string(*jt.testLine) + ")" : "";
auto const locStr = std::string("(") + loc.file_name() + ":" + to_string(loc.line()) + ")";
bool bad = !test.expect(parsed.ter, "apply " + locStr + ": No ter result!" + line);
bool bad = !test.expect(parsed.ter, "apply " + locStr + ": No ter result!");
bad =
(jt.ter && parsed.ter &&
!test.expect(
*parsed.ter == *jt.ter,
"apply " + locStr + ": Got " + transToken(*parsed.ter) + " (" +
transHuman(*parsed.ter) + "); Expected " + transToken(*jt.ter) + " (" +
transHuman(*jt.ter) + ")" + line));
transHuman(*jt.ter) + ")"));
using namespace std::string_literals;
bad = (jt.rpcCode &&
!test.expect(
@@ -438,7 +437,7 @@ Env::postconditions(
: "NO RESULT") +
" (" + parsed.rpcMessage + "); Expected " +
RPC::get_error_info(jt.rpcCode->first).token.c_str() + " (" +
jt.rpcCode->second + ")" + line)) ||
jt.rpcCode->second + ")")) ||
bad;
// If we have an rpcCode (just checked), then the rpcException check is
// optional - the 'error' field may not be defined, but if it is, it must
@@ -450,7 +449,7 @@ Env::postconditions(
(!jt.rpcException->second || parsed.rpcException == *jt.rpcException->second)),
"apply " + locStr + ": Got RPC result "s + parsed.rpcError + " (" +
parsed.rpcException + "); Expected " + jt.rpcException->first + " (" +
jt.rpcException->second.value_or("n/a") + ")" + line)) ||
jt.rpcException->second.value_or("n/a") + ")")) ||
bad;
if (bad)
{

15
src/test/jtx/impl/testline.cpp
View File

@@ -1,15 +0,0 @@
#include <test/jtx/testline.h>
namespace xrpl {
namespace test {
namespace jtx {
void
testline::operator()(Env&, JTx& jt) const
{
jt.testLine = line_;
}
} // namespace jtx
} // namespace test
} // namespace xrpl

31
src/test/jtx/testline.h
View File

@@ -1,31 +0,0 @@
#pragma once
#include <test/jtx/Env.h>
namespace xrpl {
namespace test {
namespace jtx {
/** Store the line number of the current test in a JTx.
Intended to help debug failing transaction submission tests.
*/
class testline
{
private:
int line_;
public:
explicit testline(int line) : line_(line)
{
}
void
operator()(Env&, JTx& jt) const;
};
#define THISLINE testline(__LINE__)
} // namespace jtx
} // namespace test
} // namespace xrpl