convert VMTests to BlockchainTests

retesteth/Options.cpp

@@ -75,8 +75,7 @@ void printHelp()
     cout << setw(30) << "--filltests" << setw(0) << "Run test fillers\n";
     cout << setw(30) << "--fillchain" << setw(25) << "When filling the state tests, fill tests as blockchain instead\n";
     cout << setw(30) << "--showhash" << setw(25) << "Show filler hash debug information\n";
-    cout << setw(30) << "--poststate" << setw(25)
-         << "Show post state hash or fullstate if --fullstate defined\n";
+    cout << setw(30) << "--poststate" << setw(25) << "Show post state hash or fullstate\n";
     cout << setw(30) << "--fullstate" << setw(25) << "Do not compress large states to hash\n";
     //	cout << setw(30) << "--randomcode <MaxOpcodeNum>" << setw(25) << "Generate smart random EVM
     //code\n"; 	cout << setw(30) << "--createRandomTest" << setw(25) << "Create random test and
@@ -225,7 +224,10 @@ Options::Options(int argc, const char** argv)
         else if (arg == "--fullstate")
             fullstate = true;
         else if (arg == "--poststate")
+        {
             poststate = true;
+            fullstate = true;
+        }
         else if (arg == "--verbosity")
 		{
 			throwIfNoArgumentFollows();

retesteth/dataObject/DataObject.h

@@ -155,35 +155,16 @@ class DataObject
             _assert(m_type == DataType::Null,
                 "m_type == DataType::Null (DataObject& operator=). Overwriting dataobject that is "
                 "not NULL");
-        else
-        {
-            // overwrite value and key
-            if (m_type != DataType::Null)
-            {
-                replace(_value);
-                return *this;
-            }
-        }
 
-        // initialize new element if it was null before, but keep the key; DataObject[key] =
-        m_type = _value.type();
-        switch (_value.type())
+        if (m_type != DataType::Null)
+            replace(_value);         // overwrite value and key
+        else
         {
-        case DataType::Integer:
-            m_intVal = _value.asInt();
-            break;
-        case DataType::String:
-            m_strVal = _value.asString();
-            break;
-        case DataType::Bool:
-            m_boolVal = _value.asBool();
-            break;
-        default:
-            break;
+            // keep the key "newkey" for object["newkey"] = object2;  declarations when object["newkey"] is null;
+            string const currentKey = m_strKey;
+            replace(_value);
+            m_strKey = currentKey;
         }
-        m_allowOverwrite = _value.isOverwritable();
-        setAutosort(_value.isAutosort());
-        m_subObjects = _value.getSubObjects();
         return *this;
     }
 

retesteth/ethObjects/common.h

@@ -9,4 +9,5 @@
 #include "rpcResponse/scheme_debugTraceTransaction.h"
 #include "stateTest/scheme_env.h"
 #include "stateTest/scheme_stateTest.h"
+#include "vmTest/scheme_vmTest.h"
 #include "stateTest/scheme_RPCTest.h"

retesteth/ethObjects/expectSection/scheme_expectAccount.h

@@ -70,9 +70,10 @@ class scheme_expectAccount : public object
             {
                 // check that empty element is not set
                 // if a post state has the value of 'key' as zero, such 'key' does not listed
+                string const& val = _storage.count(key) ? _storage.atKey(key).asString() : "";
                 checkMessage(!_storage.count(key), CompareResult::IncorrectStorage,
                     message + " has storage key '" + element.getKey() +
-                        "'. Test expected storage key: '" + element.getKey() +
+                        "' : '" + val + "'. Test expected storage key: '" + element.getKey() +
                         "' to be set to zero");
             }
             else
@@ -96,15 +97,18 @@ class scheme_expectAccount : public object
         checkMessage(expectStorage.getSubObjects().size() >= _storage.getSubObjects().size(),
             CompareResult::IncorrectStorage,
             TestOutputHelper::get().testName() + " Remote account '" + address() +
-                "' storage has more storage records then expected!");
+                "' storage has more storage records than expected!");
 
         if (expectStorage.getSubObjects().size() < _storage.getSubObjects().size())
         {
             for (auto const& element : _storage.getSubObjects())
             {
+                string expected = "0";
+                if (expectStorage.count(element.getKey()))
+                    expected = expectStorage.atKey(element.getKey()).asString();
                 string const message = "incorrect remote storage [" + element.getKey() +
                                        "] = " + element.asString() + ", test expected [" +
-                                       element.getKey() + "] = 0";
+                                       element.getKey() + "] = " + expected;
                 ETH_MARK_ERROR(message);
             }
         }

