Moves function call test to separate class.

Author: erak

test/libsolidity/SemanticTest.cpp

@@ -35,166 +35,6 @@ using namespace boost::algorithm;
 using namespace boost::unit_test;
 namespace fs = boost::filesystem;
 
-namespace
-{
-	using FunctionCallTest = SemanticTest::FunctionCallTest;
-	using FunctionCall = dev::solidity::test::FunctionCall;
-	using ParamList = dev::solidity::test::ParameterList;
-
-
-	string formatBytes(bytes const& _bytes, ParamList const& _params)
-	{
-		stringstream resultStream;
-		if (_bytes.empty())
-			return {};
-		auto it = _bytes.begin();
-		for (auto const& param: _params)
-		{
-			long offset = static_cast<long>(param.abiType.size);
-			auto offsetIter = it + offset;
-			soltestAssert(offsetIter <= _bytes.end(), "Byte range can not be extended past the end of given bytes.");
-
-			bytes byteRange{it, offsetIter};
-			switch (param.abiType.type)
-			{
-			case ABIType::SignedDec:
-				if (*byteRange.begin() & 0x80)
-					resultStream << u2s(fromBigEndian<u256>(byteRange));
-				else
-					resultStream << fromBigEndian<u256>(byteRange);
-				break;
-			case ABIType::UnsignedDec:
-				// Check if the detected type was wrong and if this could
-				// be signed. If an unsigned was detected in the expectations,
-				// but the actual result returned a signed, it would be formatted
-				// incorrectly.
-				if (*byteRange.begin() & 0x80)
-					resultStream << u2s(fromBigEndian<u256>(byteRange));
-				else
-					resultStream << fromBigEndian<u256>(byteRange);
-				break;
-			case ABIType::Failure:
-				break;
-			case ABIType::None:
-				break;
-			}
-			it += offset;
-			if (it != _bytes.end() && !(param.abiType.type == ABIType::None))
-				resultStream << ", ";
-		}
-		soltestAssert(it == _bytes.end(), "Parameter encoding too short for the given byte range.");
-		return resultStream.str();
-	}
-
-	string formatRawArguments(ParamList const& _params, string const& _linePrefix = "")
-	{
-		stringstream resultStream;
-		for (auto const& param: _params)
-		{
-			if (param.format.newline)
-				resultStream << endl << _linePrefix << "//";
-			resultStream << " " << param.rawString;
-			if (&param != &_params.back())
-				resultStream << ",";
-		}
-		return resultStream.str();
-	}
-
-	string formatFunctionCallTest(
-		FunctionCallTest const& _test,
-		string const& _linePrefix = "",
-		bool const _renderResult = false,
-		bool const _highlight = false
-	)
-	{
-		using namespace soltest;
-		using Token = soltest::Token;
-
-		stringstream _stream;
-		FunctionCall call = _test.call;
-		bool highlight = !_test.matchesExpectation() && _highlight;
-
-		auto formatOutput = [&](bool const _singleLine)
-		{
-			string ws = " ";
-			string arrow = formatToken(Token::Arrow);
-			string colon = formatToken(Token::Colon);
-			string comma = formatToken(Token::Comma);
-			string comment = formatToken(Token::Comment);
-			string ether = formatToken(Token::Ether);
-			string newline = formatToken(Token::Newline);
-			string failure = formatToken(Token::Failure);
-
-			/// Prints the function signature. This is the same independent from the display-mode.
-			_stream << _linePrefix << newline << ws << call.signature;
-			if (call.value > u256(0))
-				_stream << comma << ws << call.value << ws << ether;
-			if (!call.arguments.rawBytes().empty())
-			{
-				string output = formatRawArguments(call.arguments.parameters, _linePrefix);
-				_stream << colon << output;
-			}
-
-			/// Prints comments on the function parameters and the arrow taking
-			/// the display-mode into account.
-			if (_singleLine)
-			{
-				if (!call.arguments.comment.empty())
-					_stream << ws << comment << call.arguments.comment << comment;
-				_stream << ws << arrow << ws;
-			}
-			else
-			{
-				_stream << endl << _linePrefix << newline << ws;
-				if (!call.arguments.comment.empty())
-				{
-					 _stream << comment << call.arguments.comment << comment;
-					 _stream << endl << _linePrefix << newline << ws;
-				}
-				_stream << arrow << ws;
-			}
-
-			/// Print either the expected output or the actual result output
-			string result;
-			if (!_renderResult)
-			{
-				bytes output = call.expectations.rawBytes();
-				bool const isFailure = call.expectations.failure;
-				result = isFailure ? failure : formatBytes(output, call.expectations.result);
-			}
-			else
-			{
-				bytes output = _test.rawBytes;
-				bool const isFailure = _test.failure;
-				result = isFailure ? failure : formatBytes(output, call.expectations.result);
-			}
-			AnsiColorized(_stream, highlight, {RED_BACKGROUND}) << result;
-
-			/// Print comments on expectations taking the display-mode into account.
-			if (_singleLine)
-			{
-				if (!call.expectations.comment.empty())
-					_stream << ws << comment << call.expectations.comment << comment;
-			}
-			else
-			{
-				if (!call.expectations.comment.empty())
-				{
-					_stream << endl << _linePrefix << newline << ws;
-					_stream << comment << call.expectations.comment << comment;
-				}
-			}
-		};
-
-		if (call.displayMode == FunctionCall::DisplayMode::SingleLine)
-			formatOutput(true);
-		else
-			formatOutput(false);
-		_stream << endl;
-
-		return _stream.str();
-	}
-}
 
 SemanticTest::SemanticTest(string const& _filename, string const& _ipcPath):
 	SolidityExecutionFramework(_ipcPath)
