Add EEST make directive and fix test run

Author: somnergy

.editorconfig

@@ -0,0 +1,59 @@
+[*]
+cpp_indent_braces=false
+cpp_indent_multi_line_relative_to=innermost_parenthesis
+cpp_indent_within_parentheses=indent
+cpp_indent_preserve_within_parentheses=false
+cpp_indent_case_labels=false
+cpp_indent_case_contents=true
+cpp_indent_case_contents_when_block=false
+cpp_indent_lambda_braces_when_parameter=true
+cpp_indent_goto_labels=one_left
+cpp_indent_preprocessor=leftmost_column
+cpp_indent_access_specifiers=false
+cpp_indent_namespace_contents=true
+cpp_indent_preserve_comments=false
+cpp_new_line_before_open_brace_namespace=ignore
+cpp_new_line_before_open_brace_type=ignore
+cpp_new_line_before_open_brace_function=ignore
+cpp_new_line_before_open_brace_block=ignore
+cpp_new_line_before_open_brace_lambda=ignore
+cpp_new_line_scope_braces_on_separate_lines=false
+cpp_new_line_close_brace_same_line_empty_type=false
+cpp_new_line_close_brace_same_line_empty_function=false
+cpp_new_line_before_catch=true
+cpp_new_line_before_else=true
+cpp_new_line_before_while_in_do_while=false
+cpp_space_before_function_open_parenthesis=remove
+cpp_space_within_parameter_list_parentheses=false
+cpp_space_between_empty_parameter_list_parentheses=false
+cpp_space_after_keywords_in_control_flow_statements=true
+cpp_space_within_control_flow_statement_parentheses=false
+cpp_space_before_lambda_open_parenthesis=false
+cpp_space_within_cast_parentheses=false
+cpp_space_after_cast_close_parenthesis=false
+cpp_space_within_expression_parentheses=false
+cpp_space_before_block_open_brace=true
+cpp_space_between_empty_braces=false
+cpp_space_before_initializer_list_open_brace=false
+cpp_space_within_initializer_list_braces=true
+cpp_space_preserve_in_initializer_list=true
+cpp_space_before_open_square_bracket=false
+cpp_space_within_square_brackets=false
+cpp_space_before_empty_square_brackets=false
+cpp_space_between_empty_square_brackets=false
+cpp_space_group_square_brackets=true
+cpp_space_within_lambda_brackets=false
+cpp_space_between_empty_lambda_brackets=false
+cpp_space_before_comma=false
+cpp_space_after_comma=true
+cpp_space_remove_around_member_operators=true
+cpp_space_before_inheritance_colon=true
+cpp_space_before_constructor_colon=true
+cpp_space_remove_before_semicolon=true
+cpp_space_after_semicolon=false
+cpp_space_remove_around_unary_operator=true
+cpp_space_around_binary_operator=insert
+cpp_space_around_assignment_operator=insert
+cpp_space_pointer_reference_alignment=left
+cpp_space_around_ternary_operator=insert
+cpp_wrap_preserve_blocks=one_liners

Makefile

@@ -3,3 +3,6 @@ eest_blockchain_tests eest-blockchain-tests:
 	cmake -B build/eest -G Ninja -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=ON -DTESTS_DIR=third_party/eest-fixtures/blockchain_tests
 	cmake --build build/eest
 	ctest --test-dir build/eest --parallel
+
+rv32im_eest_blockchain_tests: 
+	cd qemu_runner && make rv32im_eest_blockchain_tests

qemu_runner/CMakeLists.txt

@@ -124,4 +124,4 @@ if(TESTS_DIR)
         )
         set_tests_properties(${TEST_NAME} PROPERTIES SKIP_RETURN_CODE 2)
     endforeach()
-endif()
+endif()

zilk_core/dev/state_transition.cpp

@@ -4,8 +4,8 @@
 #include "state_transition.hpp"
 
 #include <bit>
+#include <format>
 #include <fstream>
-#include <iostream>
 #include <stdexcept>
 
 #include <magic_enum.hpp>
@@ -22,6 +22,7 @@
 #include <zilk_core/core/types/address.hpp>
 #include <zilk_core/core/types/evmc_bytes32.hpp>
 #include <zilk_core/dev/common/ecc_key_pair.hpp>
+#include <zilk_core/print.hpp>
 
 #include "expected_state.hpp"
 
