Add logs.expectEvent(..). Initial log tracking.

aarlt · aarlt · commit 6418b5851312 · 2021-01-11T21:18:19.000-05:00
diff --git a/test/ExecutionFramework.h b/test/ExecutionFramework.h
@@ -51,6 +51,25 @@ class ExecutionFramework
 {
 
 public:
+	/// LOG record.
+	struct log_record
+	{
+		/// The address of the account which created the log.
+		util::h160 creator;
+
+		/// The data attached to the log.
+		bytes data;
+
+		/// The log topics.
+		std::vector<util::h256> topics;
+
+		/// Equal operator.
+		bool operator==(const log_record& other) const noexcept
+		{
+			return creator == other.creator && data == other.data && topics == other.topics;
+		}
+	};
+
 	ExecutionFramework();
 	ExecutionFramework(langutil::EVMVersion _evmVersion, std::vector<boost::filesystem::path> const& _vmPaths);
 	virtual ~ExecutionFramework() = default;
@@ -277,6 +296,22 @@ class ExecutionFramework
 	util::h160 logAddress(size_t _logIdx) const;
 	bytes logData(size_t _logIdx) const;
 
+	std::vector<log_record> recordedLogs() {
+		std::vector<log_record> logs{};
+		for (size_t logIdx = 0; logIdx < numLogs(); ++logIdx)
+		{
+			log_record record;
+			const auto& data = m_evmcHost->recorded_logs.at(logIdx).data;
+			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;
+	}
+
 	langutil::EVMVersion m_evmVersion;
 	solidity::frontend::RevertStrings m_revertStrings = solidity::frontend::RevertStrings::Default;
 	solidity::frontend::OptimiserSettings m_optimiserSettings = solidity::frontend::OptimiserSettings::minimal();
diff --git a/test/libsolidity/SemanticTest.cpp b/test/libsolidity/SemanticTest.cpp
@@ -56,6 +56,7 @@ SemanticTest::SemanticTest(string const& _filename, langutil::EVMVersion _evmVer
 				{"logTopic(uint256,uint256)", std::bind(&SemanticTest::logTopic, this, _1)},
 				{"logAddress(uint256)", std::bind(&SemanticTest::logAddress, this, _1)},
 				{"logData(uint256)", std::bind(&SemanticTest::logData, this, _1)},
+				{"expectEvent(uint256,string)", std::bind(&SemanticTest::expectEvent, this, _1)},
 			}}};
 
 	string choice = m_reader.stringSetting("compileViaYul", "default");
@@ -142,6 +143,7 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 			selectVM(evmc_capabilities::EVMC_CAPABILITY_EVM1);
 
 		reset();
+		m_touchedLogs.clear();
 
 		m_compileViaYul = _compileViaYul;
 		if (_compileToEwasm)
@@ -162,6 +164,14 @@ 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);
+			previousCall = &test;
+		}
+
 		for (auto& test: m_tests)
 		{
 			if (constructed)
@@ -261,6 +271,7 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 
 					if (m_transactionSuccessful != !test.call().expectations.failure || outputMismatch)
 						success = false;
+					success = checkLogs(test);
 					test.setFailure(!m_transactionSuccessful);
 				}
 
@@ -269,6 +280,10 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 			}
 		}
 
