diff --git a/scripts/check_style.sh b/scripts/check_style.sh index 6a1b2c15e..22ad32536 100755 --- a/scripts/check_style.sh +++ b/scripts/check_style.sh @@ -45,6 +45,7 @@ NAMESPACE_STD_FREE_FILES=( test/libsolidity/* test/libsolidity/analysis/* test/libsolidity/interface/* + test/libsolidity/util/* ) ( diff --git a/test/libsolidity/util/BytesUtils.cpp b/test/libsolidity/util/BytesUtils.cpp index 58d1baacd..fe519bf5b 100644 --- a/test/libsolidity/util/BytesUtils.cpp +++ b/test/libsolidity/util/BytesUtils.cpp @@ -37,7 +37,6 @@ using namespace solidity; using namespace solidity::util; using namespace solidity::frontend; using namespace solidity::frontend::test; -using namespace std; bytes BytesUtils::alignLeft(bytes _bytes) { @@ -73,7 +72,7 @@ bytes BytesUtils::applyAlign( } } -bytes BytesUtils::convertBoolean(string const& _literal) +bytes BytesUtils::convertBoolean(std::string const& _literal) { if (_literal == "true") return bytes{true}; @@ -83,7 +82,7 @@ bytes BytesUtils::convertBoolean(string const& _literal) BOOST_THROW_EXCEPTION(TestParserError("Boolean literal invalid.")); } -bytes BytesUtils::convertNumber(string const& _literal) +bytes BytesUtils::convertNumber(std::string const& _literal) { try { @@ -95,13 +94,13 @@ bytes BytesUtils::convertNumber(string const& _literal) } } -bytes BytesUtils::convertFixedPoint(string const& _literal, size_t& o_fractionalDigits) +bytes BytesUtils::convertFixedPoint(std::string const& _literal, size_t& o_fractionalDigits) { size_t dotPos = _literal.find('.'); o_fractionalDigits = dotPos < _literal.size() ? _literal.size() - dotPos : 0; bool negative = !_literal.empty() && _literal.at(0) == '-'; // remove decimal point - string valueInteger = _literal.substr(0, dotPos) + _literal.substr(dotPos + 1); + std::string valueInteger = _literal.substr(0, dotPos) + _literal.substr(dotPos + 1); // erase leading zeros to avoid parsing as octal. while (!valueInteger.empty() && (valueInteger.at(0) == '0' || valueInteger.at(0) == '-')) valueInteger.erase(valueInteger.begin()); @@ -120,7 +119,7 @@ bytes BytesUtils::convertFixedPoint(string const& _literal, size_t& o_fractional } } -bytes BytesUtils::convertHexNumber(string const& _literal) +bytes BytesUtils::convertHexNumber(std::string const& _literal) { try { @@ -132,7 +131,7 @@ bytes BytesUtils::convertHexNumber(string const& _literal) } } -bytes BytesUtils::convertString(string const& _literal) +bytes BytesUtils::convertString(std::string const& _literal) { try { @@ -144,18 +143,18 @@ bytes BytesUtils::convertString(string const& _literal) } } -string BytesUtils::formatUnsigned(bytes const& _bytes) +std::string BytesUtils::formatUnsigned(bytes const& _bytes) { - stringstream os; + std::stringstream os; soltestAssert(!_bytes.empty() && _bytes.size() <= 32, ""); return fromBigEndian(_bytes).str(); } -string BytesUtils::formatSigned(bytes const& _bytes) +std::string BytesUtils::formatSigned(bytes const& _bytes) { - stringstream os; + std::stringstream os; soltestAssert(!_bytes.empty() && _bytes.size() <= 32, ""); @@ -167,9 +166,9 @@ string BytesUtils::formatSigned(bytes const& _bytes) return os.str(); } -string BytesUtils::formatBoolean(bytes const& _bytes) +std::string BytesUtils::formatBoolean(bytes const& _bytes) { - stringstream os; + std::stringstream os; u256 result = fromBigEndian(_bytes); if (result == 0) @@ -182,32 +181,32 @@ string BytesUtils::formatBoolean(bytes const& _bytes) return os.str(); } -string BytesUtils::formatHex(bytes const& _bytes, bool _shorten) +std::string BytesUtils::formatHex(bytes const& _bytes, bool _shorten) { soltestAssert(!_bytes.empty() && _bytes.size() <= 32, ""); u256 value = fromBigEndian(_bytes); - string output = toCompactHexWithPrefix(value); + std::string output = toCompactHexWithPrefix(value); if (_shorten) return output.substr(0, output.size() - countRightPaddedZeros(_bytes) * 2); return output; } -string BytesUtils::formatHexString(bytes const& _bytes) +std::string BytesUtils::formatHexString(bytes const& _bytes) { - stringstream os; + std::stringstream os; os << "hex\"" << util::toHex(_bytes) << "\""; return os.str(); } -string BytesUtils::formatString(bytes const& _bytes, size_t _cutOff) +std::string BytesUtils::formatString(bytes const& _bytes, size_t _cutOff) { - stringstream os; + std::stringstream os; os << "\""; - for (size_t i = 0; i < min(_cutOff, _bytes.size()); ++i) + for (size_t i = 0; i < std::min(_cutOff, _bytes.size()); ++i) { auto const v = _bytes[i]; switch (v) @@ -232,7 +231,7 @@ string BytesUtils::formatString(bytes const& _bytes, size_t _cutOff) std::string BytesUtils::formatFixedPoint(bytes const& _bytes, bool _signed, size_t _fractionalDigits) { - string decimal; + std::string decimal; bool negative = false; if (_signed) { @@ -246,19 +245,19 @@ std::string BytesUtils::formatFixedPoint(bytes const& _bytes, bool _signed, size { size_t numDigits = decimal.length() - (negative ? 1 : 0); if (_fractionalDigits >= numDigits) - decimal.insert(negative ? 1 : 0, string(_fractionalDigits + 1 - numDigits, '0')); + decimal.insert(negative ? 1 : 0, std::string(_fractionalDigits + 1 - numDigits, '0')); decimal.insert(decimal.length() - _fractionalDigits, "."); } return decimal; } -string BytesUtils::formatRawBytes( +std::string BytesUtils::formatRawBytes( bytes const& _bytes, solidity::frontend::test::ParameterList const& _parameters, - string _linePrefix + std::string _linePrefix ) { - stringstream os; + std::stringstream os; ParameterList parameters; auto it = _bytes.begin(); @@ -283,7 +282,7 @@ string BytesUtils::formatRawBytes( for (auto const& parameter: parameters) { - long actualSize = min( + long actualSize = std::min( distance(it, _bytes.end()), static_cast(parameter.abiType.size) ); @@ -292,7 +291,7 @@ string BytesUtils::formatRawBytes( os << _linePrefix << byteRange; if (¶meter != ¶meters.back()) - os << endl; + os << std::endl; it += actualSize; } @@ -300,12 +299,12 @@ string BytesUtils::formatRawBytes( return os.str(); } -string BytesUtils::formatBytes( +std::string BytesUtils::formatBytes( bytes const& _bytes, ABIType const& _abiType ) { - stringstream os; + std::stringstream os; switch (_abiType.type) { @@ -330,7 +329,7 @@ string BytesUtils::formatBytes( { auto entropy = [](std::string const& str) -> double { double result = 0; - map frequencies; + std::map frequencies; for (char c: str) frequencies[c]++; for (auto p: frequencies) @@ -376,13 +375,13 @@ string BytesUtils::formatBytes( return os.str(); } -string BytesUtils::formatBytesRange( +std::string BytesUtils::formatBytesRange( bytes _bytes, solidity::frontend::test::ParameterList const& _parameters, bool _highlight ) { - stringstream os; + std::stringstream os; ParameterList parameters; auto it = _bytes.begin(); @@ -407,7 +406,7 @@ string BytesUtils::formatBytesRange( for (auto const& parameter: parameters) { - long actualSize = min( + long actualSize = std::min( distance(it, _bytes.end()), static_cast(parameter.abiType.size) ); diff --git a/test/libsolidity/util/BytesUtilsTests.cpp b/test/libsolidity/util/BytesUtilsTests.cpp index f05430bfb..f5a15db33 100644 --- a/test/libsolidity/util/BytesUtilsTests.cpp +++ b/test/libsolidity/util/BytesUtilsTests.cpp @@ -22,7 +22,6 @@ #include -using namespace std; using namespace solidity::util; using namespace solidity::test; diff --git a/test/libsolidity/util/Common.cpp b/test/libsolidity/util/Common.cpp index e5dddb721..6f96b7f6e 100644 --- a/test/libsolidity/util/Common.cpp +++ b/test/libsolidity/util/Common.cpp @@ -20,22 +20,21 @@ #include -using namespace std; using namespace solidity; using namespace solidity::frontend; -string test::withPreamble(string const& _sourceCode, bool _addAbicoderV1Pragma) +std::string test::withPreamble(std::string const& _sourceCode, bool _addAbicoderV1Pragma) { - static string const versionPragma = "pragma solidity >=0.0;\n"; - static string const licenseComment = "// SPDX-License-Identifier: GPL-3.0\n"; - static string const abicoderPragma = "pragma abicoder v1;\n"; + static std::string const versionPragma = "pragma solidity >=0.0;\n"; + static std::string const licenseComment = "// SPDX-License-Identifier: GPL-3.0\n"; + static std::string const abicoderPragma = "pragma abicoder v1;\n"; // NOTE: These checks are intentionally loose to match weird cases. // We can manually adjust a test case where this causes problem. - bool licenseMissing = _sourceCode.find("SPDX-License-Identifier:") == string::npos; + bool licenseMissing = _sourceCode.find("SPDX-License-Identifier:") == std::string::npos; bool abicoderMissing = - _sourceCode.find("pragma experimental ABIEncoderV2;") == string::npos && - _sourceCode.find("pragma abicoder") == string::npos; + _sourceCode.find("pragma experimental ABIEncoderV2;") == std::string::npos && + _sourceCode.find("pragma abicoder") == std::string::npos; return versionPragma + @@ -52,16 +51,16 @@ StringMap test::withPreamble(StringMap _sources, bool _addAbicoderV1Pragma) return _sources; } -string test::stripPreReleaseWarning(string const& _stderrContent) +std::string test::stripPreReleaseWarning(std::string const& _stderrContent) { - static regex const preReleaseWarningRegex{ + static std::regex const preReleaseWarningRegex{ R"(Warning( \(3805\))?: This is a pre-release compiler version, please do not use it in production\.\n)" R"((\n)?)" }; - static regex const noOutputRegex{ + static std::regex const noOutputRegex{ R"(Compiler run successful, no output requested\.\n)" }; - string output = regex_replace(_stderrContent, preReleaseWarningRegex, ""); - return regex_replace(std::move(output), noOutputRegex, ""); + std::string output = std::regex_replace(_stderrContent, preReleaseWarningRegex, ""); + return std::regex_replace(std::move(output), noOutputRegex, ""); } diff --git a/test/libsolidity/util/ContractABIUtils.cpp b/test/libsolidity/util/ContractABIUtils.cpp index 10363551b..641c9107d 100644 --- a/test/libsolidity/util/ContractABIUtils.cpp +++ b/test/libsolidity/util/ContractABIUtils.cpp @@ -41,96 +41,95 @@ using namespace solidity; using namespace solidity::util; using namespace solidity::langutil; using namespace solidity::frontend::test; -using namespace std; namespace { using ParameterList = solidity::frontend::test::ParameterList; -size_t arraySize(string const& _arrayType) +size_t arraySize(std::string const& _arrayType) { auto leftBrack = _arrayType.find("["); auto rightBrack = _arrayType.rfind("]"); soltestAssert( - leftBrack != string::npos && - rightBrack != string::npos && + leftBrack != std::string::npos && + rightBrack != std::string::npos && rightBrack == _arrayType.size() - 1 && leftBrack < rightBrack, "" ); - string size = _arrayType.substr(leftBrack + 1, rightBrack - leftBrack - 1); + std::string size = _arrayType.substr(leftBrack + 1, rightBrack - leftBrack - 1); return static_cast(stoi(size)); } -bool isBool(string const& _type) +bool isBool(std::string const& _type) { return _type == "bool"; } -bool isUint(string const& _type) +bool isUint(std::string const& _type) { - return regex_match(_type, regex{"uint\\d*"}); + return regex_match(_type, std::regex{"uint\\d*"}); } -bool isInt(string const& _type) +bool isInt(std::string const& _type) { - return regex_match(_type, regex{"int\\d*"}); + return regex_match(_type, std::regex{"int\\d*"}); } -bool isFixedBytes(string const& _type) +bool isFixedBytes(std::string const& _type) { - return regex_match(_type, regex{"bytes\\d+"}); + return regex_match(_type, std::regex{"bytes\\d+"}); } -bool isBytes(string const& _type) +bool isBytes(std::string const& _type) { - return regex_match(_type, regex{"\\bbytes\\b"}); + return regex_match(_type, std::regex{"\\bbytes\\b"}); } -bool isString(string const& _type) +bool isString(std::string const& _type) { return _type == "string"; } -bool isFixedBoolArray(string const& _type) +bool isFixedBoolArray(std::string const& _type) { - return regex_match(_type, regex{"bool\\[\\d+\\]"}); + return regex_match(_type, std::regex{"bool\\[\\d+\\]"}); } -bool isFixedUintArray(string const& _type) +bool isFixedUintArray(std::string const& _type) { - return regex_match(_type, regex{"uint\\d*\\[\\d+\\]"}); + return regex_match(_type, std::regex{"uint\\d*\\[\\d+\\]"}); } -bool isFixedIntArray(string const& _type) +bool isFixedIntArray(std::string const& _type) { - return regex_match(_type, regex{"int\\d*\\[\\d+\\]"}); + return regex_match(_type, std::regex{"int\\d*\\[\\d+\\]"}); } -bool isFixedStringArray(string const& _type) +bool isFixedStringArray(std::string const& _type) { - return regex_match(_type, regex{"string\\[\\d+\\]"}); + return regex_match(_type, std::regex{"string\\[\\d+\\]"}); } -bool isTuple(string const& _type) +bool isTuple(std::string const& _type) { return _type == "tuple"; } -bool isFixedTupleArray(string const& _type) +bool isFixedTupleArray(std::string const& _type) { - return regex_match(_type, regex{"tuple\\[\\d+\\]"}); + return regex_match(_type, std::regex{"tuple\\[\\d+\\]"}); } -optional isFixedPoint(string const& type) +std::optional isFixedPoint(std::string const& type) { - optional fixedPointType; - smatch matches; - if (regex_match(type, matches, regex{"(u?)fixed(\\d+)x(\\d+)"})) + std::optional fixedPointType; + std::smatch matches; + if (regex_match(type, matches, std::regex{"(u?)fixed(\\d+)x(\\d+)"})) { ABIType abiType(ABIType::SignedFixedPoint); if (matches[1].str() == "u") @@ -141,10 +140,10 @@ optional isFixedPoint(string const& type) return fixedPointType; } -string functionSignatureFromABI(Json::Value const& _functionABI) +std::string functionSignatureFromABI(Json::Value const& _functionABI) { auto inputs = _functionABI["inputs"]; - string signature = {_functionABI["name"].asString() + "("}; + std::string signature = {_functionABI["name"].asString() + "("}; size_t parameterCount = 0; for (auto const& input: inputs) @@ -163,7 +162,7 @@ string functionSignatureFromABI(Json::Value const& _functionABI) std::optional ContractABIUtils::parametersFromJsonOutputs( ErrorReporter& _errorReporter, Json::Value const& _contractABI, - string const& _functionSignature + std::string const& _functionSignature ) { if (!_contractABI) @@ -178,7 +177,7 @@ std::optional ContractABIUtils::paramet for (auto const& output: function["outputs"]) { - string type = output["type"].asString(); + std::string type = output["type"].asString(); ABITypes inplaceTypes; ABITypes dynamicTypes; @@ -216,7 +215,7 @@ bool ContractABIUtils::appendTypesFromName( bool _isCompoundType ) { - string type = _functionOutput["type"].asString(); + std::string type = _functionOutput["type"].asString(); if (isBool(type)) _inplaceTypes.push_back(ABIType{ABIType::Boolean}); else if (isUint(type)) @@ -245,16 +244,16 @@ bool ContractABIUtils::appendTypesFromName( _dynamicTypes += inplaceTypes + dynamicTypes; } else if (isFixedBoolArray(type)) - _inplaceTypes += vector(arraySize(type), ABIType{ABIType::Boolean}); + _inplaceTypes += std::vector(arraySize(type), ABIType{ABIType::Boolean}); else if (isFixedUintArray(type)) - _inplaceTypes += vector(arraySize(type), ABIType{ABIType::UnsignedDec}); + _inplaceTypes += std::vector(arraySize(type), ABIType{ABIType::UnsignedDec}); else if (isFixedIntArray(type)) - _inplaceTypes += vector(arraySize(type), ABIType{ABIType::SignedDec}); + _inplaceTypes += std::vector(arraySize(type), ABIType{ABIType::SignedDec}); else if (isFixedStringArray(type)) { _inplaceTypes.push_back(ABIType{ABIType::Hex}); - _dynamicTypes += vector(arraySize(type), ABIType{ABIType::Hex}); + _dynamicTypes += std::vector(arraySize(type), ABIType{ABIType::Hex}); for (size_t i = 0; i < arraySize(type); i++) { @@ -262,7 +261,7 @@ bool ContractABIUtils::appendTypesFromName( _dynamicTypes.push_back(ABIType{ABIType::String, ABIType::AlignLeft}); } } - else if (optional fixedPointType = isFixedPoint(type)) + else if (std::optional fixedPointType = isFixedPoint(type)) _inplaceTypes.push_back(*fixedPointType); else if (isBytes(type)) return false; @@ -280,7 +279,7 @@ void ContractABIUtils::overwriteParameters( solidity::frontend::test::ParameterList const& _sourceParameters ) { - using namespace placeholders; + using namespace std::placeholders; for (auto&& [source, target]: ranges::views::zip(_sourceParameters, _targetParameters)) if ( source.abiType.size != target.abiType.size || @@ -304,8 +303,8 @@ solidity::frontend::test::ParameterList ContractABIUtils::preferredParameters( { _errorReporter.warning( "Encoding does not match byte range. The call returned " + - to_string(_bytes.size()) + " bytes, but " + - to_string(encodingSize(_targetParameters)) + " bytes were expected." + std::to_string(_bytes.size()) + " bytes, but " + + std::to_string(encodingSize(_targetParameters)) + " bytes were expected." ); return _sourceParameters; } diff --git a/test/libsolidity/util/TestFileParser.cpp b/test/libsolidity/util/TestFileParser.cpp index 915586ad2..3fba998a0 100644 --- a/test/libsolidity/util/TestFileParser.cpp +++ b/test/libsolidity/util/TestFileParser.cpp @@ -40,7 +40,6 @@ using namespace solidity; using namespace solidity::util; using namespace solidity::frontend; using namespace solidity::frontend::test; -using namespace std; using Token = soltest::Token; @@ -54,9 +53,9 @@ char TestFileParser::Scanner::peek() const noexcept return *next; } -vector TestFileParser::parseFunctionCalls(size_t _lineOffset) +std::vector TestFileParser::parseFunctionCalls(size_t _lineOffset) { - vector calls; + std::vector calls; if (!accept(Token::EOS)) { soltestAssert(m_scanner.currentToken() == Token::Unknown, ""); @@ -84,8 +83,8 @@ vector TestFileParser::parseFunctionCall if (calls.empty()) BOOST_THROW_EXCEPTION(TestParserError("Expected function call before gas usage filter.")); - string runType = m_scanner.currentLiteral(); - if (set{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0) + std::string runType = m_scanner.currentLiteral(); + if (std::set{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0) { m_scanner.scanNextToken(); expect(Token::Colon); @@ -104,7 +103,7 @@ vector TestFileParser::parseFunctionCall if (accept(Token::Library, true)) { expect(Token::Colon); - string libraryName; + std::string libraryName; if (accept(Token::String)) { call.libraryFile = m_scanner.currentLiteral(); @@ -184,7 +183,7 @@ vector TestFileParser::parseFunctionCall catch (TestParserError const& _e) { BOOST_THROW_EXCEPTION( - TestParserError("Line " + to_string(_lineOffset + m_lineNumber) + ": " + _e.what()) + TestParserError("Line " + std::to_string(_lineOffset + m_lineNumber) + ": " + _e.what()) ); } } @@ -193,12 +192,12 @@ vector TestFileParser::parseFunctionCall return calls; } -vector TestFileParser::parseFunctionCallSideEffects() +std::vector TestFileParser::parseFunctionCallSideEffects() { - vector result; + std::vector result; while (accept(Token::Tilde, false)) { - string effect = m_scanner.currentLiteral(); + std::string effect = m_scanner.currentLiteral(); result.emplace_back(effect); soltestAssert(m_scanner.currentToken() == Token::Tilde, ""); m_scanner.scanNextToken(); @@ -232,9 +231,9 @@ bool TestFileParser::expect(Token _token, bool const _advance) return true; } -pair TestFileParser::parseFunctionSignature() +std::pair TestFileParser::parseFunctionSignature() { - string signature; + std::string signature; bool hasName = false; if (accept(Token::Identifier, false)) @@ -250,7 +249,7 @@ pair TestFileParser::parseFunctionSignature() signature += formatToken(Token::LParen); expect(Token::LParen); - string parameters; + std::string parameters; if (!accept(Token::RParen, false)) parameters = parseIdentifierOrTuple(); @@ -367,7 +366,7 @@ Parameter TestFileParser::parseParameter() BOOST_THROW_EXCEPTION(TestParserError("Invalid boolean literal.")); parameter.abiType = ABIType{ABIType::Boolean, ABIType::AlignRight, 32}; - string parsed = parseBoolean(); + std::string parsed = parseBoolean(); parameter.rawString += parsed; parameter.rawBytes = BytesUtils::applyAlign( parameter.alignment, @@ -381,7 +380,7 @@ Parameter TestFileParser::parseParameter() BOOST_THROW_EXCEPTION(TestParserError("Invalid hex number literal.")); parameter.abiType = ABIType{ABIType::Hex, ABIType::AlignRight, 32}; - string parsed = parseHexNumber(); + std::string parsed = parseHexNumber(); parameter.rawString += parsed; parameter.rawBytes = BytesUtils::applyAlign( parameter.alignment, @@ -396,7 +395,7 @@ Parameter TestFileParser::parseParameter() if (parameter.alignment != Parameter::Alignment::None) BOOST_THROW_EXCEPTION(TestParserError("Hex string literals cannot be aligned or padded.")); - string parsed = parseString(); + std::string parsed = parseString(); parameter.rawString += "hex\"" + parsed + "\""; parameter.rawBytes = BytesUtils::convertHexNumber(parsed); parameter.abiType = ABIType{ @@ -410,7 +409,7 @@ Parameter TestFileParser::parseParameter() if (parameter.alignment != Parameter::Alignment::None) BOOST_THROW_EXCEPTION(TestParserError("String literals cannot be aligned or padded.")); - string parsed = parseString(); + std::string parsed = parseString(); parameter.abiType = ABIType{ABIType::String, ABIType::AlignLeft, parsed.size()}; parameter.rawString += "\"" + parsed + "\""; parameter.rawBytes = BytesUtils::applyAlign( @@ -424,12 +423,12 @@ Parameter TestFileParser::parseParameter() auto type = isSigned ? ABIType::SignedDec : ABIType::UnsignedDec; parameter.abiType = ABIType{type, ABIType::AlignRight, 32}; - string parsed = parseDecimalNumber(); + std::string parsed = parseDecimalNumber(); parameter.rawString += parsed; if (isSigned) parsed = "-" + parsed; - if (parsed.find('.') == string::npos) + if (parsed.find('.') == std::string::npos) parameter.rawBytes = BytesUtils::applyAlign( parameter.alignment, parameter.abiType, @@ -458,9 +457,9 @@ Parameter TestFileParser::parseParameter() return parameter; } -string TestFileParser::parseIdentifierOrTuple() +std::string TestFileParser::parseIdentifierOrTuple() { - string identOrTuple; + std::string identOrTuple; auto parseArrayDimensions = [&]() { @@ -499,43 +498,43 @@ string TestFileParser::parseIdentifierOrTuple() return identOrTuple; } -string TestFileParser::parseBoolean() +std::string TestFileParser::parseBoolean() { - string literal = m_scanner.currentLiteral(); + std::string literal = m_scanner.currentLiteral(); expect(Token::Boolean); return literal; } -string TestFileParser::parseComment() +std::string TestFileParser::parseComment() { - string comment = m_scanner.currentLiteral(); + std::string comment = m_scanner.currentLiteral(); if (accept(Token::Comment, true)) return comment; - return string{}; + return std::string{}; } -string TestFileParser::parseDecimalNumber() +std::string TestFileParser::parseDecimalNumber() { - string literal = m_scanner.currentLiteral(); + std::string literal = m_scanner.currentLiteral(); expect(Token::Number); return literal; } -string TestFileParser::parseHexNumber() +std::string TestFileParser::parseHexNumber() { - string literal = m_scanner.currentLiteral(); + std::string literal = m_scanner.currentLiteral(); expect(Token::HexNumber); return literal; } -string TestFileParser::parseString() +std::string TestFileParser::parseString() { - string literal = m_scanner.currentLiteral(); + std::string literal = m_scanner.currentLiteral(); expect(Token::String); return literal; } -void TestFileParser::Scanner::readStream(istream& _stream) +void TestFileParser::Scanner::readStream(std::istream& _stream) { std::string line; // TODO: std::getline(..) removes newlines '\n', if present. This could be improved. @@ -644,16 +643,16 @@ void TestFileParser::Scanner::scanNextToken() m_currentLiteral = ""; } else - BOOST_THROW_EXCEPTION(TestParserError("Unexpected character: '" + string{current()} + "'")); + BOOST_THROW_EXCEPTION(TestParserError("Unexpected character: '" + std::string{current()} + "'")); break; } } while (m_currentToken == Token::Whitespace); } -string TestFileParser::Scanner::readLine() +std::string TestFileParser::Scanner::readLine() { - string line; + std::string line; // Right now the scanner discards all (real) new-lines '\n' in TestFileParser::Scanner::readStream(..). // Token::NewLine is defined as `//`, and NOT '\n'. We are just searching here for the next `/`. // Note that `/` anywhere else than at the beginning of a line is currently forbidden (TODO: until we fix newline handling). @@ -666,9 +665,9 @@ string TestFileParser::Scanner::readLine() return line; } -string TestFileParser::Scanner::scanComment() +std::string TestFileParser::Scanner::scanComment() { - string comment; + std::string comment; advance(); while (current() != '#') @@ -679,9 +678,9 @@ string TestFileParser::Scanner::scanComment() return comment; } -string TestFileParser::Scanner::scanIdentifierOrKeyword() +std::string TestFileParser::Scanner::scanIdentifierOrKeyword() { - string identifier; + std::string identifier; identifier += current(); while (langutil::isIdentifierPart(peek())) { @@ -691,9 +690,9 @@ string TestFileParser::Scanner::scanIdentifierOrKeyword() return identifier; } -string TestFileParser::Scanner::scanDecimalNumber() +std::string TestFileParser::Scanner::scanDecimalNumber() { - string number; + std::string number; number += current(); while (langutil::isDecimalDigit(peek()) || '.' == peek()) { @@ -703,9 +702,9 @@ string TestFileParser::Scanner::scanDecimalNumber() return number; } -string TestFileParser::Scanner::scanHexNumber() +std::string TestFileParser::Scanner::scanHexNumber() { - string number; + std::string number; number += current(); while (langutil::isHexDigit(peek())) { @@ -715,9 +714,9 @@ string TestFileParser::Scanner::scanHexNumber() return number; } -string TestFileParser::Scanner::scanString() +std::string TestFileParser::Scanner::scanString() { - string str; + std::string str; advance(); while (current() != '\"') @@ -766,7 +765,7 @@ string TestFileParser::Scanner::scanString() // TODO: use fromHex() from CommonData char TestFileParser::Scanner::scanHexPart() { - auto toLower = [](char _c) -> char { return tolower(_c, locale::classic()); }; + auto toLower = [](char _c) -> char { return tolower(_c, std::locale::classic()); }; advance(); // skip 'x' diff --git a/test/libsolidity/util/TestFileParserTests.cpp b/test/libsolidity/util/TestFileParserTests.cpp index 6f9aec64d..59934fdb2 100644 --- a/test/libsolidity/util/TestFileParserTests.cpp +++ b/test/libsolidity/util/TestFileParserTests.cpp @@ -30,7 +30,6 @@ #include #include -using namespace std; using namespace solidity::util; using namespace solidity::test; @@ -43,23 +42,23 @@ using Mode = FunctionCall::DisplayMode; namespace { -vector parse(string const& _source, std::map const& _builtins = {}) +std::vector parse(std::string const& _source, std::map const& _builtins = {}) { - istringstream stream{_source, ios_base::out}; + std::istringstream stream{_source, std::ios_base::out}; return TestFileParser{stream, _builtins}.parseFunctionCalls(0); } void testFunctionCall( FunctionCall const& _call, FunctionCall::DisplayMode _mode, - string _signature = "", + std::string _signature = "", bool _failure = true, bytes _arguments = bytes{}, bytes _expectations = bytes{}, FunctionValue _value = { 0 }, - string _argumentComment = "", - string _expectationComment = "", - vector _rawArguments = vector{}, + std::string _argumentComment = "", + std::string _expectationComment = "", + std::vector _rawArguments = std::vector{}, bool _isConstructor = false, bool _isLibrary = false ) @@ -242,7 +241,7 @@ BOOST_AUTO_TEST_CASE(call_revert_message) "f()", true, fmt::encodeArgs(), - fromHex("08c379a0") + fmt::encodeDyn(string{"Revert"}) + fromHex("08c379a0") + fmt::encodeDyn(std::string{"Revert"}) ); } @@ -364,7 +363,7 @@ BOOST_AUTO_TEST_CASE(scanner_hex_values) )"; auto const calls = parse(source); BOOST_REQUIRE_EQUAL(calls.size(), 1); - testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(string("\x20\x00\xff", 3))); + testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(std::string("\x20\x00\xff", 3))); } BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid1) @@ -382,7 +381,7 @@ BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid2) )"; auto const calls = parse(source); BOOST_REQUIRE_EQUAL(calls.size(), 1); - testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(string("\x1", 1))); + testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(std::string("\x1", 1))); } BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid3) @@ -447,7 +446,7 @@ BOOST_AUTO_TEST_CASE(call_arguments_string) Mode::SingleLine, "f(string)", false, - fmt::encodeDyn(string{"any"}) + fmt::encodeDyn(std::string{"any"}) ); } @@ -485,7 +484,7 @@ BOOST_AUTO_TEST_CASE(call_return_string) "f()", false, fmt::encodeArgs(), - fmt::encodeDyn(string{"any"}) + fmt::encodeDyn(std::string{"any"}) ); } @@ -976,7 +975,7 @@ BOOST_AUTO_TEST_CASE(call_effects) // ~ bla bla // ~ bla bla bla )"; - vector calls = parse(source, builtins); + std::vector calls = parse(source, builtins); BOOST_REQUIRE_EQUAL(calls.size(), 1); BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 3); BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "bla"); diff --git a/test/libsolidity/util/TestFunctionCall.cpp b/test/libsolidity/util/TestFunctionCall.cpp index a50b3caf0..64dfbd982 100644 --- a/test/libsolidity/util/TestFunctionCall.cpp +++ b/test/libsolidity/util/TestFunctionCall.cpp @@ -28,33 +28,32 @@ using namespace solidity; using namespace solidity::util; using namespace solidity::frontend::test; -using namespace std; using Token = soltest::Token; -string TestFunctionCall::format( +std::string TestFunctionCall::format( ErrorReporter& _errorReporter, - string const& _linePrefix, + std::string const& _linePrefix, RenderMode _renderMode, bool const _highlight, bool const _interactivePrint ) const { - stringstream stream; + std::stringstream stream; bool highlight = !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 wei = formatToken(Token::Wei); - string newline = formatToken(Token::Newline); - string failure = formatToken(Token::Failure); + std::string ws = " "; + std::string arrow = formatToken(Token::Arrow); + std::string colon = formatToken(Token::Colon); + std::string comma = formatToken(Token::Comma); + std::string comment = formatToken(Token::Comment); + std::string ether = formatToken(Token::Ether); + std::string wei = formatToken(Token::Wei); + std::string newline = formatToken(Token::Newline); + std::string failure = formatToken(Token::Failure); if (m_call.kind == FunctionCall::Kind::Library) { @@ -83,7 +82,7 @@ string TestFunctionCall::format( } if (!m_call.arguments.rawBytes().empty()) { - string output = formatRawParameters(m_call.arguments.parameters, _linePrefix); + std::string output = formatRawParameters(m_call.arguments.parameters, _linePrefix); stream << colon; if (!m_call.arguments.parameters.at(0).format.newline) stream << ws; @@ -107,17 +106,17 @@ string TestFunctionCall::format( } else { - stream << endl << _linePrefix << newline << ws; + stream << std::endl << _linePrefix << newline << ws; if (!m_call.arguments.comment.empty()) { stream << comment << m_call.arguments.comment << comment; - stream << endl << _linePrefix << newline << ws; + stream << std::endl << _linePrefix << newline << ws; } stream << arrow; } /// Format either the expected output or the actual result output - string result; + std::string result; if (_renderMode != RenderMode::ActualValuesExpectedGas) { bool const isFailure = m_call.expectations.failure; @@ -162,7 +161,7 @@ string TestFunctionCall::format( m_call.signature ); - string bytesOutput = abiParams ? + std::string bytesOutput = abiParams ? BytesUtils::formatRawBytes(output, abiParams.value(), _linePrefix) : BytesUtils::formatRawBytes( output, @@ -194,12 +193,12 @@ string TestFunctionCall::format( { if (!m_call.expectations.comment.empty()) { - stream << endl << _linePrefix << newline << ws; + stream << std::endl << _linePrefix << newline << ws; stream << comment << m_call.expectations.comment << comment; } } - vector sideEffects; + std::vector sideEffects; if (_renderMode == RenderMode::ExpectedValuesExpectedGas || _renderMode == RenderMode::ExpectedValuesActualGas) sideEffects = m_call.expectedSideEffects; else @@ -221,10 +220,10 @@ string TestFunctionCall::format( return stream.str(); } -string TestFunctionCall::formatBytesParameters( +std::string TestFunctionCall::formatBytesParameters( ErrorReporter& _errorReporter, bytes const& _bytes, - string const& _signature, + std::string const& _signature, solidity::frontend::test::ParameterList const& _parameters, bool _highlight, bool _failure @@ -232,7 +231,7 @@ string TestFunctionCall::formatBytesParameters( { using ParameterList = solidity::frontend::test::ParameterList; - stringstream os; + std::stringstream os; if (_bytes.empty()) return {}; @@ -281,7 +280,7 @@ string TestFunctionCall::formatBytesParameters( } } -string TestFunctionCall::formatFailure( +std::string TestFunctionCall::formatFailure( ErrorReporter& _errorReporter, solidity::frontend::test::FunctionCall const& _call, bytes const& _output, @@ -289,7 +288,7 @@ string TestFunctionCall::formatFailure( bool _highlight ) const { - stringstream os; + std::stringstream os; os << formatToken(Token::Failure); @@ -311,34 +310,34 @@ string TestFunctionCall::formatFailure( return os.str(); } -string TestFunctionCall::formatRawParameters( +std::string TestFunctionCall::formatRawParameters( solidity::frontend::test::ParameterList const& _params, std::string const& _linePrefix ) const { - stringstream os; + std::stringstream os; for (auto const& param: _params) if (!param.rawString.empty()) { if (param.format.newline) - os << endl << _linePrefix << "// "; + os << std::endl << _linePrefix << "// "; for (auto const c: param.rawString) // NOTE: Even though we have a toHex() overload specifically for uint8_t, the compiler // chooses the one for bytes if the second argument is omitted. - os << (c >= ' ' ? string(1, c) : "\\x" + util::toHex(static_cast(c), HexCase::Lower)); + os << (c >= ' ' ? std::string(1, c) : "\\x" + util::toHex(static_cast(c), HexCase::Lower)); if (¶m != &_params.back()) os << ", "; } return os.str(); } -string TestFunctionCall::formatGasExpectations( - string const& _linePrefix, +std::string TestFunctionCall::formatGasExpectations( + std::string const& _linePrefix, bool _useActualCost, bool _showDifference ) const { - stringstream os; + std::stringstream os; for (auto const& [runType, gasUsed]: (_useActualCost ? m_gasCosts : m_call.expectations.gasUsed)) if (!runType.empty()) { @@ -357,9 +356,9 @@ string TestFunctionCall::formatGasExpectations( percent = static_cast( 100.0 * (static_cast(difference) / static_cast(m_call.expectations.gasUsed.at(runType))) ); - os << endl << _linePrefix << "// gas " << runType << ": " << (gasUsed.str()); + os << std::endl << _linePrefix << "// gas " << runType << ": " << (gasUsed.str()); if (_showDifference && differentResults && _useActualCost) - os << " [" << showpos << difference << " (" << percent << "%)]"; + os << " [" << std::showpos << difference << " (" << percent << "%)]"; } return os.str(); } diff --git a/test/libsolidity/util/TestFunctionCallTests.cpp b/test/libsolidity/util/TestFunctionCallTests.cpp index e321ac676..fa3fe995c 100644 --- a/test/libsolidity/util/TestFunctionCallTests.cpp +++ b/test/libsolidity/util/TestFunctionCallTests.cpp @@ -25,7 +25,6 @@ #include -using namespace std; using namespace solidity::util; using namespace solidity::test; @@ -39,8 +38,8 @@ BOOST_AUTO_TEST_CASE(format_unsigned_singleline) bytes expectedBytes = toBigEndian(u256{1}); ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(uint8)", {0}, arguments, expectations}; call.omitsArrow = false; @@ -59,8 +58,8 @@ BOOST_AUTO_TEST_CASE(format_unsigned_singleline_signed_encoding) bytes expectedBytes = toBigEndian(u256{1}); ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(uint8)", {0}, arguments, expectations}; call.omitsArrow = false; @@ -79,8 +78,8 @@ BOOST_AUTO_TEST_CASE(format_unsigned_multiline) bytes expectedBytes = toBigEndian(u256{1}); ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; Parameter result{expectedBytes, "1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{result}, false, string{}, {}}; - FunctionCallArgs arguments{vector{}, string{}}; + FunctionCallExpectations expectations{std::vector{result}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{}, std::string{}}; FunctionCall call{"f(uint8)", {0}, arguments, expectations}; call.omitsArrow = false; call.displayMode = FunctionCall::DisplayMode::MultiLine; @@ -94,8 +93,8 @@ BOOST_AUTO_TEST_CASE(format_multiple_unsigned_singleline) bytes expectedBytes = toBigEndian(u256{1}); ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param, param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param, param}, string{}}; + FunctionCallExpectations expectations{std::vector{param, param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param, param}, std::string{}}; FunctionCall call{"f(uint8, uint8)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -108,8 +107,8 @@ BOOST_AUTO_TEST_CASE(format_signed_singleline) bytes expectedBytes = toBigEndian(u256{-1}); ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "-1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(int8)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -128,8 +127,8 @@ BOOST_AUTO_TEST_CASE(format_hex_singleline) bytes expectedBytes = result + bytes(32 - result.size(), 0); ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "0x31", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(bytes32)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -150,8 +149,8 @@ BOOST_AUTO_TEST_CASE(format_hex_string_singleline) bytes expectedBytes = fromHex("4200ef"); ABIType abiType{ABIType::HexString, ABIType::AlignLeft, 3}; Parameter param{expectedBytes, "hex\"4200ef\"", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(string)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -164,8 +163,8 @@ BOOST_AUTO_TEST_CASE(format_bool_true_singleline) bytes expectedBytes = toBigEndian(u256{true}); ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "true", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(bool)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -185,8 +184,8 @@ BOOST_AUTO_TEST_CASE(format_bool_false_singleline) bytes expectedBytes = toBigEndian(u256{false}); ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "false", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(bool)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -199,8 +198,8 @@ BOOST_AUTO_TEST_CASE(format_bool_left_singleline) bytes expectedBytes = toBigEndian(u256{false}); ABIType abiType{ABIType::Boolean, ABIType::AlignLeft, 32}; Parameter param{expectedBytes, "left(false)", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(bool)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -214,8 +213,8 @@ BOOST_AUTO_TEST_CASE(format_hex_number_right_singleline) bytes expectedBytes = result + bytes(32 - result.size(), 0); ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "right(0x42)", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(bool)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -228,8 +227,8 @@ BOOST_AUTO_TEST_CASE(format_empty_byte_range) bytes expectedBytes; ABIType abiType{ABIType::None, ABIType::AlignNone, 0}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{param}, false, string{}, {}}; - FunctionCallArgs arguments{vector{}, string{}}; + FunctionCallExpectations expectations{std::vector{param}, false, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{}, std::string{}}; FunctionCall call{"f()", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call}; @@ -242,8 +241,8 @@ BOOST_AUTO_TEST_CASE(format_failure_singleline) bytes expectedBytes = toBigEndian(u256{1}); ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; - FunctionCallExpectations expectations{vector{}, true, string{}, {}}; - FunctionCallArgs arguments{vector{param}, string{}}; + FunctionCallExpectations expectations{std::vector{}, true, std::string{}, {}}; + FunctionCallArgs arguments{std::vector{param}, std::string{}}; FunctionCall call{"f(uint8)", {0}, arguments, expectations}; call.omitsArrow = false; TestFunctionCall test{call};