@@ -47,7 +48,7 @@ StateTransition::StateTransition(const std::string& unified_rlp_str) noexcept {
 
     // Read from binary
     unified_rlp_ = ByteView{reinterpret_cast<const uint8_t*>(unified_rlp_str.data()), unified_rlp_str.size()};
-    std::cout << "in ctor unified_rlp_str RLP length: " << unified_rlp_str.size() << " unified_rlp_ RLP length: " << unified_rlp_.size() << "\n";
+    sys_println(std::format("in ctor unified_rlp_str RLP length: {} unified_rlp_ RLP length: {}", unified_rlp_str.size(), unified_rlp_.size()).c_str());
 }
 
 StateTransition::StateTransition(const bool terminate_on_error, const bool show_diagnostics) noexcept
@@ -335,7 +336,7 @@ namespace {
             if (invalid) {
                 return Status::kPassed;
             }
-            std::cout << "Failure to read hex" << std::endl;
+            sys_println("Failure to read hex");
             return Status::kFailed;
         }
 
@@ -361,7 +362,7 @@ namespace {
             if (invalid) {
                 return Status::kPassed;
             }
-            std::cout << "Failure to decode RLP" << std::endl;
+            sys_println("Failure to decode RLP");
             return Status::kFailed;
         }
 
@@ -370,13 +371,13 @@ namespace {
             if (invalid) {
                 return Status::kPassed;
             }
-            std::cout << "Validation error " << magic_enum::enum_name<ValidationResult>(err) << std::endl;
+            sys_println(std::format("Validation error {}", magic_enum::enum_name<ValidationResult>(err)).c_str());
             return Status::kFailed;
         }
 
         if (invalid) {
-            std::cout << "Invalid block executed successfully\n";
-            std::cout << "Expected: " << json_block["expectException"] << std::endl;
+            sys_println("Invalid block executed successfully");
+            sys_println(std::format("Expected: {}", json_block["expectException"].dump()).c_str());
             return Status::kFailed;
         }
 
