slot_subfield test

src/test/app/SetHook_test.cpp

@@ -4699,6 +4699,102 @@ public:
     void
     test_slot_subfield()
     {
+        testcase("Test slot_subfield");
+        using namespace jtx;
+
+        Env env{*this, supported_amendments()};
+
+        auto const bob = Account{"bob"};
+        auto const alice = Account{"alice"};
+        env.fund(XRP(10000), alice);
+        env.fund(XRP(10000), bob);
+
+        TestHook hook = wasm[R"[test.hook](
+            #include <stdint.h>
+            extern int32_t _g       (uint32_t id, uint32_t maxiter);
+            #define GUARD(maxiter) _g((1ULL << 31U) + __LINE__, (maxiter)+1)
+            extern int64_t accept   (uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+            extern int64_t rollback (uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+            extern int64_t slot_size(uint32_t);
+            extern int64_t slot (uint32_t write_ptr, uint32_t write_len, uint32_t slot_no);
+            extern int64_t otxn_slot(uint32_t);
+            extern int64_t slot_subfield(uint32_t, uint32_t, uint32_t);
+            extern int64_t slot_count(uint32_t);
+            extern int64_t slot_set(uint32_t, uint32_t, uint32_t);
+            #define sfMemos ((15U << 16U) + 9U)
+            #define sfMemoData ((7U << 16U) + 13U)
+            #define sfLastLedgerSequence ((2U << 16U) + 0x1BU)
+            #define sfHashes ((19U << 16U) + 2U)
+            #define NOT_AN_OBJECT -23
+            #define DOESNT_EXIST -5
+            #define NO_FREE_SLOTS -6
+            #define INVALID_FIELD -17
+            #define ASSERT(x)\
+                if (!(x))\
+                    rollback((uint32_t)#x, sizeof(#x), __LINE__);
+           
+            #define SBUF(x) (uint32_t)(x), sizeof(x)
+            // skip keylet
+            uint8_t kl_sk[] =                                                                                          
+            {                                                                                                          
+                0x00U, 0x68U,                                                                                          
+                0xB4U,0x97U,0x9AU,0x36U,0xCDU,0xC7U,0xF3U,0xD3U,0xD5U,0xC3U,                                           
+                0x1AU,0x4EU,0xAEU,0x2AU,0xC7U,0xD7U,0x20U,0x9DU,0xDAU,0x87U,                                           
+                0x75U,0x88U,0xB9U,0xAFU,0xC6U,0x67U,0x99U,0x69U,0x2AU,0xB0U,                                           
+                0xD6U,0x6BU                                                                                            
+            };  
+
+            int64_t hook(uint32_t reserved )
+            {
+                _g(1,1);
+               
+                ASSERT(slot_subfield(1, 1, 1) == DOESNT_EXIST);
+ 
+                ASSERT(slot_set(SBUF(kl_sk), 1) == 1);
+
+                ASSERT(slot_size(1) > 0);
+   
+                ASSERT(slot_subfield(1, sfLastLedgerSequence, 0) == 2);
+
+                ASSERT(slot_size(2) >0);
+                ASSERT(slot_size(1) > slot_size(2));
+
+                ASSERT(slot_subfield(1, sfHashes, 0) == 3);
+
+                ASSERT(slot_size(3) > 0);
+                ASSERT(slot_size(1) > slot_size(3));
+                
+                // request a field that is invalid
+                ASSERT(slot_subfield(1, 0xFFFFFFFFUL, 0) == INVALID_FIELD);
+
+                // request a field that isn't present
+                ASSERT(slot_subfield(1, sfMemos, 0) == DOESNT_EXIST);
+
+                // request a subfield from something that's not an object
+                ASSERT(slot_subfield(3, sfMemoData, 0) == NOT_AN_OBJECT);
+
+                // overwrite an existing slot
+                ASSERT(slot_subfield(1, sfLastLedgerSequence, 3) == 3);
+                ASSERT(slot_size(2) == slot_size(3));
+
+                // test slot exhaustion
+                for (int i = 0; GUARD(255), i < 252; ++i)
+                    ASSERT(slot_subfield(1, sfLastLedgerSequence, 0) > 0);
+                    
+                ASSERT(slot_subfield(1, sfLastLedgerSequence, 0) == NO_FREE_SLOTS);
+
+                accept(0,0,0);
+            }
+        )[test.hook]"];
+
+        // install the hook on alice
+        env(ripple::test::jtx::hook(alice, {{hso(hook, overrideFlag)}}, 0),
+            M("set slot_subfield"),
+            HSFEE);
+        env.close();
+
+        // invoke the hook
+        env(pay(bob, alice, XRP(1)), M("test slot_subfield"), fee(XRP(1)));
     }
 
     void
@@ -7178,7 +7274,7 @@ public:
         test_slot_float();
         test_slot_set();       //
         test_slot_size();      //
-        test_slot_subarray();
+        test_slot_subarray();  //
         test_slot_subfield();
         test_slot_type();