xrpld
Loading...
Searching...
No Matches
VaultTests.cpp
1// Auto-generated unit tests for ledger entry Vault
2
3
4#include <gtest/gtest.h>
5
6#include <protocol_autogen/TestHelpers.h>
7
8#include <xrpl/protocol/STLedgerEntry.h>
9#include <xrpl/protocol_autogen/ledger_entries/Vault.h>
10#include <xrpl/protocol_autogen/ledger_entries/Ticket.h>
11
12#include <string>
13
14namespace xrpl::ledger_entries {
15
16// 1 & 4) Set fields via builder setters, build, then read them back via
17// wrapper getters. After build(), validate() should succeed for both the
18// builder's STObject and the wrapper's SLE.
19TEST(VaultTests, BuilderSettersRoundTrip)
20{
21 UInt256 const index{1u};
22
23 auto const previousTxnIDValue = canonical_UINT256();
24 auto const previousTxnLgrSeqValue = canonical_UINT32();
25 auto const sequenceValue = canonical_UINT32();
26 auto const ownerNodeValue = canonical_UINT64();
27 auto const ownerValue = canonical_ACCOUNT();
28 auto const accountValue = canonical_ACCOUNT();
29 auto const dataValue = canonical_VL();
30 auto const assetValue = canonical_ISSUE();
31 auto const assetsTotalValue = canonical_NUMBER();
32 auto const assetsAvailableValue = canonical_NUMBER();
33 auto const assetsMaximumValue = canonical_NUMBER();
34 auto const lossUnrealizedValue = canonical_NUMBER();
35 auto const yieldUnrealizedValue = canonical_NUMBER();
36 auto const assetsDeployedValue = canonical_NUMBER();
37 auto const shareMPTIDValue = canonical_UINT192();
38 auto const withdrawalPolicyValue = canonical_UINT8();
39 auto const scaleValue = canonical_UINT8();
40 auto const lEVersionValue = canonical_UINT8();
41 auto const vaultKindValue = canonical_UINT8();
42 auto const subscriptionDateValue = canonical_UINT32();
43 auto const redemptionDateValue = canonical_UINT32();
44
45 VaultBuilder builder{
46 previousTxnIDValue,
47 previousTxnLgrSeqValue,
48 sequenceValue,
49 ownerNodeValue,
50 ownerValue,
51 accountValue,
52 assetValue,
53 shareMPTIDValue,
54 withdrawalPolicyValue
55 };
56
57 builder.setData(dataValue);
58 builder.setAssetsTotal(assetsTotalValue);
59 builder.setAssetsAvailable(assetsAvailableValue);
60 builder.setAssetsMaximum(assetsMaximumValue);
61 builder.setLossUnrealized(lossUnrealizedValue);
62 builder.setYieldUnrealized(yieldUnrealizedValue);
63 builder.setAssetsDeployed(assetsDeployedValue);
64 builder.setScale(scaleValue);
65 builder.setLEVersion(lEVersionValue);
66 builder.setVaultKind(vaultKindValue);
67 builder.setSubscriptionDate(subscriptionDateValue);
68 builder.setRedemptionDate(redemptionDateValue);
69
70 builder.setLedgerIndex(index);
71 builder.setFlags(0x1u);
72
73 EXPECT_TRUE(builder.validate());
74
75 auto const entry = builder.build(index);
76
77 EXPECT_TRUE(entry.validate());
78
79 {
80 auto const& expected = previousTxnIDValue;
81 auto const actual = entry.getPreviousTxnID();
82 expectEqualField(expected, actual, "sfPreviousTxnID");
83 }
84
85 {
86 auto const& expected = previousTxnLgrSeqValue;
87 auto const actual = entry.getPreviousTxnLgrSeq();
88 expectEqualField(expected, actual, "sfPreviousTxnLgrSeq");
89 }
90
91 {
92 auto const& expected = sequenceValue;
93 auto const actual = entry.getSequence();
94 expectEqualField(expected, actual, "sfSequence");
95 }
96
97 {
98 auto const& expected = ownerNodeValue;
99 auto const actual = entry.getOwnerNode();
100 expectEqualField(expected, actual, "sfOwnerNode");
101 }
102
103 {
104 auto const& expected = ownerValue;
105 auto const actual = entry.getOwner();
106 expectEqualField(expected, actual, "sfOwner");
107 }
108
109 {
110 auto const& expected = accountValue;
111 auto const actual = entry.getAccount();
112 expectEqualField(expected, actual, "sfAccount");
113 }
114
115 {
116 auto const& expected = assetValue;
117 auto const actual = entry.getAsset();
118 expectEqualField(expected, actual, "sfAsset");
119 }
120
121 {
122 auto const& expected = shareMPTIDValue;
123 auto const actual = entry.getShareMPTID();
124 expectEqualField(expected, actual, "sfShareMPTID");
125 }
126
127 {
128 auto const& expected = withdrawalPolicyValue;
129 auto const actual = entry.getWithdrawalPolicy();
130 expectEqualField(expected, actual, "sfWithdrawalPolicy");
131 }
132
133 {
134 auto const& expected = dataValue;
135 auto const actualOpt = entry.getData();
136 ASSERT_TRUE(actualOpt.has_value());
137 expectEqualField(expected, *actualOpt, "sfData");
138 EXPECT_TRUE(entry.hasData());
139 }
140
141 {
142 auto const& expected = assetsTotalValue;
143 auto const actualOpt = entry.getAssetsTotal();
144 ASSERT_TRUE(actualOpt.has_value());
145 expectEqualField(expected, *actualOpt, "sfAssetsTotal");
146 EXPECT_TRUE(entry.hasAssetsTotal());
147 }
148
149 {
150 auto const& expected = assetsAvailableValue;
151 auto const actualOpt = entry.getAssetsAvailable();
152 ASSERT_TRUE(actualOpt.has_value());
153 expectEqualField(expected, *actualOpt, "sfAssetsAvailable");
154 EXPECT_TRUE(entry.hasAssetsAvailable());
155 }
156
157 {
158 auto const& expected = assetsMaximumValue;
159 auto const actualOpt = entry.getAssetsMaximum();
160 ASSERT_TRUE(actualOpt.has_value());
161 expectEqualField(expected, *actualOpt, "sfAssetsMaximum");
162 EXPECT_TRUE(entry.hasAssetsMaximum());
163 }
164
165 {
166 auto const& expected = lossUnrealizedValue;
167 auto const actualOpt = entry.getLossUnrealized();
168 ASSERT_TRUE(actualOpt.has_value());
169 expectEqualField(expected, *actualOpt, "sfLossUnrealized");
170 EXPECT_TRUE(entry.hasLossUnrealized());
171 }
172
173 {
174 auto const& expected = yieldUnrealizedValue;
175 auto const actualOpt = entry.getYieldUnrealized();
176 ASSERT_TRUE(actualOpt.has_value());
177 expectEqualField(expected, *actualOpt, "sfYieldUnrealized");
178 EXPECT_TRUE(entry.hasYieldUnrealized());
179 }
180
181 {
182 auto const& expected = assetsDeployedValue;
183 auto const actualOpt = entry.getAssetsDeployed();
184 ASSERT_TRUE(actualOpt.has_value());
185 expectEqualField(expected, *actualOpt, "sfAssetsDeployed");
186 EXPECT_TRUE(entry.hasAssetsDeployed());
187 }
188
189 {
190 auto const& expected = scaleValue;
191 auto const actualOpt = entry.getScale();
192 ASSERT_TRUE(actualOpt.has_value());
193 expectEqualField(expected, *actualOpt, "sfScale");
194 EXPECT_TRUE(entry.hasScale());
195 }
196
197 {
198 auto const& expected = lEVersionValue;
199 auto const actualOpt = entry.getLEVersion();
200 ASSERT_TRUE(actualOpt.has_value());
201 expectEqualField(expected, *actualOpt, "sfLEVersion");
202 EXPECT_TRUE(entry.hasLEVersion());
203 }
204
205 {
206 auto const& expected = vaultKindValue;
207 auto const actualOpt = entry.getVaultKind();
208 ASSERT_TRUE(actualOpt.has_value());
209 expectEqualField(expected, *actualOpt, "sfVaultKind");
210 EXPECT_TRUE(entry.hasVaultKind());
211 }
212
213 {
214 auto const& expected = subscriptionDateValue;
215 auto const actualOpt = entry.getSubscriptionDate();
216 ASSERT_TRUE(actualOpt.has_value());
217 expectEqualField(expected, *actualOpt, "sfSubscriptionDate");
218 EXPECT_TRUE(entry.hasSubscriptionDate());
219 }
220
221 {
222 auto const& expected = redemptionDateValue;
223 auto const actualOpt = entry.getRedemptionDate();
224 ASSERT_TRUE(actualOpt.has_value());
225 expectEqualField(expected, *actualOpt, "sfRedemptionDate");
226 EXPECT_TRUE(entry.hasRedemptionDate());
227 }
228
229 EXPECT_TRUE(entry.hasLedgerIndex());
230 auto const ledgerIndex = entry.getLedgerIndex();
231 ASSERT_TRUE(ledgerIndex.has_value());
232 EXPECT_EQ(*ledgerIndex, index);
233 EXPECT_EQ(entry.getKey(), index);
234}
235
236// 2 & 4) Start from an SLE, set fields directly on it, construct a builder
237// from that SLE, build a new wrapper, and verify all fields (and validate()).
238TEST(VaultTests, BuilderFromSleRoundTrip)
239{
240 UInt256 const index{2u};
241
242 auto const previousTxnIDValue = canonical_UINT256();
243 auto const previousTxnLgrSeqValue = canonical_UINT32();
244 auto const sequenceValue = canonical_UINT32();
245 auto const ownerNodeValue = canonical_UINT64();
246 auto const ownerValue = canonical_ACCOUNT();
247 auto const accountValue = canonical_ACCOUNT();
248 auto const dataValue = canonical_VL();
249 auto const assetValue = canonical_ISSUE();
250 auto const assetsTotalValue = canonical_NUMBER();
251 auto const assetsAvailableValue = canonical_NUMBER();
252 auto const assetsMaximumValue = canonical_NUMBER();
253 auto const lossUnrealizedValue = canonical_NUMBER();
254 auto const yieldUnrealizedValue = canonical_NUMBER();
255 auto const assetsDeployedValue = canonical_NUMBER();
256 auto const shareMPTIDValue = canonical_UINT192();
257 auto const withdrawalPolicyValue = canonical_UINT8();
258 auto const scaleValue = canonical_UINT8();
259 auto const lEVersionValue = canonical_UINT8();
260 auto const vaultKindValue = canonical_UINT8();
261 auto const subscriptionDateValue = canonical_UINT32();
262 auto const redemptionDateValue = canonical_UINT32();
263
264 auto sle = std::make_shared<SLE>(Vault::entryType, index);
265
266 sle->at(sfPreviousTxnID) = previousTxnIDValue;
267 sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue;
268 sle->at(sfSequence) = sequenceValue;
269 sle->at(sfOwnerNode) = ownerNodeValue;
270 sle->at(sfOwner) = ownerValue;
271 sle->at(sfAccount) = accountValue;
272 sle->at(sfData) = dataValue;
273 sle->at(sfAsset) = STIssue(sfAsset, assetValue);
274 sle->at(sfAssetsTotal) = assetsTotalValue;
275 sle->at(sfAssetsAvailable) = assetsAvailableValue;
276 sle->at(sfAssetsMaximum) = assetsMaximumValue;
277 sle->at(sfLossUnrealized) = lossUnrealizedValue;
278 sle->at(sfYieldUnrealized) = yieldUnrealizedValue;
279 sle->at(sfAssetsDeployed) = assetsDeployedValue;
280 sle->at(sfShareMPTID) = shareMPTIDValue;
281 sle->at(sfWithdrawalPolicy) = withdrawalPolicyValue;
282 sle->at(sfScale) = scaleValue;
283 sle->at(sfLEVersion) = lEVersionValue;
284 sle->at(sfVaultKind) = vaultKindValue;
285 sle->at(sfSubscriptionDate) = subscriptionDateValue;
286 sle->at(sfRedemptionDate) = redemptionDateValue;
287
288 VaultBuilder builderFromSle{sle};
289 EXPECT_TRUE(builderFromSle.validate());
290
291 auto const entryFromBuilder = builderFromSle.build(index);
292
293 Vault entryFromSle{sle};
294 EXPECT_TRUE(entryFromBuilder.validate());
295 EXPECT_TRUE(entryFromSle.validate());
296
297 {
298 auto const& expected = previousTxnIDValue;
299
300 auto const fromSle = entryFromSle.getPreviousTxnID();
301 auto const fromBuilder = entryFromBuilder.getPreviousTxnID();
302
303 expectEqualField(expected, fromSle, "sfPreviousTxnID");
304 expectEqualField(expected, fromBuilder, "sfPreviousTxnID");
305 }
306
307 {
308 auto const& expected = previousTxnLgrSeqValue;
309
310 auto const fromSle = entryFromSle.getPreviousTxnLgrSeq();
311 auto const fromBuilder = entryFromBuilder.getPreviousTxnLgrSeq();
312
313 expectEqualField(expected, fromSle, "sfPreviousTxnLgrSeq");
314 expectEqualField(expected, fromBuilder, "sfPreviousTxnLgrSeq");
315 }
316
317 {
318 auto const& expected = sequenceValue;
319
320 auto const fromSle = entryFromSle.getSequence();
321 auto const fromBuilder = entryFromBuilder.getSequence();
322
323 expectEqualField(expected, fromSle, "sfSequence");
324 expectEqualField(expected, fromBuilder, "sfSequence");
325 }
326
327 {
328 auto const& expected = ownerNodeValue;
329
330 auto const fromSle = entryFromSle.getOwnerNode();
331 auto const fromBuilder = entryFromBuilder.getOwnerNode();
332
333 expectEqualField(expected, fromSle, "sfOwnerNode");
334 expectEqualField(expected, fromBuilder, "sfOwnerNode");
335 }
336
337 {
338 auto const& expected = ownerValue;
339
340 auto const fromSle = entryFromSle.getOwner();
341 auto const fromBuilder = entryFromBuilder.getOwner();
342
343 expectEqualField(expected, fromSle, "sfOwner");
344 expectEqualField(expected, fromBuilder, "sfOwner");
345 }
346
347 {
348 auto const& expected = accountValue;
349
350 auto const fromSle = entryFromSle.getAccount();
351 auto const fromBuilder = entryFromBuilder.getAccount();
352
353 expectEqualField(expected, fromSle, "sfAccount");
354 expectEqualField(expected, fromBuilder, "sfAccount");
355 }
356
357 {
358 auto const& expected = assetValue;
359
360 auto const fromSle = entryFromSle.getAsset();
361 auto const fromBuilder = entryFromBuilder.getAsset();
362
363 expectEqualField(expected, fromSle, "sfAsset");
364 expectEqualField(expected, fromBuilder, "sfAsset");
365 }
366
367 {
368 auto const& expected = shareMPTIDValue;
369
370 auto const fromSle = entryFromSle.getShareMPTID();
371 auto const fromBuilder = entryFromBuilder.getShareMPTID();
372
373 expectEqualField(expected, fromSle, "sfShareMPTID");
374 expectEqualField(expected, fromBuilder, "sfShareMPTID");
375 }
376
377 {
378 auto const& expected = withdrawalPolicyValue;
379
380 auto const fromSle = entryFromSle.getWithdrawalPolicy();
381 auto const fromBuilder = entryFromBuilder.getWithdrawalPolicy();
382
383 expectEqualField(expected, fromSle, "sfWithdrawalPolicy");
384 expectEqualField(expected, fromBuilder, "sfWithdrawalPolicy");
385 }
386
387 {
388 auto const& expected = dataValue;
389
390 auto const fromSleOpt = entryFromSle.getData();
391 auto const fromBuilderOpt = entryFromBuilder.getData();
392
393 ASSERT_TRUE(fromSleOpt.has_value());
394 ASSERT_TRUE(fromBuilderOpt.has_value());
395
396 expectEqualField(expected, *fromSleOpt, "sfData");
397 expectEqualField(expected, *fromBuilderOpt, "sfData");
398 }
399
400 {
401 auto const& expected = assetsTotalValue;
402
403 auto const fromSleOpt = entryFromSle.getAssetsTotal();
404 auto const fromBuilderOpt = entryFromBuilder.getAssetsTotal();
405
406 ASSERT_TRUE(fromSleOpt.has_value());
407 ASSERT_TRUE(fromBuilderOpt.has_value());
408
409 expectEqualField(expected, *fromSleOpt, "sfAssetsTotal");
410 expectEqualField(expected, *fromBuilderOpt, "sfAssetsTotal");
411 }
412
413 {
414 auto const& expected = assetsAvailableValue;
415
416 auto const fromSleOpt = entryFromSle.getAssetsAvailable();
417 auto const fromBuilderOpt = entryFromBuilder.getAssetsAvailable();
418
419 ASSERT_TRUE(fromSleOpt.has_value());
420 ASSERT_TRUE(fromBuilderOpt.has_value());
421
422 expectEqualField(expected, *fromSleOpt, "sfAssetsAvailable");
423 expectEqualField(expected, *fromBuilderOpt, "sfAssetsAvailable");
424 }
425
426 {
427 auto const& expected = assetsMaximumValue;
428
429 auto const fromSleOpt = entryFromSle.getAssetsMaximum();
430 auto const fromBuilderOpt = entryFromBuilder.getAssetsMaximum();
431
432 ASSERT_TRUE(fromSleOpt.has_value());
433 ASSERT_TRUE(fromBuilderOpt.has_value());
434
435 expectEqualField(expected, *fromSleOpt, "sfAssetsMaximum");
436 expectEqualField(expected, *fromBuilderOpt, "sfAssetsMaximum");
437 }
438
439 {
440 auto const& expected = lossUnrealizedValue;
441
442 auto const fromSleOpt = entryFromSle.getLossUnrealized();
443 auto const fromBuilderOpt = entryFromBuilder.getLossUnrealized();
444
445 ASSERT_TRUE(fromSleOpt.has_value());
446 ASSERT_TRUE(fromBuilderOpt.has_value());
447
448 expectEqualField(expected, *fromSleOpt, "sfLossUnrealized");
449 expectEqualField(expected, *fromBuilderOpt, "sfLossUnrealized");
450 }
451
452 {
453 auto const& expected = yieldUnrealizedValue;
454
455 auto const fromSleOpt = entryFromSle.getYieldUnrealized();
456 auto const fromBuilderOpt = entryFromBuilder.getYieldUnrealized();
457
458 ASSERT_TRUE(fromSleOpt.has_value());
459 ASSERT_TRUE(fromBuilderOpt.has_value());
460
461 expectEqualField(expected, *fromSleOpt, "sfYieldUnrealized");
462 expectEqualField(expected, *fromBuilderOpt, "sfYieldUnrealized");
463 }
464
465 {
466 auto const& expected = assetsDeployedValue;
467
468 auto const fromSleOpt = entryFromSle.getAssetsDeployed();
469 auto const fromBuilderOpt = entryFromBuilder.getAssetsDeployed();
470
471 ASSERT_TRUE(fromSleOpt.has_value());
472 ASSERT_TRUE(fromBuilderOpt.has_value());
473
474 expectEqualField(expected, *fromSleOpt, "sfAssetsDeployed");
475 expectEqualField(expected, *fromBuilderOpt, "sfAssetsDeployed");
476 }
477
478 {
479 auto const& expected = scaleValue;
480
481 auto const fromSleOpt = entryFromSle.getScale();
482 auto const fromBuilderOpt = entryFromBuilder.getScale();
483
484 ASSERT_TRUE(fromSleOpt.has_value());
485 ASSERT_TRUE(fromBuilderOpt.has_value());
486
487 expectEqualField(expected, *fromSleOpt, "sfScale");
488 expectEqualField(expected, *fromBuilderOpt, "sfScale");
489 }
490
491 {
492 auto const& expected = lEVersionValue;
493
494 auto const fromSleOpt = entryFromSle.getLEVersion();
495 auto const fromBuilderOpt = entryFromBuilder.getLEVersion();
496
497 ASSERT_TRUE(fromSleOpt.has_value());
498 ASSERT_TRUE(fromBuilderOpt.has_value());
499
500 expectEqualField(expected, *fromSleOpt, "sfLEVersion");
501 expectEqualField(expected, *fromBuilderOpt, "sfLEVersion");
502 }
503
504 {
505 auto const& expected = vaultKindValue;
506
507 auto const fromSleOpt = entryFromSle.getVaultKind();
508 auto const fromBuilderOpt = entryFromBuilder.getVaultKind();
509
510 ASSERT_TRUE(fromSleOpt.has_value());
511 ASSERT_TRUE(fromBuilderOpt.has_value());
512
513 expectEqualField(expected, *fromSleOpt, "sfVaultKind");
514 expectEqualField(expected, *fromBuilderOpt, "sfVaultKind");
515 }
516
517 {
518 auto const& expected = subscriptionDateValue;
519
520 auto const fromSleOpt = entryFromSle.getSubscriptionDate();
521 auto const fromBuilderOpt = entryFromBuilder.getSubscriptionDate();
522
523 ASSERT_TRUE(fromSleOpt.has_value());
524 ASSERT_TRUE(fromBuilderOpt.has_value());
525
526 expectEqualField(expected, *fromSleOpt, "sfSubscriptionDate");
527 expectEqualField(expected, *fromBuilderOpt, "sfSubscriptionDate");
528 }
529
530 {
531 auto const& expected = redemptionDateValue;
532
533 auto const fromSleOpt = entryFromSle.getRedemptionDate();
534 auto const fromBuilderOpt = entryFromBuilder.getRedemptionDate();
535
536 ASSERT_TRUE(fromSleOpt.has_value());
537 ASSERT_TRUE(fromBuilderOpt.has_value());
538
539 expectEqualField(expected, *fromSleOpt, "sfRedemptionDate");
540 expectEqualField(expected, *fromBuilderOpt, "sfRedemptionDate");
541 }
542
543 EXPECT_EQ(entryFromSle.getKey(), index);
544 EXPECT_EQ(entryFromBuilder.getKey(), index);
545}
546
547// 3) Verify wrapper throws when constructed from wrong ledger entry type.
548TEST(VaultTests, WrapperThrowsOnWrongEntryType)
549{
550 UInt256 const index{3u};
551
552 // Build a valid ledger entry of a different type
553 // Ticket requires: Account, OwnerNode, TicketSequence, PreviousTxnID, PreviousTxnLgrSeq
554 // Check requires: Account, Destination, SendMax, Sequence, OwnerNode, DestinationNode, PreviousTxnID, PreviousTxnLgrSeq
555 TicketBuilder wrongBuilder{
561 auto wrongEntry = wrongBuilder.build(index);
562
563 EXPECT_THROW(Vault{wrongEntry.getSle()}, std::runtime_error);
564}
565
566// 4) Verify builder throws when constructed from wrong ledger entry type.
567TEST(VaultTests, BuilderThrowsOnWrongEntryType)
568{
569 UInt256 const index{4u};
570
571 // Build a valid ledger entry of a different type
572 TicketBuilder wrongBuilder{
578 auto wrongEntry = wrongBuilder.build(index);
579
580 EXPECT_THROW(VaultBuilder{wrongEntry.getSle()}, std::runtime_error);
581}
582
583// 5) Build with only required fields and verify optional fields return nullopt.
584TEST(VaultTests, OptionalFieldsReturnNullopt)
585{
586 UInt256 const index{3u};
587
588 auto const previousTxnIDValue = canonical_UINT256();
589 auto const previousTxnLgrSeqValue = canonical_UINT32();
590 auto const sequenceValue = canonical_UINT32();
591 auto const ownerNodeValue = canonical_UINT64();
592 auto const ownerValue = canonical_ACCOUNT();
593 auto const accountValue = canonical_ACCOUNT();
594 auto const assetValue = canonical_ISSUE();
595 auto const shareMPTIDValue = canonical_UINT192();
596 auto const withdrawalPolicyValue = canonical_UINT8();
597
598 VaultBuilder builder{
599 previousTxnIDValue,
600 previousTxnLgrSeqValue,
601 sequenceValue,
602 ownerNodeValue,
603 ownerValue,
604 accountValue,
605 assetValue,
606 shareMPTIDValue,
607 withdrawalPolicyValue
608 };
609
610 auto const entry = builder.build(index);
611
612 // Verify optional fields are not present
613 EXPECT_FALSE(entry.hasData());
614 EXPECT_FALSE(entry.getData().has_value());
615 EXPECT_FALSE(entry.hasAssetsTotal());
616 EXPECT_FALSE(entry.getAssetsTotal().has_value());
617 EXPECT_FALSE(entry.hasAssetsAvailable());
618 EXPECT_FALSE(entry.getAssetsAvailable().has_value());
619 EXPECT_FALSE(entry.hasAssetsMaximum());
620 EXPECT_FALSE(entry.getAssetsMaximum().has_value());
621 EXPECT_FALSE(entry.hasLossUnrealized());
622 EXPECT_FALSE(entry.getLossUnrealized().has_value());
623 EXPECT_FALSE(entry.hasYieldUnrealized());
624 EXPECT_FALSE(entry.getYieldUnrealized().has_value());
625 EXPECT_FALSE(entry.hasAssetsDeployed());
626 EXPECT_FALSE(entry.getAssetsDeployed().has_value());
627 EXPECT_FALSE(entry.hasScale());
628 EXPECT_FALSE(entry.getScale().has_value());
629 EXPECT_FALSE(entry.hasLEVersion());
630 EXPECT_FALSE(entry.getLEVersion().has_value());
631 EXPECT_FALSE(entry.hasVaultKind());
632 EXPECT_FALSE(entry.getVaultKind().has_value());
633 EXPECT_FALSE(entry.hasSubscriptionDate());
634 EXPECT_FALSE(entry.getSubscriptionDate().has_value());
635 EXPECT_FALSE(entry.hasRedemptionDate());
636 EXPECT_FALSE(entry.getRedemptionDate().has_value());
637}
638}
UInt256 const & getKey() const
Get the key (index) of this ledger entry.
bool validate() const
Validate the ledger entry.
Derived & setLedgerIndex(UInt256 const &value)
Set the ledger index.
Derived & setFlags(uint32_t value)
Set the flags.
bool validate() const
Validate the ledger entry.
Builder for Ticket ledger entries.
Definition Ticket.h:112
Ticket build(UInt256 const &index)
Build and return the completed Ticket wrapper.
Definition Ticket.h:211
Builder for Vault ledger entries.
Definition Vault.h:444
VaultBuilder & setVaultKind(std::decay_t< typename SF_UINT8::type::value_type > const &value)
Set sfVaultKind (SoeDefault).
Definition Vault.h:693
VaultBuilder & setAssetsAvailable(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfAssetsAvailable (SoeDefault).
Definition Vault.h:594
VaultBuilder & setRedemptionDate(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfRedemptionDate (SoeOptional).
Definition Vault.h:715
VaultBuilder & setAssetsDeployed(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfAssetsDeployed (SoeDefault).
Definition Vault.h:638
VaultBuilder & setScale(std::decay_t< typename SF_UINT8::type::value_type > const &value)
Set sfScale (SoeDefault).
Definition Vault.h:671
VaultBuilder & setAssetsTotal(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfAssetsTotal (SoeDefault).
Definition Vault.h:583
Vault build(UInt256 const &index)
Build and return the completed Vault wrapper.
Definition Vault.h:727
VaultBuilder & setSubscriptionDate(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfSubscriptionDate (SoeOptional).
Definition Vault.h:704
VaultBuilder & setLossUnrealized(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfLossUnrealized (SoeDefault).
Definition Vault.h:616
VaultBuilder & setData(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfData (SoeOptional).
Definition Vault.h:561
VaultBuilder & setLEVersion(std::decay_t< typename SF_UINT8::type::value_type > const &value)
Set sfLEVersion (SoeDefault).
Definition Vault.h:682
VaultBuilder & setAssetsMaximum(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfAssetsMaximum (SoeDefault).
Definition Vault.h:605
VaultBuilder & setYieldUnrealized(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfYieldUnrealized (SoeDefault).
Definition Vault.h:627
Ledger Entry: Vault.
Definition Vault.h:28
protocol_autogen::Optional< SF_NUMBER::type::value_type > getAssetsMaximum() const
Get sfAssetsMaximum (SoeDefault).
Definition Vault.h:203
SF_ISSUE::type::value_type getAsset() const
Get sfAsset (SoeRequired).
Definition Vault.h:144
protocol_autogen::Optional< SF_VL::type::value_type > getData() const
Get sfData (SoeOptional).
Definition Vault.h:120
SF_UINT32::type::value_type getPreviousTxnLgrSeq() const
Get sfPreviousTxnLgrSeq (SoeRequired).
Definition Vault.h:65
SF_ACCOUNT::type::value_type getOwner() const
Get sfOwner (SoeRequired).
Definition Vault.h:98
protocol_autogen::Optional< SF_NUMBER::type::value_type > getLossUnrealized() const
Get sfLossUnrealized (SoeDefault).
Definition Vault.h:227
protocol_autogen::Optional< SF_UINT8::type::value_type > getLEVersion() const
Get sfLEVersion (SoeDefault).
Definition Vault.h:345
protocol_autogen::Optional< SF_NUMBER::type::value_type > getYieldUnrealized() const
Get sfYieldUnrealized (SoeDefault).
Definition Vault.h:251
static constexpr LedgerEntryType entryType
Definition Vault.h:30
protocol_autogen::Optional< SF_NUMBER::type::value_type > getAssetsAvailable() const
Get sfAssetsAvailable (SoeDefault).
Definition Vault.h:179
protocol_autogen::Optional< SF_UINT8::type::value_type > getScale() const
Get sfScale (SoeDefault).
Definition Vault.h:321
SF_UINT192::type::value_type getShareMPTID() const
Get sfShareMPTID (SoeRequired).
Definition Vault.h:299
SF_UINT256::type::value_type getPreviousTxnID() const
Get sfPreviousTxnID (SoeRequired).
Definition Vault.h:54
protocol_autogen::Optional< SF_NUMBER::type::value_type > getAssetsDeployed() const
Get sfAssetsDeployed (SoeDefault).
Definition Vault.h:275
SF_UINT8::type::value_type getWithdrawalPolicy() const
Get sfWithdrawalPolicy (SoeRequired).
Definition Vault.h:310
protocol_autogen::Optional< SF_NUMBER::type::value_type > getAssetsTotal() const
Get sfAssetsTotal (SoeDefault).
Definition Vault.h:155
SF_UINT64::type::value_type getOwnerNode() const
Get sfOwnerNode (SoeRequired).
Definition Vault.h:87
SF_UINT32::type::value_type getSequence() const
Get sfSequence (SoeRequired).
Definition Vault.h:76
protocol_autogen::Optional< SF_UINT32::type::value_type > getRedemptionDate() const
Get sfRedemptionDate (SoeOptional).
Definition Vault.h:417
SF_ACCOUNT::type::value_type getAccount() const
Get sfAccount (SoeRequired).
Definition Vault.h:109
protocol_autogen::Optional< SF_UINT32::type::value_type > getSubscriptionDate() const
Get sfSubscriptionDate (SoeOptional).
Definition Vault.h:393
protocol_autogen::Optional< SF_UINT8::type::value_type > getVaultKind() const
Get sfVaultKind (SoeDefault).
Definition Vault.h:369
T make_shared(T... args)
TEST(AccountRootTests, BuilderSettersRoundTrip)
BaseUInt< 256 > UInt256
Definition base_uint.h:581
void expectEqualField(T const &expected, T const &actual, char const *fieldName)