Initial generic expectation updates through Behaviour class.

Author: aarlt

test/CMakeLists.txt

@@ -58,6 +58,11 @@ set(liblangutil_sources
 detect_stray_source_files("${liblangutil_sources}" "liblangutil/")
 
 set(libsolidity_sources
+    libsolidity/Builtin.h
+    libsolidity/Behaviour.h
+    libsolidity/behaviour/SmokeBehaviour.h
+    libsolidity/behaviour/LogsBehaviour.h
+    libsolidity/behaviour/LogsBehaviour.cpp
     libsolidity/ABIDecoderTests.cpp
     libsolidity/ABIEncoderTests.cpp
     libsolidity/ABIJsonTest.cpp

test/ExecutionFramework.cpp

@@ -29,6 +29,7 @@
 
 #include <libsolutil/CommonIO.h>
 #include <libsolutil/FunctionSelector.h>
+#include <libsolidity/util/SoltestTypes.h>
 
 #include <liblangutil/Exceptions.h>
 
@@ -79,6 +80,23 @@ void ExecutionFramework::selectVM(evmc_capabilities _cap)
 	reset();
 }
 
+std::vector<solidity::frontend::test::LogRecord>  ExecutionFramework::recordedLogs() const {
+	std::vector<solidity::frontend::test::LogRecord> logs{};
+	for (size_t logIdx = 0; logIdx < numLogs(); ++logIdx)
+	{
+		solidity::frontend::test::LogRecord record;
+		const auto& data = m_evmcHost->recorded_logs.at(logIdx).data;
+		record.index = logIdx;
+		record.data = bytes{data.begin(), data.end()};
+		record.creator = EVMHost::convertFromEVMC(m_evmcHost->recorded_logs.at(logIdx).creator);
+		for (size_t topicIdx = 0; topicIdx < numLogTopics(logIdx); ++topicIdx) {
+			record.topics.emplace_back(EVMHost::convertFromEVMC(m_evmcHost->recorded_logs.at(logIdx).topics.at(topicIdx)));
+		}
+		logs.emplace_back(record);
+	}
+	return logs;
+}
+
 void ExecutionFramework::reset()
 {
 	m_evmcHost->reset();

test/ExecutionFramework.h

@@ -39,6 +39,11 @@
 
 #include <boost/test/unit_test.hpp>
 
+namespace solidity::frontend::test
+{
+struct LogRecord;
+} // namespace solidity::frontend::test
+
 namespace solidity::test
 {
 using rational = boost::rational<bigint>;
@@ -51,6 +56,8 @@ class ExecutionFramework
 {
 
 public:
+	std::vector<solidity::frontend::test::LogRecord> recordedLogs() const;
+
 	ExecutionFramework();
 	ExecutionFramework(langutil::EVMVersion _evmVersion, std::vector<boost::filesystem::path> const& _vmPaths);
 	virtual ~ExecutionFramework() = default;
@@ -240,6 +247,21 @@ class ExecutionFramework
 		return result;
 	}
 
+	/// @returns the (potentially newly created) _ith address.
+	util::h160 account(size_t _i);
+
+	u256 balanceAt(util::h160 const& _addr);
+	bool storageEmpty(util::h160 const& _addr);
+	bool addressHasCode(util::h160 const& _addr);
+
+	size_t numLogs() const;
+	size_t numLogTopics(size_t _logIdx) const;
+	util::h256 logTopic(size_t _logIdx, size_t _topicIdx) const;
+	util::h160 logAddress(size_t _logIdx) const;
+	bytes logData(size_t _logIdx) const;
+
+
+
 private:
 	template <class CppFunction, class... Args>
 	auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
@@ -264,19 +286,6 @@ class ExecutionFramework
 	size_t currentTimestamp();
 	size_t blockTimestamp(u256 _number);
 
-	/// @returns the (potentially newly created) _ith address.
-	util::h160 account(size_t _i);
-
-	u256 balanceAt(util::h160 const& _addr);
-	bool storageEmpty(util::h160 const& _addr);
-	bool addressHasCode(util::h160 const& _addr);
-
-	size_t numLogs() const;
-	size_t numLogTopics(size_t _logIdx) const;
-	util::h256 logTopic(size_t _logIdx, size_t _topicIdx) const;
-	util::h160 logAddress(size_t _logIdx) const;
-	bytes logData(size_t _logIdx) const;
-
 	langutil::EVMVersion m_evmVersion;
 	solidity::frontend::RevertStrings m_revertStrings = solidity::frontend::RevertStrings::Default;
 	solidity::frontend::OptimiserSettings m_optimiserSettings = solidity::frontend::OptimiserSettings::minimal();

test/libsolidity/Behaviour.h

@@ -0,0 +1,68 @@
+/*
+	This file is part of solidity.
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "Builtin.h"
+#include <memory>
+#include <vector>
+
+namespace solidity::frontend::test
+{
+
+class TestFunctionCall;
+
+class Behaviour
+{
+public:
+	Behaviour() = default;
+	virtual ~Behaviour() = default;
+
+	virtual void begin() {}
+	virtual void before(TestFunctionCall const& _call) { (void) _call; }
+	virtual void after(TestFunctionCall const& _call) { (void) _call; }
+	virtual void end() {}
+
+	virtual bool isValid(const TestFunctionCall& _call)
+	{
+		(void) _call;
+		return true;
+	}
+
+	virtual void
+	printExpectedResult(TestFunctionCall const& _call, std::string const& _indentation, std::ostream& _stream)
+	{
+		(void) _call;
+		(void) _indentation;
+		(void) _stream;
+	}
+
+	virtual void
+	printObtainedResult(TestFunctionCall const& _call, std::string const& _indentation, std::ostream& _stream)
+	{
+		(void) _call;
+		(void) _indentation;
+		(void) _stream;
+	}
+
+	virtual void printToFile(TestFunctionCall const& _call, std::ostream& _stream)
+	{
+		(void) _call;
+		(void) _stream;
+	}
+};
+
+using Behaviours = std::vector<std::shared_ptr<Behaviour>>;
+
+} // namespace solidity::frontend::test

test/libsolidity/Builtin.h

@@ -0,0 +1,55 @@
+/*
+	This file is part of solidity.
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <functional>
+#include <map>
+#include <optional>
+#include <test/libsolidity/util/SoltestErrors.h>
+#include <test/libsolidity/util/SoltestTypes.h>
+#include <utility>
+#include <vector>
+#include <memory>
+
+namespace solidity::frontend::test
+{
+
+class TestFunctionCall;
+
+class Builtin
+{
+	/// This is the actual implementation of the builtin function.
+	std::function<std::optional<bytes>(FunctionCall const&)> m_builtin = nullptr;
+
+public:
+	Builtin() = default;
+	virtual ~Builtin() = default;
+
+	explicit Builtin(std::function<std::optional<bytes>(FunctionCall const&)> _builtin)
+	{
+		m_builtin = std::move(_builtin);
+	}
+
+	virtual std::optional<bytes> builtin(FunctionCall const& _call)
+	{
+		if (m_builtin != nullptr)
+			return m_builtin(_call);
+		return std::optional<bytes>();
+	}
+};
+
+using Builtins = std::map<std::string, std::map<std::string, std::shared_ptr<Builtin>>>;
+
+} // namespace solidity::frontend::test

test/libsolidity/SemanticTest.cpp

@@ -12,15 +12,20 @@
 	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <test/libsolidity/SemanticTest.h>
-#include <test/libsolidity/util/BytesUtils.h>
-#include <libsolutil/Whiskers.h>
-#include <libyul/Exceptions.h>
-#include <test/Common.h>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/throw_exception.hpp>
+#include <libsolutil/Whiskers.h>
+#include <libyul/Exceptions.h>
+#include <test/Common.h>
+#include <test/libsolidity/SemanticTest.h>
+#include <test/libsolidity/util/BytesUtils.h>
+
+#include <test/libsolidity/Behaviour.h>
+#include <test/libsolidity/Builtin.h>
+#include <test/libsolidity/behaviour/LogsBehaviour.h>
+#include <test/libsolidity/behaviour/SmokeBehaviour.h>
 
 #include <algorithm>
 #include <cctype>
@@ -50,13 +55,24 @@ SemanticTest::SemanticTest(string const& _filename, langutil::EVMVersion _evmVer
 	m_enforceViaYul(enforceViaYul)
 {
 	using namespace std::placeholders;
-	m_builtins
-		= {{"smoke",
-			{
-				{"test0", {std::bind(&SemanticTest::builtinSmokeTest, this, _1)}},
-				{"test1", {std::bind(&SemanticTest::builtinSmokeTest, this, _1)}},
-				{"test2", {std::bind(&SemanticTest::builtinSmokeTest, this, _1)}},
-			}}};
+	// clang-format off
+	auto simpleSmokeBuiltin = std::make_shared<Builtin>(
+		std::bind(&SemanticTest::builtinSmokeTest, this, _1)
+	);
+	m_builtins =
+		{
+			{"smoke",
+				{{"test0", simpleSmokeBuiltin},
+			 	{"test1", simpleSmokeBuiltin},
+			 	{"test2", simpleSmokeBuiltin}}
+			}
+		};
+	m_behaviours =
+		{
+			std::make_shared<SmokeBehaviour>(),
+			std::make_shared<LogsBehaviour>(this)
+		};
+	// clang-format on
 
 	string choice = m_reader.stringSetting("compileViaYul", "default");
 	if (choice == "also")
@@ -130,7 +146,13 @@ TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePref
 	return result;
 }
 
-TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm)
+void SemanticTest::addBuiltin(std::string _module, std::string _function, std::shared_ptr<Builtin> _builtin)
+{
+	m_builtins[_module][_function] = _builtin;
+}
+
+TestCase::TestResult SemanticTest::runTest(
+	ostream& _stream, string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm)
 {
 	bool success = true;
 
@@ -160,11 +182,28 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 
 	bool constructed = false;
 
+	// Iterate through the test calls and set the previous call.
+	TestFunctionCall* previousCall{nullptr};
+	for (auto& test: m_tests)
+	{
+		test.setPreviousCall(previousCall);
+		test.setBehaviours(&m_behaviours);
+		previousCall = &test;
+	}
+
+	for (auto& behaviour: m_behaviours)
+		behaviour->begin();
+
 	for (auto& test: m_tests)
 	{
+		for (auto& behaviour: m_behaviours)
+			behaviour->before(test);
+
 		if (constructed)
 		{
-			soltestAssert(test.call().kind != FunctionCall::Kind::Library, "Libraries have to be deployed before any other call.");
+			soltestAssert(
+				test.call().kind != FunctionCall::Kind::Library,
+				"Libraries have to be deployed before any other call.");
 			soltestAssert(
 				test.call().kind != FunctionCall::Kind::Constructor,
 				"Constructor has to be the first function call expect for library deployments.");
@@ -214,7 +253,7 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 				boost::split(builtinPath, test.call().signature, boost::is_any_of("."));
 				soltestAssert(builtinPath.size() == 2, "");
 				auto builtin = m_builtins[builtinPath.front()][builtinPath.back()];
-				std::optional<bytes> builtinOutput{builtin.function(test.call())};
+				std::optional<bytes> builtinOutput{builtin->builtin(test.call())};
 				if (builtinOutput.has_value())
 				{
 					test.setFailure(false);
@@ -245,7 +284,7 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 				boost::split(builtinPath, test.call().expectations.builtin->signature, boost::is_any_of("."));
 				assert(builtinPath.size() == 2);
 				auto builtin = m_builtins[builtinPath.front()][builtinPath.back()];
-				std::optional<bytes> builtinResult = builtin.function(*test.call().expectations.builtin);
+				std::optional<bytes> builtinResult = builtin->builtin(*test.call().expectations.builtin);
 				if (builtinResult.has_value())
 					expectationOutput = builtinResult.value();
 				else
@@ -273,8 +312,29 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 			test.setRawBytes(std::move(output));
 			test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName()));
 		}
+
+		for (auto& behaviour: m_behaviours)
+			behaviour->after(test);
+	}
+
+	// The artificialFunctionCall is an artificially created function call,
+	// where it's previous call is pointing to the last call of the test.
+	TestFunctionCall artificialFunctionCall(FunctionCall{});
+	artificialFunctionCall.setBehaviours(&m_behaviours);
+	artificialFunctionCall.setPreviousCall(previousCall);
+	for (auto& behaviour: m_behaviours)
+	{
+		behaviour->before(artificialFunctionCall);
+		behaviour->after(artificialFunctionCall);
 	}
 
+	for (auto& behaviour: m_behaviours)
+		behaviour->end();
+
+	for (auto& test: m_tests)
+		for (auto& behaviour: m_behaviours)
+			success &= behaviour->isValid(test);
+
 	if (!m_runWithYul && _compileViaYul)
 	{
 		m_compileViaYulCanBeSet = success;