retesteth/ethObjects/vmTest/scheme_vmTest.cpp

@@ -0,0 +1,95 @@
+#include "scheme_vmTest.h"
+using namespace test;
+using namespace std;
+
+scheme_vmTestBase::scheme_vmTestBase(DataObject const& _test)
+  : object(_test), m_checker(_test), m_env(_test.atKey("env")), m_pre(_test.atKey("pre"))
+{}
+
+scheme_vmTestBase::fieldChecker::fieldChecker(DataObject const& _test)
+{
+    ETH_ERROR_REQUIRE_MESSAGE(_test.count("env"), "VM test must have 'env' section");
+    ETH_ERROR_REQUIRE_MESSAGE(_test.count("pre"), "VM test must have 'pre' section");
+}
+
+/*
+scheme_vmTest::scheme_vmTest(DataObject const& _test)
+  : scheme_vmTestBase(_test), m_checker(_test), m_post(_test.atKey("post"))
+{
+}
+
+scheme_vmTest::fieldChecker::fieldChecker(DataObject const& _test)
+{
+    requireJsonFields(_test, "stateTest " + _test.getKey(), {
+        {"_info", {DataType::Object} },
+        {"env", {DataType::Object} },
+        {"pre", {DataType::Object} },
+        {"transaction", {DataType::Object} },
+        {"post", {DataType::Object} }
+    });
+
+    requireJsonFields(_test.atKey("_info"), "stateTest " + _test.getKey() + " _info ",
+        {
+            {"comment", {{DataType::String}, jsonField::Required}},
+            {"source", {{DataType::String}, jsonField::Required}},
+            {"sourceHash", {{DataType::String}, jsonField::Required}},
+            {"lllcversion", {{DataType::String}, jsonField::Required}},
+            {"filledwith", {{DataType::String}, jsonField::Optional}},
+            {"filling-rpc-server", {{DataType::String}, jsonField::Optional}},
+            {"filling-tool-version", {{DataType::String}, jsonField::Optional}},
+        });
+
+    // Check that `data` in compiled test is not just a string but a binary string
+    ETH_ERROR_REQUIRE_MESSAGE(_test.atKey("transaction").count("data"),
+        "Field `data` not found in `transaction` section (" + TestInfo::caseName() + ")");
+    ETH_ERROR_REQUIRE_MESSAGE(_test.atKey("transaction").atKey("data").type() == DataType::Array,
+        "Field `data` in `transaction` section is expected to be Array! (" +
+            TestOutputHelper::get().testName() + ")");
+    for (auto const& element : _test.atKey("transaction").atKey("data").getSubObjects())
+        ETH_ERROR_REQUIRE_MESSAGE(stringIntegerType(element.asString()) == DigitsType::HexPrefixed,
+            "Field `data` in `transaction` section is expected to be binary prefixed with `0x` in "
++ TestOutputHelper::get().testName() + ", but got: `" + element.asString() + "`");
+}
+*/
+
+scheme_vmTestFiller::fieldChecker::fieldChecker(DataObject const& _test)
+{
+    requireJsonFields(_test, "vmTestFiller " + _test.getKey(),
+        {{"_info", {{DataType::Object}, jsonField::Optional}},
+            {"env", {{DataType::Object}, jsonField::Required}},
+            {"pre", {{DataType::Object}, jsonField::Required}},
+            {"exec", {{DataType::Object}, jsonField::Required}},
+            {"expect", {{DataType::Object}, jsonField::Optional}},
+            {"expectOut", {{DataType::String}, jsonField::Optional}}});
+    if (_test.count("expectOut"))
+        ETH_WARNING("Unable to verify `expectOut` when creating a stateTest from VMTest " +
+                    TestOutputHelper::get().testInfo().getMessage());
+}
+
+DataObject translateExecToTransaction(DataObject const& _exec)
+{
+    DataObject gtransaction;
+    requireJsonFields(_exec, "vmTestFiller exec",
+        {{"address", {{DataType::String}, jsonField::Required}},
+            {"caller", {{DataType::String}, jsonField::Required}},
+            {"data", {{DataType::String}, jsonField::Required}},
+            {"code", {{DataType::String}, jsonField::Optional}},
+            {"gas", {{DataType::String}, jsonField::Required}},
+            {"gasPrice", {{DataType::String}, jsonField::Required}},
+            {"origin", {{DataType::String}, jsonField::Required}},
+            {"value", {{DataType::String}, jsonField::Required}}});
+    gtransaction["data"].addArrayObject(DataObject(_exec.atKey("data").asString()));
+    gtransaction["gasLimit"].addArrayObject(DataObject(_exec.atKey("gas").asString()));
+    gtransaction["gasPrice"] = _exec.atKey("gasPrice");
+    gtransaction["nonce"] = "0";
+    gtransaction["secretKey"] = "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8";
+    gtransaction["to"] = _exec.atKey("address");
+    gtransaction["value"].addArrayObject(DataObject(_exec.atKey("value").asString()));
+    return gtransaction;
+}
+
+scheme_vmTestFiller::scheme_vmTestFiller(DataObject const& _test)
+  : scheme_vmTestBase(_test),
+    m_checker(_test),
+    m_gtransaction(translateExecToTransaction(_test.atKey("exec")))
+{}

