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/util/TestFunctionCall.cpp

@@ -18,6 +18,7 @@
 #include <test/libsolidity/util/ContractABIUtils.h>
 
 #include <libsolutil/AnsiColorized.h>
+#include <libsolutil/JSON.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
@@ -32,6 +33,32 @@ using namespace std;
 
 using Token = soltest::Token;
 
+string TestFunctionCall::findEventSignature(solidity::test::ExecutionFramework::log_record const& log) const
+{
+	for (auto& entity: m_contractABI)
+		if (entity["type"].isString() && entity["type"].asString() == "event")
+		{
+			string name{entity["name"].asString()};
+			bool anonymous{entity["anonymous"].asBool()};
+			vector<string> argumentTypes;
+			for (auto& input: entity["inputs"])
+				argumentTypes.emplace_back(input["internalType"].asString());
+			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))
+					return signature;
+			}
+		}
+	return "";
+}
+
 string TestFunctionCall::format(
 	ErrorReporter& _errorReporter,
 	string const& _linePrefix,
@@ -41,7 +68,7 @@ string TestFunctionCall::format(
 {
 	stringstream stream;
 
-	bool highlight = !matchesExpectation() && _highlight;
+	bool highlight = (!matchesExpectation() || hasUnconsumedLogs()) && _highlight;
 
 	auto formatOutput = [&](bool const _singleLine)
 	{
@@ -93,7 +120,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
@@ -134,6 +160,23 @@ string TestFunctionCall::format(
 					result += ": ";
 				result += formatRawParameters(builtin->arguments.parameters);
 			}
+			else if (hasUnconsumedLogs())
+			{
+				stringstream str;
+				for (auto& log: unconsumedLogs())
+				{
+					string signature{findEventSignature(log)};
+					str << std::endl
+						<< "  // logs.expectEvent(uint256,string): " << log.index << ", "
+						<< "\"" + signature + "\" -> ";
+					for (auto& topic : log.topics)
+						if ((topic != *log.topics.begin() && !signature.empty()) || signature.empty())
+							str << util::toCompactHexWithPrefix(u256{topic}) << ", ";
+					if (!log.data.empty())
+						str << util::toHex(log.data, HexPrefix::Add);
+				}
+				result += str.str();
+			}
 			else
 			{
 				bool const isFailure = m_call.expectations.failure;
@@ -152,6 +195,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,8 @@ class TestFunctionCall
 	}
 
 private:
+	std::string 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.