Improve unittests

src/ripple/beast/unit_test/match.hpp

@@ -94,6 +94,14 @@ selector::operator()(suite_info const& s)
             return ! s.manual();
         }
 
+        // check start of name
+        if (s.name().starts_with(pat_) || s.full_name().starts_with(pat_))
+        {
+            // Don't change the mode so that the partial pattern can match
+            // more than once
+            return !s.manual();
+        }
+
         return false;
 
     case suite:

src/test/app/NFTokenBurn_test.cpp

@@ -26,7 +26,7 @@
 
 namespace ripple {
 
-class NFTokenBurn_test : public beast::unit_test::suite
+class NFTokenBurn0_test : public beast::unit_test::suite
 {
     // Helper function that returns the owner count of an account root.
     static std::uint32_t
@@ -786,22 +786,69 @@ class NFTokenBurn_test : public beast::unit_test::suite
         testBurnTooManyOffers(features);
     }
 
+protected:
+    void
+    run(std::uint32_t instance, bool last = false)
+    {
+        using namespace test::jtx;
+        static FeatureBitset const all{
+            supported_amendments() - featureXahauGenesis};
+        static FeatureBitset const fixNFTDir{fixNFTokenDirV1};
+
+        static std::array<FeatureBitset, 4> const feats{
+            all - fixNonFungibleTokensV1_2 - fixNFTDir - fixNFTokenRemint,
+            all - fixNonFungibleTokensV1_2 - fixNFTokenRemint,
+            all - fixNFTokenRemint,
+            all};
+
+        if (BEAST_EXPECT(instance < feats.size()))
+        {
+            testWithFeats(feats[instance]);
+        }
+        BEAST_EXPECT(!last || instance == feats.size() - 1);
+    }
+
 public:
     void
     run() override
     {
-        using namespace test::jtx;
-        FeatureBitset const all{supported_amendments() - featureXahauGenesis};
-        FeatureBitset const fixNFTDir{fixNFTokenDirV1};
-
-        testWithFeats(
-            all - fixNonFungibleTokensV1_2 - fixNFTDir - fixNFTokenRemint);
-        testWithFeats(all - fixNonFungibleTokensV1_2 - fixNFTokenRemint);
-        testWithFeats(all - fixNFTokenRemint);
-        testWithFeats(all);
+        run(0);
+    }
+};
+
+class NFTokenBurn1_test : public NFTokenBurn0_test
+{
+public:
+    void
+    run() override
+    {
+        NFTokenBurn0_test::run(1);
+    }
+};
+
+class NFTokenBurn2_test : public NFTokenBurn0_test
+{
+public:
+    void
+    run() override
+    {
+        NFTokenBurn0_test::run(2);
+    }
+};
+
+class NFTokenBurn3_test : public NFTokenBurn0_test
+{
+public:
+    void
+    run() override
+    {
+        NFTokenBurn0_test::run(3, true);
     }
 };
 
-BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBurn, tx, ripple, 3);
+BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBurn0, tx, ripple, 3);
+BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBurn1, tx, ripple, 3);
+BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBurn2, tx, ripple, 3);
+BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBurn3, tx, ripple, 3);
 
 }  // namespace ripple

src/test/app/NFToken_test.cpp

