Adds semantic tests to test framework and isoltest.

Author: erak

test/boostTest.cpp

@@ -74,11 +74,13 @@ int registerTests(
 	boost::unit_test::test_suite& _suite,
 	boost::filesystem::path const& _basepath,
 	boost::filesystem::path const& _path,
+	std::string const& _ipcPath,
 	TestCase::TestCaseCreator _testCaseCreator
 )
 {
 	int numTestsAdded = 0;
 	fs::path fullpath = _basepath / _path;
+	TestCase::Config config{fullpath.string(), _ipcPath};
 	if (fs::is_directory(fullpath))
 	{
 		test_suite* sub_suite = BOOST_TEST_SUITE(_path.filename().string());
@@ -87,7 +89,7 @@ int registerTests(
 			fs::directory_iterator()
 		))
 			if (fs::is_directory(entry.path()) || TestCase::isTestFilename(entry.path().filename()))
-				numTestsAdded += registerTests(*sub_suite, _basepath, _path / entry.path().filename(), _testCaseCreator);
+				numTestsAdded += registerTests(*sub_suite, _basepath, _path / entry.path().filename(), _ipcPath, _testCaseCreator);
 		_suite.add(sub_suite);
 	}
 	else
@@ -96,13 +98,13 @@ int registerTests(
 
 		filenames.emplace_back(new string(_path.string()));
 		_suite.add(make_test_case(
-			[fullpath, _testCaseCreator]
+			[config, _testCaseCreator]
 			{
 				BOOST_REQUIRE_NO_THROW({
 					try
 					{
 						stringstream errorStream;
-						if (!_testCaseCreator(fullpath.string())->run(errorStream))
+						if (!_testCaseCreator(config)->run(errorStream))
 							BOOST_ERROR("Test expectation mismatch.\n" + errorStream.str());
 					}
 					catch (boost::exception const& _e)
@@ -142,6 +144,7 @@ test_suite* init_unit_test_suite( int /*argc*/, char* /*argv*/[] )
 			master,
 			options.testPath / ts.path,
 			ts.subpath,
+			options.ipcPath,
 			ts.testCaseCreator
 		) > 0, std::string("no ") + ts.title + " tests found");
 	}

test/libsolidity/SemanticTest.cpp

@@ -41,17 +41,20 @@ namespace
 	using FunctionCallTest = dev::solidity::test::SemanticTest::FunctionCallTest;
 	using FunctionCall = dev::solidity::test::FunctionCall;
 
-	string formatBytes(bytes const& _bytes, ParamList const& _params, bool const _formatInvalid = false)
+	string formatBytes(bytes const& _bytes, ParamList const& _params)
 	{
 		stringstream resultStream;
 		if (_bytes.empty())
-			resultStream.str();
+			return resultStream.str();
 		auto it = _bytes.begin();
 		for (auto const& param: _params)
 		{
-			bytes byteRange{it, it + param.abiType.size};
-			// FIXME Check range
-			// TODO Check range
+			long offset = static_cast<long>(param.abiType.size);
+			auto offsetIter = it + offset;
+			if (offsetIter > _bytes.end())
+				BOOST_THROW_EXCEPTION(runtime_error("Invalid byte range defined."));
+
+			bytes byteRange{it, offsetIter};
 			switch (param.abiType.type)
 			{
 			case ABIType::SignedDec:
@@ -74,16 +77,14 @@ namespace
 				// If expectations are empty, the encoding type is invalid.
 				// In order to still print the actual result even if
 				// empty expectations were detected, it must be forced.
-				if (_formatInvalid)
-					resultStream << fromBigEndian<u256>(byteRange);
+				resultStream << fromBigEndian<u256>(byteRange);
 				break;
 			case ABIType::None:
 				// If expectations are empty, the encoding type is NONE.
-				if (_formatInvalid)
-					resultStream << fromBigEndian<u256>(byteRange);
+				resultStream << fromBigEndian<u256>(byteRange);
 				break;
 			}
-			it += param.abiType.size;
+			it += offset;
 			if (it != _bytes.end() && !(param.abiType.type == ABIType::None))
 				resultStream << ", ";
 		}
@@ -94,31 +95,43 @@ namespace
 		FunctionCallTest const& _test,
 		string const& _linePrefix = "",
 		bool const _renderResult = false,
-		bool const _higlight = false
+		bool const _highlight = false
 	)
 	{
+		using namespace solt;
+		using Token = solt::Token;
+
 		stringstream _stream;
 		FunctionCall call = _test.call;
-		bool hightlight = !_test.matchesExpectation() && _higlight;
+		bool highlight = !_test.matchesExpectation() && _highlight;
 
 		auto formatOutput = [&](bool const _singleLine)
 		{
-			_stream << _linePrefix << "// " << call.signature;
+			string ws = " ";
+			string arrow = formatToken(Token::Arrow);
+			string colon = formatToken(Token::Colon);
+			string comma = formatToken(Token::Comma);
+			string ether = formatToken(Token::Ether);
+			string newline = formatToken(Token::Newline);
+
+			_stream << _linePrefix << newline << ws << call.signature;
 			if (call.value > u256(0))
-				_stream << TestFileParser::formatToken(SoltToken::Comma)
-						<< call.value << " "
-						<< TestFileParser::formatToken(SoltToken::Ether);
+				_stream << comma << call.value << ws << ether;
 			if (!call.arguments.rawBytes().empty())
-				_stream << ": "
-						<< formatBytes(call.arguments.rawBytes(), call.arguments.parameters);
+			{
+				string output = formatBytes(call.arguments.rawBytes(), call.arguments.parameters);
+				_stream << colon << ws << output;
+			}
 			if (!_singleLine)
-				_stream << endl << _linePrefix << "// ";
+				_stream << endl << _linePrefix << newline << ws;
+			if (_singleLine)
+				_stream << ws;
+			_stream << arrow;
 			if (_singleLine)
-				_stream << " ";
-			_stream << "-> ";
+				_stream << ws;
 			if (!_singleLine)
-				_stream << endl << _linePrefix << "// ";
-			if (hightlight)
+				_stream << endl << _linePrefix << newline << ws;
+			if (highlight)
 				_stream << formatting::RED_BACKGROUND;
 			bytes output;
 			if (_renderResult)
@@ -127,7 +140,7 @@ namespace
 				output = _test.rawBytes;
 			if (!output.empty())
 				_stream << formatBytes(output, call.expectations.result);
-			if (hightlight)
+			if (highlight)
 				_stream << formatting::RESET;
 		};
 
@@ -202,10 +215,10 @@ void SemanticTest::printSource(ostream& _stream, string const& _linePrefix, bool
 		_stream << _linePrefix << line << endl;
 }
 
-void SemanticTest::printUpdatedExpectations(ostream& _stream, string const& _linePrefix) const
+void SemanticTest::printUpdatedExpectations(ostream& _stream, string const&) const
 {
 	for (auto const& test: m_tests)
-		_stream << formatFunctionCallTest(test, _linePrefix, false, false);
+		_stream << formatFunctionCallTest(test, "", false, false);
 }
 
 void SemanticTest::parseExpectations(istream& _stream)

test/libsolidity/semanticTests/smoke_test.sol

@@ -0,0 +1,17 @@
+contract C {
+    function f() public returns (uint) {
+        return 1;
+    }
+    function g(uint x, uint y) public returns (uint) {
+        return x - y;
+    }
+    function h() public payable returns (uint) {
+        return f();
+    }
+}
+// ----
+// g(uint256,uint256): 1, 2 -> -1
+// h(),1 ether -> 1
+// f()
+// ->
+// 1

test/tools/isoltest.cpp

@@ -63,8 +63,9 @@ class TestTool
 		TestCase::TestCaseCreator _testCaseCreator,
 		string const& _name,
 		fs::path const& _path,
+		string const& _ipcPath,
 		bool _formatted
-	): m_testCaseCreator(_testCaseCreator), m_formatted(_formatted), m_name(_name), m_path(_path)
+	): m_testCaseCreator(_testCaseCreator), m_name(_name), m_path(_path), m_ipcPath(_ipcPath), m_formatted(_formatted)
 	{}
 
 	enum class Result
@@ -80,6 +81,7 @@ class TestTool
 		TestCase::TestCaseCreator _testCaseCreator,
 		fs::path const& _basepath,
 		fs::path const& _path,
+		string const& _ipcPath,
 		bool const _formatted
 	);
 
@@ -95,9 +97,10 @@ class TestTool
 	Request handleResponse(bool const _exception);
 
 	TestCase::TestCaseCreator m_testCaseCreator;
-	bool const m_formatted = false;
 	string const m_name;
 	fs::path const m_path;
+	string m_ipcPath;
+	bool const m_formatted = false;
 	unique_ptr<TestCase> m_test;
 	static bool m_exitRequested;
 };