+		TestFunctionCall fakeLastTestFunctionCall(FunctionCall{});
+		fakeLastTestFunctionCall.setPreviousCall(previousCall);
+		success = checkLogs(fakeLastTestFunctionCall);
+
 		if (success && !m_runWithYul && _compileViaYul)
 		{
 			m_compileViaYulCanBeSet = true;
@@ -404,6 +419,43 @@ void SemanticTest::printUpdatedSettings(ostream& _stream, string const& _linePre
 		_stream << _linePrefix << "// " << setting.first << ": " << setting.second << endl;
 }
 
+bool SemanticTest::checkLogs(TestFunctionCall& _call)
+{
+	_call.setLogs(SolidityExecutionFramework::recordedLogs());
+
+	TestFunctionCall* producer = _call.previousCall();
+	std::vector<FunctionCall const*> consumers{};
+	// Only non-builtins are able to produce logs.
+	// So lets search from the current call up to the first non-builtin.
+	while (producer != nullptr && producer->call().kind == FunctionCall::Kind::Builtin)
+		if (producer->previousCall() != nullptr)
+		{
+			// On the way up to the producer we track all builtins that where on the way.
+			// Only builtins can consume logs, we store them in the consumers vector.
+			consumers.emplace_back(&producer->call());
+			producer = producer->previousCall();
+		}
+
+	// Producer will now point to the call that probably produced a log.
+	if (producer)
+	{
+		// We iterate through the consumers to find out what logs they have consumed.
+		for (auto& consumer: consumers)
+			for (auto logIdx: m_touchedLogs[consumer])
+				// All logs that where touched by the consumer, will be marked as
+				// touched within the producer.
+				touchLog(producer->call(), logIdx);
+
+		// Finally we update the consumed logs within the producer.
+		for (auto& logIdx: m_touchedLogs[&producer->call()])
+			producer->consumedLogs().insert(logIdx);
+
+		std::cout << producer->consumedLogs().size() << " / " << producer->logs().size() << std::endl;
+		return producer->consumedLogs().size() == producer->logs().size();
+	}
+	return true;
+}
+
 bytes SemanticTest::numLogs(FunctionCall const&)
 {
 	// numLogs()
@@ -419,6 +471,7 @@ bytes SemanticTest::numLogTopics(FunctionCall const& call)
 	size_t logCount = SolidityExecutionFramework::numLogs();
 	// todo: hex strings not supported by lexical_cast<..>(..)
 	auto logIdx = lexical_cast<size_t>(call.arguments.parameters.front().rawString);
+	touchLog(call, logIdx);
 	if (logCount > 0 && logIdx < logCount)
 		return util::toBigEndian(u256{SolidityExecutionFramework::numLogTopics(logIdx)});
 	// empty result means failure.
@@ -430,6 +483,7 @@ bytes SemanticTest::logTopic(FunctionCall const& call)
 	// logTopic(uint256,uint256)
 	assert(call.arguments.parameters.size() == 2);
 	auto logIdx = lexical_cast<size_t>(call.arguments.parameters.front().rawString);
+	touchLog(call, logIdx);
 	auto topicIdx = lexical_cast<size_t>(call.arguments.parameters.back().rawString);
 	size_t logCount = SolidityExecutionFramework::numLogs();
 	// todo: hex strings not supported by lexical_cast<..>(..)
@@ -449,6 +503,7 @@ bytes SemanticTest::logAddress(FunctionCall const& call)
 	size_t logCount = SolidityExecutionFramework::numLogs();
 	// todo: hex strings not supported by lexical_cast<..>(..)
 	auto logIdx = lexical_cast<size_t>(call.arguments.parameters.front().rawString);
+	touchLog(call, logIdx);
 	if (logCount > 0 && logIdx < logCount)
 		return util::toBigEndian(u256{u160{SolidityExecutionFramework::logAddress(logIdx)}});
 	// empty result means failure.
@@ -462,12 +517,45 @@ bytes SemanticTest::logData(FunctionCall const& call)
 	size_t logCount = SolidityExecutionFramework::numLogs();
 	// todo: hex strings not supported by lexical_cast<..>(..)
 	auto logIdx = lexical_cast<size_t>(call.arguments.parameters.front().rawString);
+	touchLog(call, logIdx);
 	if (logCount > 0 && logIdx < logCount)
 		return SolidityExecutionFramework::logData(logIdx);
 	// empty result means failure.
 	return bytes{};
 }
 
+bytes SemanticTest::expectEvent(FunctionCall const& call)
+{
+	// expectEvent(uint256,string): logIdx, eventSignature
+	assert(call.arguments.parameters.size() == 2);
+	size_t logCount = SolidityExecutionFramework::numLogs();
+	// todo: hex strings not supported by lexical_cast<..>(..)
+	auto logIdx = lexical_cast<size_t>(call.arguments.parameters.front().rawString);
+	touchLog(call, logIdx);
+	auto logSignature = call.arguments.parameters.back().rawString;
+	assert(logSignature.length() >= 2);
+	logSignature = logSignature.substr(1, logSignature.length() - 2);
+	h256 logSignatureHash{util::keccak256(logSignature)};
+	if (logCount > 0 && logIdx < logCount)
+	{
+		vector<h256> topics;
+		size_t topicCount = SolidityExecutionFramework::numLogTopics(logIdx);
+		for (size_t topicIdx = 0; topicIdx < topicCount; ++topicIdx)
+			topics.push_back(SolidityExecutionFramework::logTopic(logIdx, topicIdx));
+		// remove topics[0], if the signature matches.
+		if (!topics.empty() && topics[0] == logSignatureHash)
+			topics.erase(topics.begin());
+		bytes result;
+		for (auto& topic : topics)
+			result += util::toBigEndian(topic);
+		result += SolidityExecutionFramework::logData(logIdx);
+		// todo: anonymous events with no data would be treated as error, maybe not that important.
+		return result;
+	}
+	// empty result means failure.
+	return bytes{};
+}
+
 void SemanticTest::parseExpectations(istream& _stream)
 {
 	TestFileParser parser{_stream, &this->m_builtins};
diff --git a/test/libsolidity/SemanticTest.h b/test/libsolidity/SemanticTest.h
@@ -60,12 +60,19 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments, std::map<std::string, solidity::test::Address> const& _libraries = {});
 
 private:
+	bool checkLogs(TestFunctionCall& _call);
+
 	// logs builtins.
 	bytes numLogs(FunctionCall const& call);
 	bytes numLogTopics(FunctionCall const& call);
 	bytes logTopic(FunctionCall const& call);
 	bytes logAddress(FunctionCall const& call);
 	bytes logData(FunctionCall const& call);
+	bytes expectEvent(FunctionCall const& call);
+	void touchLog(FunctionCall const& call, size_t _logIdx)
+	{
+		m_touchedLogs[&call].insert(_logIdx);
+	}
 
 	TestResult runTest(std::ostream& _stream, std::string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm);
 	SourceMap m_sources;
@@ -79,6 +86,7 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	bool m_allowNonExistingFunctions = false;
 	bool m_compileViaYulCanBeSet = false;
 	BuiltinFunctions m_builtins;
+	std::map<FunctionCall const*, std::set<size_t>> m_touchedLogs;
 };
 
 }
