Skip to content

Commit cce7aa2

Browse files
PeterChen13579PeterChen13579
authored
style: Fix formatting via clang-format (#1809)
For #1760
1 parent 820b32c commit cce7aa2

13 files changed

+352
-305
lines changed

‎tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -310,7 +310,8 @@ TEST_F(MigrationCassandraManagerLedgerTableTest, MigrateExampleLedgerMigrator)
310310
EXPECT_EQ(newTableSize, gLedgerHeaderRawData.size());
311311

312312
auto const getAccountHash = [this](std::uint32_t seq) {
313-
return data::synchronous([&](auto ctx) { return testMigrationBackend_->fetchAccountHashViaSequence(seq, ctx); });
313+
return data::synchronous([&](auto ctx) { return testMigrationBackend_->fetchAccountHashViaSequence(seq, ctx); }
314+
);
314315
};
315316

316317
EXPECT_EQ(

‎tests/unit/rpc/handlers/BookOffersTests.cpp‎

Lines changed: 202 additions & 183 deletions
Large diffs are not rendered by default.

‎tests/unit/rpc/handlers/GatewayBalancesTests.cpp‎

Lines changed: 51 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -444,8 +444,8 @@ generateNormalPathTestBundles()
444444
overflowState.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue("JPY", kISSUER), min64, 80));
445445
return std::vector<NormalTestBundle>{
446446
NormalTestBundle{
447-
.testName="AllBranches",
448-
.mockedDir=createOwnerDirLedgerObject(
447+
.testName = "AllBranches",
448+
.mockedDir = createOwnerDirLedgerObject(
449449
{ripple::uint256{kINDEX2},
450450
ripple::uint256{kINDEX2},
451451
ripple::uint256{kINDEX2},
@@ -454,20 +454,22 @@ generateNormalPathTestBundles()
454454
ripple::uint256{kINDEX2}},
455455
kINDEX1
456456
),
457-
.mockedObjects=std::vector{// hotwallet
458-
createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
459-
// hotwallet
460-
createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
461-
// positive balance -> asset
462-
createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123),
463-
// positive balance -> asset
464-
createRippleStateLedgerObject("JPY", kISSUER, 40, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123),
465-
// obligation
466-
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123),
467-
frozenState
468-
469-
},
470-
.expectedJson=fmt::format(
457+
.mockedObjects =
458+
std::vector{
459+
// hotwallet
460+
createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
461+
// hotwallet
462+
createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
463+
// positive balance -> asset
464+
createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123),
465+
// positive balance -> asset
466+
createRippleStateLedgerObject("JPY", kISSUER, 40, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123),
467+
// obligation
468+
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123),
469+
frozenState
470+
471+
},
472+
.expectedJson = fmt::format(
471473
R"({{
472474
"obligations":{{
473475
"JPY":"50"
@@ -513,13 +515,15 @@ generateNormalPathTestBundles()
513515
kACCOUNT3,
514516
kACCOUNT
515517
),
516-
.hotwallet=fmt::format(R"("hotwallet": "{}")", kACCOUNT2)
518+
.hotwallet = fmt::format(R"("hotwallet": "{}")", kACCOUNT2)
517519
},
518520
NormalTestBundle{
519-
.testName="NoHotwallet",
520-
.mockedDir=createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1),
521-
.mockedObjects=std::vector{createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123)},
522-
.expectedJson=fmt::format(
521+
.testName = "NoHotwallet",
522+
.mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1),
523+
.mockedObjects = std::vector{createRippleStateLedgerObject(
524+
"JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123
525+
)},
526+
.expectedJson = fmt::format(
523527
R"({{
524528
"obligations":{{
525529
"JPY":"50"
@@ -533,10 +537,10 @@ generateNormalPathTestBundles()
533537
.hotwallet = R"("ledger_index" : "validated")"
534538
},
535539
NormalTestBundle{
536-
.testName="ObligationOverflow",
537-
.mockedDir=createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1),
538-
.mockedObjects=std::vector{overflowState, overflowState},
539-
.expectedJson=fmt::format(
540+
.testName = "ObligationOverflow",
541+
.mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1),
542+
.mockedObjects = std::vector{overflowState, overflowState},
543+
.expectedJson = fmt::format(
540544
R"({{
541545
"obligations":{{
542546
"JPY":"9999999999999999e80"
@@ -550,20 +554,22 @@ generateNormalPathTestBundles()
550554
.hotwallet = R"("ledger_index" : "validated")"
551555
},
552556
NormalTestBundle{
553-
.testName="HighID",
554-
.mockedDir=createOwnerDirLedgerObject(
557+
.testName = "HighID",
558+
.mockedDir = createOwnerDirLedgerObject(
555559
{ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}
556560
},
557561
kINDEX1
558562
),
559-
.mockedObjects=std::vector{// hotwallet
560-
createRippleStateLedgerObject("USD", kISSUER, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123),
561-
// hotwallet
562-
createRippleStateLedgerObject("CNY", kISSUER, 20, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123),
563-
createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT3, 100, kACCOUNT, 200, kTXN_ID, 123),
564-
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT3, 10, kACCOUNT, 20, kTXN_ID, 123)
565-
},
566-
.expectedJson=fmt::format(
563+
.mockedObjects =
564+
std::vector{
565+
// hotwallet
566+
createRippleStateLedgerObject("USD", kISSUER, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123),
567+
// hotwallet
568+
createRippleStateLedgerObject("CNY", kISSUER, 20, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123),
569+
createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT3, 100, kACCOUNT, 200, kTXN_ID, 123),
570+
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT3, 10, kACCOUNT, 20, kTXN_ID, 123)
571+
},
572+
.expectedJson = fmt::format(
567573
R"({{
568574
"obligations":{{
569575
"EUR":"30"
@@ -596,19 +602,20 @@ generateNormalPathTestBundles()
596602
kACCOUNT3,
597603
kACCOUNT
598604
),
599-
.hotwallet=fmt::format(R"("hotwallet": "{}")", kACCOUNT2)
605+
.hotwallet = fmt::format(R"("hotwallet": "{}")", kACCOUNT2)
600606
},
601607
NormalTestBundle{
602-
.testName="HotWalletArray",
603-
.mockedDir=createOwnerDirLedgerObject(
608+
.testName = "HotWalletArray",
609+
.mockedDir = createOwnerDirLedgerObject(
604610
{ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1
605611
),
606-
.mockedObjects=std::vector{
607-
createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
608-
createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
609-
createRippleStateLedgerObject("EUR", kISSUER, -30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123)
612+
.mockedObjects =
613+
std::vector{
614+
createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
615+
createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
616+
createRippleStateLedgerObject("EUR", kISSUER, -30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123)
610617

611-
},
618+
},
612619
.expectedJson = fmt::format(
613620
R"({{
614621
"balances":{{
@@ -637,7 +644,7 @@ generateNormalPathTestBundles()
637644
kACCOUNT2,
638645
kACCOUNT
639646
),
640-
.hotwallet=fmt::format(R"("hotwallet": ["{}", "{}"])", kACCOUNT2, kACCOUNT3)
647+
.hotwallet = fmt::format(R"("hotwallet": ["{}", "{}"])", kACCOUNT2, kACCOUNT3)
641648
},
642649
};
643650
}

‎tests/unit/rpc/handlers/LedgerIndexTests.cpp‎

Lines changed: 24 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -130,12 +130,30 @@ class LedgerIndexTests : public RPCLedgerIndexTest, public WithParamInterface<Le
130130
{
131131
// start from 2024-06-25T12:23:10Z to 2024-06-25T12:23:50Z with step 2
132132
return std::vector<LedgerIndexTestsCaseBundle>{
133-
{.testName="LaterThanMaxLedger", .json=R"({"date": "2024-06-25T12:23:55Z"})", .expectedLedgerIndex=kRANGE_MAX, .closeTimeIso="2024-06-25T12:23:50Z"},
134-
{.testName="GreaterThanMinLedger", .json=R"({"date": "2024-06-25T12:23:11Z"})", .expectedLedgerIndex=kRANGE_MIN, .closeTimeIso="2024-06-25T12:23:10Z"},
135-
{.testName="IsMinLedger", .json=R"({"date": "2024-06-25T12:23:10Z"})", .expectedLedgerIndex=kRANGE_MIN, .closeTimeIso="2024-06-25T12:23:10Z"},
136-
{.testName="IsMaxLedger", .json=R"({"date": "2024-06-25T12:23:50Z"})", .expectedLedgerIndex=kRANGE_MAX, .closeTimeIso="2024-06-25T12:23:50Z"},
137-
{.testName="IsMidLedger", .json=R"({"date": "2024-06-25T12:23:30Z"})", .expectedLedgerIndex=20, .closeTimeIso="2024-06-25T12:23:30Z"},
138-
{.testName="BetweenLedgers", .json=R"({"date": "2024-06-25T12:23:29Z"})", .expectedLedgerIndex=19, .closeTimeIso="2024-06-25T12:23:28Z"}
133+
{.testName = "LaterThanMaxLedger",
134+
.json = R"({"date": "2024-06-25T12:23:55Z"})",
135+
.expectedLedgerIndex = kRANGE_MAX,
136+
.closeTimeIso = "2024-06-25T12:23:50Z"},
137+
{.testName = "GreaterThanMinLedger",
138+
.json = R"({"date": "2024-06-25T12:23:11Z"})",
139+
.expectedLedgerIndex = kRANGE_MIN,
140+
.closeTimeIso = "2024-06-25T12:23:10Z"},
141+
{.testName = "IsMinLedger",
142+
.json = R"({"date": "2024-06-25T12:23:10Z"})",
143+
.expectedLedgerIndex = kRANGE_MIN,
144+
.closeTimeIso = "2024-06-25T12:23:10Z"},
145+
{.testName = "IsMaxLedger",
146+
.json = R"({"date": "2024-06-25T12:23:50Z"})",
147+
.expectedLedgerIndex = kRANGE_MAX,
148+
.closeTimeIso = "2024-06-25T12:23:50Z"},
149+
{.testName = "IsMidLedger",
150+
.json = R"({"date": "2024-06-25T12:23:30Z"})",
151+
.expectedLedgerIndex = 20,
152+
.closeTimeIso = "2024-06-25T12:23:30Z"},
153+
{.testName = "BetweenLedgers",
154+
.json = R"({"date": "2024-06-25T12:23:29Z"})",
155+
.expectedLedgerIndex = 19,
156+
.closeTimeIso = "2024-06-25T12:23:28Z"}
139157
};
140158
}
141159
};

‎tests/unit/rpc/handlers/LedgerTests.cpp‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -766,10 +766,11 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary)
766766

767767
EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1);
768768

769-
los.push_back(LedgerObject{.key=ripple::uint256{kINDEX2}, .blob=Blob{}}); // NOLINT(modernize-use-emplace)
769+
los.push_back(LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace)
770770
los.push_back(LedgerObject{
771-
.key=ripple::uint256{kINDEX1},
772-
.blob=createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData()
771+
.key = ripple::uint256{kINDEX1},
772+
.blob =
773+
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData()
773774
});
774775

775776
ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los));
@@ -809,10 +810,11 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary)
809810

