switch test_db tests to TraitsTest

Author: goodlyrottenapple

category/execution/ethereum/db/test/test_db.cpp

@@ -43,6 +43,7 @@
 #include <category/mpt/traverse.hpp>
 #include <category/mpt/traverse_util.hpp>
 #include <category/vm/evm/traits.hpp>
+#include <monad/test/traits_test.hpp>
 
 #include <ethash/keccak.hpp>
 #include <evmc/evmc.hpp>
@@ -108,24 +109,152 @@ namespace
         }
     };
 
-    struct InMemoryTrieDbFixture : public ::testing::Test
+    template <typename T, T rev>
+    struct TrieDbFixtureTraits : public ::testing::Test
+    {
+        vm::VM vm;
+
+        static constexpr auto get_trait()
+        {
+            if constexpr (std::same_as<T, monad_revision>) {
+                return monad::MonadTraits<rev>{};
+            }
+            else if constexpr (std::same_as<T, evmc_revision>) {
+                return monad::EvmTraits<rev>{};
+            }
+            else {
+                return std::monostate{};
+            }
+        }
+
+        using Trait = decltype(get_trait());
+
+        static consteval bool is_monad_revision() noexcept
+        {
+            return std::same_as<T, monad_revision>;
+        }
+
+        static consteval bool is_evmc_revision() noexcept
+        {
+            return std::same_as<T, evmc_revision>;
+        }
+
+        static constexpr std::string get_traits_name()
+        {
+            if constexpr (std::same_as<T, monad_revision>) {
+                return "/" + std::string(monad_revision_to_string(
+                                 monad::MonadTraits<rev>::monad_rev()));
+            }
+            else if constexpr (std::same_as<T, evmc_revision>) {
+                return "/" + std::string(evmc_revision_to_string(
+                                 monad::EvmTraits<rev>::evm_rev()));
+            }
+            else {
+                return "";
+            }
+        }
+    };
+
+    template <typename T, T rev>
+    struct InMemoryTrieDbFixtureTraits : public TrieDbFixtureTraits<T, rev>
     {
         static constexpr bool on_disk = false;
 
         InMemoryMachine machine;
         mpt::Db db{machine};
-        vm::VM vm;
+
+        static constexpr auto get_name()
+        {
+            return "InMemoryTrieDbFixture" +
+                   TrieDbFixtureTraits<T, rev>::get_traits_name();
+        }
     };
 
-    struct OnDiskTrieDbFixture : public ::testing::Test
+    template <monad_revision rev>
+    using MonadInMemoryTrieDbFixtureTraits =
+        InMemoryTrieDbFixtureTraits<monad_revision, rev>;
+
+    template <evmc_revision rev>
+    using EvmInMemoryTrieDbFixtureTraits =
+        InMemoryTrieDbFixtureTraits<evmc_revision, rev>;
+
+    template <typename T, T rev>
+    struct OnDiskTrieDbFixtureTraits : public TrieDbFixtureTraits<T, rev>
     {
         static constexpr bool on_disk = true;
 
         OnDiskMachine machine;
         mpt::Db db{machine, mpt::OnDiskDbConfig{}};
-        vm::VM vm;
+
+        static constexpr auto get_name()
+        {
+            return "OnDiskTrieDbFixture" +
+                   TrieDbFixtureTraits<T, rev>::get_traits_name();
+        }
+    };
+
+    template <monad_revision rev>
+    using MonadOnDiskTrieDbFixtureTraits =
+        OnDiskTrieDbFixtureTraits<monad_revision, rev>;
+
+    template <evmc_revision rev>
+    using EvmOnDiskTrieDbFixtureTraits =
+        OnDiskTrieDbFixtureTraits<evmc_revision, rev>;
+
+    // Helper to concatenate four ::testing::Types
+    template <typename... Ts>
+    struct concat_types;
+
+    template <
+        typename... Ts1, typename... Ts2, typename... Ts3, typename... Ts4>
+    struct concat_types<
+        ::testing::Types<Ts1...>, ::testing::Types<Ts2...>,
+        ::testing::Types<Ts3...>, ::testing::Types<Ts4...>>
+    {
+        using type = ::testing::Types<Ts1..., Ts2..., Ts3..., Ts4...>;
+    };
+
+    template <typename... Ts>
+    using concat_types_t = typename concat_types<Ts...>::type;
+
+    // Union of MonadRevisionTypes and EvmRevisionTypes for both InMemoryTrieDb
+    // and OnDiskTrieDb
+    using MonadEvmRevisionDBTypes = concat_types_t<
+        decltype(make_monad_revision_types<MonadInMemoryTrieDbFixtureTraits>()),
+        decltype(make_evm_revision_types<EvmInMemoryTrieDbFixtureTraits>()),
+        decltype(make_monad_revision_types<MonadOnDiskTrieDbFixtureTraits>()),
+        decltype(make_evm_revision_types<EvmOnDiskTrieDbFixtureTraits>())>;
+
+    struct RevisionTestNameGenerator
+    {
+        template <typename T>
+        static std::string GetName(int)
+        {
+            return T::get_name();
+        }
+    };
+
+    using InMemoryTrieDbFixture =
+        InMemoryTrieDbFixtureTraits<std::monostate, {}>;
+    using OnDiskTrieDbFixture = OnDiskTrieDbFixtureTraits<std::monostate, {}>;
+
+    template <typename TDB>
+    struct DBTest : public TDB
+    {
+    };
+
+    using DBTypes =
+        ::testing::Types<InMemoryTrieDbFixture, OnDiskTrieDbFixture>;
+    TYPED_TEST_SUITE(DBTest, DBTypes, RevisionTestNameGenerator);
+
+    template <typename TDB>
+    struct DBTraitsTest : public TDB
+    {
     };
 
