Introduce dedicated exception classes for soltest, derived from util::Exception

Author: cameel

test/Common.cpp

@@ -34,7 +34,6 @@
 #include <range/v3/all.hpp>
 
 #include <iostream>
-#include <stdexcept>
 
 namespace fs = boost::filesystem;
 namespace po = boost::program_options;

test/Common.h

@@ -48,7 +48,10 @@ static constexpr auto evmoneFilename = "libevmone.so";
 static constexpr auto evmoneDownloadLink = "https://github.com/ethereum/evmone/releases/download/v0.13.0/evmone-0.13.0-linux-x86_64.tar.gz";
 #endif
 
-struct ConfigException: public util::Exception {};
+struct SoltestError: public util::Exception {};
+struct ConfigException: public SoltestError {};
+struct ValidationError: public SoltestError {};
+struct ExecutionError: public SoltestError {};
 
 struct CommonOptions
 {

test/CommonSyntaxTest.cpp

@@ -32,7 +32,6 @@
 
 #include <istream>
 #include <ostream>
-#include <stdexcept>
 
 using namespace solidity;
 using namespace solidity::util;
@@ -49,7 +48,7 @@ namespace
 int parseUnsignedInteger(std::string::iterator& _it, std::string::iterator _end)
 {
 	if (_it == _end || !util::isDigit(*_it))
-		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid test expectation. Source location expected."));
+		solThrow(ValidationError, "Invalid test expectation. Source location expected.");
 	int result = 0;
 	while (_it != _end && util::isDigit(*_it))
 	{
@@ -257,8 +256,7 @@ std::vector<SyntaxTestError> CommonSyntaxTest::parseExpectations(std::istream& _
 
 		std::string errorTypeStr(typeBegin, it);
 		std::optional<Error::Type> errorType = Error::parseErrorType(errorTypeStr);
-		if (!errorType.has_value())
-			BOOST_THROW_EXCEPTION(std::runtime_error("Invalid error type: " + errorTypeStr));
+		solRequire(errorType.has_value(), ValidationError, "Invalid error type: " + errorTypeStr);
 
 		skipWhitespace(it, line.end());
 

test/FilesystemUtils.cpp

@@ -18,8 +18,12 @@
 
 #include <test/FilesystemUtils.h>
 
+#include <test/Common.h>
+
 #include <test/libsolidity/util/SoltestErrors.h>
 
+#include <fmt/format.h>
+
 #include <fstream>
 
 using namespace solidity;
@@ -37,19 +41,19 @@ void solidity::test::createFilesWithParentDirs(std::set<boost::filesystem::path>
 		newFile << _content;
 
 		if (newFile.fail() || !boost::filesystem::exists(path))
-			BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create an empty file: \"" + path.string() + "\"."));
+			solThrow(ExecutionError, "Failed to create an empty file: \"" + path.string() + "\".");
 	}
 }
 
 void solidity::test::createFileWithContent(boost::filesystem::path const& _path, std::string const& _content)
 {
 	if (boost::filesystem::is_regular_file(_path))
-		BOOST_THROW_EXCEPTION(std::runtime_error("File already exists: \"" + _path.string() + "\"."));
+		solThrow(ExecutionError, "File already exists: \"" + _path.string() + "\".");
 
 	// Use binary mode to avoid line ending conversion on Windows.
 	std::ofstream newFile(_path.string(), std::ofstream::binary);
 	if (newFile.fail() || !boost::filesystem::is_regular_file(_path))
-		BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create a file: \"" + _path.string() + "\"."));
+		solThrow(ExecutionError, "Failed to create a file: \"" + _path.string() + "\".");
 
 	newFile << _content;
 }
@@ -79,9 +83,10 @@ bool solidity::test::createSymlinkIfSupportedByFilesystem(
 	)
 		return false;
 	else
