add tests

src/ripple/app/tx/impl/SetRemarks.cpp

@@ -202,7 +202,7 @@ getRemarksIssuer(T const& sleO)
             }
             else
             {
-                issuer = (highReserve ? highAcc : lowAcc);
+                issuer = (highReserve ? lowAcc : highAcc);
                 break;
             }
         }

src/test/app/SetRemarks_test.cpp

@@ -22,14 +22,13 @@
 #include <ripple/protocol/Indexes.h>
 #include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/jss.h>
-#include <test/jtx.h>
 #include <sstream>
+#include <test/jtx.h>
 
 namespace ripple {
 namespace test {
 struct SetRemarks_test : public beast::unit_test::suite
 {
-
     // debugRemarks(env, keylet::account(alice).key);
     void
     debugRemarks(jtx::Env& env, uint256 const& id)
@@ -37,7 +36,7 @@ struct SetRemarks_test : public beast::unit_test::suite
         Json::Value params;
         params[jss::index] = strHex(id);
         auto const info = env.rpc("json", "ledger_entry", to_string(params));
-        std::cout << "Remarks: " << info[jss::result][jss::node][sfRemarks.jsonName] << "\n";
+        std::cout << "INFO: " << info << "\n";
     }
 
     void
@@ -48,9 +47,10 @@ struct SetRemarks_test : public beast::unit_test::suite
     {
         using namespace jtx;
         auto const slep = view.read(keylet::unchecked(id));
-        if (slep->isFieldPresent(sfRemarks))
+        if (slep && slep->isFieldPresent(sfRemarks))
         {
             auto const& remarksObj = slep->getFieldArray(sfRemarks);
+            BEAST_EXPECT(remarksObj.size() == marks.size());
             for (int i = 0; i < marks.size(); ++i)
             {
                 remarks::remark const expectedMark = marks[i];
@@ -67,7 +67,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 std::optional<Blob> val;
                 if (remark.isFieldPresent(sfRemarkValue))
                     val = remark.getFieldVL(sfRemarkValue);
-                    // BEAST_EXPECT(expectedMark.value == val);
+                // BEAST_EXPECT(expectedMark.value == val);
             }
         }
     }
@@ -97,6 +97,7 @@ struct SetRemarks_test : public beast::unit_test::suite
             auto const txResult =
                 withRemarks ? ter(tesSUCCESS) : ter(temDISABLED);
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 txResult);
             env.close();
         }
@@ -130,6 +131,7 @@ struct SetRemarks_test : public beast::unit_test::suite
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
                 txflags(tfClose),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -142,6 +144,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 marks.push_back({"CAFE", "DEADBEEF", 0});
             }
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -154,6 +157,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 marks.push_back({"CAFE", "DEADBEEF", 0});
             }
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -175,7 +179,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 ja[i][sfGenesisMint.jsonName][jss::Destination] = bob.human();
             }
             jv[sfRemarks.jsonName] = ja;
-            env(jv, ter(temMALFORMED));
+            env(jv, fee(XRP(1)), ter(temMALFORMED));
             env.close();
         }
         // temMALFORMED: SetRemarks: duplicate RemarkName entry.
@@ -185,6 +189,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {"CAFE", "DEADBEEF", 0},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -195,6 +200,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {"", "DEADBEEF", 0},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -206,6 +212,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {name, "DEADBEEF", 0},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -215,6 +222,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {"CAFE", "DEADBEEF", 2},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -225,6 +233,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {"CAFE", std::nullopt, 1},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -235,6 +244,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {"CAFE", "", 0},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -246,6 +256,7 @@ struct SetRemarks_test : public beast::unit_test::suite
                 {"CAFE", value, 0},
             };
             env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
                 ter(temMALFORMED));
             env.close();
         }
@@ -280,27 +291,35 @@ struct SetRemarks_test : public beast::unit_test::suite
         {
             auto const carol = Account("carol");
             env.memoize(carol);
-            auto tx = remarks::setRemarks(carol, keylet::account(carol).key, marks);
+            auto tx =
+                remarks::setRemarks(carol, keylet::account(carol).key, marks);
             tx[jss::Sequence] = 0;
-            env(tx, carol, ter(terNO_ACCOUNT));
+            env(tx, carol, fee(XRP(1)), ter(terNO_ACCOUNT));
             env.close();
         }
 
         // tecNO_TARGET - object doesnt exist
         {
-            env(remarks::setRemarks(alice, keylet::account(carol).key, marks), ter(tecNO_TARGET));
+            env(remarks::setRemarks(alice, keylet::account(carol).key, marks),
+                fee(XRP(1)),
+                ter(tecNO_TARGET));
             env.close();
         }
 
         // tecNO_PERMISSION: !issuer
         {
             env(deposit::auth(bob, alice));
-            env(remarks::setRemarks(alice, keylet::depositPreauth(bob, alice).key, marks), ter(tecNO_PERMISSION));
+            env(remarks::setRemarks(
+                    alice, keylet::depositPreauth(bob, alice).key, marks),
+                fee(XRP(1)),
+                ter(tecNO_PERMISSION));
             env.close();
         }
         // tecNO_PERMISSION: issuer != _account
         {
-            env(remarks::setRemarks(alice, keylet::account(bob).key, marks), ter(tecNO_PERMISSION));
+            env(remarks::setRemarks(alice, keylet::account(bob).key, marks),
+                fee(XRP(1)),
+                ter(tecNO_PERMISSION));
             env.close();
         }
         // tecIMMUTABLE: SetRemarks: attempt to mutate an immutable remark.