+    TYPED_TEST_SUITE(
+        DBTraitsTest, MonadEvmRevisionDBTypes, RevisionTestNameGenerator);
+
     ///////////////////////////////////////////
     // DB Getters
     ///////////////////////////////////////////
@@ -212,14 +341,6 @@ namespace
     }
 }
 
-template <typename TDB>
-struct DBTest : public TDB
-{
-};
-
-using DBTypes = ::testing::Types<InMemoryTrieDbFixture, OnDiskTrieDbFixture>;
-TYPED_TEST_SUITE(DBTest, DBTypes);
-
 TEST(DBTest, read_only)
 {
     auto const name =
@@ -886,7 +1007,7 @@ TYPED_TEST(DBTest, commit_call_frames)
 
 // test referenced from :
 // https://github.com/ethereum/tests/blob/develop/BlockchainTests/GeneralStateTests/stQuadraticComplexityTest/Call50000.json
-TYPED_TEST(DBTest, call_frames_stress_test)
+TYPED_TEST(DBTraitsTest, call_frames_stress_test)
 {
     using namespace intx;
 
@@ -959,7 +1080,7 @@ TYPED_TEST(DBTest, call_frames_stress_test)
             std::make_unique<trace::StateTracer>(std::monostate{}));
     }
 
-    auto const receipts = execute_block<EvmTraits<EVMC_SHANGHAI>>(
+    auto const receipts = execute_block<typename TestFixture::Trait>(
         EthereumMainnet{},
         block.value(),
         senders,
@@ -993,11 +1114,23 @@ TYPED_TEST(DBTest, call_frames_stress_test)
     auto const actual_call_frames =
         read_call_frame(this->db, tdb.get_block_number(), 0);
 
-    EXPECT_EQ(actual_call_frames.size(), 35799);
+    if constexpr (TestFixture::is_monad_revision()) {
+        if constexpr (TestFixture::Trait::monad_rev() >= MONAD_FIVE) {
+            EXPECT_EQ(actual_call_frames.size(), 35781);
+        }
+        else {
+            EXPECT_EQ(actual_call_frames.size(), 35799);
+        }
+    }
+    else {
+        if constexpr (TestFixture::Trait::evm_rev() >= EVMC_BERLIN) {
+            EXPECT_EQ(actual_call_frames.size(), 35799);
+        }
+    }
 }
 
-// This test is based on the test `DBTest.call_frames_stress_test`
-TYPED_TEST(DBTest, assertion_exception)
+// This test is based on the test `DBTraitsTest.call_frames_stress_test`
+TYPED_TEST(DBTraitsTest, assertion_exception)
 {
     using namespace intx;
 
@@ -1024,7 +1157,7 @@ TYPED_TEST(DBTest, assertion_exception)
                       Account{
                           .balance = std::numeric_limits<uint256_t>::max(),
                           .code_hash = STRESS_TEST_CODE_HASH}}}}},
-        Code{},
+        Code{{STRESS_TEST_CODE_HASH, STRESS_TEST_ICODE}},
         BlockHeader{.number = 0});
 
     // clang-format off