@@ -385,13 +386,12 @@ namespace {
 
     bool post_check(const InMemoryState& state, const nlohmann::json& expected) {
         if (state.accounts().size() != expected.size()) {
-            std::cout << "Account number mismatch: " << state.accounts().size() << " != " << expected.size()
-                      << std::endl;
+            sys_println(std::format("Account number mismatch: {} != {}", state.accounts().size(), expected.size()).c_str());
 
             // Find and report accounts missing from the expected set.
             for (const auto& [addr, _] : state.accounts()) {
                 if (const auto addr_hex = "0x" + hex(addr); !expected.contains(addr_hex)) {
-                    std::cout << "Unexpected account: " << addr_hex << std::endl;
+                    sys_println(std::format("Unexpected account: {}", addr_hex).c_str());
                 }
             }
 
@@ -404,36 +404,32 @@ namespace {
 
             std::optional<Account> account{state.read_account(address)};
             if (!account) {
-                std::cout << "Missing account " << entry.key() << std::endl;
+                sys_println(std::format("Missing account {}", entry.key()).c_str());
                 return false;
             }
 
             const auto expected_balance{intx::from_string<intx::uint256>(j["balance"].get<std::string>())};
             if (account->balance != expected_balance) {
-                std::cout << "Balance mismatch for " << entry.key() << ":\n"
-                          << to_string(account->balance, 16) << " != " << j["balance"] << std::endl;
+                sys_println(std::format("Balance mismatch for {}:\n{} != {}", entry.key(), to_string(account->balance, 16), j["balance"].get<std::string>()).c_str());
                 return false;
             }
 
             const auto expected_nonce{intx::from_string<intx::uint256>(j["nonce"].get<std::string>())};
             if (account->nonce != expected_nonce) {
-                std::cout << "Nonce mismatch for " << entry.key() << ":\n"
-                          << account->nonce << " != " << j["nonce"] << std::endl;
+                sys_println(std::format("Nonce mismatch for {}:\n{} != {}", entry.key(), account->nonce, j["nonce"].get<std::string>()).c_str());
                 return false;
             }
 
             auto expected_code{j["code"].get<std::string>()};
             Bytes actual_code{state.read_code(address, account->code_hash)};
             if (actual_code != from_hex(expected_code)) {
-                std::cout << "Code mismatch for " << entry.key() << ":\n"
-                          << to_hex(actual_code) << " != " << expected_code << std::endl;
+                sys_println(std::format("Code mismatch for {}:\n{} != {}", entry.key(), to_hex(actual_code), expected_code).c_str());
                 return false;
             }
 
             size_t storage_size{state.storage_size(address, account->incarnation)};
             if (storage_size != j["storage"].size()) {
-                std::cout << "Storage size mismatch for " << entry.key() << ":\n"
-                          << storage_size << " != " << j["storage"].size() << std::endl;
+                sys_println(std::format("Storage size mismatch for {}:\n{} != {}", entry.key(), storage_size, j["storage"].size()).c_str());
                 return false;
             }
 
@@ -442,8 +438,7 @@ namespace {
                 Bytes expected_value{from_hex(storage.value().get<std::string>()).value()};
                 evmc::bytes32 actual_value{state.read_storage(address, account->incarnation, to_bytes32(key))};
                 if (actual_value != to_bytes32(expected_value)) {
-                    std::cout << "Storage mismatch for " << entry.key() << " at " << storage.key() << ":\n"
-                              << to_hex(actual_value) << " != " << to_hex(expected_value) << std::endl;
+                    sys_println(std::format("Storage mismatch for {} at {}:\n{} != {}", entry.key(), storage.key(), to_hex(actual_value), to_hex(expected_value)).c_str());
                     return false;
                 }
             }
@@ -487,15 +482,15 @@ namespace {
         const auto network{json_test["network"].get<std::string>()};
         const auto config_it{test::kNetworkConfig.find(network)};
         if (config_it == test::kNetworkConfig.end()) {
-            std::cout << "unknown network " << network << std::endl;
+            sys_println(std::format("unknown network {}", network).c_str());
             return Status::kSkipped;
         }
         auto genesisRLPStr = json_test["genesisRLP"].get<std::string>();
         Bytes genesis_rlp{from_hex(genesisRLPStr).value()};
         ByteView genesis_view{genesis_rlp};
         Block genesis_block;
         if (!rlp::decode(genesis_view, genesis_block)) {
-            std::cout << "Failure to decode genesisRLP" << std::endl;
+            sys_println("Failure to decode genesisRLP");
             return Status::kFailed;
         }
 
@@ -514,8 +509,7 @@ namespace {
             evmc::bytes32 state_root{state.state_root_hash()};
             std::string expected_hex{json_test["postStateHash"].get<std::string>()};
             if (state_root != to_bytes32(from_hex(expected_hex).value())) {
-                std::cout << "postStateHash mismatch:\n"
-                          << to_hex(state_root) << " != " << expected_hex << std::endl;
+                sys_println(std::format("postStateHash mismatch:\n{} != {}", to_hex(state_root), expected_hex).c_str());
                 return Status::kFailed;
             }
             return Status::kPassed;
@@ -538,16 +532,16 @@ uint64_t StateTransition::run(uint32_t num_runs, bool is_test) {
         bool any_failed = false;
         bool any_skipped = false;
         for (const auto& [name, test] : base_json_.items()) {
-            std::cout << "  " << name << ":\n";
+            sys_println(std::format("  {}:", name).c_str());
             const auto result = blockchain_test(test);
             if (result.failed != 0) {
                 any_failed = true;
-                std::cout << "    FAILED\n";
+                sys_println("    FAILED");
             } else if (result.skipped != 0) {
-                std::cout << "    SKIPPED\n";
+                sys_println("    SKIPPED");
                 any_skipped = true;
             } else {
-                std::cout << "    passed\n";
+                sys_println("    passed");
             }
         }
         if (any_failed)
@@ -557,7 +551,7 @@ uint64_t StateTransition::run(uint32_t num_runs, bool is_test) {
         return 0;
     }
 
-    std::cout << "Running State transition. num_runs=" << num_runs << "\n";
+    sys_println(std::format("Running State transition. num_runs={}", num_runs).c_str());
     failed_count_ = 0;
     total_count_ = 0;
     uint64_t total_gas = 0;
@@ -591,7 +585,7 @@ uint64_t StateTransition::run(uint32_t num_runs, bool is_test) {
             txn_validation == ValidationResult::kOk) {
             //============== [TESTING ONLY] SIMULATING MULTIPLE RUNS=====
             for (uint32_t i = 0; i < num_runs; i++) {
-                std::cout << "Inside multiple runs loop\n";
+                sys_println("Inside multiple runs loop");
 
                 auto state_cp = read_genesis_allocation(test_data_["pre"]);
                 ExecutionProcessor ccprocessor{block, *rule_set, state_cp, config, true};