@@ -114,7 +117,7 @@ TestTool::Result TestTool::process()
 
 	try
 	{
-		m_test = m_testCaseCreator(m_path.string());
+		m_test = m_testCaseCreator(TestCase::Config{m_path.string(), m_ipcPath});
 		success = m_test->run(outputMessages, "  ", m_formatted);
 	}
 	catch(boost::exception const& _e)
@@ -198,6 +201,7 @@ TestStats TestTool::processPath(
 	TestCase::TestCaseCreator _testCaseCreator,
 	fs::path const& _basepath,
 	fs::path const& _path,
+	string const& _ipcPath,
 	bool const _formatted
 )
 {
@@ -229,7 +233,7 @@ TestStats TestTool::processPath(
 		else
 		{
 			++testCount;
-			TestTool testTool(_testCaseCreator, currentPath.string(), fullpath, _formatted);
+			TestTool testTool(_testCaseCreator, currentPath.string(), fullpath, _ipcPath, _formatted);
 			auto result = testTool.process();
 
 			switch(result)
@@ -290,6 +294,7 @@ boost::optional<TestStats> runTestSuite(
 	string const& _name,
 	fs::path const& _basePath,
 	fs::path const& _subdirectory,
+	string const& _ipcPath,
 	TestCase::TestCaseCreator _testCaseCreator,
 	bool _formatted
 )
@@ -302,7 +307,7 @@ boost::optional<TestStats> runTestSuite(
 		return {};
 	}
 
-	TestStats stats = TestTool::processPath(_testCaseCreator, _basePath, _subdirectory, _formatted);
+	TestStats stats = TestTool::processPath(_testCaseCreator, _basePath, _subdirectory, _ipcPath, _formatted);
 
 	cout << endl << _name << " Test Summary: ";
 	FormattedScope(cout, _formatted, {BOLD, stats ? GREEN : RED}) <<
@@ -326,11 +331,13 @@ int main(int argc, char *argv[])
 		TestTool::editor = "/usr/bin/editor";
 
 	fs::path testPath;
+	string ipcPath;
+	bool disableIPC = false;
 	bool disableSMT = false;
 	bool formatted = true;
 	po::options_description options(
 		R"(isoltest, tool for interactively managing test contracts.
-Usage: isoltest [Options] --testpath path
+Usage: isoltest [Options] --testpath path --ipcpath ipcpath
 Interactively validates test contracts.
 
 Allowed options)",
@@ -339,6 +346,8 @@ Allowed options)",
 	options.add_options()
 		("help", "Show this help screen.")
 		("testpath", po::value<fs::path>(&testPath), "path to test files")
+		("ipcpath", po::value<string>(&ipcPath), "path to ipc socket")
+		("no-ipc", "disable semantic tests")
 		("no-smt", "disable SMT checker")
 		("no-color", "don't use colors")
 		("editor", po::value<string>(&TestTool::editor), "editor for opening contracts");
@@ -361,8 +370,23 @@ Allowed options)",
 
 		po::notify(arguments);
 
+		if (arguments.count("no-ipc"))
+			disableIPC = true;
+		else
+		{
+			solAssert(
+				!ipcPath.empty(),
+				"No ipc path specified. The --ipcpath argument is required, unless --no-ipc is used."
+			);
+			solAssert(
+				fs::exists(ipcPath),
+				"Invalid ipc path specified."
+			);
+		}
+
 		if (arguments.count("no-smt"))
 			disableSMT = true;
+
 	}
 	catch (std::exception const& _exception)
 	{
@@ -379,10 +403,13 @@ Allowed options)",
 	// Interactive tests are added in InteractiveTests.h
 	for (auto const& ts: g_interactiveTestsuites)
 	{
+		if (ts.ipc && disableIPC)
+			continue;
+
 		if (ts.smt && disableSMT)
 			continue;
 
-		if (auto stats = runTestSuite(ts.title, testPath / ts.path, ts.subpath, ts.testCaseCreator, formatted))
+		if (auto stats = runTestSuite(ts.title, testPath / ts.path, ts.subpath, ipcPath, ts.testCaseCreator, formatted))
 			global_stats += *stats;
 		else
 			return 1;