@@ -1067,7 +1200,7 @@ TYPED_TEST(DBTest, assertion_exception)
 
     EXPECT_THROW(
         {
-            (void)execute_block<EvmTraits<EVMC_SHANGHAI>>(
+            (void)execute_block<typename TestFixture::Trait>(
                 EthereumMainnet{},
                 block.value(),
                 senders,
@@ -1084,7 +1217,7 @@ TYPED_TEST(DBTest, assertion_exception)
 
 // test referenced from :
 // https://github.com/ethereum/tests/blob/v10.0/BlockchainTests/GeneralStateTests/stRefundTest/refund50_1.json
-TYPED_TEST(DBTest, call_frames_refund)
+TYPED_TEST(DBTraitsTest, call_frames_refund)
 {
     TrieDb tdb{this->db};
 
@@ -1165,8 +1298,8 @@ TYPED_TEST(DBTest, call_frames_refund)
             std::make_unique<trace::StateTracer>(std::monostate{}));
     }
 
-    auto const receipts = execute_block<EvmTraits<EVMC_SHANGHAI>>(
-        ShanghaiEthereumMainnet{},
+    auto const receipts = execute_block<typename TestFixture::Trait>(
+        EthereumMainnet{},
         block.value(),
         senders,
         recovered_authorities,
@@ -1200,14 +1333,46 @@ TYPED_TEST(DBTest, call_frames_refund)
         read_call_frame(this->db, tdb.get_block_number(), 0);
 
     ASSERT_EQ(actual_call_frames.size(), 1);
+
+    uint64_t const gas_used = [] {
+        if constexpr (TestFixture::is_evmc_revision()) {
+            if constexpr (TestFixture::Trait::evm_rev() <= EVMC_BERLIN) {
+                // value from
+                // https://github.com/ethereum/legacytests/blob/1f581b8ccdc4c63acf5f2c5c1b155c690c32a8eb/src/LegacyTests/Constantinople/BlockchainTestsFiller/GeneralStateTests/stRefundTest/refund50_1_d0g0v0Filler.json
+                // pre.0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b.balance -
+                // expect[0].0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b.balance
+                return static_cast<uint64_t>(0x186a0 - 0x012cb9);
+            }
+            else {
+                // value from
+                // https://github.com/ethereum/execution-specs/blob/v2.18.0rc5.dev1/tests/eest/static/state_tests/stRefundTest/refund50_1Filler.json
+                // (expect[0].result.<eoa:sender:0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b>.balance
+                // -
+                // pre.<eoa:sender:0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b>.balance)
+                // / transaction.gasPrice
+                return static_cast<uint64_t>((10'000'000 - 9'631'760) / 10);
+            }
+        }
+        else {
+            if constexpr (TestFixture::Trait::monad_rev() > MONAD_ZERO) {
+                // full gas_limit is charged since >=MONAD_ONE
+                return 0x186a0;
+            }
+            else {
+                static_assert(TestFixture::Trait::evm_rev() > EVMC_BERLIN);
+                // same cost as >EVMC_BERLIN
+                return static_cast<uint64_t>((10'000'000 - 9'631'760) / 10);
+            }
+        }
+    }();
     CallFrame expected{
         .type = CallType::CALL,
         .flags = 0,
         .from = from,
         .to = ca,
         .value = 0,
         .gas = 0x186a0,
-        .gas_used = 0x8fd8,
+        .gas_used = gas_used,
         .status = EVMC_SUCCESS,
         .depth = 0,
         .logs = std::vector<CallFrame::Log>{},

test/unit/common/include/monad/test/traits_test.hpp

@@ -27,32 +27,47 @@
 
 namespace detail
 {
-    template <monad_revision rev>
-    using MonadRevisionConstant = std::integral_constant<monad_revision, rev>;
-
-    template <evmc_revision rev>
-    using EvmRevisionConstant = std::integral_constant<evmc_revision, rev>;
-
-    template <std::size_t... Is>
+    template <template <auto> class T, std::size_t... Is>
     constexpr auto make_monad_revision_types(std::index_sequence<Is...>)
     {
-        return ::testing::Types<
-            MonadRevisionConstant<static_cast<monad_revision>(Is)>...>{};
+        return ::testing::Types<T<static_cast<monad_revision>(Is)>...>{};
     }
 
-    template <std::size_t... Is>
+    template <template <auto> class T, std::size_t... Is>
     constexpr auto make_evm_revision_types(std::index_sequence<Is...>)
     {
-        return ::testing::Types<
-            EvmRevisionConstant<static_cast<evmc_revision>(Is)>...>{};
+        return ::testing::Types<T<static_cast<evmc_revision>(Is)>...>{};
     }
+}
 
-    using MonadRevisionTypes = decltype(make_monad_revision_types(
-        std::make_index_sequence<MONAD_COUNT>{}));
+template <template <auto> class T>
+constexpr auto make_monad_revision_types()
+{
+    return ::detail::make_monad_revision_types<T>(
+        std::make_index_sequence<MONAD_COUNT>{});
+}
 
+template <template <auto> class T>
+constexpr auto make_evm_revision_types()
+{
     // Skip over EVMC_REVISION which is EVMC_EXPERIMENTAL
-    using EvmRevisionTypes = decltype(make_evm_revision_types(
-        std::make_index_sequence<EVMC_MAX_REVISION>{}));
+    return ::detail::make_evm_revision_types<T>(
+        std::make_index_sequence<EVMC_MAX_REVISION>{});
+}
+
+namespace detail
+{
+    template <monad_revision rev>
+    using MonadRevisionConstant = std::integral_constant<monad_revision, rev>;
+
+    template <evmc_revision rev>
+    using EvmRevisionConstant = std::integral_constant<evmc_revision, rev>;
+
+    using MonadRevisionTypes =
+        decltype(::make_monad_revision_types<MonadRevisionConstant>());
+
+    using EvmRevisionTypes =
+        decltype(::make_evm_revision_types<EvmRevisionConstant>());
 
     // Helper to concatenate two ::testing::Types
     template <typename... Ts>