diff --git a/test/libsolidity/semanticTests/events/event_emit.sol b/test/libsolidity/semanticTests/events/event_emit.sol
@@ -1,17 +1,25 @@
 contract ClientReceipt {
-    event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
+    event D(address indexed _from, bytes32 indexed _id, uint _value);
+    event D2(address indexed _from, bytes32 indexed _id, uint _value) anonymous;
+    event D3(address _from, bytes32 indexed _id, uint _value);
     function deposit(bytes32 _id) public payable {
-        emit Deposit(msg.sender, _id, msg.value);
+        emit D(msg.sender, _id, msg.value);
+        emit D2(msg.sender, _id, msg.value);
+        emit D3(msg.sender, _id, msg.value);
+    }
+    function deposit2(bytes32 _id) public payable {
+        emit D(msg.sender, _id, msg.value);
     }
 }
+
+// logs.expectEvent(uint256,string): 0, "D(address,bytes32,uint256)" -> 0x1212121212121212121212121212120000000012, 0x1234, 18
+
+// deposit2(bytes32), 18 wei: 0x1234 ->
+// deposit(bytes32), 18 wei: 0x1234 ->
 // ====
-// compileViaYul: also
+// compileViaYul: false
 // ----
 // deposit(bytes32), 18 wei: 0x1234 ->
-// logs.numLogs() -> 1
-// logs.logAddress(uint256): 0 -> 0x0fdd67305928fcac8d213d1e47bfa6165cd0b87b
-// logs.logData(uint256): 0 -> 0x12
-// logs.numLogTopics(uint256): 0 -> 3
-// logs.logTopic(uint256,uint256): 0, 0 -> 0x19dacbf83c5de6658e14cbf7bcae5c15eca2eedecf1c66fbca928e4d351bea0f
-// logs.logTopic(uint256,uint256): 0, 1 -> 0x1212121212121212121212121212120000000012
-// logs.logTopic(uint256,uint256): 0, 2 -> 0x1234
+// logs.expectEvent(uint256,string): 0, "D(address,bytes32,uint256)" -> 0x1212121212121212121212121212120000000012, 0x1234, 18
+// logs.expectEvent(uint256,string): 1, "D2(address,bytes32,uint256)" -> 0x1212121212121212121212121212120000000012, 0x1234, 18
+// logs.expectEvent(uint256,string): 2, "D3(address,bytes32,uint256)" -> 0x1234, 0x1212121212121212121212121212120000000012, 0x12
diff --git a/test/libsolidity/util/TestFunctionCall.h b/test/libsolidity/util/TestFunctionCall.h
@@ -16,6 +16,7 @@
 
 #include <test/libsolidity/util/TestFileParser.h>
 #include <test/libsolidity/util/SoltestErrors.h>
+#include <test/ExecutionFramework.h>
 
 #include <liblangutil/Exceptions.h>
 #include <libsolutil/AnsiColorized.h>
@@ -27,6 +28,7 @@
 #include <numeric>
 #include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace solidity::frontend::test
@@ -80,6 +82,26 @@ class TestFunctionCall
 	void setFailure(const bool _failure) { m_failure = _failure; }
 	void setRawBytes(const bytes _rawBytes) { m_rawBytes = _rawBytes; }
 	void setContractABI(Json::Value _contractABI) { m_contractABI = std::move(_contractABI); }
+	std::vector<solidity::test::ExecutionFramework::log_record> logs()
+	{
+		return m_rawLogs;
+	}
+	void setLogs(std::vector<solidity::test::ExecutionFramework::log_record> _logs)
+	{
+		m_rawLogs = std::move(_logs);
+	}
+	std::set<size_t>& consumedLogs()
+	{
+		return m_consumedLogs;
+	}
+	void setPreviousCall(TestFunctionCall* _call)
+	{
+		m_previousCall = _call;
+	}
+	TestFunctionCall* previousCall()
+	{
+		return m_previousCall;
+	}
 
 private:
 	/// Tries to format the given `bytes`, applying the detected ABI types that have be set for each parameter.
@@ -124,13 +146,19 @@ class TestFunctionCall
 	FunctionCall m_call;
 	/// Result of the actual call been made.
 	bytes m_rawBytes = bytes{};
+	/// Logs created by the actual call.
+	std::vector<solidity::test::ExecutionFramework::log_record> m_rawLogs{};
+	std::set<size_t> m_consumedLogs;
+
 	/// Transaction status of the actual call. False in case of a REVERT or any other failure.
 	bool m_failure = true;
 	/// JSON object which holds the contract ABI and that is used to set the output formatting
 	/// in the interactive update routine.
 	Json::Value m_contractABI;
 	/// Flags that the test failed because the called function is not known to exist on the contract.
 	bool m_calledNonExistingFunction = false;
+
+	TestFunctionCall* m_previousCall = nullptr;
 };
 
 }