810811
EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1);
811812

812-
los.push_back(LedgerObject{.key=ripple::uint256{kINDEX2}, .blob=Blob{}}); // NOLINT(modernize-use-emplace)
813+
los.push_back(LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace)
813814
los.push_back(LedgerObject{
814-
.key=ripple::uint256{kINDEX1},
815-
.blob=createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData()
815+
.key = ripple::uint256{kINDEX1},
816+
.blob =
817+
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData()
816818
});
817819

818820
ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los));

‎tests/unit/rpc/handlers/MPTHoldersTests.cpp‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex)
264264
));
265265
runSpawn([&, this](boost::asio::yield_context yield) {
266266
auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
267-
auto const output = handler.process(input, Context{.yield=std::ref(yield)});
267+
auto const output = handler.process(input, Context{.yield = std::ref(yield)});
268268
ASSERT_FALSE(output);
269269
auto const err = rpc::makeError(output.result.error());
270270
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -285,7 +285,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex)
285285
));
286286
runSpawn([&, this](boost::asio::yield_context yield) {
287287
auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
288-
auto const output = handler.process(input, Context{.yield=std::ref(yield)});
288+
auto const output = handler.process(input, Context{.yield = std::ref(yield)});
289289
ASSERT_FALSE(output);
290290
auto const err = rpc::makeError(output.result.error());
291291
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -311,7 +311,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2)
311311
));
312312
runSpawn([&, this](boost::asio::yield_context yield) {
313313
auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
314-
auto const output = handler.process(input, Context{.yield=std::ref(yield)});
314+
auto const output = handler.process(input, Context{.yield = std::ref(yield)});
315315
ASSERT_FALSE(output);
316316
auto const err = rpc::makeError(output.result.error());
317317
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -334,7 +334,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2)
334334
));
335335
runSpawn([&, this](boost::asio::yield_context yield) {
336336
auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
337-
auto const output = handler.process(input, Context{.yield=std::ref(yield)});
337+
auto const output = handler.process(input, Context{.yield = std::ref(yield)});
338338
ASSERT_FALSE(output);
339339
auto const err = rpc::makeError(output.result.error());
340340
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -361,7 +361,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound)
361361
));
362362
runSpawn([&, this](boost::asio::yield_context yield) {
363363
auto handler = AnyHandler{MPTHoldersHandler{this->backend_}};
364-
auto const output = handler.process(input, Context{.yield=yield});
364+
auto const output = handler.process(input, Context{.yield = yield});
365365
ASSERT_FALSE(output);
366366
auto const err = rpc::makeError(output.result.error());
367367
EXPECT_EQ(err.at("error").as_string(), "objectNotFound");
@@ -391,7 +391,7 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters)
391391

392392
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
393393
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
394-
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}}));
394+
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
395395
EXPECT_CALL(
396396
*backend_,
397397
fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_)
@@ -439,7 +439,7 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts)
439439

440440
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID), 0);
441441
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
442-
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}}));
442+
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
443443
EXPECT_CALL(
444444
*backend_,
445445
fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_)
@@ -485,7 +485,7 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex)
485485

486486
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
487487
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
488-
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}}));
488+
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
489489
EXPECT_CALL(
490490
*backend_,
491491
fetchMPTHolders(
@@ -534,7 +534,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter)
534534
auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID));
535535
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
536536
auto const marker = getAccountIdWithString(kHOLDE_R1_ACCOUNT);
537-
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor=marker}));
537+
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = marker}));
538538
EXPECT_CALL(
539539
*backend_, fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_)
540540
)
@@ -580,7 +580,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs)
580580
auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
581581
auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID));
582582
std::vector<Blob> const mpts = {mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData()};
583-
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}}));
583+
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
584584
EXPECT_CALL(
585585
*backend_,
586586
fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_)
@@ -622,7 +622,7 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx)
622622

623623
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
624624
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
625-
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}}));
625+
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
626626
EXPECT_CALL(
627627
*backend_,
628628
fetchMPTHolders(

0 commit comments

Comments
 (0)