@@ -309,19 +328,24 @@ struct SetRemarks_test : public beast::unit_test::suite
             std::vector<remarks::remark> immutableMarks = {
                 {"CAFF", "DEAD", tfImmutable},
             };
-            env(remarks::setRemarks(alice, keylet::account(alice).key, immutableMarks), ter(tesSUCCESS));
+            env(remarks::setRemarks(
+                    alice, keylet::account(alice).key, immutableMarks),
+                fee(XRP(1)),
+                ter(tesSUCCESS));
             env.close();
 
             // alice cannot update immutable remark
             std::vector<remarks::remark> badMarks = {
                 {"CAFF", "DEADBEEF", 0},
             };
-            env(remarks::setRemarks(alice, keylet::account(alice).key, badMarks), ter(tecIMMUTABLE));
+            env(remarks::setRemarks(
+                    alice, keylet::account(alice).key, badMarks),
+                fee(XRP(1)),
+                ter(tecIMMUTABLE));
             env.close();
         }
         // tecCLAIM: SetRemarks: insane remarks accounting.
         {
-
         }
         // tecTOO_MANY_REMARKS: SetRemarks: an object may have at most 32
         // remarks.
@@ -335,9 +359,13 @@ struct SetRemarks_test : public beast::unit_test::suite
                 _marks.push_back({ss.str(), "DEADBEEF", 0});
                 hexValue++;
             }
-            env(remarks::setRemarks(alice, keylet::account(alice).key, _marks), ter(tesSUCCESS));
+            env(remarks::setRemarks(alice, keylet::account(alice).key, _marks),
+                fee(XRP(1)),
+                ter(tesSUCCESS));
             env.close();
-            env(remarks::setRemarks(alice, keylet::account(alice).key, marks), ter(tecTOO_MANY_REMARKS));
+            env(remarks::setRemarks(alice, keylet::account(alice).key, marks),
+                fee(XRP(1)),
+                ter(tecTOO_MANY_REMARKS));
             env.close();
         }
     }
@@ -360,12 +388,47 @@ struct SetRemarks_test : public beast::unit_test::suite
             auto const bob = Account("bob");
             env.fund(XRP(1000), alice, bob);
             env.close();
-
         }
         // tecNO_PERMISSION
         // tecTOO_MANY_REMARKS
     }
 
