cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #14581 from ethereum/purge-using-namespace-std-from-test-libsolidity-util

Browse Source 
Purge using namespace std from test/libsolidity/util
This commit is contained in:
Daniel 2023-10-02 17:53:53 +02:00 committed by GitHub
commit 72671d6c88
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 204 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
scripts/check_style.sh
View File

@ -45,6 +45,7 @@ NAMESPACE_STD_FREE_FILES=(
test/libsolidity/* test/libsolidity/*
test/libsolidity/analysis/* test/libsolidity/analysis/*
test/libsolidity/interface/* test/libsolidity/interface/*
test/libsolidity/util/*
) )
( (

65
test/libsolidity/util/BytesUtils.cpp
View File

@ -37,7 +37,6 @@ using namespace solidity;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::frontend; using namespace solidity::frontend;
using namespace solidity::frontend::test; using namespace solidity::frontend::test;
using namespace std;
bytes BytesUtils::alignLeft(bytes _bytes) 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") if (_literal == "true")
return bytes{true}; return bytes{true};
@ -83,7 +82,7 @@ bytes BytesUtils::convertBoolean(string const& _literal)
BOOST_THROW_EXCEPTION(TestParserError("Boolean literal invalid.")); BOOST_THROW_EXCEPTION(TestParserError("Boolean literal invalid."));
} }
bytes BytesUtils::convertNumber(string const& _literal) bytes BytesUtils::convertNumber(std::string const& _literal)
{ {
try 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('.'); size_t dotPos = _literal.find('.');
o_fractionalDigits = dotPos < _literal.size() ? _literal.size() - dotPos : 0; o_fractionalDigits = dotPos < _literal.size() ? _literal.size() - dotPos : 0;
bool negative = !_literal.empty() && _literal.at(0) == '-'; bool negative = !_literal.empty() && _literal.at(0) == '-';
// remove decimal point // 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. // erase leading zeros to avoid parsing as octal.
while (!valueInteger.empty() && (valueInteger.at(0) == '0' || valueInteger.at(0) == '-')) while (!valueInteger.empty() && (valueInteger.at(0) == '0' || valueInteger.at(0) == '-'))
valueInteger.erase(valueInteger.begin()); 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 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 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, ""); soltestAssert(!_bytes.empty() && _bytes.size() <= 32, "");
return fromBigEndian<u256>(_bytes).str(); return fromBigEndian<u256>(_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, ""); soltestAssert(!_bytes.empty() && _bytes.size() <= 32, "");
@ -167,9 +166,9 @@ string BytesUtils::formatSigned(bytes const& _bytes)
return os.str(); return os.str();
} }
string BytesUtils::formatBoolean(bytes const& _bytes) std::string BytesUtils::formatBoolean(bytes const& _bytes)
{ {
stringstream os; std::stringstream os;
u256 result = fromBigEndian<u256>(_bytes); u256 result = fromBigEndian<u256>(_bytes);
if (result == 0) if (result == 0)
@ -182,32 +181,32 @@ string BytesUtils::formatBoolean(bytes const& _bytes)
return os.str(); 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, ""); soltestAssert(!_bytes.empty() && _bytes.size() <= 32, "");
u256 value = fromBigEndian<u256>(_bytes); u256 value = fromBigEndian<u256>(_bytes);
string output = toCompactHexWithPrefix(value); std::string output = toCompactHexWithPrefix(value);
if (_shorten) if (_shorten)
return output.substr(0, output.size() - countRightPaddedZeros(_bytes) * 2); return output.substr(0, output.size() - countRightPaddedZeros(_bytes) * 2);
return output; 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) << "\""; os << "hex\"" << util::toHex(_bytes) << "\"";
return os.str(); 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 << "\""; 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]; auto const v = _bytes[i];
switch (v) 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) std::string BytesUtils::formatFixedPoint(bytes const& _bytes, bool _signed, size_t _fractionalDigits)
{ {
string decimal; std::string decimal;
bool negative = false; bool negative = false;
if (_signed) if (_signed)
{ {
@ -246,19 +245,19 @@ std::string BytesUtils::formatFixedPoint(bytes const& _bytes, bool _signed, size
{ {
size_t numDigits = decimal.length() - (negative ? 1 : 0); size_t numDigits = decimal.length() - (negative ? 1 : 0);
if (_fractionalDigits >= numDigits) 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, "."); decimal.insert(decimal.length() - _fractionalDigits, ".");
} }
return decimal; return decimal;
} }
string BytesUtils::formatRawBytes( std::string BytesUtils::formatRawBytes(
bytes const& _bytes, bytes const& _bytes,
solidity::frontend::test::ParameterList const& _parameters, solidity::frontend::test::ParameterList const& _parameters,
string _linePrefix std::string _linePrefix
) )
{ {
stringstream os; std::stringstream os;
ParameterList parameters; ParameterList parameters;
auto it = _bytes.begin(); auto it = _bytes.begin();
@ -283,7 +282,7 @@ string BytesUtils::formatRawBytes(
for (auto const& parameter: parameters) for (auto const& parameter: parameters)
{ {
long actualSize = min( long actualSize = std::min(
distance(it, _bytes.end()), distance(it, _bytes.end()),
static_cast<ParameterList::difference_type>(parameter.abiType.size) static_cast<ParameterList::difference_type>(parameter.abiType.size)
); );
@ -292,7 +291,7 @@ string BytesUtils::formatRawBytes(
os << _linePrefix << byteRange; os << _linePrefix << byteRange;
if (&parameter != &parameters.back()) if (&parameter != &parameters.back())
os << endl; os << std::endl;
it += actualSize; it += actualSize;
} }
@ -300,12 +299,12 @@ string BytesUtils::formatRawBytes(
return os.str(); return os.str();
} }
string BytesUtils::formatBytes( std::string BytesUtils::formatBytes(
bytes const& _bytes, bytes const& _bytes,
ABIType const& _abiType ABIType const& _abiType
) )
{ {
stringstream os; std::stringstream os;
switch (_abiType.type) switch (_abiType.type)
{ {
@ -330,7 +329,7 @@ string BytesUtils::formatBytes(
{ {
auto entropy = [](std::string const& str) -> double { auto entropy = [](std::string const& str) -> double {
double result = 0; double result = 0;
map<char, double> frequencies; std::map<char, double> frequencies;
for (char c: str) for (char c: str)
frequencies[c]++; frequencies[c]++;
for (auto p: frequencies) for (auto p: frequencies)
@ -376,13 +375,13 @@ string BytesUtils::formatBytes(
return os.str(); return os.str();
} }
string BytesUtils::formatBytesRange( std::string BytesUtils::formatBytesRange(
bytes _bytes, bytes _bytes,
solidity::frontend::test::ParameterList const& _parameters, solidity::frontend::test::ParameterList const& _parameters,
bool _highlight bool _highlight
) )
{ {
stringstream os; std::stringstream os;
ParameterList parameters; ParameterList parameters;
auto it = _bytes.begin(); auto it = _bytes.begin();
@ -407,7 +406,7 @@ string BytesUtils::formatBytesRange(
for (auto const& parameter: parameters) for (auto const& parameter: parameters)
{ {
long actualSize = min( long actualSize = std::min(
distance(it, _bytes.end()), distance(it, _bytes.end()),
static_cast<ParameterList::difference_type>(parameter.abiType.size) static_cast<ParameterList::difference_type>(parameter.abiType.size)
); );

1
test/libsolidity/util/BytesUtilsTests.cpp
View File

@ -22,7 +22,6 @@
#include <libsolutil/CommonData.h> #include <libsolutil/CommonData.h>
using namespace std;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::test; using namespace solidity::test;

25
test/libsolidity/util/Common.cpp
View File

@ -20,22 +20,21 @@
#include <regex> #include <regex>
using namespace std;
using namespace solidity; using namespace solidity;
using namespace solidity::frontend; 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 std::string const versionPragma = "pragma solidity >=0.0;\n";
static string const licenseComment = "// SPDX-License-Identifier: GPL-3.0\n"; static std::string const licenseComment = "// SPDX-License-Identifier: GPL-3.0\n";
static string const abicoderPragma = "pragma abicoder v1;\n"; static std::string const abicoderPragma = "pragma abicoder v1;\n";
// NOTE: These checks are intentionally loose to match weird cases. // NOTE: These checks are intentionally loose to match weird cases.
// We can manually adjust a test case where this causes problem. // 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 = bool abicoderMissing =
_sourceCode.find("pragma experimental ABIEncoderV2;") == string::npos && _sourceCode.find("pragma experimental ABIEncoderV2;") == std::string::npos &&
_sourceCode.find("pragma abicoder") == string::npos; _sourceCode.find("pragma abicoder") == std::string::npos;
return return
versionPragma + versionPragma +
@ -52,16 +51,16 @@ StringMap test::withPreamble(StringMap _sources, bool _addAbicoderV1Pragma)
return _sources; 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"(Warning( \(3805\))?: This is a pre-release compiler version, please do not use it in production\.\n)"
R"((\n)?)" R"((\n)?)"
}; };
static regex const noOutputRegex{ static std::regex const noOutputRegex{
R"(Compiler run successful, no output requested\.\n)" R"(Compiler run successful, no output requested\.\n)"
}; };
string output = regex_replace(_stderrContent, preReleaseWarningRegex, ""); std::string output = std::regex_replace(_stderrContent, preReleaseWarningRegex, "");
return regex_replace(std::move(output), noOutputRegex, ""); return std::regex_replace(std::move(output), noOutputRegex, "");
} }

85
test/libsolidity/util/ContractABIUtils.cpp
View File

@ -41,96 +41,95 @@ using namespace solidity;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::langutil; using namespace solidity::langutil;
using namespace solidity::frontend::test; using namespace solidity::frontend::test;
using namespace std;
namespace namespace
{ {
using ParameterList = solidity::frontend::test::ParameterList; using ParameterList = solidity::frontend::test::ParameterList;
size_t arraySize(string const& _arrayType) size_t arraySize(std::string const& _arrayType)
{ {
auto leftBrack = _arrayType.find("["); auto leftBrack = _arrayType.find("[");
auto rightBrack = _arrayType.rfind("]"); auto rightBrack = _arrayType.rfind("]");
soltestAssert( soltestAssert(
leftBrack != string::npos && leftBrack != std::string::npos &&
rightBrack != string::npos && rightBrack != std::string::npos &&
rightBrack == _arrayType.size() - 1 && rightBrack == _arrayType.size() - 1 &&
leftBrack < rightBrack, leftBrack < rightBrack,
"" ""
); );
string size = _arrayType.substr(leftBrack + 1, rightBrack - leftBrack - 1); std::string size = _arrayType.substr(leftBrack + 1, rightBrack - leftBrack - 1);
return static_cast<size_t>(stoi(size)); return static_cast<size_t>(stoi(size));
} }
bool isBool(string const& _type) bool isBool(std::string const& _type)
{ {
return _type == "bool"; 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"; 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"; 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<ABIType> isFixedPoint(string const& type) std::optional<ABIType> isFixedPoint(std::string const& type)
{ {
optional<ABIType> fixedPointType; std::optional<ABIType> fixedPointType;
smatch matches; std::smatch matches;
if (regex_match(type, matches, regex{"(u?)fixed(\\d+)x(\\d+)"})) if (regex_match(type, matches, std::regex{"(u?)fixed(\\d+)x(\\d+)"}))
{ {
ABIType abiType(ABIType::SignedFixedPoint); ABIType abiType(ABIType::SignedFixedPoint);
if (matches[1].str() == "u") if (matches[1].str() == "u")
@ -141,10 +140,10 @@ optional<ABIType> isFixedPoint(string const& type)
return fixedPointType; return fixedPointType;
} }
string functionSignatureFromABI(Json::Value const& _functionABI) std::string functionSignatureFromABI(Json::Value const& _functionABI)
{ {
auto inputs = _functionABI["inputs"]; auto inputs = _functionABI["inputs"];
string signature = {_functionABI["name"].asString() + "("}; std::string signature = {_functionABI["name"].asString() + "("};
size_t parameterCount = 0; size_t parameterCount = 0;
for (auto const& input: inputs) for (auto const& input: inputs)
@ -163,7 +162,7 @@ string functionSignatureFromABI(Json::Value const& _functionABI)
std::optional<solidity::frontend::test::ParameterList> ContractABIUtils::parametersFromJsonOutputs( std::optional<solidity::frontend::test::ParameterList> ContractABIUtils::parametersFromJsonOutputs(
ErrorReporter& _errorReporter, ErrorReporter& _errorReporter,
Json::Value const& _contractABI, Json::Value const& _contractABI,
string const& _functionSignature std::string const& _functionSignature
) )
{ {
if (!_contractABI) if (!_contractABI)
@ -178,7 +177,7 @@ std::optional<solidity::frontend::test::ParameterList> ContractABIUtils::paramet
for (auto const& output: function["outputs"]) for (auto const& output: function["outputs"])
{ {
string type = output["type"].asString(); std::string type = output["type"].asString();
ABITypes inplaceTypes; ABITypes inplaceTypes;
ABITypes dynamicTypes; ABITypes dynamicTypes;
@ -216,7 +215,7 @@ bool ContractABIUtils::appendTypesFromName(
bool _isCompoundType bool _isCompoundType
) )
{ {
string type = _functionOutput["type"].asString(); std::string type = _functionOutput["type"].asString();
if (isBool(type)) if (isBool(type))
_inplaceTypes.push_back(ABIType{ABIType::Boolean}); _inplaceTypes.push_back(ABIType{ABIType::Boolean});
else if (isUint(type)) else if (isUint(type))
@ -245,16 +244,16 @@ bool ContractABIUtils::appendTypesFromName(
_dynamicTypes += inplaceTypes + dynamicTypes; _dynamicTypes += inplaceTypes + dynamicTypes;
} }
else if (isFixedBoolArray(type)) else if (isFixedBoolArray(type))
_inplaceTypes += vector<ABIType>(arraySize(type), ABIType{ABIType::Boolean}); _inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::Boolean});
else if (isFixedUintArray(type)) else if (isFixedUintArray(type))
_inplaceTypes += vector<ABIType>(arraySize(type), ABIType{ABIType::UnsignedDec}); _inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::UnsignedDec});
else if (isFixedIntArray(type)) else if (isFixedIntArray(type))
_inplaceTypes += vector<ABIType>(arraySize(type), ABIType{ABIType::SignedDec}); _inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::SignedDec});
else if (isFixedStringArray(type)) else if (isFixedStringArray(type))
{ {
_inplaceTypes.push_back(ABIType{ABIType::Hex}); _inplaceTypes.push_back(ABIType{ABIType::Hex});
_dynamicTypes += vector<ABIType>(arraySize(type), ABIType{ABIType::Hex}); _dynamicTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::Hex});
for (size_t i = 0; i < arraySize(type); i++) for (size_t i = 0; i < arraySize(type); i++)
{ {
@ -262,7 +261,7 @@ bool ContractABIUtils::appendTypesFromName(
_dynamicTypes.push_back(ABIType{ABIType::String, ABIType::AlignLeft}); _dynamicTypes.push_back(ABIType{ABIType::String, ABIType::AlignLeft});
} }
} }
else if (optional<ABIType> fixedPointType = isFixedPoint(type)) else if (std::optional<ABIType> fixedPointType = isFixedPoint(type))
_inplaceTypes.push_back(*fixedPointType); _inplaceTypes.push_back(*fixedPointType);
else if (isBytes(type)) else if (isBytes(type))
return false; return false;
@ -280,7 +279,7 @@ void ContractABIUtils::overwriteParameters(
solidity::frontend::test::ParameterList const& _sourceParameters solidity::frontend::test::ParameterList const& _sourceParameters
) )
{ {
using namespace placeholders; using namespace std::placeholders;
for (auto&& [source, target]: ranges::views::zip(_sourceParameters, _targetParameters)) for (auto&& [source, target]: ranges::views::zip(_sourceParameters, _targetParameters))
if ( if (
source.abiType.size != target.abiType.size || source.abiType.size != target.abiType.size ||
@ -304,8 +303,8 @@ solidity::frontend::test::ParameterList ContractABIUtils::preferredParameters(
{ {
_errorReporter.warning( _errorReporter.warning(
"Encoding does not match byte range. The call returned " + "Encoding does not match byte range. The call returned " +
to_string(_bytes.size()) + " bytes, but " + std::to_string(_bytes.size()) + " bytes, but " +
to_string(encodingSize(_targetParameters)) + " bytes were expected." std::to_string(encodingSize(_targetParameters)) + " bytes were expected."
); );
return _sourceParameters; return _sourceParameters;
} }

93
test/libsolidity/util/TestFileParser.cpp
View File

@ -40,7 +40,6 @@ using namespace solidity;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::frontend; using namespace solidity::frontend;
using namespace solidity::frontend::test; using namespace solidity::frontend::test;
using namespace std;
using Token = soltest::Token; using Token = soltest::Token;
@ -54,9 +53,9 @@ char TestFileParser::Scanner::peek() const noexcept
return *next; return *next;
} }
vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCalls(size_t _lineOffset) std::vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCalls(size_t _lineOffset)
{ {
vector<FunctionCall> calls; std::vector<FunctionCall> calls;
if (!accept(Token::EOS)) if (!accept(Token::EOS))
{ {
soltestAssert(m_scanner.currentToken() == Token::Unknown, ""); soltestAssert(m_scanner.currentToken() == Token::Unknown, "");
@ -84,8 +83,8 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
if (calls.empty()) if (calls.empty())
BOOST_THROW_EXCEPTION(TestParserError("Expected function call before gas usage filter.")); BOOST_THROW_EXCEPTION(TestParserError("Expected function call before gas usage filter."));
string runType = m_scanner.currentLiteral(); std::string runType = m_scanner.currentLiteral();
if (set<string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0) if (std::set<std::string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0)
{ {
m_scanner.scanNextToken(); m_scanner.scanNextToken();
expect(Token::Colon); expect(Token::Colon);
@ -104,7 +103,7 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
if (accept(Token::Library, true)) if (accept(Token::Library, true))
{ {
expect(Token::Colon); expect(Token::Colon);
string libraryName; std::string libraryName;
if (accept(Token::String)) if (accept(Token::String))
{ {
call.libraryFile = m_scanner.currentLiteral(); call.libraryFile = m_scanner.currentLiteral();
@ -184,7 +183,7 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
catch (TestParserError const& _e) catch (TestParserError const& _e)
{ {
BOOST_THROW_EXCEPTION( 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<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
return calls; return calls;
} }
vector<string> TestFileParser::parseFunctionCallSideEffects() std::vector<std::string> TestFileParser::parseFunctionCallSideEffects()
{ {
vector<string> result; std::vector<std::string> result;
while (accept(Token::Tilde, false)) while (accept(Token::Tilde, false))
{ {
string effect = m_scanner.currentLiteral(); std::string effect = m_scanner.currentLiteral();
result.emplace_back(effect); result.emplace_back(effect);
soltestAssert(m_scanner.currentToken() == Token::Tilde, ""); soltestAssert(m_scanner.currentToken() == Token::Tilde, "");
m_scanner.scanNextToken(); m_scanner.scanNextToken();
@ -232,9 +231,9 @@ bool TestFileParser::expect(Token _token, bool const _advance)
return true; return true;
} }
pair<string, bool> TestFileParser::parseFunctionSignature() std::pair<std::string, bool> TestFileParser::parseFunctionSignature()
{ {
string signature; std::string signature;
bool hasName = false; bool hasName = false;
if (accept(Token::Identifier, false)) if (accept(Token::Identifier, false))
@ -250,7 +249,7 @@ pair<string, bool> TestFileParser::parseFunctionSignature()
signature += formatToken(Token::LParen); signature += formatToken(Token::LParen);
expect(Token::LParen); expect(Token::LParen);
string parameters; std::string parameters;
if (!accept(Token::RParen, false)) if (!accept(Token::RParen, false))
parameters = parseIdentifierOrTuple(); parameters = parseIdentifierOrTuple();
@ -367,7 +366,7 @@ Parameter TestFileParser::parseParameter()
BOOST_THROW_EXCEPTION(TestParserError("Invalid boolean literal.")); BOOST_THROW_EXCEPTION(TestParserError("Invalid boolean literal."));
parameter.abiType = ABIType{ABIType::Boolean, ABIType::AlignRight, 32}; parameter.abiType = ABIType{ABIType::Boolean, ABIType::AlignRight, 32};
string parsed = parseBoolean(); std::string parsed = parseBoolean();
parameter.rawString += parsed; parameter.rawString += parsed;
parameter.rawBytes = BytesUtils::applyAlign( parameter.rawBytes = BytesUtils::applyAlign(
parameter.alignment, parameter.alignment,
@ -381,7 +380,7 @@ Parameter TestFileParser::parseParameter()
BOOST_THROW_EXCEPTION(TestParserError("Invalid hex number literal.")); BOOST_THROW_EXCEPTION(TestParserError("Invalid hex number literal."));
parameter.abiType = ABIType{ABIType::Hex, ABIType::AlignRight, 32}; parameter.abiType = ABIType{ABIType::Hex, ABIType::AlignRight, 32};
string parsed = parseHexNumber(); std::string parsed = parseHexNumber();
parameter.rawString += parsed; parameter.rawString += parsed;
parameter.rawBytes = BytesUtils::applyAlign( parameter.rawBytes = BytesUtils::applyAlign(
parameter.alignment, parameter.alignment,
@ -396,7 +395,7 @@ Parameter TestFileParser::parseParameter()
if (parameter.alignment != Parameter::Alignment::None) if (parameter.alignment != Parameter::Alignment::None)
BOOST_THROW_EXCEPTION(TestParserError("Hex string literals cannot be aligned or padded.")); BOOST_THROW_EXCEPTION(TestParserError("Hex string literals cannot be aligned or padded."));
string parsed = parseString(); std::string parsed = parseString();
parameter.rawString += "hex\"" + parsed + "\""; parameter.rawString += "hex\"" + parsed + "\"";
parameter.rawBytes = BytesUtils::convertHexNumber(parsed); parameter.rawBytes = BytesUtils::convertHexNumber(parsed);
parameter.abiType = ABIType{ parameter.abiType = ABIType{
@ -410,7 +409,7 @@ Parameter TestFileParser::parseParameter()
if (parameter.alignment != Parameter::Alignment::None) if (parameter.alignment != Parameter::Alignment::None)
BOOST_THROW_EXCEPTION(TestParserError("String literals cannot be aligned or padded.")); 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.abiType = ABIType{ABIType::String, ABIType::AlignLeft, parsed.size()};
parameter.rawString += "\"" + parsed + "\""; parameter.rawString += "\"" + parsed + "\"";
parameter.rawBytes = BytesUtils::applyAlign( parameter.rawBytes = BytesUtils::applyAlign(
@ -424,12 +423,12 @@ Parameter TestFileParser::parseParameter()
auto type = isSigned ? ABIType::SignedDec : ABIType::UnsignedDec; auto type = isSigned ? ABIType::SignedDec : ABIType::UnsignedDec;
parameter.abiType = ABIType{type, ABIType::AlignRight, 32}; parameter.abiType = ABIType{type, ABIType::AlignRight, 32};
string parsed = parseDecimalNumber(); std::string parsed = parseDecimalNumber();
parameter.rawString += parsed; parameter.rawString += parsed;
if (isSigned) if (isSigned)
parsed = "-" + parsed; parsed = "-" + parsed;
if (parsed.find('.') == string::npos) if (parsed.find('.') == std::string::npos)
parameter.rawBytes = BytesUtils::applyAlign( parameter.rawBytes = BytesUtils::applyAlign(
parameter.alignment, parameter.alignment,
parameter.abiType, parameter.abiType,
@ -458,9 +457,9 @@ Parameter TestFileParser::parseParameter()
return parameter; return parameter;
} }
string TestFileParser::parseIdentifierOrTuple() std::string TestFileParser::parseIdentifierOrTuple()
{ {
string identOrTuple; std::string identOrTuple;
auto parseArrayDimensions = [&]() auto parseArrayDimensions = [&]()
{ {
@ -499,43 +498,43 @@ string TestFileParser::parseIdentifierOrTuple()
return identOrTuple; return identOrTuple;
} }
string TestFileParser::parseBoolean() std::string TestFileParser::parseBoolean()
{ {
string literal = m_scanner.currentLiteral(); std::string literal = m_scanner.currentLiteral();
expect(Token::Boolean); expect(Token::Boolean);
return literal; 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)) if (accept(Token::Comment, true))
return comment; 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); expect(Token::Number);
return literal; return literal;
} }
string TestFileParser::parseHexNumber() std::string TestFileParser::parseHexNumber()
{ {
string literal = m_scanner.currentLiteral(); std::string literal = m_scanner.currentLiteral();
expect(Token::HexNumber); expect(Token::HexNumber);
return literal; return literal;
} }
string TestFileParser::parseString() std::string TestFileParser::parseString()
{ {
string literal = m_scanner.currentLiteral(); std::string literal = m_scanner.currentLiteral();
expect(Token::String); expect(Token::String);
return literal; return literal;
} }
void TestFileParser::Scanner::readStream(istream& _stream) void TestFileParser::Scanner::readStream(std::istream& _stream)
{ {
std::string line; std::string line;
// TODO: std::getline(..) removes newlines '\n', if present. This could be improved. // TODO: std::getline(..) removes newlines '\n', if present. This could be improved.
@ -644,16 +643,16 @@ void TestFileParser::Scanner::scanNextToken()
m_currentLiteral = ""; m_currentLiteral = "";
} }
else else
BOOST_THROW_EXCEPTION(TestParserError("Unexpected character: '" + string{current()} + "'")); BOOST_THROW_EXCEPTION(TestParserError("Unexpected character: '" + std::string{current()} + "'"));
break; break;
} }
} }
while (m_currentToken == Token::Whitespace); 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(..). // 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 `/`. // 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). // 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; return line;
} }
string TestFileParser::Scanner::scanComment() std::string TestFileParser::Scanner::scanComment()
{ {
string comment; std::string comment;
advance(); advance();
while (current() != '#') while (current() != '#')
@ -679,9 +678,9 @@ string TestFileParser::Scanner::scanComment()
return comment; return comment;
} }
string TestFileParser::Scanner::scanIdentifierOrKeyword() std::string TestFileParser::Scanner::scanIdentifierOrKeyword()
{ {
string identifier; std::string identifier;
identifier += current(); identifier += current();
while (langutil::isIdentifierPart(peek())) while (langutil::isIdentifierPart(peek()))
{ {
@ -691,9 +690,9 @@ string TestFileParser::Scanner::scanIdentifierOrKeyword()
return identifier; return identifier;
} }
string TestFileParser::Scanner::scanDecimalNumber() std::string TestFileParser::Scanner::scanDecimalNumber()
{ {
string number; std::string number;
number += current(); number += current();
while (langutil::isDecimalDigit(peek()) || '.' == peek()) while (langutil::isDecimalDigit(peek()) || '.' == peek())
{ {
@ -703,9 +702,9 @@ string TestFileParser::Scanner::scanDecimalNumber()
return number; return number;
} }
string TestFileParser::Scanner::scanHexNumber() std::string TestFileParser::Scanner::scanHexNumber()
{ {
string number; std::string number;
number += current(); number += current();
while (langutil::isHexDigit(peek())) while (langutil::isHexDigit(peek()))
{ {
@ -715,9 +714,9 @@ string TestFileParser::Scanner::scanHexNumber()
return number; return number;
} }
string TestFileParser::Scanner::scanString() std::string TestFileParser::Scanner::scanString()
{ {
string str; std::string str;
advance(); advance();
while (current() != '\"') while (current() != '\"')
@ -766,7 +765,7 @@ string TestFileParser::Scanner::scanString()
// TODO: use fromHex() from CommonData // TODO: use fromHex() from CommonData
char TestFileParser::Scanner::scanHexPart() 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' advance(); // skip 'x'

25
test/libsolidity/util/TestFileParserTests.cpp
View File

@ -30,7 +30,6 @@
#include <test/libsolidity/util/SoltestErrors.h> #include <test/libsolidity/util/SoltestErrors.h>
#include <test/libsolidity/util/TestFileParser.h> #include <test/libsolidity/util/TestFileParser.h>
using namespace std;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::test; using namespace solidity::test;
@ -43,23 +42,23 @@ using Mode = FunctionCall::DisplayMode;
namespace namespace
{ {
vector<FunctionCall> parse(string const& _source, std::map<std::string, Builtin> const& _builtins = {}) std::vector<FunctionCall> parse(std::string const& _source, std::map<std::string, Builtin> const& _builtins = {})
{ {
istringstream stream{_source, ios_base::out}; std::istringstream stream{_source, std::ios_base::out};
return TestFileParser{stream, _builtins}.parseFunctionCalls(0); return TestFileParser{stream, _builtins}.parseFunctionCalls(0);
} }
void testFunctionCall( void testFunctionCall(
FunctionCall const& _call, FunctionCall const& _call,
FunctionCall::DisplayMode _mode, FunctionCall::DisplayMode _mode,
string _signature = "", std::string _signature = "",
bool _failure = true, bool _failure = true,
bytes _arguments = bytes{}, bytes _arguments = bytes{},
bytes _expectations = bytes{}, bytes _expectations = bytes{},
FunctionValue _value = { 0 }, FunctionValue _value = { 0 },
string _argumentComment = "", std::string _argumentComment = "",
string _expectationComment = "", std::string _expectationComment = "",
vector<string> _rawArguments = vector<string>{}, std::vector<std::string> _rawArguments = std::vector<std::string>{},
bool _isConstructor = false, bool _isConstructor = false,
bool _isLibrary = false bool _isLibrary = false
) )
@ -242,7 +241,7 @@ BOOST_AUTO_TEST_CASE(call_revert_message)
"f()", "f()",
true, true,
fmt::encodeArgs(), 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); auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 1); 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) 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); auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 1); 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) BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid3)
@ -447,7 +446,7 @@ BOOST_AUTO_TEST_CASE(call_arguments_string)
Mode::SingleLine, Mode::SingleLine,
"f(string)", "f(string)",
false, false,
fmt::encodeDyn(string{"any"}) fmt::encodeDyn(std::string{"any"})
); );
} }
@ -485,7 +484,7 @@ BOOST_AUTO_TEST_CASE(call_return_string)
"f()", "f()",
false, false,
fmt::encodeArgs(), 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 bla bla // ~ bla bla bla
)"; )";
vector<FunctionCall> calls = parse(source, builtins); std::vector<FunctionCall> calls = parse(source, builtins);
BOOST_REQUIRE_EQUAL(calls.size(), 1); BOOST_REQUIRE_EQUAL(calls.size(), 1);
BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 3); BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 3);
BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "bla"); BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "bla");

67
test/libsolidity/util/TestFunctionCall.cpp
View File

@ -28,33 +28,32 @@
using namespace solidity; using namespace solidity;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::frontend::test; using namespace solidity::frontend::test;
using namespace std;
using Token = soltest::Token; using Token = soltest::Token;
string TestFunctionCall::format( std::string TestFunctionCall::format(
ErrorReporter& _errorReporter, ErrorReporter& _errorReporter,
string const& _linePrefix, std::string const& _linePrefix,
RenderMode _renderMode, RenderMode _renderMode,
bool const _highlight, bool const _highlight,
bool const _interactivePrint bool const _interactivePrint
) const ) const
{ {
stringstream stream; std::stringstream stream;
bool highlight = !matchesExpectation() && _highlight; bool highlight = !matchesExpectation() && _highlight;
auto formatOutput = [&](bool const _singleLine) auto formatOutput = [&](bool const _singleLine)
{ {
string ws = " "; std::string ws = " ";
string arrow = formatToken(Token::Arrow); std::string arrow = formatToken(Token::Arrow);
string colon = formatToken(Token::Colon); std::string colon = formatToken(Token::Colon);
string comma = formatToken(Token::Comma); std::string comma = formatToken(Token::Comma);
string comment = formatToken(Token::Comment); std::string comment = formatToken(Token::Comment);
string ether = formatToken(Token::Ether); std::string ether = formatToken(Token::Ether);
string wei = formatToken(Token::Wei); std::string wei = formatToken(Token::Wei);
string newline = formatToken(Token::Newline); std::string newline = formatToken(Token::Newline);
string failure = formatToken(Token::Failure); std::string failure = formatToken(Token::Failure);
if (m_call.kind == FunctionCall::Kind::Library) if (m_call.kind == FunctionCall::Kind::Library)
{ {
@ -83,7 +82,7 @@ string TestFunctionCall::format(
} }
if (!m_call.arguments.rawBytes().empty()) 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; stream << colon;
if (!m_call.arguments.parameters.at(0).format.newline) if (!m_call.arguments.parameters.at(0).format.newline)
stream << ws; stream << ws;
@ -107,17 +106,17 @@ string TestFunctionCall::format(
} }
else else
{ {
stream << endl << _linePrefix << newline << ws; stream << std::endl << _linePrefix << newline << ws;
if (!m_call.arguments.comment.empty()) if (!m_call.arguments.comment.empty())
{ {
stream << comment << m_call.arguments.comment << comment; stream << comment << m_call.arguments.comment << comment;
stream << endl << _linePrefix << newline << ws; stream << std::endl << _linePrefix << newline << ws;
} }
stream << arrow; stream << arrow;
} }
/// Format either the expected output or the actual result output /// Format either the expected output or the actual result output
string result; std::string result;
if (_renderMode != RenderMode::ActualValuesExpectedGas) if (_renderMode != RenderMode::ActualValuesExpectedGas)
{ {
bool const isFailure = m_call.expectations.failure; bool const isFailure = m_call.expectations.failure;
@ -162,7 +161,7 @@ string TestFunctionCall::format(
m_call.signature m_call.signature
); );
string bytesOutput = abiParams ? std::string bytesOutput = abiParams ?
BytesUtils::formatRawBytes(output, abiParams.value(), _linePrefix) : BytesUtils::formatRawBytes(output, abiParams.value(), _linePrefix) :
BytesUtils::formatRawBytes( BytesUtils::formatRawBytes(
output, output,
@ -194,12 +193,12 @@ string TestFunctionCall::format(
{ {
if (!m_call.expectations.comment.empty()) if (!m_call.expectations.comment.empty())
{ {
stream << endl << _linePrefix << newline << ws; stream << std::endl << _linePrefix << newline << ws;
stream << comment << m_call.expectations.comment << comment; stream << comment << m_call.expectations.comment << comment;
} }
} }
vector<string> sideEffects; std::vector<std::string> sideEffects;
if (_renderMode == RenderMode::ExpectedValuesExpectedGas || _renderMode == RenderMode::ExpectedValuesActualGas) if (_renderMode == RenderMode::ExpectedValuesExpectedGas || _renderMode == RenderMode::ExpectedValuesActualGas)
sideEffects = m_call.expectedSideEffects; sideEffects = m_call.expectedSideEffects;
else else
@ -221,10 +220,10 @@ string TestFunctionCall::format(
return stream.str(); return stream.str();
} }
string TestFunctionCall::formatBytesParameters( std::string TestFunctionCall::formatBytesParameters(
ErrorReporter& _errorReporter, ErrorReporter& _errorReporter,
bytes const& _bytes, bytes const& _bytes,
string const& _signature, std::string const& _signature,
solidity::frontend::test::ParameterList const& _parameters, solidity::frontend::test::ParameterList const& _parameters,
bool _highlight, bool _highlight,
bool _failure bool _failure
@ -232,7 +231,7 @@ string TestFunctionCall::formatBytesParameters(
{ {
using ParameterList = solidity::frontend::test::ParameterList; using ParameterList = solidity::frontend::test::ParameterList;
stringstream os; std::stringstream os;
if (_bytes.empty()) if (_bytes.empty())
return {}; return {};
@ -281,7 +280,7 @@ string TestFunctionCall::formatBytesParameters(
} }
} }
string TestFunctionCall::formatFailure( std::string TestFunctionCall::formatFailure(
ErrorReporter& _errorReporter, ErrorReporter& _errorReporter,
solidity::frontend::test::FunctionCall const& _call, solidity::frontend::test::FunctionCall const& _call,
bytes const& _output, bytes const& _output,
@ -289,7 +288,7 @@ string TestFunctionCall::formatFailure(
bool _highlight bool _highlight
) const ) const
{ {
stringstream os; std::stringstream os;
os << formatToken(Token::Failure); os << formatToken(Token::Failure);
@ -311,34 +310,34 @@ string TestFunctionCall::formatFailure(
return os.str(); return os.str();
} }
string TestFunctionCall::formatRawParameters( std::string TestFunctionCall::formatRawParameters(
solidity::frontend::test::ParameterList const& _params, solidity::frontend::test::ParameterList const& _params,
std::string const& _linePrefix std::string const& _linePrefix
) const ) const
{ {
stringstream os; std::stringstream os;
for (auto const& param: _params) for (auto const& param: _params)
if (!param.rawString.empty()) if (!param.rawString.empty())
{ {
if (param.format.newline) if (param.format.newline)
os << endl << _linePrefix << "// "; os << std::endl << _linePrefix << "// ";
for (auto const c: param.rawString) for (auto const c: param.rawString)
// NOTE: Even though we have a toHex() overload specifically for uint8_t, the compiler // 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. // chooses the one for bytes if the second argument is omitted.
os << (c >= ' ' ? string(1, c) : "\\x" + util::toHex(static_cast<uint8_t>(c), HexCase::Lower)); os << (c >= ' ' ? std::string(1, c) : "\\x" + util::toHex(static_cast<uint8_t>(c), HexCase::Lower));
if (&param != &_params.back()) if (&param != &_params.back())
os << ", "; os << ", ";
} }
return os.str(); return os.str();
} }
string TestFunctionCall::formatGasExpectations( std::string TestFunctionCall::formatGasExpectations(
string const& _linePrefix, std::string const& _linePrefix,
bool _useActualCost, bool _useActualCost,
bool _showDifference bool _showDifference
) const ) const
{ {
stringstream os; std::stringstream os;
for (auto const& [runType, gasUsed]: (_useActualCost ? m_gasCosts : m_call.expectations.gasUsed)) for (auto const& [runType, gasUsed]: (_useActualCost ? m_gasCosts : m_call.expectations.gasUsed))
if (!runType.empty()) if (!runType.empty())
{ {
@ -357,9 +356,9 @@ string TestFunctionCall::formatGasExpectations(
percent = static_cast<int>( percent = static_cast<int>(
100.0 * (static_cast<double>(difference) / static_cast<double>(m_call.expectations.gasUsed.at(runType))) 100.0 * (static_cast<double>(difference) / static_cast<double>(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) if (_showDifference && differentResults && _useActualCost)
os << " [" << showpos << difference << " (" << percent << "%)]"; os << " [" << std::showpos << difference << " (" << percent << "%)]";
} }
return os.str(); return os.str();
} }

53
test/libsolidity/util/TestFunctionCallTests.cpp
View File

@ -25,7 +25,6 @@
#include <test/libsolidity/util/TestFunctionCall.h> #include <test/libsolidity/util/TestFunctionCall.h>
using namespace std;
using namespace solidity::util; using namespace solidity::util;
using namespace solidity::test; using namespace solidity::test;
@ -39,8 +38,8 @@ BOOST_AUTO_TEST_CASE(format_unsigned_singleline)
bytes expectedBytes = toBigEndian(u256{1}); bytes expectedBytes = toBigEndian(u256{1});
ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(uint8)", {0}, arguments, expectations}; FunctionCall call{"f(uint8)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
@ -59,8 +58,8 @@ BOOST_AUTO_TEST_CASE(format_unsigned_singleline_signed_encoding)
bytes expectedBytes = toBigEndian(u256{1}); bytes expectedBytes = toBigEndian(u256{1});
ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(uint8)", {0}, arguments, expectations}; FunctionCall call{"f(uint8)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
@ -79,8 +78,8 @@ BOOST_AUTO_TEST_CASE(format_unsigned_multiline)
bytes expectedBytes = toBigEndian(u256{1}); bytes expectedBytes = toBigEndian(u256{1});
ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
Parameter result{expectedBytes, "1", abiType, FormatInfo{}}; Parameter result{expectedBytes, "1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{result}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{result}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{}, std::string{}};
FunctionCall call{"f(uint8)", {0}, arguments, expectations}; FunctionCall call{"f(uint8)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
call.displayMode = FunctionCall::DisplayMode::MultiLine; call.displayMode = FunctionCall::DisplayMode::MultiLine;
@ -94,8 +93,8 @@ BOOST_AUTO_TEST_CASE(format_multiple_unsigned_singleline)
bytes expectedBytes = toBigEndian(u256{1}); bytes expectedBytes = toBigEndian(u256{1});
ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param, param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param, param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param, param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param, param}, std::string{}};
FunctionCall call{"f(uint8, uint8)", {0}, arguments, expectations}; FunctionCall call{"f(uint8, uint8)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -108,8 +107,8 @@ BOOST_AUTO_TEST_CASE(format_signed_singleline)
bytes expectedBytes = toBigEndian(u256{-1}); bytes expectedBytes = toBigEndian(u256{-1});
ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "-1", abiType, FormatInfo{}}; Parameter param{expectedBytes, "-1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(int8)", {0}, arguments, expectations}; FunctionCall call{"f(int8)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -128,8 +127,8 @@ BOOST_AUTO_TEST_CASE(format_hex_singleline)
bytes expectedBytes = result + bytes(32 - result.size(), 0); bytes expectedBytes = result + bytes(32 - result.size(), 0);
ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32}; ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "0x31", abiType, FormatInfo{}}; Parameter param{expectedBytes, "0x31", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(bytes32)", {0}, arguments, expectations}; FunctionCall call{"f(bytes32)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -150,8 +149,8 @@ BOOST_AUTO_TEST_CASE(format_hex_string_singleline)
bytes expectedBytes = fromHex("4200ef"); bytes expectedBytes = fromHex("4200ef");
ABIType abiType{ABIType::HexString, ABIType::AlignLeft, 3}; ABIType abiType{ABIType::HexString, ABIType::AlignLeft, 3};
Parameter param{expectedBytes, "hex\"4200ef\"", abiType, FormatInfo{}}; Parameter param{expectedBytes, "hex\"4200ef\"", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(string)", {0}, arguments, expectations}; FunctionCall call{"f(string)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -164,8 +163,8 @@ BOOST_AUTO_TEST_CASE(format_bool_true_singleline)
bytes expectedBytes = toBigEndian(u256{true}); bytes expectedBytes = toBigEndian(u256{true});
ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32}; ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "true", abiType, FormatInfo{}}; Parameter param{expectedBytes, "true", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(bool)", {0}, arguments, expectations}; FunctionCall call{"f(bool)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -185,8 +184,8 @@ BOOST_AUTO_TEST_CASE(format_bool_false_singleline)
bytes expectedBytes = toBigEndian(u256{false}); bytes expectedBytes = toBigEndian(u256{false});
ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32}; ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "false", abiType, FormatInfo{}}; Parameter param{expectedBytes, "false", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(bool)", {0}, arguments, expectations}; FunctionCall call{"f(bool)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -199,8 +198,8 @@ BOOST_AUTO_TEST_CASE(format_bool_left_singleline)
bytes expectedBytes = toBigEndian(u256{false}); bytes expectedBytes = toBigEndian(u256{false});
ABIType abiType{ABIType::Boolean, ABIType::AlignLeft, 32}; ABIType abiType{ABIType::Boolean, ABIType::AlignLeft, 32};
Parameter param{expectedBytes, "left(false)", abiType, FormatInfo{}}; Parameter param{expectedBytes, "left(false)", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(bool)", {0}, arguments, expectations}; FunctionCall call{"f(bool)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -214,8 +213,8 @@ BOOST_AUTO_TEST_CASE(format_hex_number_right_singleline)
bytes expectedBytes = result + bytes(32 - result.size(), 0); bytes expectedBytes = result + bytes(32 - result.size(), 0);
ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32}; ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "right(0x42)", abiType, FormatInfo{}}; Parameter param{expectedBytes, "right(0x42)", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(bool)", {0}, arguments, expectations}; FunctionCall call{"f(bool)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -228,8 +227,8 @@ BOOST_AUTO_TEST_CASE(format_empty_byte_range)
bytes expectedBytes; bytes expectedBytes;
ABIType abiType{ABIType::None, ABIType::AlignNone, 0}; ABIType abiType{ABIType::None, ABIType::AlignNone, 0};
Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{param}, false, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{}, std::string{}};
FunctionCall call{"f()", {0}, arguments, expectations}; FunctionCall call{"f()", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};
@ -242,8 +241,8 @@ BOOST_AUTO_TEST_CASE(format_failure_singleline)
bytes expectedBytes = toBigEndian(u256{1}); bytes expectedBytes = toBigEndian(u256{1});
ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32}; ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
Parameter param{expectedBytes, "1", abiType, FormatInfo{}}; Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
FunctionCallExpectations expectations{vector<Parameter>{}, true, string{}, {}}; FunctionCallExpectations expectations{std::vector<Parameter>{}, true, std::string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}}; FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(uint8)", {0}, arguments, expectations}; FunctionCall call{"f(uint8)", {0}, arguments, expectations};
call.omitsArrow = false; call.omitsArrow = false;
TestFunctionCall test{call}; TestFunctionCall test{call};