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/analysis/*
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::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<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, "");
@ -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<u256>(_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<u256>(_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<ParameterList::difference_type>(parameter.abiType.size)
);
@ -292,7 +291,7 @@ string BytesUtils::formatRawBytes(
os << _linePrefix << byteRange;
if (&parameter != &parameters.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<char, double> frequencies;
std::map<char, double> 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<ParameterList::difference_type>(parameter.abiType.size)
);

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

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

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

@ -20,22 +20,21 @@
#include <regex>
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, "");
}

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

@ -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<size_t>(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<ABIType> isFixedPoint(string const& type)
std::optional<ABIType> isFixedPoint(std::string const& type)
{
optional<ABIType> fixedPointType;
smatch matches;
if (regex_match(type, matches, regex{"(u?)fixed(\\d+)x(\\d+)"}))
std::optional<ABIType> 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<ABIType> 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<solidity::frontend::test::ParameterList> ContractABIUtils::parametersFromJsonOutputs(
ErrorReporter& _errorReporter,
Json::Value const& _contractABI,
string const& _functionSignature
std::string const& _functionSignature
)
{
if (!_contractABI)
@ -178,7 +177,7 @@ std::optional<solidity::frontend::test::ParameterList> 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<ABIType>(arraySize(type), ABIType{ABIType::Boolean});
_inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::Boolean});
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))
_inplaceTypes += vector<ABIType>(arraySize(type), ABIType{ABIType::SignedDec});
_inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::SignedDec});
else if (isFixedStringArray(type))
{
_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++)
{
@ -262,7 +261,7 @@ bool ContractABIUtils::appendTypesFromName(
_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);
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;
}

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

@ -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<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))
{
soltestAssert(m_scanner.currentToken() == Token::Unknown, "");
@ -84,8 +83,8 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
if (calls.empty())
BOOST_THROW_EXCEPTION(TestParserError("Expected function call before gas usage filter."));
string runType = m_scanner.currentLiteral();
if (set<string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0)
std::string runType = m_scanner.currentLiteral();
if (std::set<std::string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0)
{
m_scanner.scanNextToken();
expect(Token::Colon);
@ -104,7 +103,7 @@ vector<solidity::frontend::test::FunctionCall> 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<solidity::frontend::test::FunctionCall> 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<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
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))
{
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<string, bool> TestFileParser::parseFunctionSignature()
std::pair<std::string, bool> TestFileParser::parseFunctionSignature()
{
string signature;
std::string signature;
bool hasName = false;
if (accept(Token::Identifier, false))
@ -250,7 +249,7 @@ pair<string, bool> 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'

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

@ -30,7 +30,6 @@
#include <test/libsolidity/util/SoltestErrors.h>
#include <test/libsolidity/util/TestFileParser.h>
using namespace std;
using namespace solidity::util;
using namespace solidity::test;
@ -43,23 +42,23 @@ using Mode = FunctionCall::DisplayMode;
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);
}
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<string> _rawArguments = vector<string>{},
std::string _argumentComment = "",
std::string _expectationComment = "",
std::vector<std::string> _rawArguments = std::vector<std::string>{},
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<FunctionCall> calls = parse(source, builtins);
std::vector<FunctionCall> 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");

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

@ -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<string> sideEffects;
std::vector<std::string> 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<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())
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<int>(
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)
os << " [" << showpos << difference << " (" << percent << "%)]";
os << " [" << std::showpos << difference << " (" << percent << "%)]";
}
return os.str();
}

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

@ -25,7 +25,6 @@
#include <test/libsolidity/util/TestFunctionCall.h>
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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{result}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{result}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{}, 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<Parameter>{param, param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param, param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param, param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{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<Parameter>{param}, false, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{}, 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<Parameter>{}, true, string{}, {}};
FunctionCallArgs arguments{vector<Parameter>{param}, string{}};
FunctionCallExpectations expectations{std::vector<Parameter>{}, true, std::string{}, {}};
FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
FunctionCall call{"f(uint8)", {0}, arguments, expectations};
call.omitsArrow = false;
TestFunctionCall test{call};