-		BOOST_THROW_EXCEPTION(std::runtime_error(
-			"Failed to create a symbolic link: \"" + _linkName.string() + "\""
-			" -> " + _targetPath.string() + "\"."
-			" " + symlinkCreationError.message() + "."
+		solThrow(ExecutionError, fmt::format(
+			"Failed to create a symbolic link: \"{}\" -> {}\". {}.",
+			_linkName.string(),
+			_targetPath.string(),
+			symlinkCreationError.message()
 		));
 }

test/TestCase.cpp

@@ -20,13 +20,14 @@
 #include <test/TestCase.h>
 
 #include <libsolutil/AnsiColorized.h>
+#include <libsolutil/Exceptions.h>
 #include <libsolutil/StringUtils.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 
 #include <iostream>
-#include <stdexcept>
 
+using namespace std::string_literals;
 using namespace solidity;
 using namespace solidity::frontend;
 using namespace solidity::frontend::test;
@@ -66,7 +67,7 @@ bool TestCase::shouldRun()
 void TestCase::expect(std::string::iterator& _it, std::string::iterator _end, std::string::value_type _c)
 {
 	if (_it == _end || *_it != _c)
-		BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Invalid test expectation. Expected: \"") + _c + "\"."));
+		solThrow(ValidationError, "Invalid test expectation. Expected: \""s + _c + "\".");
 	++_it;
 }
 
@@ -120,8 +121,7 @@ void EVMVersionRestrictedTestCase::processEVMVersionSetting()
 		version = std::make_optional<langutil::EVMVersion>();
 	else
 		version = langutil::EVMVersion::fromString(versionString);
-	if (!version)
-		BOOST_THROW_EXCEPTION(std::runtime_error{"Invalid EVM version: \"" + versionString + "\""});
+	solRequire(version, ValidationError, "Invalid EVM version: \"" + versionString + "\"");
 
 	langutil::EVMVersion evmVersion = CommonOptions::get().evmVersion();
 	bool comparisonResult;
@@ -138,7 +138,7 @@ void EVMVersionRestrictedTestCase::processEVMVersionSetting()
 	else if (comparator == "!")
 		comparisonResult = !(evmVersion == version);
 	else
-		BOOST_THROW_EXCEPTION(std::runtime_error{"Invalid EVM comparator: \"" + comparator + "\""});
+		solThrow(ValidationError, "Invalid EVM comparator: \"" + comparator + "\"");
 
 	if (!comparisonResult)
 		m_shouldRun = false;
@@ -160,7 +160,7 @@ void EVMVersionRestrictedTestCase::processBytecodeFormatSetting()
 	else if (bytecodeFormatString == ">=EOFv1" && !eofVersion.has_value())
 		m_shouldRun = false;
 	else if (bytecodeFormatString != "legacy" && bytecodeFormatString != ">=EOFv1" )
-		BOOST_THROW_EXCEPTION(std::runtime_error{"Invalid bytecodeFormat flag: \"" + bytecodeFormatString + "\""});
+		solThrow(ValidationError, "Invalid bytecodeFormat flag: \"" + bytecodeFormatString + "\"");
 }
 
 EVMVersionRestrictedTestCase::EVMVersionRestrictedTestCase(std::string const& _filename):

test/TestCaseReader.cpp

@@ -24,13 +24,15 @@
 #include <boost/filesystem.hpp>
 
 using namespace solidity::frontend::test;
+using namespace solidity::test;
 
 namespace fs = boost::filesystem;
 
-TestCaseReader::TestCaseReader(std::string const& _filename): m_fileStream(_filename), m_fileName(_filename)
+TestCaseReader::TestCaseReader(std::string const& _filename):
+	m_fileStream(_filename),
+	m_fileName(_filename)
 {
-	if (!m_fileStream)
-		BOOST_THROW_EXCEPTION(std::runtime_error("Cannot open file: \"" + _filename + "\"."));
+	solRequire(m_fileStream, ValidationError, "Cannot open file: \"" + _filename + "\".");
 	m_fileStream.exceptions(std::ios::badbit);
 
 	std::tie(m_sources, m_lineNumber) = parseSourcesAndSettingsWithLineNumber(m_fileStream);
@@ -47,7 +49,7 @@ TestCaseReader::TestCaseReader(std::istringstream const& _str)
 std::string const& TestCaseReader::source() const
 {
 	if (m_sources.sources.size() != 1)
-		BOOST_THROW_EXCEPTION(std::runtime_error("Expected single source definition, but got multiple sources."));
+		solThrow(ValidationError, "Expected single source definition, but got multiple sources.");
 	return m_sources.sources.at(m_sources.mainSourceFile);
 }
 
@@ -68,7 +70,7 @@ bool TestCaseReader::boolSetting(std::string const& _name, bool _defaultValue)
 	if (value == "true")
 		return true;
 
-	BOOST_THROW_EXCEPTION(std::runtime_error("Invalid Boolean value: " + value + "."));
+	solThrow(ValidationError, "Invalid Boolean value: " + value + ".");
 }
 
 size_t TestCaseReader::sizetSetting(std::string const& _name, size_t _defaultValue)
