Basic expectation generation, if events where not consumed.

Author: aarlt

test/ExecutionFramework.h

@@ -51,9 +51,9 @@ class ExecutionFramework
 {
 
 public:
-	/// LOG record.
 	struct log_record
 	{
+		size_t index;
 		/// The address of the account which created the log.
 		util::h160 creator;
 
@@ -302,6 +302,7 @@ class ExecutionFramework
 		{
 			log_record 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) {

test/libsolidity/SemanticTest.cpp

@@ -282,7 +282,7 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 
 		TestFunctionCall fakeLastTestFunctionCall(FunctionCall{});
 		fakeLastTestFunctionCall.setPreviousCall(previousCall);
-		success = checkLogs(fakeLastTestFunctionCall);
+		success &= checkLogs(fakeLastTestFunctionCall);
 
 		if (success && !m_runWithYul && _compileViaYul)
 		{
@@ -428,7 +428,9 @@ bool SemanticTest::checkLogs(TestFunctionCall& _call)
 	// 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)
+		if (producer->previousCall() == nullptr)
+			break;
+		else
 		{
 			// 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.
@@ -450,8 +452,8 @@ bool SemanticTest::checkLogs(TestFunctionCall& _call)
 		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();
+		// It is ok if some builtins consumed log events.
+		return producer->consumedLogs().size() >= producer->logs().size();
 	}
 	return true;
 }

test/libsolidity/semanticTests/events/event_emit.sol

@@ -1,25 +1,18 @@
 contract ClientReceipt {
-    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);
+    event A(address _from, bytes32 _id, uint _value);
+    event B(address _from, bytes32 _id, uint indexed _value) anonymous;
+    event C(address _from, bytes32 indexed _id, uint _value);
     function deposit(bytes32 _id) public payable {
-        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);
+        emit A(msg.sender, _id, msg.value);
+        emit B(msg.sender, _id, msg.value);
+        emit C(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: false
 // ----
 // deposit(bytes32), 18 wei: 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
+// logs.expectEvent(uint256,string): 0, "A(address,bytes32,uint256)" -> 0x1212121212121212121212121212120000000012, 0x1234, 0x12
+// logs.expectEvent(uint256,string): 1, "" -> 0x12, 0x1212121212121212121212121212120000000012, 0x1234
+// logs.expectEvent(uint256,string): 2, "C(address,bytes32,uint256)" -> 0x1234, 0x1212121212121212121212121212120000000012, 0x12

test/libsolidity/util/TestFunctionCall.cpp

@@ -18,7 +18,9 @@
 #include <test/libsolidity/util/ContractABIUtils.h>
 
 #include <libsolutil/AnsiColorized.h>
+#include <libsolutil/JSON.h>
 
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 
 #include <optional>
@@ -32,6 +34,46 @@ using namespace std;
 
 using Token = soltest::Token;
 
+TestFunctionCall::EventInformation
+TestFunctionCall::findEventSignature(solidity::test::ExecutionFramework::log_record const& log) const
+{
+	for (const auto& entity: m_contractABI)
+	{
+		EventInformation eventInfo;
+		if (entity["type"].isString() && entity["type"].asString() == "event")
+		{
+			string name{entity["name"].asString()};
+			bool anonymous{entity["anonymous"].asBool()};
+			vector<string> argumentTypes;
+			for (const auto& input: entity["inputs"])
+			{
+				string type{input["internalType"].asString()};
+				argumentTypes.emplace_back(type);
+				if (input["indexed"].asBool())
+					eventInfo.indexedTypes.push_back(type);
+				else
+					eventInfo.nonIndexedTypes.push_back(type);
+			}
+			if (!name.empty() && !anonymous)
+			{
+				std::string signature{name};
+				signature += "(";
+				for (auto& arg: argumentTypes)
+					signature += arg + ",";
+				if (!argumentTypes.empty())
+					signature = signature.substr(0, signature.length() - 1);
+				signature += ")";
+				if (!log.topics.empty() && log.topics[0] == util::keccak256(signature))
+				{
+					eventInfo.signature = signature;
+					return eventInfo;
+				}
+			}
+		}
+	}
+	return {};
+}
+
 string TestFunctionCall::format(
 	ErrorReporter& _errorReporter,
 	string const& _linePrefix,
@@ -41,7 +83,7 @@ string TestFunctionCall::format(
 {
 	stringstream stream;
 
-	bool highlight = !matchesExpectation() && _highlight;
+	bool highlight = (!matchesExpectation() || hasUnconsumedLogs()) && _highlight;
 
 	auto formatOutput = [&](bool const _singleLine)
 	{
@@ -93,7 +135,6 @@ string TestFunctionCall::format(
 			if (!m_call.arguments.parameters.at(0).format.newline)
 				stream << ws;
 			stream << output;
-
 		}
 
 		/// Formats comments on the function parameters and the arrow taking
@@ -116,15 +157,60 @@ string TestFunctionCall::format(
 			stream << endl << _linePrefix << newline << ws;
 			if (!m_call.arguments.comment.empty())
 			{
-				 stream << comment << m_call.arguments.comment << comment;
-				 stream << endl << _linePrefix << newline << ws;
+				stream << comment << m_call.arguments.comment << comment;
+				stream << endl << _linePrefix << newline << ws;
 			}
 			stream << arrow;
 		}
 
 		/// Format either the expected output or the actual result output
 		string result;
 		auto& builtin = m_call.expectations.builtin;
+		if (hasUnconsumedLogs())
+		{
+			for (auto& log: unconsumedLogs())
+			{
+				EventInformation eventInfo = findEventSignature(log);
+				string signature{eventInfo.signature};
+				stream << std::endl
+					   << "// logs.expectEvent(uint256,string): " << log.index << ", "
+					   << "\"" + signature + "\" -> ";
+
+				vector<u256> topicsAndData;
+				for (auto& topic: log.topics)
+					if ((topic != *log.topics.begin() && !signature.empty()) || signature.empty())
+						topicsAndData.emplace_back(u256{topic});
+
+				assert(log.data.size() % 32 == 0);
+
+				if (eventInfo.signature.empty())
+				{
+					for (long current = 0; current < static_cast<long>(log.data.size() / 32); ++current)
+					{
+						bytes parameter{log.data.begin() + current * 32, log.data.begin() + current * 32 + 32};
+						topicsAndData.emplace_back(util::fromBigEndian<u256>(parameter));
+					}
+				}
+				else
+				{
+					long current = 0;
+					for (auto& type: eventInfo.nonIndexedTypes)
+					{
+						// todo: use type information to improve decoding.
+						(void) type;
+						bytes parameter{log.data.begin() + current, log.data.begin() + current + 32};
+						current += 32;
+						topicsAndData.emplace_back(util::fromBigEndian<u256>(parameter));
+					}
+				}
+				for (auto& element: topicsAndData)
+				{
+					stream << util::toCompactHexWithPrefix(element);
+					if (&element != &*topicsAndData.rbegin())
+						stream << ", ";
+				}
+			}
+		}
 		if (!_renderResult)
 		{
 			if (builtin)
@@ -152,6 +238,13 @@ string TestFunctionCall::format(
 			if (m_calledNonExistingFunction)
 				_errorReporter.warning("The function \"" + m_call.signature + "\" is not known to the compiler.");
 
+			if (m_consumedLogs.size() != m_rawLogs.size())
+			{
+				stringstream str;
+				str << "The function \"" << m_call.signature << "\" produced " << m_rawLogs.size() <<" log(s), but only " << m_consumedLogs.size() << " log(s) where consumed.";
+				_errorReporter.error(str.str());
+			}
+
 			if (builtin)
 				_errorReporter.warning("The expectation \"" + builtin->signature + ": " + formatRawParameters(builtin->arguments.parameters) + "\" will be replaced with the actual value returned by the test.");
 

test/libsolidity/util/TestFunctionCall.h

@@ -82,7 +82,7 @@ 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()
+	std::vector<solidity::test::ExecutionFramework::log_record> logs() const
 	{
 		return m_rawLogs;
 	}
@@ -94,6 +94,18 @@ class TestFunctionCall
 	{
 		return m_consumedLogs;
 	}
+	bool hasUnconsumedLogs() const
+	{
+		return m_consumedLogs.size() < m_rawLogs.size();
+	}
+	std::vector<solidity::test::ExecutionFramework::log_record> unconsumedLogs() const
+	{
+		std::vector<solidity::test::ExecutionFramework::log_record> result;
+		for (auto& log: m_rawLogs)
+			if (m_consumedLogs.find(log.index) == m_consumedLogs.end())
+				result.emplace_back(m_rawLogs[log.index]);
+		return result;
+	}
 	void setPreviousCall(TestFunctionCall* _call)
 	{
 		m_previousCall = _call;
@@ -104,6 +116,14 @@ class TestFunctionCall
 	}
 
 private:
+	struct EventInformation
+	{
+		std::string signature;
+		std::vector<std::string> indexedTypes;
+		std::vector<std::string> nonIndexedTypes;
+	};
+	EventInformation findEventSignature(solidity::test::ExecutionFramework::log_record const& log) const;
+
 	/// Tries to format the given `bytes`, applying the detected ABI types that have be set for each parameter.
 	/// Throws if there's a mismatch in the size of `bytes` and the desired formats that are specified
 	/// in the ABI type.