rippled
Loading...
Searching...
No Matches
ServerDefinitions_test.cpp
1#include <test/jtx.h>
2
3#include <xrpl/beast/unit_test.h>
4#include <xrpl/protocol/LedgerFormats.h>
5#include <xrpl/protocol/SOTemplate.h>
6#include <xrpl/protocol/TxFlags.h>
7#include <xrpl/protocol/jss.h>
8
9namespace xrpl {
10
11namespace test {
12
13class ServerDefinitions_test : public beast::unit_test::suite
14{
15public:
16 void
17 testServerDefinitions()
18 {
19 testcase("server_definitions");
20
21 using namespace test::jtx;
22
23 {
24 Env env(*this);
25 auto const result = env.rpc("server_definitions");
26 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
27 BEAST_EXPECT(result[jss::result][jss::status] == "success");
28 BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
29 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
30 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_RESULTS));
31 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
32 BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
33 BEAST_EXPECT(result[jss::result].isMember(jss::hash));
34
35 // test a random element of each result
36 // (testing the whole output would be difficult to maintain)
37
38 {
39 auto const firstField = result[jss::result][jss::FIELDS][0u];
40 BEAST_EXPECT(firstField[0u].asString() == "Generic");
41 BEAST_EXPECT(firstField[1][jss::isSerialized].asBool() == false);
42 BEAST_EXPECT(firstField[1][jss::isSigningField].asBool() == false);
43 BEAST_EXPECT(firstField[1][jss::isVLEncoded].asBool() == false);
44 BEAST_EXPECT(firstField[1][jss::nth].asUInt() == 0);
45 BEAST_EXPECT(firstField[1][jss::type].asString() == "Unknown");
46 }
47
48 BEAST_EXPECT(
49 result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"].asUInt() == 97);
50 BEAST_EXPECT(
51 result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"].asUInt() == 121);
52 BEAST_EXPECT(result[jss::result][jss::TRANSACTION_TYPES]["Payment"].asUInt() == 0);
53 BEAST_EXPECT(result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8);
54
55 // check exception SFields
56 {
57 auto const fieldExists = [&](std::string name) {
58 for (auto& field : result[jss::result][jss::FIELDS])
59 {
60 if (field[0u].asString() == name)
61 {
62 return true;
63 }
64 }
65 return false;
66 };
67 BEAST_EXPECT(fieldExists("Generic"));
68 BEAST_EXPECT(fieldExists("Invalid"));
69 BEAST_EXPECT(fieldExists("ObjectEndMarker"));
70 BEAST_EXPECT(fieldExists("ArrayEndMarker"));
71 BEAST_EXPECT(fieldExists("taker_gets_funded"));
72 BEAST_EXPECT(fieldExists("taker_pays_funded"));
73 BEAST_EXPECT(fieldExists("hash"));
74 BEAST_EXPECT(fieldExists("index"));
75 }
76
77 // test that base_uint types are replaced with "Hash" prefix
78 {
79 auto const types = result[jss::result][jss::TYPES];
80 BEAST_EXPECT(types["Hash128"].asUInt() == 4);
81 BEAST_EXPECT(types["Hash160"].asUInt() == 17);
82 BEAST_EXPECT(types["Hash192"].asUInt() == 21);
83 BEAST_EXPECT(types["Hash256"].asUInt() == 5);
84 BEAST_EXPECT(types["Hash384"].asUInt() == 22);
85 BEAST_EXPECT(types["Hash512"].asUInt() == 23);
86 }
87
88 // test the properties of the LEDGER_ENTRY_FLAGS section
89 {
90 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
91 Json::Value const& leFlags = result[jss::result][jss::LEDGER_ENTRY_FLAGS];
92
93 // sanity test the mapped value of a few arbitrarily chosen flags
94 BEAST_EXPECT(leFlags["AccountRoot"]["lsfDisallowXRP"] == 0x00080000);
95 BEAST_EXPECT(leFlags["AccountRoot"]["lsfDepositAuth"] == 0x01000000);
96 BEAST_EXPECT(leFlags["AccountRoot"]["lsfAllowTrustLineClawback"] == 0x80000000);
97
98 BEAST_EXPECT(leFlags["RippleState"]["lsfHighFreeze"] == 0x00800000);
99 BEAST_EXPECT(leFlags["RippleState"]["lsfAMMNode"] == 0x01000000);
100
101 BEAST_EXPECT(leFlags["DirNode"]["lsfNFTokenBuyOffers"] == 0x00000001);
102 BEAST_EXPECT(leFlags["MPTokenIssuance"]["lsfMPTCanTrade"] == 0x00000010);
103 BEAST_EXPECT(leFlags["Credential"]["lsfAccepted"] == 0x00010000);
104 BEAST_EXPECT(leFlags["Loan"]["lsfLoanImpaired"] == 0x00020000);
105 BEAST_EXPECT(leFlags["Vault"]["lsfVaultPrivate"] == 0x00010000);
106 BEAST_EXPECT(leFlags["MPToken"]["lsfMPTAuthorized"] == 0x00000002);
107 }
108
109 // validate the correctness of few chosen transaction flags
110 {
111 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FLAGS));
112 Json::Value const& txFlags = result[jss::result][jss::TRANSACTION_FLAGS];
113
114 BEAST_EXPECT(txFlags["universal"]["tfFullyCanonicalSig"] == 0x80000000);
115 BEAST_EXPECT(txFlags["universal"]["tfInnerBatchTxn"] == 0x40000000);
116
117 BEAST_EXPECT(txFlags["AccountSet"]["tfRequireAuth"] == 0x00040000);
118 BEAST_EXPECT(txFlags["AccountSet"]["tfAllowXRP"] == 0x00200000);
119
120 BEAST_EXPECT(txFlags["MPTokenIssuanceSet"]["tfMPTLock"] == 0x00000001);
121 BEAST_EXPECT(txFlags["MPTokenIssuanceSet"]["tfMPTUnlock"] == 0x00000002);
122
123 BEAST_EXPECT(txFlags["AMMDeposit"]["tfLPToken"] == 0x00010000);
124 BEAST_EXPECT(txFlags["AMMDeposit"]["tfLimitLPToken"] == 0x00400000);
125 }
126
127 // validate the correctness of the AccountSpecificFlags section
128 {
129 BEAST_EXPECT(result[jss::result].isMember(jss::ACCOUNT_SET_FLAGS));
130 Json::Value const& asFlags = result[jss::result][jss::ACCOUNT_SET_FLAGS];
131
132 BEAST_EXPECT(asFlags["asfDisallowXRP"] == 3);
133 BEAST_EXPECT(asFlags["asfGlobalFreeze"] == 7);
134 BEAST_EXPECT(asFlags["asfDisallowIncomingNFTokenOffer"] == 12);
135 BEAST_EXPECT(asFlags["asfDisallowIncomingTrustline"] == 15);
136 }
137
138 // test the response fields of the TRANSACTION_FORMATS section
139 {
140 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FORMATS));
141 Json::Value const& txnFormats = result[jss::result][jss::TRANSACTION_FORMATS];
142
143 // first validate the contents of "common"
144 {
145 BEAST_EXPECT(txnFormats.isMember("common"));
146 Json::Value const& section = txnFormats["common"];
147
148 BEAST_EXPECT(section[0u][jss::name] == "TransactionType");
149 BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
150
151 BEAST_EXPECT(section[1u][jss::name] == "Flags");
152 BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
153
154 BEAST_EXPECT(section[2u][jss::name] == "SourceTag");
155 BEAST_EXPECT(section[2u][jss::optionality] == soeOPTIONAL);
156
157 BEAST_EXPECT(section[3u][jss::name] == "Account");
158 BEAST_EXPECT(section[3u][jss::optionality] == soeREQUIRED);
159
160 BEAST_EXPECT(section[4u][jss::name] == "Sequence");
161 BEAST_EXPECT(section[4u][jss::optionality] == soeREQUIRED);
162
163 BEAST_EXPECT(section[5u][jss::name] == "PreviousTxnID");
164 BEAST_EXPECT(section[5u][jss::optionality] == soeOPTIONAL);
165
166 BEAST_EXPECT(section[6u][jss::name] == "LastLedgerSequence");
167 BEAST_EXPECT(section[6u][jss::optionality] == soeOPTIONAL);
168
169 BEAST_EXPECT(section[7u][jss::name] == "AccountTxnID");
170 BEAST_EXPECT(section[7u][jss::optionality] == soeOPTIONAL);
171
172 BEAST_EXPECT(section[8u][jss::name] == "Fee");
173 BEAST_EXPECT(section[8u][jss::optionality] == soeREQUIRED);
174
175 BEAST_EXPECT(section[9u][jss::name] == "OperationLimit");
176 BEAST_EXPECT(section[9u][jss::optionality] == soeOPTIONAL);
177
178 BEAST_EXPECT(section[10u][jss::name] == "Memos");
179 BEAST_EXPECT(section[10u][jss::optionality] == soeOPTIONAL);
180
181 BEAST_EXPECT(section[11u][jss::name] == "SigningPubKey");
182 BEAST_EXPECT(section[11u][jss::optionality] == soeREQUIRED);
183
184 BEAST_EXPECT(section[12u][jss::name] == "TicketSequence");
185 BEAST_EXPECT(section[12u][jss::optionality] == soeOPTIONAL);
186
187 BEAST_EXPECT(section[13u][jss::name] == "TxnSignature");
188 BEAST_EXPECT(section[13u][jss::optionality] == soeOPTIONAL);
189
190 BEAST_EXPECT(section[14u][jss::name] == "Signers");
191 BEAST_EXPECT(section[14u][jss::optionality] == soeOPTIONAL);
192
193 BEAST_EXPECT(section[15u][jss::name] == "NetworkID");
194 BEAST_EXPECT(section[15u][jss::optionality] == soeOPTIONAL);
195
196 BEAST_EXPECT(section[16u][jss::name] == "Delegate");
197 BEAST_EXPECT(section[16u][jss::optionality] == soeOPTIONAL);
198 }
199
200 // validate the contents of four arbitrarily selected transactions validate the
201 // format of the OracleSet transaction
202 {
203 BEAST_EXPECT(txnFormats.isMember("OracleSet"));
204 Json::Value const& section = txnFormats["OracleSet"];
205
206 BEAST_EXPECT(section[0u][jss::name] == "OracleDocumentID");
207 BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
208
209 BEAST_EXPECT(section[1u][jss::name] == "Provider");
210 BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
211
212 BEAST_EXPECT(section[2u][jss::name] == "URI");
213 BEAST_EXPECT(section[2u][jss::optionality] == soeOPTIONAL);
214
215 BEAST_EXPECT(section[3u][jss::name] == "AssetClass");
216 BEAST_EXPECT(section[3u][jss::optionality] == soeOPTIONAL);
217
218 BEAST_EXPECT(section[4u][jss::name] == "LastUpdateTime");
219 BEAST_EXPECT(section[4u][jss::optionality] == soeREQUIRED);
220
221 BEAST_EXPECT(section[5u][jss::name] == "PriceDataSeries");
222 BEAST_EXPECT(section[5u][jss::optionality] == soeREQUIRED);
223 }
224
225 // validate the format of the PermissionedDomainDelete transaction
226 {
227 BEAST_EXPECT(txnFormats.isMember("PermissionedDomainDelete"));
228 Json::Value const& section = txnFormats["PermissionedDomainDelete"];
229
230 BEAST_EXPECT(section[0u][jss::name] == "DomainID");
231 BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
232 }
233
234 // validate the format of the Clawback transaction
235 {
236 BEAST_EXPECT(txnFormats.isMember("Clawback"));
237 Json::Value const& section = txnFormats["Clawback"];
238
239 BEAST_EXPECT(section[0u][jss::name] == "Amount");
240 BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
241
242 BEAST_EXPECT(section[1u][jss::name] == "Holder");
243 BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
244 }
245
246 // validate the format of the SetFee transaction
247 {
248 BEAST_EXPECT(txnFormats.isMember("SetFee"));
249 Json::Value const& section = txnFormats["SetFee"];
250
251 BEAST_EXPECT(section[0u][jss::name] == "LedgerSequence");
252 BEAST_EXPECT(section[0u][jss::optionality] == soeOPTIONAL);
253
254 BEAST_EXPECT(section[1u][jss::name] == "BaseFee");
255 BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
256
257 BEAST_EXPECT(section[2u][jss::name] == "ReferenceFeeUnits");
258 BEAST_EXPECT(section[2u][jss::optionality] == soeOPTIONAL);
259
260 BEAST_EXPECT(section[3u][jss::name] == "ReserveBase");
261 BEAST_EXPECT(section[3u][jss::optionality] == soeOPTIONAL);
262
263 BEAST_EXPECT(section[4u][jss::name] == "ReserveIncrement");
264 BEAST_EXPECT(section[4u][jss::optionality] == soeOPTIONAL);
265
266 BEAST_EXPECT(section[5u][jss::name] == "BaseFeeDrops");
267 BEAST_EXPECT(section[5u][jss::optionality] == soeOPTIONAL);
268
269 BEAST_EXPECT(section[6u][jss::name] == "ReserveBaseDrops");
270 BEAST_EXPECT(section[6u][jss::optionality] == soeOPTIONAL);
271
272 BEAST_EXPECT(section[7u][jss::name] == "ReserveIncrementDrops");
273 BEAST_EXPECT(section[7u][jss::optionality] == soeOPTIONAL);
274 }
275 }
276
277 // test the properties of the LEDGER_ENTRY_FORMATS section in server_definitions
278 // response
279 {
280 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
281
282 // Note: For the purposes of software maintenance, this test does not exhaustively
283 // validate all the LEDGER_ENTRY_FORMATS
284
285 // check "common" first
286 {
287 Json::Value const& observedCommonLedgerEntry =
288 result[jss::result][jss::LEDGER_ENTRY_FORMATS]["common"];
289
290 BEAST_EXPECT(observedCommonLedgerEntry[0u][jss::name] == "LedgerIndex");
291 BEAST_EXPECT(observedCommonLedgerEntry[0u][jss::optionality] == soeOPTIONAL);
292
293 BEAST_EXPECT(observedCommonLedgerEntry[1u][jss::name] == "LedgerEntryType");
294 BEAST_EXPECT(observedCommonLedgerEntry[1u][jss::optionality] == soeREQUIRED);
295
296 BEAST_EXPECT(observedCommonLedgerEntry[2u][jss::name] == "Flags");
297 BEAST_EXPECT(observedCommonLedgerEntry[2u][jss::optionality] == soeREQUIRED);
298 }
299
300 // test the contents of an arbitrary ledger-entry (DID)
301 {
302 Json::Value const& observedDIDLedgerEntry =
303 result[jss::result][jss::LEDGER_ENTRY_FORMATS]["DID"];
304
305 BEAST_EXPECT(observedDIDLedgerEntry[0u][jss::name] == "Account");
306 BEAST_EXPECT(observedDIDLedgerEntry[0u][jss::optionality] == soeREQUIRED);
307
308 BEAST_EXPECT(observedDIDLedgerEntry[1u][jss::name] == "DIDDocument");
309 BEAST_EXPECT(observedDIDLedgerEntry[1u][jss::optionality] == soeOPTIONAL);
310
311 BEAST_EXPECT(observedDIDLedgerEntry[2u][jss::name] == "URI");
312 BEAST_EXPECT(observedDIDLedgerEntry[2u][jss::optionality] == soeOPTIONAL);
313
314 BEAST_EXPECT(observedDIDLedgerEntry[3u][jss::name] == "Data");
315 BEAST_EXPECT(observedDIDLedgerEntry[3u][jss::optionality] == soeOPTIONAL);
316
317 BEAST_EXPECT(observedDIDLedgerEntry[4u][jss::name] == "OwnerNode");
318 BEAST_EXPECT(observedDIDLedgerEntry[4u][jss::optionality] == soeREQUIRED);
319
320 BEAST_EXPECT(observedDIDLedgerEntry[5u][jss::name] == "PreviousTxnID");
321 BEAST_EXPECT(observedDIDLedgerEntry[5u][jss::optionality] == soeREQUIRED);
322
323 BEAST_EXPECT(observedDIDLedgerEntry[6u][jss::name] == "PreviousTxnLgrSeq");
324 BEAST_EXPECT(observedDIDLedgerEntry[6u][jss::optionality] == soeREQUIRED);
325 }
326
327 // test the contents of an arbitrary ledger-entry (NegativeUNL)
328 {
329 Json::Value const& observedNunlLedgerEntry =
330 result[jss::result][jss::LEDGER_ENTRY_FORMATS]["NegativeUNL"];
331
332 BEAST_EXPECT(observedNunlLedgerEntry[0u][jss::name] == "DisabledValidators");
333 BEAST_EXPECT(observedNunlLedgerEntry[0u][jss::optionality] == soeOPTIONAL);
334
335 BEAST_EXPECT(observedNunlLedgerEntry[1u][jss::name] == "ValidatorToDisable");
336 BEAST_EXPECT(observedNunlLedgerEntry[1u][jss::optionality] == soeOPTIONAL);
337
338 BEAST_EXPECT(observedNunlLedgerEntry[2u][jss::name] == "ValidatorToReEnable");
339 BEAST_EXPECT(observedNunlLedgerEntry[2u][jss::optionality] == soeOPTIONAL);
340
341 BEAST_EXPECT(observedNunlLedgerEntry[3u][jss::name] == "PreviousTxnID");
342 BEAST_EXPECT(observedNunlLedgerEntry[3u][jss::optionality] == soeOPTIONAL);
343
344 BEAST_EXPECT(observedNunlLedgerEntry[4u][jss::name] == "PreviousTxnLgrSeq");
345 BEAST_EXPECT(observedNunlLedgerEntry[4u][jss::optionality] == soeOPTIONAL);
346 }
347 }
348
349 // Exhaustive test: verify all transaction flags from getAllTxFlags() appear in the
350 // output
351 {
352 Json::Value const& txFlags = result[jss::result][jss::TRANSACTION_FLAGS];
353
354 for (auto const& [txName, flagMap] : getAllTxFlags())
355 {
356 BEAST_EXPECT(txFlags.isMember(txName));
357 if (txFlags.isMember(txName))
358 {
359 for (auto const& [flagName, flagValue] : flagMap)
360 {
361 BEAST_EXPECT(txFlags[txName].isMember(flagName));
362 if (txFlags[txName].isMember(flagName))
363 {
364 BEAST_EXPECT(txFlags[txName][flagName].asUInt() == flagValue);
365 }
366 }
367 }
368 }
369 }
370
371 // Exhaustive test: verify all ledger entry flags from getAllLedgerFlags() appear in the
372 // output
373 {
374 Json::Value const& leFlags = result[jss::result][jss::LEDGER_ENTRY_FLAGS];
375
376 for (auto const& [ledgerType, flagMap] : getAllLedgerFlags())
377 {
378 BEAST_EXPECT(leFlags.isMember(ledgerType));
379 if (leFlags.isMember(ledgerType))
380 {
381 for (auto const& [flagName, flagValue] : flagMap)
382 {
383 BEAST_EXPECT(leFlags[ledgerType].isMember(flagName));
384 if (leFlags[ledgerType].isMember(flagName))
385 {
386 BEAST_EXPECT(leFlags[ledgerType][flagName].asUInt() == flagValue);
387 }
388 }
389 }
390 }
391 }
392
393 // Exhaustive test: verify all AccountSet flags from getAsfFlagMap() appear in the
394 // output
395 {
396 Json::Value const& asFlags = result[jss::result][jss::ACCOUNT_SET_FLAGS];
397
398 for (auto const& [flagName, flagValue] : getAsfFlagMap())
399 {
400 BEAST_EXPECT(asFlags.isMember(flagName));
401 if (asFlags.isMember(flagName))
402 {
403 BEAST_EXPECT(asFlags[flagName].asInt() == flagValue);
404 }
405 }
406 }
407
408 // test providing the same hash
409 {
410 Env env(*this);
411 auto const firstResult = env.rpc("server_definitions");
412 auto const hash = firstResult[jss::result][jss::hash].asString();
413 auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
414
415 auto const result = env.rpc("json", "server_definitions", hashParam);
416 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
417 BEAST_EXPECT(result[jss::result][jss::status] == "success");
418 BEAST_EXPECT(!result[jss::result].isMember(jss::FIELDS));
419 BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
420 BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
421 BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
422 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_RESULTS));
423 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_TYPES));
424 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_FLAGS));
425 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_FORMATS));
426 BEAST_EXPECT(!result[jss::result].isMember(jss::TYPES));
427 BEAST_EXPECT(result[jss::result].isMember(jss::hash));
428 }
429
430 // test providing a different hash
431 {
432 Env env(*this);
433 std::string const hash =
434 "54296160385A27154BFA70A239DD8E8FD4CC2DB7BA32D970BA3A5B132CF749"
435 "D1";
436 auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
437
438 auto const result = env.rpc("json", "server_definitions", hashParam);
439 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
440 BEAST_EXPECT(result[jss::result][jss::status] == "success");
441 BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
442 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
443 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
444 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
445 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_RESULTS));
446 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
447 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FLAGS));
448 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FORMATS));
449 BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
450 BEAST_EXPECT(result[jss::result].isMember(jss::hash));
451 }
452 }
453 }
454
455 void
456 run() override
457 {
458 testServerDefinitions();
459 }
460};
461
462BEAST_DEFINE_TESTSUITE(ServerDefinitions, rpc, xrpl);
463
464} // namespace test
465} // namespace xrpl
Json::Value
Represents a JSON value.
Definition json_value.h:130
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition json_value.cpp:476
Json::Value::isMember
bool isMember(char const *key) const
Return true if the object has a member named key.
Definition json_value.cpp:1017
beast::unit_test::suite
A testsuite class.
Definition suite.h:51
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition suite.h:150
xrpl::test::ServerDefinitions_test
Definition ServerDefinitions_test.cpp:14
xrpl::test::ServerDefinitions_test::testServerDefinitions
void testServerDefinitions()
Definition ServerDefinitions_test.cpp:17
xrpl::test::ServerDefinitions_test::run
void run() override
Runs the suite.
Definition ServerDefinitions_test.cpp:456
xrpl::test::jtx::Env
A transaction testing environment.
Definition Env.h:122
xrpl::test::jtx::Env::rpc
Json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:847
xrpl::test::jtx::rpc
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition rpc.h:15
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::soeOPTIONAL
@ soeOPTIONAL
Definition SOTemplate.h:17
xrpl::soeREQUIRED
@ soeREQUIRED
Definition SOTemplate.h:16
xrpl::getAllTxFlags
FlagMapPairList const & getAllTxFlags()
Definition TxFlags.h:303
xrpl::getAllLedgerFlags
std::vector< std::pair< std::string, LedgerFlagMap > > const & getAllLedgerFlags()
Definition LedgerFormats.h:252
xrpl::getAsfFlagMap
std::map< std::string, FlagValue > const & getAsfFlagMap()
Definition TxFlags.h:431
Generated by doxygen 1.9.8