retesteth/ethObjects/vmTest/scheme_vmTest.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "../expectSection/scheme_expectSection.h"
+#include "../object.h"
+#include "scheme_vmTestBase.h"
+
+#include <retesteth/Options.h>
+#include <retesteth/TestHelper.h>
+
+using namespace test;
+using namespace testprivate;
+
+namespace test
+{
+/*
+    class scheme_vmTest : public scheme_vmTestBase
+    {
+        public:
+        scheme_vmTest(DataObject const& _test);
+
+        private:
+        class fieldChecker
+        {
+            public:
+            fieldChecker(DataObject const& _test);
+        };
+        fieldChecker m_checker;
+    };
+*/
+
+class scheme_vmTestFiller : public scheme_vmTestBase
+{
+public:
+    scheme_vmTestFiller(DataObject const& _test);
+    scheme_generalTransaction const& getTransaction() { return m_gtransaction; }
+
+private:
+    class fieldChecker
+    {
+    public:
+        fieldChecker(DataObject const& _test);
+    };
+    fieldChecker m_checker;
+    scheme_generalTransaction m_gtransaction;
+};
+}  // namespace test

retesteth/ethObjects/vmTest/scheme_vmTestBase.h

@@ -0,0 +1,31 @@
+#pragma once
+#include "../object.h"
+#include "../stateTest/scheme_env.h"
+#include "../stateTest/scheme_state.h"
+#include "../stateTest/scheme_transaction.h"
+
+#include <dataObject/DataObject.h>
+#include <retesteth/Options.h>
+#include <retesteth/TestHelper.h>
+
+using namespace test;
+namespace testprivate
+{
+class scheme_vmTestBase : public object
+{
+public:
+    scheme_vmTestBase(DataObject const& _test);
+    scheme_env const& getEnv() const { return m_env; }
+    scheme_state const& getPre() const { return m_pre; }
+
+private:
+    class fieldChecker
+    {
+    public:
+        fieldChecker(DataObject const& _test);
+    };
+    fieldChecker m_checker;
+    scheme_env m_env;
+    scheme_state m_pre;
+};
+}  // namespace testprivate

retesteth/testSuites/StateTests.cpp

@@ -212,6 +212,10 @@ DataObject FillTest(DataObject const& _testFile)
 
                     scheme_block blockInfo =
                         session.eth_getBlockByNumber(latestBlockNumber, Options::get().vmtrace);
+                    if (Options::get().poststate)
+                        ETH_STDOUT_MESSAGE("PostState " +
+                                           TestOutputHelper::get().testInfo().getMessage() +
+                                           " : \n" + blockInfo.getStateHash());
                     if (Options::get().vmtrace)
                         printVmTrace(session, trHash, blockInfo.getStateHash());
                     if (Options::get().fullstate)
@@ -220,11 +224,7 @@ DataObject FillTest(DataObject const& _testFile)
                         compareStates(expect.getExpectState(), remoteState);
                     }
                     else
-                    {
-                        if (Options::get().poststate)
-                            ETH_STDOUT_MESSAGE("PostState " + TestOutputHelper::get().testInfo().getMessage() +  " : \n" + blockInfo.getStateHash());
                         compareStates(expect.getExpectState(), session, blockInfo);
-                    }
 
                     DataObject indexes;
                     DataObject transactionResults;