+    void
+    testDelete(FeatureBitset features)
+    {
+        testcase("delete");
+        using namespace jtx;
+
+        // setup env
+        Env env{*this, features};
+        auto const alice = Account("alice");
+        auto const bob = Account("bob");
+        env.fund(XRP(1000), alice, bob);
+        env.close();
+
+        auto const id = keylet::account(alice).key;
+
+        // Set Remarks
+        {
+            std::vector<remarks::remark> marks = {
+                {"CAFE", "DEADBEEF", 0},
+            };
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+
+        // Delete Remarks
+        {
+            std::vector<remarks::remark> marks = {
+                {"CAFE", std::nullopt, 0},
+            };
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, {});
+        }
+    }
+
     void
     testLedgerObjects(FeatureBitset features)
     {
@@ -374,45 +437,155 @@ struct SetRemarks_test : public beast::unit_test::suite
 
         // setup env
         Env env{*this, features};
+        // Env env{*this, envconfig(), features, nullptr,
+        //     beast::severities::kTrace
+        // };
         auto const alice = Account("alice");
         auto const bob = Account("bob");
-        env.fund(XRP(1000), alice, bob);
+        auto const gw = Account("gw");
+        auto const USD = gw["USD"];
+        env.fund(XRP(10000), alice, bob, gw);
+        env.close();
+        env.trust(USD(10000), alice);
+        env.trust(USD(10000), bob);
+        env.close();
+        env(pay(gw, alice, USD(1000)));
+        env(pay(gw, bob, USD(1000)));
         env.close();
 
         std::vector<remarks::remark> marks = {
             {"CAFE", "DEADBEEF", 0},
         };
 
-        // getRemarksIssuer: ltACCOUNT_ROOT
+        // ltACCOUNT_ROOT
         {
             auto const id = keylet::account(alice).key;
-            env(remarks::setRemarks(alice, id, marks));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltOFFER
+        {
+            auto const id = keylet::offer(alice, env.seq(alice)).key;
+            env(offer(alice, XRP(10), USD(10)), fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltESCROW
+        {
+            using namespace std::literals::chrono_literals;
+            auto const id = keylet::escrow(alice, env.seq(alice)).key;
+            env(escrow::create(alice, bob, XRP(10)),
+                escrow::finish_time(env.now() + 1s),
+                fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltTICKET
+        {
+            auto const id = keylet::ticket(alice, env.seq(alice) + 1).key;
+            env(ticket::create(alice, 10), fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltPAYCHAN
+        {
+            using namespace std::literals::chrono_literals;
+            auto const id = keylet::payChan(alice, bob, env.seq(alice)).key;
+            auto const pk = alice.pk();
+            auto const settleDelay = 100s;
+            env(paychan::create(alice, bob, XRP(10), settleDelay, pk),
+                fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltCHECK
+        {
+            auto const id = keylet::check(alice, env.seq(alice)).key;
+            env(check::create(alice, bob, XRP(10)), fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltDEPOSIT_PREAUTH
+        {
+            env(fset(bob, asfDepositAuth));
+            auto const id = keylet::depositPreauth(alice, bob).key;
+            env(deposit::auth(alice, bob), fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltURI_TOKEN
+        {
+            std::string const uri(256, 'A');
+            auto const id =
+                keylet::uritoken(alice, Blob(uri.begin(), uri.end())).key;
+            env(uritoken::mint(alice, uri), fee(XRP(1)));
+            env(remarks::setRemarks(alice, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltRIPPLE_STATE: bal < 0
+        {
+            auto const alice2 = Account("alice2");
+            env.fund(XRP(1000), alice2);
+            env.close();
+            env.trust(USD(10000), alice2);
+            auto const id = keylet::line(alice2, USD).key;
+            env(pay(gw, alice2, USD(1000)));
+            env(remarks::setRemarks(gw, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltRIPPLE_STATE: bal > 0
+        {
+            auto const carol0 = Account("carol0");
+            env.fund(XRP(1000), carol0);
+            env.close();
+            env.trust(USD(10000), carol0);
+            auto const id = keylet::line(carol0, USD).key;
+            env(pay(gw, carol0, USD(1000)));
+            env(remarks::setRemarks(gw, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltRIPPLE_STATE: highReserve
+        {
+            auto const dan1 = Account("dan1");
+            env.fund(XRP(1000), dan1);
+            env.close();
+            env.trust(USD(1000), dan1);
+            auto const id = keylet::line(dan1, USD).key;
+            env(remarks::setRemarks(gw, id, marks), fee(XRP(1)));
+            env.close();
+            validateRemarks(*env.current(), id, marks);
+        }
+        // ltRIPPLE_STATE: lowReserve
+        {
+            auto const bob0 = Account("bob0");
+            env.fund(XRP(1000), bob0);
+            env.close();
+            env.trust(USD(1000), bob0);
+            auto const id = keylet::line(bob0, USD).key;
+            env(remarks::setRemarks(gw, id, marks), fee(XRP(1)));
             env.close();
-            debugRemarks(env, id);
             validateRemarks(*env.current(), id, marks);
         }
-        // getRemarksIssuer: ltOFFER
-        // getRemarksIssuer: ltESCROW
-        // getRemarksIssuer: ltTICKET
-        // getRemarksIssuer: ltPAYCHAN
-        // getRemarksIssuer: ltCHECK
-        // getRemarksIssuer: ltDEPOSIT_PREAUTH
-        // getRemarksIssuer: ltNFTOKEN_OFFER
-        // getRemarksIssuer: ltURI_TOKEN
-        // getRemarksIssuer: ltRIPPLE_STATE: bal < 0
-        // getRemarksIssuer: ltRIPPLE_STATE: bal > 0
-        // getRemarksIssuer: ltRIPPLE_STATE: !high & !low
-        // getRemarksIssuer: ltRIPPLE_STATE: high & low
     }
 
     void
     testWithFeats(FeatureBitset features)
     {
-        // testEnabled(features);
+        testEnabled(features);
-        // testPreflightInvalid(features);
+        testPreflightInvalid(features);
-        // testPreclaimInvalid(features);
+        testPreclaimInvalid(features);
-        // testDoApplyInvalid(features);
+        testDoApplyInvalid(features);
-        // testDelete(features);
+        testDelete(features);
         testLedgerObjects(features);
     }