@@ -94,10 +96,10 @@ std::string TestCaseReader::stringSetting(std::string const& _name, std::string
 void TestCaseReader::ensureAllSettingsRead() const
 {
 	if (!m_unreadSettings.empty())
-		BOOST_THROW_EXCEPTION(std::runtime_error(
-			"Unknown setting(s): " +
-			util::joinHumanReadable(m_unreadSettings | ranges::views::keys)
-		));
+		solThrow(
+			ValidationError,
+			"Unknown setting(s): " + util::joinHumanReadable(m_unreadSettings | ranges::views::keys)
+		);
 }
 
 std::pair<SourceMap, size_t> TestCaseReader::parseSourcesAndSettingsWithLineNumber(std::istream& _stream)
@@ -137,7 +139,7 @@ std::pair<SourceMap, size_t> TestCaseReader::parseSourcesAndSettingsWithLineNumb
 					line.size() - sourceDelimiterEnd.size() - sourceDelimiterStart.size()
 				));
 				if (sources.count(currentSourceName))
-					BOOST_THROW_EXCEPTION(std::runtime_error("Multiple definitions of test source \"" + currentSourceName + "\"."));
+					solThrow(ValidationError, "Multiple definitions of test source \"" + currentSourceName + "\".");
 			}
 			else if (boost::algorithm::starts_with(line, externalSourceDelimiterStart) && boost::algorithm::ends_with(line, sourceDelimiterEnd))
 			{
@@ -163,16 +165,16 @@ std::pair<SourceMap, size_t> TestCaseReader::parseSourcesAndSettingsWithLineNumb
 				if (!externalSourceTarget.is_relative() || !externalSourceTarget.root_path().empty())
 					// NOTE: UNC paths (ones starting with // or \\) are considered relative by Boost
 					// since they have an empty root directory (but non-empty root name).
-					BOOST_THROW_EXCEPTION(std::runtime_error("External Source paths need to be relative to the location of the test case."));
+					solThrow(ValidationError, "External Source paths need to be relative to the location of the test case.");
 				fs::path externalSourceFullPath = testCaseParentDir / externalSourceTarget;
 				std::string externalSourceContent;
 				if (!fs::exists(externalSourceFullPath))
-					BOOST_THROW_EXCEPTION(std::runtime_error("External Source '" + externalSourceTarget.string() + "' not found."));
+					solThrow(ValidationError, "External Source '" + externalSourceTarget.string() + "' not found.");
 				else
 					externalSourceContent = util::readFileAsString(externalSourceFullPath);
 
 				if (sources.count(externalSourceName))
-					BOOST_THROW_EXCEPTION(std::runtime_error("Multiple definitions of test source \"" + externalSourceName + "\"."));
+					solThrow(ValidationError, "Multiple definitions of test source \"" + externalSourceName + "\".");
 				sources[externalSourceName] = externalSourceContent;
 				externalSources[externalSourceName] = externalSourceTarget;
 			}
@@ -183,15 +185,15 @@ std::pair<SourceMap, size_t> TestCaseReader::parseSourcesAndSettingsWithLineNumb
 		{
 			size_t colon = line.find(':');
 			if (colon == std::string::npos)
-				BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Expected \":\" inside setting.")));
+				solThrow(ValidationError, "Expected \":\" inside setting.");
 			std::string key = line.substr(comment.size(), colon - comment.size());
 			std::string value = line.substr(colon + 1);
 			boost::algorithm::trim(key);
 			boost::algorithm::trim(value);
 			m_settings[key] = value;
 		}
 		else
-			BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Expected \"//\" or \"// ---\" to terminate settings and source.")));
+			solThrow(ValidationError, "Expected \"//\" or \"// ---\" to terminate settings and source.");
 	}
 	// Register the last source as the main one
 	sources[currentSourceName] = currentSource;
@@ -208,6 +210,6 @@ std::string TestCaseReader::parseSimpleExpectations(std::istream& _file)
 		else if (line == "//")
 			result += "\n";
 		else