@@ -218,27 +58,27 @@ bool SemanticTest::run(ostream& _stream, string const& _linePrefix, bool const _
 	for (auto& test: m_tests)
 	{
 		bytes output = callContractFunctionWithValueNoEncoding(
-			test.call.signature,
-			test.call.value,
-			test.call.arguments.rawBytes()
+			test.call().signature,
+			test.call().value,
+			test.call().arguments.rawBytes()
 		);
 
-		if ((m_transactionSuccessful == test.call.expectations.failure) || (output != test.call.expectations.rawBytes()))
+		if ((m_transactionSuccessful == test.call().expectations.failure) || (output != test.call().expectations.rawBytes()))
 			success = false;
 
-		test.failure = !m_transactionSuccessful;
-		test.rawBytes = std::move(output);
+		test.setFailure(!m_transactionSuccessful);
+		test.setRawBytes(std::move(output));
 	}
 
 	if (!success)
 	{
 		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Expected result:" << endl;
 		for (auto const& test: m_tests)
-			_stream << formatFunctionCallTest(test, _linePrefix, false, true & _formatted);
+			_stream << test.format(_linePrefix, false, true & _formatted) << endl;
 
 		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Obtained result:" << endl;
 		for (auto const& test: m_tests)
-			_stream << formatFunctionCallTest(test, _linePrefix, true, true & _formatted);
+			_stream << test.format(_linePrefix, true, true & _formatted) << endl;
 
 		AnsiColorized(_stream, _formatted, {BOLD, RED}) << _linePrefix
 			<< "Attention: Updates on the test will apply the detected format displayed." << endl;
@@ -258,14 +98,14 @@ void SemanticTest::printSource(ostream& _stream, string const& _linePrefix, bool
 void SemanticTest::printUpdatedExpectations(ostream& _stream, string const&) const
 {
 	for (auto const& test: m_tests)
-		_stream << formatFunctionCallTest(test, "", true, false);
+		_stream << test.format("", true, false) << endl;
 }
 
 void SemanticTest::parseExpectations(istream& _stream)
 {
 	TestFileParser parser{_stream};
 	for (auto const& call: parser.parseFunctionCalls())
-		m_tests.emplace_back(FunctionCallTest{call, bytes{}, string{}});
+		m_tests.emplace_back(TestFunctionCall{call});
 }
 
 bool SemanticTest::deploy(string const& _contractName, u256 const& _value, bytes const& _arguments)

test/libsolidity/SemanticTest.h

@@ -15,6 +15,7 @@
 #pragma once
 
 #include <test/libsolidity/util/TestFileParser.h>
+#include <test/libsolidity/util/TestFunctionCall.h>
 #include <test/libsolidity/SolidityExecutionFramework.h>
 #include <test/libsolidity/AnalysisFramework.h>
 #include <test/TestCase.h>
@@ -42,35 +43,6 @@ namespace test
 class SemanticTest: public SolidityExecutionFramework, public TestCase
 {
 public:
-	/**
-	 * Represents a function call and the result it returned. It stores the call
-	 * representation itself, the actual byte result (if any) and a string representation
-	 * used for the interactive update routine provided by isoltest. It also provides
-	 * functionality to compare the actual result with the expectations attached to the
-	 * call object, as well as a way to reset the result if executed multiple times.
-	 */
-	struct FunctionCallTest
-	{
-		FunctionCall call;
-		bytes rawBytes;
-		std::string output;
-		bool failure = true;
-		/// Compares raw expectations (which are converted to a byte representation before),
-		/// and also the expected transaction status of the function call to the actual test results.
-		bool matchesExpectation() const
-		{
-			return failure == call.expectations.failure && rawBytes == call.expectations.rawBytes();
-		}
-		/// Resets current results in case the function was called and the result
-		/// stored already (e.g. if test case was updated via isoltest).
-		void reset()
-		{
-			failure = true;
-			rawBytes = bytes{};
-			output = std::string{};
-		}
-	};
-
 	static std::unique_ptr<TestCase> create(Config const& _options)
 	{ return std::make_unique<SemanticTest>(_options.filename, _options.ipcPath); }
 
@@ -90,8 +62,9 @@ class SemanticTest: public SolidityExecutionFramework, public TestCase
 	/// Returns true if deployment was successful, false otherwise.
 	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments);
 
+private:
 	std::string m_source;
-	std::vector<FunctionCallTest> m_tests;
+	std::vector<TestFunctionCall> m_tests;
 };
 
 }

test/libsolidity/util/TestFileParser.cpp

@@ -195,12 +195,12 @@ tuple<bytes, ABIType, string> TestFileParser::parseABITypeLiteral()
 	try
 	{
 		u256 number{0};
-		ABIType abiType{ABIType::None, 0};
+		ABIType abiType{ABIType::None, ABIType::AlignRight, 0};
 		string rawString;
 
 		if (accept(Token::Sub))
 		{
-			abiType = ABIType{ABIType::SignedDec, 32};
+			abiType = ABIType{ABIType::SignedDec, ABIType::AlignRight, 32};
 			expect(Token::Sub);
 			rawString += formatToken(Token::Sub);
 			string parsed = parseNumber();
@@ -211,14 +211,14 @@ tuple<bytes, ABIType, string> TestFileParser::parseABITypeLiteral()
 		{
 			if (accept(Token::Number))
 			{
-				abiType = ABIType{ABIType::UnsignedDec, 32};
+				abiType = ABIType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
 				string parsed = parseNumber();
 				rawString += parsed;
 				number = convertNumber(parsed);
 			}
 			else if (accept(Token::Failure, true))
 			{
-				abiType = ABIType{ABIType::Failure, 0};
+				abiType = ABIType{ABIType::Failure, ABIType::AlignRight, 0};
 				return make_tuple(bytes{}, abiType, rawString);
 			}
 		}

test/libsolidity/util/TestFileParser.h

@@ -98,13 +98,22 @@ namespace soltest
  */
 struct ABIType
 {
-	enum Type {
+	enum Type
+	{
 		UnsignedDec,
 		SignedDec,
 		Failure,
 		None
 	};
+
+	enum Align
+	{
+		AlignLeft,
+		AlignRight
+	};
+
 	Type type = ABIType::None;
+	Align align = Align::AlignRight;
 	size_t size = 0;
 };