@@ -27,7 +27,7 @@
 
 namespace ripple {
 
-class NFToken_test : public beast::unit_test::suite
+class NFToken0_test : public beast::unit_test::suite
 {
     FeatureBitset const disallowIncoming{featureDisallowIncoming};
 
@@ -6843,23 +6843,74 @@ class NFToken_test : public beast::unit_test::suite
 
 public:
     void
-    run() override
+    run(std::uint32_t instance, bool last = false)
     {
         using namespace test::jtx;
-        FeatureBitset const all{supported_amendments()};
-        FeatureBitset const fixNFTDir{fixNFTokenDirV1};
+        static FeatureBitset const all{supported_amendments()};
+        static FeatureBitset const fixNFTDir{fixNFTokenDirV1};
 
-        testWithFeats(
-            all - fixNFTDir - fixNonFungibleTokensV1_2 - fixNFTokenRemint);
-        testWithFeats(
+        static std::array<FeatureBitset, 5> const feats{
+            all - fixNFTDir - fixNonFungibleTokensV1_2 - fixNFTokenRemint,
             all - disallowIncoming - fixNonFungibleTokensV1_2 -
-            fixNFTokenRemint);
-        testWithFeats(all - fixNonFungibleTokensV1_2 - fixNFTokenRemint);
-        testWithFeats(all - fixNFTokenRemint);
-        testWithFeats(all);
+                fixNFTokenRemint,
+            all - fixNonFungibleTokensV1_2 - fixNFTokenRemint,
+            all - fixNFTokenRemint,
+            all};
+
+        if (BEAST_EXPECT(instance < feats.size()))
+        {
+            testWithFeats(feats[instance]);
+        }
+        BEAST_EXPECT(!last || instance == feats.size() - 1);
+    }
+
+    void
+    run() override
+    {
+        run(0);
+    }
+};
+
+class NFToken1_test : public NFToken0_test
+{
+    void
+    run() override
+    {
+        NFToken0_test::run(1);
+    }
+};
+
+class NFToken2_test : public NFToken0_test
+{
+    void
+    run() override
+    {
+        NFToken0_test::run(2);
+    }
+};
+
+class NFToken3_test : public NFToken0_test
+{
+    void
+    run() override
+    {
+        NFToken0_test::run(3);
+    }
+};
+
+class NFToken4_test : public NFToken0_test
+{
+    void
+    run() override
+    {
+        NFToken0_test::run(4, true);
     }
 };
 
-BEAST_DEFINE_TESTSUITE_PRIO(NFToken, tx, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(NFToken0, tx, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(NFToken1, tx, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(NFToken2, tx, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(NFToken3, tx, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(NFToken4, tx, ripple, 2);
 
 }  // namespace ripple

src/test/app/Offer_test.cpp

@@ -27,7 +27,7 @@
 namespace ripple {
 namespace test {
 
-class Offer_test : public beast::unit_test::suite
+class Offer0_test : public beast::unit_test::suite
 {
     XRPAmount
     reserve(jtx::Env& env, std::uint32_t count)
@@ -5394,26 +5394,77 @@ class Offer_test : public beast::unit_test::suite
     }
 
     void
-    run() override
+    run(std::uint32_t instance, bool last = false)
     {
         using namespace jtx;
-        FeatureBitset const all{supported_amendments() - featureXahauGenesis};
-        FeatureBitset const flowCross{featureFlowCross};
-        FeatureBitset const takerDryOffer{fixTakerDryOfferRemoval};
-        FeatureBitset const rmSmallIncreasedQOffers{fixRmSmallIncreasedQOffers};
-        FeatureBitset const immediateOfferKilled{featureImmediateOfferKilled};
+        static FeatureBitset const all{
+            supported_amendments() - featureXahauGenesis};
+        static FeatureBitset const flowCross{featureFlowCross};
+        static FeatureBitset const takerDryOffer{fixTakerDryOfferRemoval};
+        static FeatureBitset const rmSmallIncreasedQOffers{
+            fixRmSmallIncreasedQOffers};
+        static FeatureBitset const immediateOfferKilled{
+            featureImmediateOfferKilled};
+
+        static std::array<FeatureBitset, 5> const feats{
+            all - takerDryOffer - immediateOfferKilled,
+            all - flowCross - takerDryOffer - immediateOfferKilled,
+            all - flowCross - immediateOfferKilled,
+            all - rmSmallIncreasedQOffers - immediateOfferKilled,
+            all};
+
+        if (BEAST_EXPECT(instance < feats.size()))
+        {
+            testAll(feats[instance]);
+        }
+        BEAST_EXPECT(!last || instance == feats.size() - 1);
+    }
 
-        testAll(all - takerDryOffer - immediateOfferKilled);
-        testAll(all - flowCross - takerDryOffer - immediateOfferKilled);
-        testAll(all - flowCross - immediateOfferKilled);
-        testAll(all - rmSmallIncreasedQOffers - immediateOfferKilled);
-        testAll(all);
+    void
+    run() override
+    {
+        run(0);
         testFalseAssert();
-        testOfferID(all);
     }
 };
 
-class Offer_manual_test : public Offer_test
+class Offer1_test : public Offer0_test
+{
+    void
+    run() override
+    {
+        Offer0_test::run(1);
+    }
+};
+
+class Offer2_test : public Offer0_test
+{
+    void
+    run() override
+    {
+        Offer0_test::run(2);
+    }
+};
+
+class Offer3_test : public Offer0_test
+{
+    void
+    run() override
+    {
+        Offer0_test::run(3);
+    }
+};
+
+class Offer4_test : public Offer0_test
+{
+    void
+    run() override
+    {
+        Offer0_test::run(4, true);
+    }
+};
+
+class Offer_manual_test : public Offer0_test
 {
     void
     run() override
@@ -5433,7 +5484,11 @@ class Offer_manual_test : public Offer_test
     }
 };
 
-BEAST_DEFINE_TESTSUITE_PRIO(Offer, tx, ripple, 4);
+BEAST_DEFINE_TESTSUITE_PRIO(Offer0, tx, ripple, 4);
+BEAST_DEFINE_TESTSUITE_PRIO(Offer1, tx, ripple, 4);
+BEAST_DEFINE_TESTSUITE_PRIO(Offer2, tx, ripple, 4);
+BEAST_DEFINE_TESTSUITE_PRIO(Offer3, tx, ripple, 4);
+BEAST_DEFINE_TESTSUITE_PRIO(Offer4, tx, ripple, 4);
 BEAST_DEFINE_TESTSUITE_MANUAL_PRIO(Offer_manual, tx, ripple, 20);
 
 }  // namespace test

src/test/app/SetHookTSH_test.cpp

@@ -39,7 +39,7 @@ namespace test {
             return;          \
     }
 
-struct SetHookTSH_test : public beast::unit_test::suite
+struct SetHookTSH0_test : public beast::unit_test::suite
 {
 private:
     const uint64_t tshSTRONG = 0;
@@ -5537,18 +5537,48 @@ struct SetHookTSH_test : public beast::unit_test::suite
 
 public:
     void
-    run() override
+    run(std::uint32_t instance, bool last = false)
     {
         using namespace test::jtx;
-        auto const sa = supported_amendments();
-        testTSH(sa - fixXahauV1 - fixXahauV2);
-        testTSH(sa - fixXahauV2);
-        testTSH(sa);
-        testEmittedTxn(sa);
+        static FeatureBitset const all{supported_amendments()};
+
+        static std::array<FeatureBitset, 3> const feats{
+            all,
+            all - fixXahauV1 - fixXahauV2,
+            all - fixXahauV2,
+        };
+
+        if (BEAST_EXPECT(instance < feats.size()))
+        {
+            testTSH(feats[instance]);
+        }
+        if (instance == 0)
+        {
+            testEmittedTxn(feats[instance]);
+        }
+        BEAST_EXPECT(!last || instance == feats.size() - 1);
+    }
+    void
+    run() override
+    {
+        run(0);
     }
 };
-
-BEAST_DEFINE_TESTSUITE(SetHookTSH, app, ripple);
+#define SETHOOKTSH_TEST(i, last)                         \
+    class SetHookTSH##i##_test : public SetHookTSH0_test \
+    {                                                    \
+        void                                             \
+        run() override                                   \
+        {                                                \
+            SetHookTSH0_test::run(i, last);              \
+        }                                                \
+    };
+SETHOOKTSH_TEST(1, false)
+SETHOOKTSH_TEST(2, false)
+
+BEAST_DEFINE_TESTSUITE_PRIO(SetHookTSH0, app, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(SetHookTSH1, app, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(SetHookTSH2, app, ripple, 2);
 
 }  // namespace test
-}  // namespace ripple
+}  // namespace ripple