-			BOOST_THROW_EXCEPTION(std::runtime_error("Test expectations must start with \"// \"."));
+			solThrow(ValidationError, "Test expectations must start with \"// \".");
 	return result;
 }

test/TestCaseReader.h

@@ -18,15 +18,19 @@
 
 #pragma once
 
+#include <test/Common.h>
+
 #include <test/libsolidity/util/SoltestErrors.h>
 
 #include <libsolutil/StringUtils.h>
 
-#include <range/v3/view/map.hpp>
-
 #include <boost/filesystem.hpp>
 #include <boost/throw_exception.hpp>
 
+#include <fmt/format.h>
+
+#include <range/v3/view/map.hpp>
+
 #include <fstream>
 #include <map>
 #include <string>
@@ -91,10 +95,11 @@ E TestCaseReader::enumSetting(std::string const& _name, std::map<std::string, E>
 
 	std::string value = stringSetting(_name, _defaultChoice);
 
-	if (_choices.count(value) == 0)
-		BOOST_THROW_EXCEPTION(std::runtime_error(
-			"Invalid Enum value: " + value + ". Available choices: " + util::joinHumanReadable(_choices | ranges::views::keys) + "."
-		));
+	solRequire(_choices.count(value) != 0, solidity::test::ValidationError, fmt::format(
+		"Invalid Enum value: {}. Available choices: {}.",
+		value,
+		util::joinHumanReadable(_choices | ranges::views::keys)
+	));
 
 	return _choices.at(value);
 }

test/libevmasm/EVMAssemblyTest.cpp

@@ -64,7 +64,7 @@ EVMAssemblyTest::EVMAssemblyTest(std::string const& _filename):
 	else if (boost::algorithm::ends_with(_filename, ".asm"))
 		m_assemblyFormat = AssemblyFormat::Plain;
 	else
-		BOOST_THROW_EXCEPTION(std::runtime_error("Not an assembly test: \"" + _filename + "\". Allowed extensions: .asm, .asmjson."));
+		solThrow(ValidationError, "Not an assembly test: \"" + _filename + "\". Allowed extensions: .asm, .asmjson.");
 
 	m_selectedOutputs = m_reader.stringSetting("outputs", "Assembly,Bytecode,Opcodes,SourceMappings");
 	OptimisationPreset optimizationPreset = m_reader.enumSetting<OptimisationPreset>(

test/libevmasm/PlainAssemblyParser.cpp

@@ -68,7 +68,7 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou
 				expectNoMoreArguments();
 
 				if (!immediateArgument.starts_with("0x"))
-					BOOST_THROW_EXCEPTION(std::runtime_error(formatError("The immediate argument to PUSH must be a hex number prefixed with '0x'.")));
+					solThrow(ValidationError, formatError("The immediate argument to PUSH must be a hex number prefixed with '0x'."));
 
 				immediateArgument.remove_prefix("0x"s.size());
 				codeJSON.push_back({{"name", "PUSH"}, {"value", immediateArgument}});
@@ -83,7 +83,7 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou
 			codeJSON.push_back({{"name", "JUMPDEST"}});
 		}
 		else
-			BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Unknown instruction.")));
+			solThrow(ValidationError, formatError("Unknown instruction."));
 	}
 	return {{".code", codeJSON}};
 }
@@ -113,7 +113,7 @@ std::string_view PlainAssemblyParser::expectArgument()
 {
 	bool hasArgument = advanceToken();
 	if (!hasArgument)
-		BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Missing argument(s).")));
+		solThrow(ValidationError, formatError("Missing argument(s)."));
 
 	return currentToken().value;
 }
@@ -122,7 +122,7 @@ void PlainAssemblyParser::expectNoMoreArguments()
 {
 	bool hasArgument = advanceToken();
 	if (hasArgument)
-		BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Too many arguments.")));
+		solThrow(ValidationError, formatError("Too many arguments."));
 }
 
 void PlainAssemblyParser::advanceLine(std::string_view _line)

test/libevmasm/PlainAssemblyParser.h

@@ -46,7 +46,7 @@ class PlainAssemblyParser
 {
 public:
 	/// Parses plain assembly format and returns the equivalent assembly  JSON.
-	/// Errors are reported by throwing runtime_error.
+	/// Errors are reported by throwing ValidationError.
 	Json parse(std::string _sourceName, std::string const& _source);
 
 protected: