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

deprecate using namespace std

Browse Source 
test: updat filereader test

deprecate namespace std

deprecate namespace std

deprecate namespace std

deprecate namespace std

deprecate namespace std

deprecate namespace std

deprecate namespace std

deprecate namespace std

deprecated std namespace

deprecated std namespace

deprecated std namespace

deprecated std namespace

deprecated std namespace

deprecated std namespace

deprecated std namespace

deprecated std namespace

deprecated std namespace

depecrate namespace std

deprecated namespace std

check ci

clean line

Co-authored-by: Nikola Matić <nikola.matic@ethereum.org>

purge line

pure line

deprecate std

deprecate std

deprecate std

deprecate std

deprecate std

deprecate

deprecate std

bye namespace
This commit is contained in:
Paul 2023-08-30 00:08:06 +00:00 committed by Nikola Matic
parent df03f1412d
commit b3230b0bdc
52 changed files with 923 additions and 960 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
scripts/check_style.sh
View File

@ -38,6 +38,13 @@ NAMESPACE_STD_FREE_FILES=(
libyul/backends/evm/*
libyul/optimiser/*
solc/*
test/contracts/*
test/libevmasm/*
test/liblangutil/*
test/libsolutil/*
test/libsolidity/*
test/libsolidity/analysis/*
test/libsolidity/interface/*
)
(

39
test/contracts/AuctionRegistrar.cpp
View File

@ -32,7 +32,6 @@
#include <string>
#include <optional>
using namespace std;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::test;
@ -235,47 +234,47 @@ protected:
{
public:
RegistrarInterface(SolidityExecutionFramework& _framework): ContractInterface(_framework) {}
void reserve(string const& _name)
void reserve(std::string const& _name)
{
callString("reserve", _name);
}
h160 owner(string const& _name)
h160 owner(std::string const& _name)
{
return callStringReturnsAddress("owner", _name);
}
void setAddress(string const& _name, h160 const& _address, bool _primary)
void setAddress(std::string const& _name, h160 const& _address, bool _primary)
{
callStringAddressBool("setAddress", _name, _address, _primary);
}
h160 addr(string const& _name)
h160 addr(std::string const& _name)
{
return callStringReturnsAddress("addr", _name);
}
string name(h160 const& _addr)
std::string name(h160 const& _addr)
{
return callAddressReturnsString("name", _addr);
}
void setSubRegistrar(string const& _name, h160 const& _address)
void setSubRegistrar(std::string const& _name, h160 const& _address)
{
callStringAddress("setSubRegistrar", _name, _address);
}
h160 subRegistrar(string const& _name)
h160 subRegistrar(std::string const& _name)
{
return callStringReturnsAddress("subRegistrar", _name);
}
void setContent(string const& _name, h256 const& _content)
void setContent(std::string const& _name, h256 const& _content)
{
callStringBytes32("setContent", _name, _content);
}
h256 content(string const& _name)
h256 content(std::string const& _name)
{
return callStringReturnsBytes32("content", _name);
}
void transfer(string const& _name, h160 const& _target)
void transfer(std::string const& _name, h160 const& _target)
{
return callStringAddress("transfer", _name, _target);
}
void disown(string const& _name)
void disown(std::string const& _name)
{
return callString("disown", _name);
}
@ -298,7 +297,7 @@ BOOST_AUTO_TEST_CASE(reserve)
{
// Test that reserving works for long strings
deployRegistrar();
vector<string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"};
std::vector<std::string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"};
RegistrarInterface registrar(*this);
@ -317,7 +316,7 @@ BOOST_AUTO_TEST_CASE(double_reserve_long)
{
// Test that it is not possible to re-reserve from a different address.
deployRegistrar();
string name = "abcabcabcabcabcabcabcabcabcabca";
std::string name = "abcabcabcabcabcabcabcabcabcabca";
RegistrarInterface registrar(*this);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), m_sender);
@ -333,10 +332,10 @@ BOOST_AUTO_TEST_CASE(properties)
// Test setting and retrieving the various properties works.
deployRegistrar();
RegistrarInterface registrar(*this);
string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"};
std::string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"};
size_t addr = 0x9872543;
size_t count = 1;
for (string const& name: names)
for (std::string const& name: names)
{
m_sender = account(0);
sendEther(account(count), u256(20) * ether);
@ -369,7 +368,7 @@ BOOST_AUTO_TEST_CASE(properties)
BOOST_AUTO_TEST_CASE(transfer)
{
deployRegistrar();
string name = "abcaoeguaoucaeoduceo";
std::string name = "abcaoeguaoucaeoduceo";
RegistrarInterface registrar(*this);
registrar.reserve(name);
registrar.setContent(name, h256(u256(123)));
@ -381,7 +380,7 @@ BOOST_AUTO_TEST_CASE(transfer)
BOOST_AUTO_TEST_CASE(disown)
{
deployRegistrar();
string name = "abcaoeguaoucaeoduceo";
std::string name = "abcaoeguaoucaeoduceo";
RegistrarInterface registrar(*this);
registrar.reserve(name);
@ -408,7 +407,7 @@ BOOST_AUTO_TEST_CASE(disown)
BOOST_AUTO_TEST_CASE(auction_simple)
{
deployRegistrar();
string name = "x";
std::string name = "x";
RegistrarInterface registrar(*this);
// initiate auction
@ -426,7 +425,7 @@ BOOST_AUTO_TEST_CASE(auction_simple)
BOOST_AUTO_TEST_CASE(auction_bidding)
{
deployRegistrar();
string name = "x";
std::string name = "x";
unsigned startTime = 0x776347e2;
m_evmcHost->tx_context.block_timestamp = startTime;

5
test/contracts/Wallet.cpp
View File

@ -38,7 +38,6 @@
#include <test/libsolidity/SolidityExecutionFramework.h>
using namespace std;
using namespace solidity::test;
using namespace solidity::util;
@ -445,7 +444,7 @@ class WalletTestFramework: public SolidityExecutionFramework
protected:
void deployWallet(
u256 const& _value = 0,
vector<h160> const& _owners = vector<h160>{},
std::vector<h160> const& _owners = std::vector<h160>{},
u256 _required = 1,
u256 _dailyLimit = 0
)
@ -535,7 +534,7 @@ BOOST_AUTO_TEST_CASE(remove_owner)
BOOST_AUTO_TEST_CASE(initial_owners)
{
vector<h160> owners{
std::vector<h160> owners{
h160("0x42c56279432962a17176998a4747d1b4d6ed4367"),
h160("0xd4d4669f5ba9f4c27d38ef02a358c339b5560c47"),
h160("0xe6716f9544a56c530d868e4bfbacb172315bdead"),

76
test/libevmasm/Assembler.cpp
View File

@ -34,9 +34,9 @@
#include <string>
#include <tuple>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::evmasm;
using namespace std::string_literals;
namespace solidity::frontend::test
{
@ -55,34 +55,34 @@ BOOST_AUTO_TEST_SUITE(Assembler)
BOOST_AUTO_TEST_CASE(all_assembly_items)
{
map<string, unsigned> indices = {
std::map<std::string, unsigned> indices = {
{ "root.asm", 0 },
{ "sub.asm", 1 },
{ "verbatim.asm", 2 }
};
EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
Assembly _assembly{evmVersion, false, {}};
auto root_asm = make_shared<string>("root.asm");
auto root_asm = std::make_shared<std::string>("root.asm");
_assembly.setSourceLocation({1, 3, root_asm});
Assembly _subAsm{evmVersion, false, {}};
auto sub_asm = make_shared<string>("sub.asm");
auto sub_asm = std::make_shared<std::string>("sub.asm");
_subAsm.setSourceLocation({6, 8, sub_asm});
Assembly _verbatimAsm(evmVersion, true, "");
auto verbatim_asm = make_shared<string>("verbatim.asm");
auto verbatim_asm = std::make_shared<std::string>("verbatim.asm");
_verbatimAsm.setSourceLocation({8, 18, verbatim_asm});
// PushImmutable
_subAsm.appendImmutable("someImmutable");
_subAsm.append(AssemblyItem(PushTag, 0));
_subAsm.append(Instruction::INVALID);
shared_ptr<Assembly> _subAsmPtr = make_shared<Assembly>(_subAsm);
std::shared_ptr<Assembly> _subAsmPtr = std::make_shared<Assembly>(_subAsm);
_verbatimAsm.appendVerbatim({0xff,0xff}, 0, 0);
_verbatimAsm.appendVerbatim({0x74, 0x65, 0x73, 0x74}, 0, 1);
_verbatimAsm.append(Instruction::MSTORE);
shared_ptr<Assembly> _verbatimAsmPtr = make_shared<Assembly>(_verbatimAsm);
std::shared_ptr<Assembly> _verbatimAsmPtr = std::make_shared<Assembly>(_verbatimAsm);
// Tag
auto tag = _assembly.newTag();
@ -177,7 +177,7 @@ BOOST_AUTO_TEST_CASE(all_assembly_items)
"\n"
"auxdata: 0x4266eeaa\n"
);
string json{
std::string json{
"{\".auxdata\":\"4266eeaa\",\".code\":["
"{\"begin\":1,\"end\":3,\"name\":\"tag\",\"source\":0,\"value\":\"1\"},"
"{\"begin\":1,\"end\":3,\"name\":\"JUMPDEST\",\"source\":0},"
@ -221,11 +221,11 @@ BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
// Tests for 1, 2, 3 number of immutables.
for (int numImmutables = 1; numImmutables <= 3; ++numImmutables)
{
BOOST_TEST_MESSAGE("NumImmutables: "s + to_string(numImmutables));
BOOST_TEST_MESSAGE("NumImmutables: "s + std::to_string(numImmutables));
// Tests for the cases 1, 2, 3 occurrences of an immutable reference.
for (int numActualRefs = 1; numActualRefs <= 3; ++numActualRefs)
{
BOOST_TEST_MESSAGE("NumActualRefs: "s + to_string(numActualRefs));
BOOST_TEST_MESSAGE("NumActualRefs: "s + std::to_string(numActualRefs));
auto const NumExpectedMappings =
(
2 + // PUSH <a> PUSH <b>
@ -238,21 +238,21 @@ BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
NumSubs + // PUSH <addr> for every sub assembly
1; // INVALID
auto assemblyName = make_shared<string>("root.asm");
auto subName = make_shared<string>("sub.asm");
auto assemblyName = std::make_shared<std::string>("root.asm");
auto subName = std::make_shared<std::string>("sub.asm");
map<string, unsigned> indices = {
std::map<std::string, unsigned> indices = {
{ *assemblyName, 0 },
{ *subName, 1 }
};
auto subAsm = make_shared<Assembly>(evmVersion, false, string{});
auto subAsm = std::make_shared<Assembly>(evmVersion, false, std::string{});
for (char i = 0; i < numImmutables; ++i)
{
for (int r = 0; r < numActualRefs; ++r)
{
subAsm->setSourceLocation(SourceLocation{10*i, 10*i + 6 + r, subName});
subAsm->appendImmutable(string(1, char('a' + i))); // "a", "b", ...
subAsm->appendImmutable(std::string(1, char('a' + i))); // "a", "b", ...
}
}
@ -262,34 +262,34 @@ BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
assembly.setSourceLocation({10*i, 10*i + 3+i, assemblyName});
assembly.append(u256(0x71)); // immutble value
assembly.append(u256(0)); // target... modules?
assembly.appendImmutableAssignment(string(1, char('a' + i - 1)));
assembly.appendImmutableAssignment(std::string(1, char('a' + i - 1)));
}
assembly.appendSubroutine(subAsm);
checkCompilation(assembly);
string const sourceMappings = AssemblyItem::computeSourceMapping(assembly.items(), indices);
std::string const sourceMappings = AssemblyItem::computeSourceMapping(assembly.items(), indices);
auto const numberOfMappings = std::count(sourceMappings.begin(), sourceMappings.end(), ';');
LinkerObject const& obj = assembly.assemble();
string const disassembly = disassemble(obj.bytecode, evmVersion, "\n");
std::string const disassembly = disassemble(obj.bytecode, evmVersion, "\n");
auto const numberOfOpcodes = std::count(disassembly.begin(), disassembly.end(), '\n');
#if 0 // {{{ debug prints
{
LinkerObject const& subObj = assembly.sub(0).assemble();
string const subDisassembly = disassemble(subObj.bytecode, "\n");
cout << '\n';
cout << "### immutables: " << numImmutables << ", refs: " << numActualRefs << '\n';
cout << " - srcmap: \"" << sourceMappings << "\"\n";
cout << " - src mappings: " << numberOfMappings << '\n';
cout << " - opcodes: " << numberOfOpcodes << '\n';
cout << " - subs: " << assembly.numSubs() << '\n';
cout << " - sub opcodes " << std::count(subDisassembly.begin(), subDisassembly.end(), '\n') << '\n';
cout << " - sub srcmaps " << AssemblyItem::computeSourceMapping(subAsm->items(), indices) << '\n';
cout << " - main bytecode:\n\t" << disassemble(obj.bytecode, "\n\t");
cout << "\r - sub bytecode:\n\t" << disassemble(subObj.bytecode, "\n\t");
std::string const subDisassembly = disassemble(subObj.bytecode, "\n");
std::cout << '\n';
std::cout << "### immutables: " << numImmutables << ", refs: " << numActualRefs << '\n';
std::cout << " - srcmap: \"" << sourceMappings << "\"\n";
std::cout << " - src mappings: " << numberOfMappings << '\n';
std::cout << " - opcodes: " << numberOfOpcodes << '\n';
std::cout << " - subs: " << assembly.numSubs() << '\n';
std::cout << " - sub opcodes " << std::count(subDisassembly.begin(), subDisassembly.end(), '\n') << '\n';
std::cout << " - sub srcmaps " << AssemblyItem::computeSourceMapping(subAsm->items(), indices) << '\n';
std::cout << " - main bytecode:\n\t" << disassemble(obj.bytecode, "\n\t");
std::cout << "\r - sub bytecode:\n\t" << disassemble(subObj.bytecode, "\n\t");
}
#endif // }}}
@ -301,22 +301,22 @@ BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
BOOST_AUTO_TEST_CASE(immutable)
{
map<string, unsigned> indices = {
std::map<std::string, unsigned> indices = {
{ "root.asm", 0 },
{ "sub.asm", 1 }
};
EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
Assembly _assembly{evmVersion, true, {}};
auto root_asm = make_shared<string>("root.asm");
auto root_asm = std::make_shared<std::string>("root.asm");
_assembly.setSourceLocation({1, 3, root_asm});
Assembly _subAsm{evmVersion, false, {}};
auto sub_asm = make_shared<string>("sub.asm");
auto sub_asm = std::make_shared<std::string>("sub.asm");
_subAsm.setSourceLocation({6, 8, sub_asm});
_subAsm.appendImmutable("someImmutable");
_subAsm.appendImmutable("someOtherImmutable");
_subAsm.appendImmutable("someImmutable");
shared_ptr<Assembly> _subAsmPtr = make_shared<Assembly>(_subAsm);
std::shared_ptr<Assembly> _subAsmPtr = std::make_shared<Assembly>(_subAsm);
_assembly.append(u256(42));
_assembly.append(u256(0));
@ -330,9 +330,9 @@ BOOST_AUTO_TEST_CASE(immutable)
checkCompilation(_assembly);
string genericPush0 = evmVersion.hasPush0() ? "5f" : "6000";
std::string genericPush0 = evmVersion.hasPush0() ? "5f" : "6000";
// PUSH1 0x1b v/s PUSH1 0x19
string dataOffset = evmVersion.hasPush0() ? "6019" : "601b" ;
std::string dataOffset = evmVersion.hasPush0() ? "6019" : "601b" ;
BOOST_CHECK_EQUAL(
_assembly.assemble().toHex(),
@ -406,8 +406,8 @@ BOOST_AUTO_TEST_CASE(subobject_encode_decode)
EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
Assembly assembly{evmVersion, true, {}};
shared_ptr<Assembly> subAsmPtr = make_shared<Assembly>(evmVersion, false, string{});
shared_ptr<Assembly> subSubAsmPtr = make_shared<Assembly>(evmVersion, false, string{});
std::shared_ptr<Assembly> subAsmPtr = std::make_shared<Assembly>(evmVersion, false, std::string{});
std::shared_ptr<Assembly> subSubAsmPtr = std::make_shared<Assembly>(evmVersion, false, std::string{});
assembly.appendSubroutine(subAsmPtr);
subAsmPtr->appendSubroutine(subSubAsmPtr);
@ -416,7 +416,7 @@ BOOST_AUTO_TEST_CASE(subobject_encode_decode)
BOOST_REQUIRE_THROW(assembly.encodeSubPath({1}), solidity::evmasm::AssemblyException);
BOOST_REQUIRE_THROW(assembly.decodeSubPath(1), solidity::evmasm::AssemblyException);
vector<size_t> subPath{0, 0};
std::vector<size_t> subPath{0, 0};
BOOST_CHECK(assembly.decodeSubPath(assembly.encodeSubPath(subPath)) == subPath);
}

17
test/libevmasm/Optimiser.cpp
View File

@ -39,7 +39,6 @@
#include <tuple>
#include <memory>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::evmasm;
@ -874,7 +873,7 @@ BOOST_AUTO_TEST_CASE(block_deduplicator)
BlockDeduplicator deduplicator(input);
deduplicator.deduplicate();
set<u256> pushTags;
std::set<u256> pushTags;
for (AssemblyItem const& item: input)
if (item.type() == PushTag)
pushTags.insert(item.data());
@ -968,7 +967,7 @@ BOOST_AUTO_TEST_CASE(block_deduplicator_loops)
BlockDeduplicator deduplicator(input);
deduplicator.deduplicate();
set<u256> pushTags;
std::set<u256> pushTags;
for (AssemblyItem const& item: input)
if (item.type() == PushTag)
pushTags.insert(item.data());
@ -1051,7 +1050,7 @@ BOOST_AUTO_TEST_CASE(peephole_pop_calldatasize)
BOOST_AUTO_TEST_CASE(peephole_commutative_swap1)
{
vector<Instruction> ops{
std::vector<Instruction> ops{
Instruction::ADD,
Instruction::MUL,
Instruction::EQ,
@ -1088,7 +1087,7 @@ BOOST_AUTO_TEST_CASE(peephole_commutative_swap1)
BOOST_AUTO_TEST_CASE(peephole_noncommutative_swap1)
{
// NOTE: not comprehensive
vector<Instruction> ops{
std::vector<Instruction> ops{
Instruction::SUB,
Instruction::DIV,
Instruction::SDIV,
@ -1125,7 +1124,7 @@ BOOST_AUTO_TEST_CASE(peephole_noncommutative_swap1)
BOOST_AUTO_TEST_CASE(peephole_swap_comparison)
{
map<Instruction, Instruction> swappableOps{
std::map<Instruction, Instruction> swappableOps{
{ Instruction::LT, Instruction::GT },
{ Instruction::GT, Instruction::LT },
{ Instruction::SLT, Instruction::SGT },
@ -1261,7 +1260,7 @@ BOOST_AUTO_TEST_CASE(jumpdest_removal_subassemblies)
settings.expectedExecutionsPerDeployment = OptimiserSettings{}.expectedExecutionsPerDeployment;
Assembly main{settings.evmVersion, false, {}};
AssemblyPointer sub = make_shared<Assembly>(settings.evmVersion, true, string{});
AssemblyPointer sub = std::make_shared<Assembly>(settings.evmVersion, true, std::string{});
sub->append(u256(1));
auto t1 = sub->newTag();
@ -1428,7 +1427,7 @@ BOOST_AUTO_TEST_CASE(verbatim_knownstate)
Instruction::DUP3,
Instruction::DUP4
});
map<int, unsigned> const& stackElements = state.stackElements();
std::map<int, unsigned> const& stackElements = state.stackElements();
BOOST_CHECK(state.stackHeight() == 4);
// One more than stack height because of the initial unknown element.
@ -1540,7 +1539,7 @@ BOOST_AUTO_TEST_CASE(cse_remove_redundant_shift_masking)
BOOST_AUTO_TEST_CASE(cse_remove_unwanted_masking_of_address)
{
vector<Instruction> ops{
std::vector<Instruction> ops{
Instruction::ADDRESS,
Instruction::CALLER,
Instruction::ORIGIN,

35
test/liblangutil/CharStream.cpp
View File

@ -28,7 +28,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity::test;
namespace boost::test_tools::tt_detail
@ -39,16 +38,16 @@ struct print_log_value<std::optional<int>>
{
void operator()(std::ostream& _out, std::optional<int> const& _value) const
{
_out << (_value ? to_string(*_value) : "[nullopt]");
_out << (_value ? to_string(*_value) : "[std::nullopt]");
}
};
template<>
struct print_log_value<nullopt_t>
struct print_log_value<std::nullopt_t>
{
void operator()(std::ostream& _out, nullopt_t const&) const
void operator()(std::ostream& _out, std::nullopt_t const&) const
{
_out << "[nullopt]";
_out << "[std::nullopt]";
}
};
@ -77,7 +76,7 @@ BOOST_AUTO_TEST_CASE(test_fail)
namespace
{
std::optional<int> toPosition(int _line, int _column, string const& _text)
std::optional<int> toPosition(int _line, int _column, std::string const& _text)
{
return CharStream{_text, "source"}.translateLineColumnToPosition(
LineColumn{_line, _column}
@ -88,30 +87,30 @@ std::optional<int> toPosition(int _line, int _column, string const& _text)
BOOST_AUTO_TEST_CASE(translateLineColumnToPosition)
{
BOOST_CHECK_EQUAL(toPosition(-1, 0, "ABC"), nullopt);
BOOST_CHECK_EQUAL(toPosition(0, -1, "ABC"), nullopt);
BOOST_CHECK_EQUAL(toPosition(-1, 0, "ABC"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(0, -1, "ABC"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(0, 0, ""), 0);
BOOST_CHECK_EQUAL(toPosition(1, 0, ""), nullopt);
BOOST_CHECK_EQUAL(toPosition(0, 1, ""), nullopt);
BOOST_CHECK_EQUAL(toPosition(1, 0, ""), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(0, 1, ""), std::nullopt);
// With last line containing no LF
BOOST_CHECK_EQUAL(toPosition(0, 0, "ABC"), 0);
BOOST_CHECK_EQUAL(toPosition(0, 1, "ABC"), 1);
BOOST_CHECK_EQUAL(toPosition(0, 2, "ABC"), 2);
BOOST_CHECK_EQUAL(toPosition(0, 3, "ABC"), 3);
BOOST_CHECK_EQUAL(toPosition(0, 4, "ABC"), nullopt);
BOOST_CHECK_EQUAL(toPosition(1, 0, "ABC"), nullopt);
BOOST_CHECK_EQUAL(toPosition(0, 4, "ABC"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(1, 0, "ABC"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(0, 3, "ABC\nDEF"), 3);
BOOST_CHECK_EQUAL(toPosition(0, 4, "ABC\nDEF"), nullopt);
BOOST_CHECK_EQUAL(toPosition(0, 4, "ABC\nDEF"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(1, 0, "ABC\nDEF"), 4);
BOOST_CHECK_EQUAL(toPosition(1, 1, "ABC\nDEF"), 5);
BOOST_CHECK_EQUAL(toPosition(1, 2, "ABC\nDEF"), 6);
BOOST_CHECK_EQUAL(toPosition(1, 3, "ABC\nDEF"), 7);
BOOST_CHECK_EQUAL(toPosition(1, 4, "ABC\nDEF"), nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF"), nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF"), nullopt);
BOOST_CHECK_EQUAL(toPosition(1, 4, "ABC\nDEF"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF"), std::nullopt);
// With last line containing LF
BOOST_CHECK_EQUAL(toPosition(0, 0, "ABC\nDEF\n"), 0);
@ -122,9 +121,9 @@ BOOST_AUTO_TEST_CASE(translateLineColumnToPosition)
BOOST_CHECK_EQUAL(toPosition(1, 1, "ABC\nDEF\n"), 5);
BOOST_CHECK_EQUAL(toPosition(1, 2, "ABC\nDEF\n"), 6);
BOOST_CHECK_EQUAL(toPosition(1, 3, "ABC\nDEF\n"), 7);
BOOST_CHECK_EQUAL(toPosition(1, 4, "ABC\nDEF\n"), nullopt);
BOOST_CHECK_EQUAL(toPosition(1, 4, "ABC\nDEF\n"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF\n"), 8);
BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF\n"), nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF\n"), std::nullopt);
BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF\nGHI\n"), 8);
BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF\nGHI\n"), 9);

42
test/liblangutil/Scanner.cpp
View File

@ -24,8 +24,8 @@
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity::langutil;
using namespace std::string_literals;
namespace solidity::langutil::test
{
@ -89,15 +89,15 @@ BOOST_AUTO_TEST_CASE(assembly_multiple_assign)
BOOST_AUTO_TEST_CASE(string_printable)
{
for (unsigned v = 0x20; v < 0x7e; v++) {
string lit{static_cast<char>(v)};
std::string lit{static_cast<char>(v)};
// Escape \ and " (since we are quoting with ")
if (v == '\\' || v == '"')
lit = string{'\\'} + lit;
lit = std::string{'\\'} + lit;
CharStream stream(" { \"" + lit + "\"", "");
Scanner scanner(stream);
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), string{static_cast<char>(v)});
BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string{static_cast<char>(v)});
BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
}
// Special case of unescaped " for strings quoted with '
@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(string_nonprintable)
// Skip the valid ones
if (v >= 0x20 && v <= 0x7e)
continue;
string lit{static_cast<char>(v)};
std::string lit{static_cast<char>(v)};
CharStream stream(" { \"" + lit + "\"", "");
Scanner scanner(stream);
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
@ -148,14 +148,14 @@ BOOST_AUTO_TEST_CASE(string_escapes_all)
struct TestScanner
{
unique_ptr<CharStream> stream;
unique_ptr<Scanner> scanner;
explicit TestScanner(string _text) { reset(std::move(_text)); }
std::unique_ptr<CharStream> stream;
std::unique_ptr<Scanner> scanner;
explicit TestScanner(std::string _text) { reset(std::move(_text)); }
void reset(std::string _text)
{
stream = make_unique<CharStream>(std::move(_text), "");
scanner = make_unique<Scanner>(*stream);
stream = std::make_unique<CharStream>(std::move(_text), "");
scanner = std::make_unique<Scanner>(*stream);
}
decltype(auto) currentToken() { return scanner->currentToken(); }
@ -801,7 +801,7 @@ BOOST_AUTO_TEST_CASE(regular_line_break_in_single_line_comment)
{
for (auto const& nl: {"\r", "\n", "\r\n"})
{
TestScanner scanner("// abc " + string(nl) + " def ");
TestScanner scanner("// abc " + std::string(nl) + " def ");
BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
@ -813,10 +813,10 @@ BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_single_line_comment)
{
for (auto const& nl: {"\v", "\f", "\xE2\x80\xA8", "\xE2\x80\xA9"})
{
TestScanner scanner("// abc " + string(nl) + " def ");
TestScanner scanner("// abc " + std::string(nl) + " def ");
BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
for (size_t i = 0; i < string(nl).size() - 1; i++)
for (size_t i = 0; i < std::string(nl).size() - 1; i++)
BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
@ -828,7 +828,7 @@ BOOST_AUTO_TEST_CASE(regular_line_breaks_in_single_line_doc_comment)
{
for (auto const& nl: {"\r", "\n", "\r\n"})
{
TestScanner scanner("/// abc " + string(nl) + " def ");
TestScanner scanner("/// abc " + std::string(nl) + " def ");
BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "abc ");
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
@ -856,10 +856,10 @@ BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_single_line_doc_comment)
{
for (auto const& nl: {"\v", "\f", "\xE2\x80\xA8", "\xE2\x80\xA9"})
{
TestScanner scanner("/// abc " + string(nl) + " def ");
TestScanner scanner("/// abc " + std::string(nl) + " def ");
BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "abc ");
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
for (size_t i = 0; i < string(nl).size() - 1; i++)
for (size_t i = 0; i < std::string(nl).size() - 1; i++)
BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
@ -884,9 +884,9 @@ BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_strings)
{
for (auto const& nl: {"\v", "\f", "\xE2\x80\xA8", "\xE2\x80\xA9"})
{
TestScanner scanner("\"abc " + string(nl) + " def\"");
TestScanner scanner("\"abc " + std::string(nl) + " def\"");
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
for (size_t i = 0; i < string(nl).size(); i++)
for (size_t i = 0; i < std::string(nl).size(); i++)
BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
@ -898,7 +898,7 @@ BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_strings)
BOOST_AUTO_TEST_CASE(solidity_keywords)
{
// These are tokens which have a different meaning in Yul.
string keywords = "return byte bool address var in true false leave switch case default";
std::string keywords = "return byte bool address var in true false leave switch case default";
TestScanner scanner(keywords);
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Return);
BOOST_CHECK_EQUAL(scanner.next(), Token::Byte);
@ -962,7 +962,7 @@ BOOST_AUTO_TEST_CASE(yul_identifier_with_dots)
BOOST_AUTO_TEST_CASE(yul_function)
{
string sig = "function f(a, b) -> x, y";
std::string sig = "function f(a, b) -> x, y";
TestScanner scanner(sig);
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
@ -994,7 +994,7 @@ BOOST_AUTO_TEST_CASE(yul_function)
BOOST_AUTO_TEST_CASE(yul_function_with_whitespace)
{
string sig = "function f (a, b) - > x, y";
std::string sig = "function f (a, b) - > x, y";
TestScanner scanner(sig);
BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);

43
test/libsolidity/ABIDecoderTests.cpp
View File

@ -28,7 +28,6 @@
#include <test/libsolidity/ABITestsCommon.h>
using namespace std;
using namespace std::placeholders;
using namespace solidity::test;
@ -39,7 +38,7 @@ BOOST_FIXTURE_TEST_SUITE(ABIDecoderTest, SolidityExecutionFramework)
BOOST_AUTO_TEST_CASE(value_types)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function f(uint a, uint16 b, uint24 c, int24 d, bytes3 x, bool e, C g) public returns (uint) {
if (a != 1) return 1;
@ -57,14 +56,14 @@ BOOST_AUTO_TEST_CASE(value_types)
compileAndRun(sourceCode);
ABI_CHECK(callContractFunction(
"f(uint256,uint16,uint24,int24,bytes3,bool,address)",
1, 2, 3, 4, string("abc"), true, m_contractAddress
1, 2, 3, 4, std::string("abc"), true, m_contractAddress
), encodeArgs(u256(20)));
)
}
BOOST_AUTO_TEST_CASE(decode_from_memory_simple)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
uint public _a;
uint[] public _b;
@ -90,7 +89,7 @@ BOOST_AUTO_TEST_CASE(decode_from_memory_simple)
BOOST_AUTO_TEST_CASE(decode_function_type)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract D {
function () external returns (uint) public _a;
constructor(function () external returns (uint) a) {
@ -124,7 +123,7 @@ BOOST_AUTO_TEST_CASE(decode_function_type)
BOOST_AUTO_TEST_CASE(decode_function_type_array)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract D {
function () external returns (uint)[] public _a;
constructor(function () external returns (uint)[] memory a) {
@ -190,7 +189,7 @@ BOOST_AUTO_TEST_CASE(decode_function_type_array)
BOOST_AUTO_TEST_CASE(decode_from_memory_complex)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
uint public _a;
uint[] public _b;
@ -209,23 +208,23 @@ BOOST_AUTO_TEST_CASE(decode_from_memory_complex)
3, 0x21, 0x22, 0x23,
// c
0x40, 0x80,
8, string("abcdefgh"),
52, string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")
8, std::string("abcdefgh"),
52, std::string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")
));
ABI_CHECK(callContractFunction("_a()"), encodeArgs(7));
ABI_CHECK(callContractFunction("_b(uint256)", 0), encodeArgs(0x21));
ABI_CHECK(callContractFunction("_b(uint256)", 1), encodeArgs(0x22));
ABI_CHECK(callContractFunction("_b(uint256)", 2), encodeArgs(0x23));
ABI_CHECK(callContractFunction("_b(uint256)", 3), encodeArgs());
ABI_CHECK(callContractFunction("_c(uint256)", 0), encodeArgs(0x20, 8, string("abcdefgh")));
ABI_CHECK(callContractFunction("_c(uint256)", 1), encodeArgs(0x20, 52, string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")));
ABI_CHECK(callContractFunction("_c(uint256)", 0), encodeArgs(0x20, 8, std::string("abcdefgh")));
ABI_CHECK(callContractFunction("_c(uint256)", 1), encodeArgs(0x20, 52, std::string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")));
ABI_CHECK(callContractFunction("_c(uint256)", 2), encodeArgs());
)
}
BOOST_AUTO_TEST_CASE(short_input_value_type)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function f(uint a, uint b) public pure returns (uint) { return a; }
}
@ -240,7 +239,7 @@ BOOST_AUTO_TEST_CASE(short_input_value_type)
BOOST_AUTO_TEST_CASE(short_input_array)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function f(uint[] memory a) public pure returns (uint) { return 7; }
}
@ -257,7 +256,7 @@ BOOST_AUTO_TEST_CASE(short_input_array)
BOOST_AUTO_TEST_CASE(short_dynamic_input_array)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function f(bytes[1] memory a) public pure returns (uint) { return 7; }
}
@ -270,7 +269,7 @@ BOOST_AUTO_TEST_CASE(short_dynamic_input_array)
BOOST_AUTO_TEST_CASE(short_input_bytes)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function e(bytes memory a) public pure returns (uint) { return 7; }
function f(bytes[] memory a) public pure returns (uint) { return 7; }
@ -291,7 +290,7 @@ BOOST_AUTO_TEST_CASE(short_input_bytes)
BOOST_AUTO_TEST_CASE(validation_int_inside_arrays)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
enum E { A, B }
function f(uint16[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
@ -315,7 +314,7 @@ BOOST_AUTO_TEST_CASE(validation_int_inside_arrays)
BOOST_AUTO_TEST_CASE(validation_function_type)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function f(function () external) public pure returns (uint r) { r = 1; }
function g(function () external[] memory) public pure returns (uint r) { r = 2; }
@ -324,8 +323,8 @@ BOOST_AUTO_TEST_CASE(validation_function_type)
}
)";
bool newDecoder = false;
string validFun{"01234567890123456789abcd"};
string invalidFun{"01234567890123456789abcdX"};
std::string validFun{"01234567890123456789abcd"};
std::string invalidFun{"01234567890123456789abcdX"};
BOTH_ENCODERS(
compileAndRun(sourceCode);
ABI_CHECK(callContractFunction("f(function)", validFun), encodeArgs(1));
@ -343,7 +342,7 @@ BOOST_AUTO_TEST_CASE(validation_function_type)
BOOST_AUTO_TEST_CASE(struct_short)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
struct S { int a; uint b; bytes16 c; }
function f(S memory s) public pure returns (S memory q) {
@ -370,7 +369,7 @@ BOOST_AUTO_TEST_CASE(struct_short)
BOOST_AUTO_TEST_CASE(complex_struct)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
enum E {A, B, C}
struct T { uint x; E e; uint8 y; }
@ -390,7 +389,7 @@ BOOST_AUTO_TEST_CASE(complex_struct)
)";
NEW_ENCODER(
compileAndRun(sourceCode, 0, "C");
string sig = "f(uint256,(address,(uint256,uint8,uint8)[])[2],(address,(uint256,uint8,uint8)[])[],uint256)";
std::string sig = "f(uint256,(address,(uint256,uint8,uint8)[])[2],(address,(uint256,uint8,uint8)[])[],uint256)";
bytes args = encodeArgs(
7, 0x80, 0x1e0, 8,
// S[2] s1

95
test/libsolidity/ABIEncoderTests.cpp
View File

@ -32,7 +32,6 @@
#include <string>
#include <tuple>
using namespace std;
using namespace std::placeholders;
using namespace solidity::util;
using namespace solidity::test;
@ -50,7 +49,7 @@ BOOST_FIXTURE_TEST_SUITE(ABIEncoderTest, SolidityExecutionFramework)
BOOST_AUTO_TEST_CASE(value_types)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(uint a, uint16 b, uint24 c, int24 d, bytes3 x, bool, C);
function f() public {
@ -67,14 +66,14 @@ BOOST_AUTO_TEST_CASE(value_types)
compileAndRun(sourceCode);
callContractFunction("f()");
REQUIRE_LOG_DATA(encodeArgs(
10, u256(65534), u256(0x121212), u256(-1), string("\x1b\xab\xab"), true, h160("fffffffffffffffffffffffffffffffffffffffb")
10, u256(65534), u256(0x121212), u256(-1), std::string("\x1b\xab\xab"), true, h160("fffffffffffffffffffffffffffffffffffffffb")
));
)
}
BOOST_AUTO_TEST_CASE(string_literal)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(string, bytes20, string);
function f() public {
@ -86,9 +85,9 @@ BOOST_AUTO_TEST_CASE(string_literal)
compileAndRun(sourceCode);
callContractFunction("f()");
REQUIRE_LOG_DATA(encodeArgs(
0x60, string("abcde"), 0xa0,
6, string("abcdef"),
0x8b, string("abcdefabcdefgehabcabcasdfjklabcdefabcedefghabcabcasdfjklabcdefabcdefghabcabcasdfjklabcdeefabcdefghabcabcasdefjklabcdefabcdefghabcabcasdfjkl")
0x60, std::string("abcde"), 0xa0,
6, std::string("abcdef"),
0x8b, std::string("abcdefabcdefgehabcabcasdfjklabcdefabcedefghabcabcasdfjklabcdefabcdefghabcabcasdfjklabcdeefabcdefghabcabcasdefjklabcdefabcdefghabcabcasdfjkl")
));
)
}
@ -96,7 +95,7 @@ BOOST_AUTO_TEST_CASE(string_literal)
BOOST_AUTO_TEST_CASE(enum_type_cleanup)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
enum E { A, B }
function f(uint x) public returns (E en) {
@ -114,7 +113,7 @@ BOOST_AUTO_TEST_CASE(enum_type_cleanup)
BOOST_AUTO_TEST_CASE(conversion)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(bytes4, bytes4, uint16, uint8, int16, int8);
function f() public {
@ -132,7 +131,7 @@ BOOST_AUTO_TEST_CASE(conversion)
compileAndRun(sourceCode);
callContractFunction("f()");
REQUIRE_LOG_DATA(encodeArgs(
string(3, 0) + string("\x0a"), string("\xf1\xf2"),
std::string(3, 0) + std::string("\x0a"), std::string("\xf1\xf2"),
0xff, 0xff, u256(-1), u256(1)
));
)
@ -140,7 +139,7 @@ BOOST_AUTO_TEST_CASE(conversion)
BOOST_AUTO_TEST_CASE(memory_array_one_dim)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(uint a, int16[] b, uint c);
function f() public {
@ -172,7 +171,7 @@ BOOST_AUTO_TEST_CASE(memory_array_one_dim)
BOOST_AUTO_TEST_CASE(memory_array_two_dim)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(uint a, int16[][2] b, uint c);
function f() public {
@ -197,7 +196,7 @@ BOOST_AUTO_TEST_CASE(memory_array_two_dim)
BOOST_AUTO_TEST_CASE(memory_byte_array)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(uint a, bytes[] b, uint c);
function f() public {
@ -214,15 +213,15 @@ BOOST_AUTO_TEST_CASE(memory_byte_array)
REQUIRE_LOG_DATA(encodeArgs(
10, 0x60, 11,
2, 0x40, 0xc0,
66, string("abcabcdefghjklmnopqrsuvwabcdefgijklmnopqrstuwabcdefgijklmnoprstuvw"),
63, string("abcdefghijklmnopqrtuvwabcfghijklmnopqstuvwabcdeghijklmopqrstuvw")
66, std::string("abcabcdefghjklmnopqrsuvwabcdefgijklmnopqrstuwabcdefgijklmnoprstuvw"),
63, std::string("abcdefghijklmnopqrtuvwabcfghijklmnopqstuvwabcdeghijklmopqrstuvw")
));
)
}
BOOST_AUTO_TEST_CASE(storage_byte_array)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
bytes short;
bytes long;
@ -239,15 +238,15 @@ BOOST_AUTO_TEST_CASE(storage_byte_array)
callContractFunction("f()");
REQUIRE_LOG_DATA(encodeArgs(
0x40, 0x80,
31, string("123456789012345678901234567890a"),
75, string("ffff123456789012345678901234567890afffffffff123456789012345678901234567890a")
31, std::string("123456789012345678901234567890a"),
75, std::string("ffff123456789012345678901234567890afffffffff123456789012345678901234567890a")
));
)
}
BOOST_AUTO_TEST_CASE(storage_array)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
address[3] addr;
event E(address[3] a);
@ -274,7 +273,7 @@ BOOST_AUTO_TEST_CASE(storage_array)
BOOST_AUTO_TEST_CASE(storage_array_dyn)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
address[] addr;
event E(address[] a);
@ -301,7 +300,7 @@ BOOST_AUTO_TEST_CASE(storage_array_dyn)
BOOST_AUTO_TEST_CASE(storage_array_compact)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
int72[] x;
event E(int72[]);
@ -329,7 +328,7 @@ BOOST_AUTO_TEST_CASE(storage_array_compact)
BOOST_AUTO_TEST_CASE(external_function)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(function(uint) external returns (uint), function(uint) external returns (uint));
function(uint) external returns (uint) g;
@ -342,14 +341,14 @@ BOOST_AUTO_TEST_CASE(external_function)
BOTH_ENCODERS(
compileAndRun(sourceCode);
callContractFunction("f(uint256)", u256(0));
string functionIdF = asString(m_contractAddress.ref()) + asString(util::selectorFromSignatureH32("f(uint256)").ref());
std::string functionIdF = asString(m_contractAddress.ref()) + asString(util::selectorFromSignatureH32("f(uint256)").ref());
REQUIRE_LOG_DATA(encodeArgs(functionIdF, functionIdF));
)
}
BOOST_AUTO_TEST_CASE(external_function_cleanup)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(function(uint) external returns (uint), function(uint) external returns (uint));
// This test relies on the fact that g is stored in slot zero.
@ -364,13 +363,13 @@ BOOST_AUTO_TEST_CASE(external_function_cleanup)
BOTH_ENCODERS(
compileAndRun(sourceCode);
callContractFunction("f(uint256)", u256(0));
REQUIRE_LOG_DATA(encodeArgs(string(24, char(-1)), string(24, char(-1))));
REQUIRE_LOG_DATA(encodeArgs(std::string(24, char(-1)), std::string(24, char(-1))));
)
}
BOOST_AUTO_TEST_CASE(calldata)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
event E(bytes);
function f(bytes calldata a) external {
@ -378,8 +377,8 @@ BOOST_AUTO_TEST_CASE(calldata)
}
}
)";
string s("abcdef");
string t("abcdefgggggggggggggggggggggggggggggggggggggggghhheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeggg");
std::string s("abcdef");
std::string t("abcdefgggggggggggggggggggggggggggggggggggggggghhheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeggg");
BOTH_ENCODERS(
compileAndRun(sourceCode);
callContractFunction("f(bytes)", 0x20, s.size(), s);
@ -393,7 +392,7 @@ BOOST_AUTO_TEST_CASE(function_name_collision)
{
// This tests a collision between a function name used by inline assembly
// and by the ABI encoder
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
function f(uint x) public returns (uint) {
assembly {
@ -417,7 +416,7 @@ BOOST_AUTO_TEST_CASE(function_name_collision)
BOOST_AUTO_TEST_CASE(structs)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
struct S { uint16 a; uint16 b; T[] sub; uint16 c; }
struct T { uint64[2] x; }
@ -452,13 +451,13 @@ BOOST_AUTO_TEST_CASE(structs)
);
BOOST_CHECK(callContractFunction("f()") == encoded);
REQUIRE_LOG_DATA(encoded);
BOOST_CHECK_EQUAL(logTopic(0, 0), keccak256(string("e(uint16,(uint16,uint16,(uint64[2])[],uint16))")));
BOOST_CHECK_EQUAL(logTopic(0, 0), keccak256(std::string("e(uint16,(uint16,uint16,(uint64[2])[],uint16))")));
)
}
BOOST_AUTO_TEST_CASE(structs2)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
enum E {A, B, C}
struct T { uint x; E e; uint8 y; }
@ -517,7 +516,7 @@ BOOST_AUTO_TEST_CASE(structs2)
BOOST_AUTO_TEST_CASE(bool_arrays)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
bool[] x;
bool[4] y;
@ -550,7 +549,7 @@ BOOST_AUTO_TEST_CASE(bool_arrays)
BOOST_AUTO_TEST_CASE(bool_arrays_split)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
bool[] x;
bool[4] y;
@ -587,7 +586,7 @@ BOOST_AUTO_TEST_CASE(bool_arrays_split)
BOOST_AUTO_TEST_CASE(bytesNN_arrays)
{
// This tests that encoding packed arrays from storage work correctly.
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
bytes8[] x;
bytesWIDTH[SIZE] y;
@ -610,12 +609,12 @@ BOOST_AUTO_TEST_CASE(bytesNN_arrays)
{
for (size_t width: {1u, 2u, 4u, 5u, 7u, 15u, 16u, 17u, 31u, 32u})
{
string source = boost::algorithm::replace_all_copy(sourceCode, "SIZE", to_string(size));
source = boost::algorithm::replace_all_copy(source, "UINTWIDTH", to_string(width * 8));
source = boost::algorithm::replace_all_copy(source, "WIDTH", to_string(width));
std::string source = boost::algorithm::replace_all_copy(sourceCode, "SIZE", std::to_string(size));
source = boost::algorithm::replace_all_copy(source, "UINTWIDTH", std::to_string(width * 8));
source = boost::algorithm::replace_all_copy(source, "WIDTH", std::to_string(width));
compileAndRun(source, 0, "C");
ABI_CHECK(callContractFunction("store()"), bytes{});
vector<u256> arr;
std::vector<u256> arr;
for (size_t i = 0; i < size; i ++)
arr.emplace_back(u256(i + 1) << (8 * (32 - width)));
bytes encoded = encodeArgs(
@ -632,7 +631,7 @@ BOOST_AUTO_TEST_CASE(bytesNN_arrays)
BOOST_AUTO_TEST_CASE(bytesNN_arrays_dyn)
{
// This tests that encoding packed arrays from storage work correctly.
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
bytes8[] x;
bytesWIDTH[] y;
@ -655,12 +654,12 @@ BOOST_AUTO_TEST_CASE(bytesNN_arrays_dyn)
{
for (size_t width: {1u, 2u, 4u, 5u, 7u, 15u, 16u, 17u, 31u, 32u})
{
string source = boost::algorithm::replace_all_copy(sourceCode, "SIZE", to_string(size));
source = boost::algorithm::replace_all_copy(source, "UINTWIDTH", to_string(width * 8));
source = boost::algorithm::replace_all_copy(source, "WIDTH", to_string(width));
std::string source = boost::algorithm::replace_all_copy(sourceCode, "SIZE", std::to_string(size));
source = boost::algorithm::replace_all_copy(source, "UINTWIDTH", std::to_string(width * 8));
source = boost::algorithm::replace_all_copy(source, "WIDTH", std::to_string(width));
compileAndRun(source, 0, "C");
ABI_CHECK(callContractFunction("store()"), bytes{});
vector<u256> arr;
std::vector<u256> arr;
for (size_t i = 0; i < size; i ++)
arr.emplace_back(u256(i + 1) << (8 * (32 - width)));
bytes encoded = encodeArgs(
@ -677,7 +676,7 @@ BOOST_AUTO_TEST_CASE(bytesNN_arrays_dyn)
BOOST_AUTO_TEST_CASE(packed_structs)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
struct S { bool a; int8 b; function() external g; bytes3 d; int8 e; }
S s;
@ -712,7 +711,7 @@ BOOST_AUTO_TEST_CASE(packed_structs)
BOOST_AUTO_TEST_CASE(struct_in_constructor)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
struct S {
string a;
@ -732,7 +731,7 @@ BOOST_AUTO_TEST_CASE(struct_in_constructor)
BOOST_AUTO_TEST_CASE(struct_in_constructor_indirect)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
struct S {
string a;
@ -765,7 +764,7 @@ BOOST_AUTO_TEST_CASE(struct_in_constructor_indirect)
BOOST_AUTO_TEST_CASE(struct_in_constructor_data_short)
{
string sourceCode = R"(
std::string sourceCode = R"(
contract C {
struct S {
string a;

9
test/libsolidity/ABIJsonTest.cpp
View File

@ -28,20 +28,19 @@
#include <fstream>
using namespace std;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::frontend;
using namespace solidity::frontend::test;
ABIJsonTest::ABIJsonTest(string const& _filename):
ABIJsonTest::ABIJsonTest(std::string const& _filename):
TestCase(_filename)
{
m_source = m_reader.source();
m_expectation = m_reader.simpleExpectations();
}
TestCase::TestResult ABIJsonTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
TestCase::TestResult ABIJsonTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
{
CompilerStack compiler;
@ -52,11 +51,11 @@ TestCase::TestResult ABIJsonTest::run(ostream& _stream, string const& _linePrefi
compiler.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
if (!compiler.parseAndAnalyze())
BOOST_THROW_EXCEPTION(runtime_error("Parsing contract failed"));
BOOST_THROW_EXCEPTION(std::runtime_error("Parsing contract failed"));
m_obtainedResult.clear();
bool first = true;
for (string const& contractName: compiler.contractNames())
for (std::string const& contractName: compiler.contractNames())
{
if (!first)
m_obtainedResult += "\n\n";

4
test/libsolidity/ABITestsCommon.h
View File

@ -23,7 +23,7 @@ namespace solidity::frontend::test
#define NEW_ENCODER(CODE) \
{ \
string sourceCodeTmp = sourceCode; \
std::string sourceCodeTmp = sourceCode; \
sourceCode = "pragma abicoder v2;\n" + sourceCode; \
{ CODE } \
sourceCode = sourceCodeTmp; \
@ -31,7 +31,7 @@ namespace solidity::frontend::test
#define OLD_ENCODER(CODE) \
{ \
string sourceCodeTmp = sourceCode; \
std::string sourceCodeTmp = sourceCode; \
sourceCode = "pragma abicoder v1;\n" + sourceCode; \
{ CODE } \
sourceCode = sourceCodeTmp; \

110
test/libsolidity/ASTJSONTest.cpp
View File

@ -36,22 +36,22 @@
#include <memory>
#include <stdexcept>
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace solidity::frontend::test;
using namespace solidity::util::formatting;
using namespace solidity::util;
using namespace solidity;
using namespace std;
namespace fs = boost::filesystem;
using namespace boost::unit_test;
using namespace std::string_literals;
namespace
{
string const sourceDelimiter("==== Source: ");
std::string const sourceDelimiter("==== Source: ");
string compilerStateToString(CompilerStack::State _state)
std::string compilerStateToString(CompilerStack::State _state)
{
switch (_state)
{
@ -65,17 +65,17 @@ string compilerStateToString(CompilerStack::State _state)
soltestAssert(false, "Unexpected value of state parameter");
}
CompilerStack::State stringToCompilerState(const string& _state)
CompilerStack::State stringToCompilerState(const std::string& _state)
{
for (unsigned int i = CompilerStack::State::Empty; i <= CompilerStack::State::CompilationSuccessful; ++i)
{
if (_state == compilerStateToString(CompilerStack::State(i)))
return CompilerStack::State(i);
}
BOOST_THROW_EXCEPTION(runtime_error("Unsupported compiler state (" + _state + ") in test contract file"));
BOOST_THROW_EXCEPTION(std::runtime_error("Unsupported compiler state (" + _state + ") in test contract file"));
}
void replaceVersionWithTag(string& _input)
void replaceVersionWithTag(std::string& _input)
{
boost::algorithm::replace_all(
_input,
@ -84,7 +84,7 @@ void replaceVersionWithTag(string& _input)
);
}
void replaceTagWithVersion(string& _input)
void replaceTagWithVersion(std::string& _input)
{
boost::algorithm::replace_all(
_input,
@ -95,9 +95,9 @@ void replaceTagWithVersion(string& _input)
}
void ASTJSONTest::generateTestVariants(string const& _filename)
void ASTJSONTest::generateTestVariants(std::string const& _filename)
{
string_view baseName = _filename;
std::string_view baseName = _filename;
baseName.remove_suffix(4);
const std::vector<CompilerStack::State> variantCompileStates = {
@ -117,18 +117,18 @@ void ASTJSONTest::generateTestVariants(string const& _filename)
}
}
void ASTJSONTest::fillSources(string const& _filename)
void ASTJSONTest::fillSources(std::string const& _filename)
{
ifstream file(_filename);
std::ifstream file(_filename);
if (!file)
BOOST_THROW_EXCEPTION(runtime_error("Cannot open test contract: \"" + _filename + "\"."));
file.exceptions(ios::badbit);
BOOST_THROW_EXCEPTION(std::runtime_error("Cannot open test contract: \"" + _filename + "\"."));
file.exceptions(std::ios::badbit);
string sourceName;
string source;
string line;
string const delimiter("// ----");
string const failMarker("// failAfter:");
std::string sourceName;
std::string source;
std::string line;
std::string const delimiter("// ----");
std::string const failMarker("// failAfter:");
while (getline(file, line))
{
if (boost::algorithm::starts_with(line, sourceDelimiter))
@ -140,14 +140,14 @@ void ASTJSONTest::fillSources(string const& _filename)
sourceDelimiter.size(),
line.size() - " ===="s.size() - sourceDelimiter.size()
);
source = string();
source = std::string();
}
else if (boost::algorithm::starts_with(line, failMarker))
{
string state = line.substr(failMarker.size());
std::string state = line.substr(failMarker.size());
boost::algorithm::trim(state);
if (m_expectedFailAfter.has_value())
BOOST_THROW_EXCEPTION(runtime_error("Duplicated \"failAfter\" directive"));
BOOST_THROW_EXCEPTION(std::runtime_error("Duplicated \"failAfter\" directive"));
m_expectedFailAfter = stringToCompilerState(state);
}
@ -161,7 +161,7 @@ void ASTJSONTest::fillSources(string const& _filename)
void ASTJSONTest::validateTestConfiguration() const
{
if (m_variants.empty())
BOOST_THROW_EXCEPTION(runtime_error("No file with expected result found."));
BOOST_THROW_EXCEPTION(std::runtime_error("No file with expected result found."));
if (m_expectedFailAfter.has_value())
{
@ -172,8 +172,8 @@ void ASTJSONTest::validateTestConfiguration() const
if (unexpectedTestVariant != m_variants.end())
BOOST_THROW_EXCEPTION(
runtime_error(
string("Unexpected JSON file: ") + unexpectedTestVariant->astFilename() +
std::runtime_error(
std::string("Unexpected JSON file: ") + unexpectedTestVariant->astFilename() +
" in \"failAfter: " +
compilerStateToString(m_expectedFailAfter.value()) + "\" scenario."
)
@ -181,23 +181,23 @@ void ASTJSONTest::validateTestConfiguration() const
}
}
ASTJSONTest::ASTJSONTest(string const& _filename):
ASTJSONTest::ASTJSONTest(std::string const& _filename):
EVMVersionRestrictedTestCase(_filename)
{
if (!boost::algorithm::ends_with(_filename, ".sol"))
BOOST_THROW_EXCEPTION(runtime_error("Invalid test contract file name: \"" + _filename + "\"."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid test contract file name: \"" + _filename + "\"."));
generateTestVariants(_filename);
fillSources(_filename);
validateTestConfiguration();
}
TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted)
TestCase::TestResult ASTJSONTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
{
CompilerStack c;
StringMap sources;
map<string, unsigned> sourceIndices;
std::map<std::string, unsigned> sourceIndices;
for (size_t i = 0; i < m_sources.size(); i++)
{
sources[m_sources[i].first] = m_sources[i].second;
@ -237,10 +237,10 @@ TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefi
bool ASTJSONTest::runTest(
TestVariant& _variant,
map<string, unsigned> const& _sourceIndices,
std::map<std::string, unsigned> const& _sourceIndices,
CompilerStack& _compiler,
ostream& _stream,
string const& _linePrefix,
std::ostream& _stream,
std::string const& _linePrefix,
bool const _formatted
)
{
@ -249,7 +249,7 @@ bool ASTJSONTest::runTest(
for (size_t i = 0; i < m_sources.size(); i++)
{
ostringstream result;
std::ostringstream result;
ASTJsonExporter(_compiler.state(), _sourceIndices).print(result, _compiler.ast(m_sources[i].first), JsonFormat{ JsonFormat::Pretty });
_variant.result += result.str();
if (i != m_sources.size() - 1)
@ -264,49 +264,49 @@ bool ASTJSONTest::runTest(
if (_variant.expectation != _variant.result)
{
string nextIndentLevel = _linePrefix + " ";
std::string nextIndentLevel = _linePrefix + " ";
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) <<
_linePrefix <<
"Expected result" <<
(!_variant.name().empty() ? " (" + _variant.name() + "):" : ":") <<
endl;
std::endl;
{
istringstream stream(_variant.expectation);
string line;
std::istringstream stream(_variant.expectation);
std::string line;
while (getline(stream, line))
_stream << nextIndentLevel << line << endl;
_stream << nextIndentLevel << line << std::endl;
}
_stream << endl;
_stream << std::endl;
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) <<
_linePrefix <<
"Obtained result" <<
(!_variant.name().empty() ? " (" + _variant.name() + "):" : ":") <<
endl;
std::endl;
{
istringstream stream(_variant.result);
string line;
std::istringstream stream(_variant.result);
std::string line;
while (getline(stream, line))
_stream << nextIndentLevel << line << endl;
_stream << nextIndentLevel << line << std::endl;
}
_stream << endl;
_stream << std::endl;
return false;
}
return true;
}
void ASTJSONTest::printSource(ostream& _stream, string const& _linePrefix, bool const) const
void ASTJSONTest::printSource(std::ostream& _stream, std::string const& _linePrefix, bool const) const
{
for (auto const& source: m_sources)
{
if (m_sources.size() > 1 || source.first != "a")
_stream << _linePrefix << sourceDelimiter << source.first << " ====" << endl << endl;
stringstream stream(source.second);
string line;
_stream << _linePrefix << sourceDelimiter << source.first << " ====" << std::endl << std::endl;
std::stringstream stream(source.second);
std::string line;
while (getline(stream, line))
_stream << _linePrefix << line << endl;
_stream << endl;
_stream << _linePrefix << line << std::endl;
_stream << std::endl;
}
}
@ -320,13 +320,13 @@ void ASTJSONTest::printUpdatedExpectations(std::ostream&, std::string const&) co
);
}
void ASTJSONTest::updateExpectation(string const& _filename, string const& _expectation, string const& _variant) const
void ASTJSONTest::updateExpectation(std::string const& _filename, std::string const& _expectation, std::string const& _variant) const
{
ofstream file(_filename.c_str());
if (!file) BOOST_THROW_EXCEPTION(runtime_error("Cannot write " + _variant + "AST expectation to \"" + _filename + "\"."));
file.exceptions(ios::badbit);
std::ofstream file(_filename.c_str());
if (!file) BOOST_THROW_EXCEPTION(std::runtime_error("Cannot write " + _variant + "AST expectation to \"" + _filename + "\"."));
file.exceptions(std::ios::badbit);
string replacedResult = _expectation;
std::string replacedResult = _expectation;
replaceVersionWithTag(replacedResult);
file << replacedResult;

38
test/libsolidity/ASTPropertyTest.cpp
View File

@ -40,23 +40,23 @@ using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace solidity::frontend::test;
using namespace solidity;
using namespace std;
using namespace std::string_literals;
ASTPropertyTest::ASTPropertyTest(string const& _filename):
ASTPropertyTest::ASTPropertyTest(std::string const& _filename):
TestCase(_filename)
{
if (!boost::algorithm::ends_with(_filename, ".sol"))
BOOST_THROW_EXCEPTION(runtime_error("Not a Solidity file: \"" + _filename + "\"."));
BOOST_THROW_EXCEPTION(std::runtime_error("Not a Solidity file: \"" + _filename + "\"."));
m_source = m_reader.source();
readExpectations();
soltestAssert(m_tests.size() > 0, "No tests specified in " + _filename);
}
string ASTPropertyTest::formatExpectations(bool _obtainedResult)
std::string ASTPropertyTest::formatExpectations(bool _obtainedResult)
{
string expectations;
for (string const& testId: m_testOrder)
std::string expectations;
for (std::string const& testId: m_testOrder)
{
soltestAssert(m_tests.count(testId) > 0);
expectations +=
@ -68,10 +68,10 @@ string ASTPropertyTest::formatExpectations(bool _obtainedResult)
return expectations;
}
vector<StringPair> ASTPropertyTest::readKeyValuePairs(string const& _input)
std::vector<StringPair> ASTPropertyTest::readKeyValuePairs(std::string const& _input)
{
vector<StringPair> result;
for (string line: _input | ranges::views::split('\n') | ranges::to<vector<string>>)
std::vector<StringPair> result;
for (std::string line: _input | ranges::views::split('\n') | ranges::to<std::vector<std::string>>)
{
boost::trim(line);
if (line.empty())
@ -83,14 +83,14 @@ vector<StringPair> ASTPropertyTest::readKeyValuePairs(string const& _input)
);
auto colonPosition = line.find_first_of(':');
soltestAssert(colonPosition != string::npos, "Property test is missing a colon: " + line);
soltestAssert(colonPosition != std::string::npos, "Property test is missing a colon: " + line);
StringPair pair{
boost::trim_copy(line.substr(0, colonPosition)),
boost::trim_copy(line.substr(colonPosition + 1))
};
soltestAssert(!get<0>(pair).empty() != false, "Empty key in property test: " + line);
soltestAssert(!get<1>(pair).empty() != false, "Empty value in property test: " + line);
soltestAssert(!std::get<0>(pair).empty() != false, "Empty key in property test: " + line);
soltestAssert(!std::get<1>(pair).empty() != false, "Empty value in property test: " + line);
result.push_back(pair);
}
@ -110,7 +110,7 @@ void ASTPropertyTest::readExpectations()
void ASTPropertyTest::extractTestsFromAST(Json::Value const& _astJson)
{
queue<Json::Value> nodesToVisit;
std::queue<Json::Value> nodesToVisit;
nodesToVisit.push(_astJson);
while (!nodesToVisit.empty())
@ -121,7 +121,7 @@ void ASTPropertyTest::extractTestsFromAST(Json::Value const& _astJson)
for (auto&& member: node)
nodesToVisit.push(member);
else if (node.isObject())
for (string const& memberName: node.getMemberNames())
for (std::string const& memberName: node.getMemberNames())
{
if (memberName != "documentation")
{
@ -129,12 +129,12 @@ void ASTPropertyTest::extractTestsFromAST(Json::Value const& _astJson)
continue;
}
string nodeDocstring = node["documentation"].isObject() ?
std::string nodeDocstring = node["documentation"].isObject() ?
node["documentation"]["text"].asString() :
node["documentation"].asString();
soltestAssert(!nodeDocstring.empty());
vector<StringPair> pairs = readKeyValuePairs(nodeDocstring);
std::vector<StringPair> pairs = readKeyValuePairs(nodeDocstring);
if (pairs.empty())
continue;
@ -151,7 +151,7 @@ void ASTPropertyTest::extractTestsFromAST(Json::Value const& _astJson)
m_tests[testId].property = testedProperty;
soltestAssert(node.isMember("nodeType"));
optional<Json::Value> propertyNode = jsonValueByPath(node, testedProperty);
std::optional<Json::Value> propertyNode = jsonValueByPath(node, testedProperty);
soltestAssert(
propertyNode.has_value(),
node["nodeType"].asString() + " node does not have a property named \""s + testedProperty + "\""
@ -179,7 +179,7 @@ void ASTPropertyTest::extractTestsFromAST(Json::Value const& _astJson)
m_obtainedResult = formatExpectations(true /* _obtainedResult */);
}
TestCase::TestResult ASTPropertyTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted)
TestCase::TestResult ASTPropertyTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
{
CompilerStack compiler;
@ -190,7 +190,7 @@ TestCase::TestResult ASTPropertyTest::run(ostream& _stream, string const& _lineP
compiler.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
if (!compiler.parseAndAnalyze())
BOOST_THROW_EXCEPTION(runtime_error(
BOOST_THROW_EXCEPTION(std::runtime_error(
"Parsing contract failed" +
SourceReferenceFormatter::formatErrorInformation(compiler.errors(), compiler, _formatted)
));

21
test/libsolidity/AnalysisFramework.cpp
View File

@ -35,16 +35,15 @@
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace solidity::frontend::test;
pair<SourceUnit const*, ErrorList>
std::pair<SourceUnit const*, ErrorList>
AnalysisFramework::parseAnalyseAndReturnError(
string const& _source,
std::string const& _source,
bool _reportWarnings,
bool _insertLicenseAndVersionPragma,
bool _allowMultipleErrors
@ -99,7 +98,7 @@ ErrorList AnalysisFramework::filterErrors(ErrorList const& _errorList, bool _inc
{
SourceLocation const* location = currentError->sourceLocation();
// sufficient for now, but in future we might clone the error completely, including the secondary location
newError = make_shared<Error>(
newError = std::make_shared<Error>(
currentError->errorId(),
currentError->type(),
messagePrefix + " ....",
@ -114,18 +113,18 @@ ErrorList AnalysisFramework::filterErrors(ErrorList const& _errorList, bool _inc
return errors;
}
SourceUnit const* AnalysisFramework::parseAndAnalyse(string const& _source)
SourceUnit const* AnalysisFramework::parseAndAnalyse(std::string const& _source)
{
auto sourceAndError = parseAnalyseAndReturnError(_source);
BOOST_REQUIRE(!!sourceAndError.first);
string message;
std::string message;
if (!sourceAndError.second.empty())
message = "Unexpected error: " + formatErrors(compiler().errors());
BOOST_REQUIRE_MESSAGE(sourceAndError.second.empty(), message);
return sourceAndError.first;
}
bool AnalysisFramework::success(string const& _source)
bool AnalysisFramework::success(std::string const& _source)
{
return parseAnalyseAndReturnError(_source).second.empty();
}
@ -138,7 +137,7 @@ ErrorList AnalysisFramework::expectError(std::string const& _source, bool _warni
return sourceAndErrors.second;
}
string AnalysisFramework::formatErrors(
std::string AnalysisFramework::formatErrors(
langutil::ErrorList const& _errors,
bool _colored,
bool _withErrorIds
@ -152,7 +151,7 @@ string AnalysisFramework::formatErrors(
);
}
string AnalysisFramework::formatError(
std::string AnalysisFramework::formatError(
Error const& _error,
bool _colored,
bool _withErrorIds
@ -166,11 +165,11 @@ string AnalysisFramework::formatError(
);
}
ContractDefinition const* AnalysisFramework::retrieveContractByName(SourceUnit const& _source, string const& _name)
ContractDefinition const* AnalysisFramework::retrieveContractByName(SourceUnit const& _source, std::string const& _name)
{
ContractDefinition* contract = nullptr;
for (shared_ptr<ASTNode> const& node: _source.nodes())
for (std::shared_ptr<ASTNode> const& node: _source.nodes())
if ((contract = dynamic_cast<ContractDefinition*>(node.get())) && contract->name() == _name)
return contract;

49
test/libsolidity/Assembly.cpp
View File

@ -43,7 +43,6 @@
#include <string>
#include <iostream>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::evmasm;
@ -90,7 +89,7 @@ evmasm::AssemblyItems compileContract(std::shared_ptr<CharStream> _sourceCode)
RevertStrings::Default,
solidity::test::CommonOptions::get().optimize ? OptimiserSettings::standard() : OptimiserSettings::minimal()
);
compiler.compileContract(*contract, map<ContractDefinition const*, shared_ptr<Compiler const>>{}, bytes());
compiler.compileContract(*contract, std::map<ContractDefinition const*, std::shared_ptr<Compiler const>>{}, bytes());
return compiler.runtimeAssembly().items();
}
@ -102,7 +101,7 @@ void printAssemblyLocations(AssemblyItems const& _items)
{
auto printRepeated = [](SourceLocation const& _loc, size_t _repetitions)
{
cout <<
std::cout <<
"\t\tvector<SourceLocation>(" <<
_repetitions <<
", SourceLocation{" <<
@ -111,10 +110,10 @@ void printAssemblyLocations(AssemblyItems const& _items)
_loc.end <<
", make_shared<string>(\"" <<
*_loc.sourceName <<
"\")}) +" << endl;
"\")}) +" << std::endl;
};
vector<SourceLocation> locations;
std::vector<SourceLocation> locations;
for (auto const& item: _items)
locations.push_back(item.location());
size_t repetitions = 0;
@ -136,15 +135,15 @@ void printAssemblyLocations(AssemblyItems const& _items)
printRepeated(*previousLoc, repetitions);
}
void checkAssemblyLocations(AssemblyItems const& _items, vector<SourceLocation> const& _locations)
void checkAssemblyLocations(AssemblyItems const& _items, std::vector<SourceLocation> const& _locations)
{
BOOST_CHECK_EQUAL(_items.size(), _locations.size());
for (size_t i = 0; i < min(_items.size(), _locations.size()); ++i)
for (size_t i = 0; i < std::min(_items.size(), _locations.size()); ++i)
{
if (_items[i].location().start != _locations[i].start ||
_items[i].location().end != _locations[i].end)
{
BOOST_CHECK_MESSAGE(false, "Location mismatch for item " + to_string(i) + ". Found the following locations:");
BOOST_CHECK_MESSAGE(false, "Location mismatch for item " + std::to_string(i) + ". Found the following locations:");
printAssemblyLocations(_items);
return;
}
@ -158,7 +157,7 @@ BOOST_AUTO_TEST_SUITE(Assembly)
BOOST_AUTO_TEST_CASE(location_test)
{
string sourceCode = R"(
std::string sourceCode = R"(
pragma abicoder v1;
contract test {
function f() public returns (uint256 a) {
@ -166,34 +165,34 @@ BOOST_AUTO_TEST_CASE(location_test)
}
}
)";
AssemblyItems items = compileContract(make_shared<CharStream>(sourceCode, ""));
shared_ptr<string> sourceName = make_shared<string>();
AssemblyItems items = compileContract(std::make_shared<CharStream>(sourceCode, ""));
std::shared_ptr<std::string> sourceName = std::make_shared<std::string>();
bool hasShifts = solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting();
auto codegenCharStream = make_shared<CharStream>("", "--CODEGEN--");
auto codegenCharStream = std::make_shared<CharStream>("", "--CODEGEN--");
vector<SourceLocation> locations;
std::vector<SourceLocation> locations;
if (solidity::test::CommonOptions::get().optimize)
locations =
vector<SourceLocation>(31, SourceLocation{23, 103, sourceName}) +
vector<SourceLocation>(1, SourceLocation{41, 100, sourceName}) +
vector<SourceLocation>(1, SourceLocation{93, 95, sourceName}) +
vector<SourceLocation>(15, SourceLocation{41, 100, sourceName});
std::vector<SourceLocation>(31, SourceLocation{23, 103, sourceName}) +
std::vector<SourceLocation>(1, SourceLocation{41, 100, sourceName}) +
std::vector<SourceLocation>(1, SourceLocation{93, 95, sourceName}) +
std::vector<SourceLocation>(15, SourceLocation{41, 100, sourceName});
else
locations =
vector<SourceLocation>(hasShifts ? 31 : 32, SourceLocation{23, 103, sourceName}) +
vector<SourceLocation>(24, SourceLocation{41, 100, sourceName}) +
vector<SourceLocation>(1, SourceLocation{70, 79, sourceName}) +
vector<SourceLocation>(1, SourceLocation{93, 95, sourceName}) +
vector<SourceLocation>(2, SourceLocation{86, 95, sourceName}) +
vector<SourceLocation>(2, SourceLocation{41, 100, sourceName});
std::vector<SourceLocation>(hasShifts ? 31 : 32, SourceLocation{23, 103, sourceName}) +
std::vector<SourceLocation>(24, SourceLocation{41, 100, sourceName}) +
std::vector<SourceLocation>(1, SourceLocation{70, 79, sourceName}) +
std::vector<SourceLocation>(1, SourceLocation{93, 95, sourceName}) +
std::vector<SourceLocation>(2, SourceLocation{86, 95, sourceName}) +
std::vector<SourceLocation>(2, SourceLocation{41, 100, sourceName});
checkAssemblyLocations(items, locations);
}
BOOST_AUTO_TEST_CASE(jump_type)
{
auto sourceCode = make_shared<CharStream>(R"(
auto sourceCode = std::make_shared<CharStream>(R"(
pragma abicoder v1;
contract C {
function f(uint a) public pure returns (uint t) {
@ -206,7 +205,7 @@ BOOST_AUTO_TEST_CASE(jump_type)
)", "");
AssemblyItems items = compileContract(sourceCode);
string jumpTypes;
std::string jumpTypes;
for (AssemblyItem const& item: items)
if (item.getJumpType() != AssemblyItem::JumpType::Ordinary)
jumpTypes += item.getJumpTypeAsString() + "\n";

15
test/libsolidity/ErrorCheck.cpp
View File

@ -27,7 +27,6 @@
#include <set>
#include <iostream>
using namespace std;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
@ -42,29 +41,29 @@ std::string errorMessage(Error const& _e)
bool solidity::frontend::test::searchErrorMessage(Error const& _err, std::string const& _substr)
{
if (string const* errorMessage = _err.comment())
if (std::string const* errorMessage = _err.comment())
{
if (errorMessage->find(_substr) == std::string::npos)
{
cout << "Expected message \"" << _substr << "\" but found \"" << *errorMessage << "\".\n";
std::cout << "Expected message \"" << _substr << "\" but found \"" << *errorMessage << "\".\n";
return false;
}
return true;
}
else
cout << "Expected error message but found none." << endl;
std::cout << "Expected error message but found none." << std::endl;
return _substr.empty();
}
string solidity::frontend::test::searchErrors(ErrorList const& _errors, vector<pair<Error::Type, string>> const& _expectations)
std::string solidity::frontend::test::searchErrors(ErrorList const& _errors, std::vector<std::pair<Error::Type, std::string>> const& _expectations)
{
auto expectations = _expectations;
for (auto const& error: _errors)
{
string msg = errorMessage(*error);
std::string msg = errorMessage(*error);
bool found = false;
for (auto it = expectations.begin(); it != expectations.end(); ++it)
if (msg.find(it->second) != string::npos && error->type() == it->first)
if (msg.find(it->second) != std::string::npos && error->type() == it->first)
{
found = true;
expectations.erase(it);
@ -75,7 +74,7 @@ string solidity::frontend::test::searchErrors(ErrorList const& _errors, vector<p
}
if (!expectations.empty())
{
string msg = "Expected error(s) not present:\n";
std::string msg = "Expected error(s) not present:\n";
for (auto const& expectation: expectations)
msg += expectation.second + "\n";
return msg;

3
test/libsolidity/GasCosts.cpp
View File

@ -26,7 +26,6 @@
#include <cmath>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::langutil;
using namespace solidity::evmasm;
@ -168,7 +167,7 @@ BOOST_AUTO_TEST_CASE(string_storage)
BOOST_AUTO_TEST_CASE(single_callvaluecheck)
{
string sourceCode = R"(
std::string sourceCode = R"(
// All functions nonpayable, we can check callvalue at the beginning
contract Nonpayable {
address a;

35
test/libsolidity/GasMeter.cpp
View File

@ -28,7 +28,6 @@
#include <libsolidity/ast/AST.h>
#include <libsolidity/interface/GasEstimator.h>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::evmasm;
using namespace solidity::frontend;
@ -40,7 +39,7 @@ namespace solidity::frontend::test
class GasMeterTestFramework: public SolidityExecutionFramework
{
public:
void compile(string const& _sourceCode)
void compile(std::string const& _sourceCode)
{
m_compiler.reset();
m_compiler.setSources({{"", "pragma solidity >=0.0;\n"
@ -50,10 +49,10 @@ public:
BOOST_REQUIRE_MESSAGE(m_compiler.compile(), "Compiling contract failed");
}
void testCreationTimeGas(string const& _sourceCode, u256 const& _tolerance = u256(0))
void testCreationTimeGas(std::string const& _sourceCode, u256 const& _tolerance = u256(0))
{
compileAndRun(_sourceCode);
auto state = make_shared<KnownState>();
auto state = std::make_shared<KnownState>();
PathGasMeter meter(*m_compiler.assemblyItems(m_compiler.lastContractName()), solidity::test::CommonOptions::get().evmVersion());
GasMeter::GasConsumption gas = meter.estimateMax(0, state);
u256 bytecodeSize(m_compiler.runtimeObject(m_compiler.lastContractName()).bytecode.size());
@ -74,7 +73,7 @@ public:
/// Compares the gas computed by PathGasMeter for the given signature (but unknown arguments)
/// against the actual gas usage computed by the VM on the given set of argument variants.
void testRunTimeGas(string const& _sig, vector<bytes> _argumentVariants, u256 const& _tolerance = u256(0))
void testRunTimeGas(std::string const& _sig, std::vector<bytes> _argumentVariants, u256 const& _tolerance = u256(0))
{
u256 gasUsed = 0;
GasMeter::GasConsumption gas;
@ -83,8 +82,8 @@ public:
{
sendMessage(hash.asBytes() + arguments, false, 0);
BOOST_CHECK(m_transactionSuccessful);
gasUsed = max(gasUsed, m_gasUsed);
gas = max(gas, gasForTransaction(hash.asBytes() + arguments, false));
gasUsed = std::max(gasUsed, m_gasUsed);
gas = std::max(gas, gasForTransaction(hash.asBytes() + arguments, false));
}
gas += GasEstimator(solidity::test::CommonOptions::get().evmVersion()).functionalEstimation(
@ -171,7 +170,7 @@ BOOST_AUTO_TEST_CASE(branches)
}
)";
testCreationTimeGas(sourceCode, 1);
testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2), encodeArgs(8)}, 1);
testRunTimeGas("f(uint256)", std::vector<bytes>{encodeArgs(2), encodeArgs(8)}, 1);
}
BOOST_AUTO_TEST_CASE(function_calls)
@ -196,7 +195,7 @@ BOOST_AUTO_TEST_CASE(function_calls)
// However, GasMeter always assumes cold costs.
testRunTimeGas(
"f(uint256)",
vector<bytes>{encodeArgs(2), encodeArgs(8)},
std::vector<bytes>{encodeArgs(2), encodeArgs(8)},
m_evmVersion < EVMVersion::berlin() ?
u256(0) :
u256(2100)
@ -225,13 +224,13 @@ BOOST_AUTO_TEST_CASE(multiple_external_functions)
// However, GasMeter always assumes cold costs.
testRunTimeGas(
"f(uint256)",
vector<bytes>{encodeArgs(2), encodeArgs(8)},
std::vector<bytes>{encodeArgs(2), encodeArgs(8)},
m_evmVersion < EVMVersion::berlin() ?
u256(0) :
u256(2100)
);
testRunTimeGas("g(uint256)", vector<bytes>{encodeArgs(2)});
testRunTimeGas("g(uint256)", std::vector<bytes>{encodeArgs(2)});
}
BOOST_AUTO_TEST_CASE(exponent_size)
@ -250,9 +249,9 @@ BOOST_AUTO_TEST_CASE(exponent_size)
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2)});
testRunTimeGas("g(uint256)", vector<bytes>{encodeArgs(2)});
testRunTimeGas("h(uint256)", vector<bytes>{encodeArgs(2)});
testRunTimeGas("f(uint256)", std::vector<bytes>{encodeArgs(2)});
testRunTimeGas("g(uint256)", std::vector<bytes>{encodeArgs(2)});
testRunTimeGas("h(uint256)", std::vector<bytes>{encodeArgs(2)});
}
BOOST_AUTO_TEST_CASE(balance_gas)
@ -265,7 +264,7 @@ BOOST_AUTO_TEST_CASE(balance_gas)
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("lookup_balance(address)", vector<bytes>{encodeArgs(2), encodeArgs(100)});
testRunTimeGas("lookup_balance(address)", std::vector<bytes>{encodeArgs(2), encodeArgs(100)});
}
BOOST_AUTO_TEST_CASE(extcodesize_gas)
@ -280,7 +279,7 @@ BOOST_AUTO_TEST_CASE(extcodesize_gas)
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("f()", vector<bytes>{encodeArgs()});
testRunTimeGas("f()", std::vector<bytes>{encodeArgs()});
}
BOOST_AUTO_TEST_CASE(regular_functions_exclude_fallback)
@ -294,7 +293,7 @@ BOOST_AUTO_TEST_CASE(regular_functions_exclude_fallback)
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("x()", vector<bytes>{encodeArgs()});
testRunTimeGas("x()", std::vector<bytes>{encodeArgs()});
}
BOOST_AUTO_TEST_CASE(complex_control_flow)
@ -335,7 +334,7 @@ BOOST_AUTO_TEST_CASE(complex_control_flow)
)";
testCreationTimeGas(sourceCode);
// max gas is used for small x
testRunTimeGas("ln(int128)", vector<bytes>{encodeArgs(0), encodeArgs(10), encodeArgs(105), encodeArgs(30000)});
testRunTimeGas("ln(int128)", std::vector<bytes>{encodeArgs(0), encodeArgs(10), encodeArgs(105), encodeArgs(30000)});
}
BOOST_AUTO_TEST_SUITE_END()

27
test/libsolidity/GasTest.cpp
View File

@ -33,10 +33,9 @@ using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace solidity::frontend::test;
using namespace solidity;
using namespace std;
using namespace boost::unit_test;
GasTest::GasTest(string const& _filename):
GasTest::GasTest(std::string const& _filename):
TestCase(_filename)
{
m_source = m_reader.source();
@ -48,20 +47,20 @@ GasTest::GasTest(string const& _filename):
void GasTest::parseExpectations(std::istream& _stream)
{
map<std::string, std::string>* currentKind = nullptr;
string line;
std::map<std::string, std::string>* currentKind = nullptr;
std::string line;
while (getline(_stream, line))
if (!boost::starts_with(line, "// "))
BOOST_THROW_EXCEPTION(runtime_error("Invalid expectation: expected \"// \"."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid expectation: expected \"// \"."));
else if (boost::ends_with(line, ":"))
{
string kind = line.substr(3, line.length() - 4);
std::string kind = line.substr(3, line.length() - 4);
boost::trim(kind);
currentKind = &m_expectations[std::move(kind)];
}
else if (!currentKind)
BOOST_THROW_EXCEPTION(runtime_error("No function kind specified. Expected \"creation:\", \"external:\" or \"internal:\"."));
BOOST_THROW_EXCEPTION(std::runtime_error("No function kind specified. Expected \"creation:\", \"external:\" or \"internal:\"."));
else
{
auto it = line.begin() + 3;
@ -69,18 +68,18 @@ void GasTest::parseExpectations(std::istream& _stream)
auto functionNameBegin = it;
while (it != line.end() && *it != ':')
++it;
string functionName(functionNameBegin, it);
std::string functionName(functionNameBegin, it);
if (functionName == "fallback")
functionName.clear();
expect(it, line.end(), ':');
skipWhitespace(it, line.end());
if (it == line.end())
BOOST_THROW_EXCEPTION(runtime_error("Invalid expectation: expected gas cost."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid expectation: expected gas cost."));
(*currentKind)[functionName] = std::string(it, line.end());
}
}
void GasTest::printUpdatedExpectations(ostream& _stream, string const& _linePrefix) const
void GasTest::printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const
{
Json::Value estimates = compiler().gasEstimates(compiler().lastContractName());
for (auto groupIt = estimates.begin(); groupIt != estimates.end(); ++groupIt)
@ -98,7 +97,7 @@ void GasTest::printUpdatedExpectations(ostream& _stream, string const& _linePref
}
}
TestCase::TestResult GasTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
TestCase::TestResult GasTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
{
compiler().reset();
// Prerelease CBOR metadata varies in size due to changing version numbers and build dates.
@ -153,10 +152,10 @@ TestCase::TestResult GasTest::run(ostream& _stream, string const& _linePrefix, b
}
}
void GasTest::printSource(ostream& _stream, string const& _linePrefix, bool) const
void GasTest::printSource(std::ostream& _stream, std::string const& _linePrefix, bool) const
{
string line;
istringstream input(m_source);
std::string line;
std::istringstream input(m_source);
while (getline(input, line))
_stream << _linePrefix << line << std::endl;
}

11
test/libsolidity/Imports.cpp
View File

@ -32,7 +32,6 @@
#include <string>
using namespace std;
namespace solidity::frontend::test
{
@ -42,7 +41,7 @@ BOOST_AUTO_TEST_SUITE(SolidityImports)
BOOST_AUTO_TEST_CASE(remappings)
{
CompilerStack c;
c.setRemappings(vector<ImportRemapper::Remapping>{{"", "s", "s_1.4.6"},{"", "t", "Tee"}});
c.setRemappings(std::vector<ImportRemapper::Remapping>{{"", "s", "s_1.4.6"},{"", "t", "Tee"}});
c.setSources({
{"a", "import \"s/s.sol\"; contract A is S {} pragma solidity >=0.0;"},
{"b", "import \"t/tee.sol\"; contract A is Tee {} pragma solidity >=0.0;"},
@ -56,7 +55,7 @@ BOOST_AUTO_TEST_CASE(remappings)
BOOST_AUTO_TEST_CASE(context_dependent_remappings)
{
CompilerStack c;
c.setRemappings(vector<ImportRemapper::Remapping>{{"a", "s", "s_1.4.6"}, {"b", "s", "s_1.4.7"}});
c.setRemappings(std::vector<ImportRemapper::Remapping>{{"a", "s", "s_1.4.6"}, {"b", "s", "s_1.4.7"}});
c.setSources({
{"a/a.sol", "import \"s/s.sol\"; contract A is SSix {} pragma solidity >=0.0;"},
{"b/b.sol", "import \"s/s.sol\"; contract B is SSeven {} pragma solidity >=0.0;"},
@ -70,7 +69,7 @@ BOOST_AUTO_TEST_CASE(context_dependent_remappings)
BOOST_AUTO_TEST_CASE(context_dependent_remappings_ensure_default_and_module_preserved)
{
CompilerStack c;
c.setRemappings(vector<ImportRemapper::Remapping>{
c.setRemappings(std::vector<ImportRemapper::Remapping>{
{"", "foo", "vendor/foo_2.0.0"},
{"vendor/bar", "foo", "vendor/foo_1.0.0"},
{"", "bar", "vendor/bar"}
@ -88,7 +87,7 @@ BOOST_AUTO_TEST_CASE(context_dependent_remappings_ensure_default_and_module_pres
BOOST_AUTO_TEST_CASE(context_dependent_remappings_order_independent_1)
{
CompilerStack c;
c.setRemappings(vector<ImportRemapper::Remapping>{{"a", "x/y/z", "d"}, {"a/b", "x", "e"}});
c.setRemappings(std::vector<ImportRemapper::Remapping>{{"a", "x/y/z", "d"}, {"a/b", "x", "e"}});
c.setSources({
{"a/main.sol", "import \"x/y/z/z.sol\"; contract Main is D {} pragma solidity >=0.0;"},
{"a/b/main.sol", "import \"x/y/z/z.sol\"; contract Main is E {} pragma solidity >=0.0;"},
@ -102,7 +101,7 @@ BOOST_AUTO_TEST_CASE(context_dependent_remappings_order_independent_1)
BOOST_AUTO_TEST_CASE(context_dependent_remappings_order_independent_2)
{
CompilerStack c;
c.setRemappings(vector<ImportRemapper::Remapping>{{"a/b", "x", "e"}, {"a", "x/y/z", "d"}});
c.setRemappings(std::vector<ImportRemapper::Remapping>{{"a/b", "x", "e"}, {"a", "x/y/z", "d"}});
c.setSources({
{"a/main.sol", "import \"x/y/z/z.sol\"; contract Main is D {} pragma solidity >=0.0;"},
{"a/b/main.sol", "import \"x/y/z/z.sol\"; contract Main is E {} pragma solidity >=0.0;"},

21
test/libsolidity/InlineAssembly.cpp
View File

@ -42,7 +42,6 @@
#include <optional>
#include <string>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::yul;
@ -53,7 +52,7 @@ namespace
{
std::optional<Error> parseAndReturnFirstError(
string const& _source,
std::string const& _source,
bool _assemble = false,
bool _allowWarnings = true,
YulStack::Language _language = YulStack::Language::Assembly,
@ -79,7 +78,7 @@ std::optional<Error> parseAndReturnFirstError(
BOOST_FAIL("Fatal error leaked.");
success = false;
}
shared_ptr<Error const> error;
std::shared_ptr<Error const> error;
for (auto const& e: stack.errors())
{
if (_allowWarnings && e->type() == Error::Type::Warning)
@ -99,7 +98,7 @@ std::optional<Error> parseAndReturnFirstError(
}
bool successParse(
string const& _source,
std::string const& _source,
bool _assemble = false,
bool _allowWarnings = true,
YulStack::Language _language = YulStack::Language::Assembly,
@ -109,7 +108,7 @@ bool successParse(
return !parseAndReturnFirstError(_source, _assemble, _allowWarnings, _language, _machine);
}
bool successAssemble(string const& _source, bool _allowWarnings = true, YulStack::Language _language = YulStack::Language::Assembly)
bool successAssemble(std::string const& _source, bool _allowWarnings = true, YulStack::Language _language = YulStack::Language::Assembly)
{
return
successParse(_source, true, _allowWarnings, _language, YulStack::Machine::EVM);
@ -128,7 +127,7 @@ Error expectError(
return *error;
}
void parsePrintCompare(string const& _source, bool _canWarn = false)
void parsePrintCompare(std::string const& _source, bool _canWarn = false)
{
YulStack stack(
solidity::test::CommonOptions::get().evmVersion(),
@ -142,7 +141,7 @@ void parsePrintCompare(string const& _source, bool _canWarn = false)
BOOST_REQUIRE(!Error::containsErrors(stack.errors()));
else
BOOST_REQUIRE(stack.errors().empty());
string expectation = "object \"object\" {\n code " + boost::replace_all_copy(_source, "\n", "\n ") + "\n}\n";
std::string expectation = "object \"object\" {\n code " + boost::replace_all_copy(_source, "\n", "\n ") + "\n}\n";
BOOST_CHECK_EQUAL(stack.print(), expectation);
}
@ -219,8 +218,8 @@ BOOST_AUTO_TEST_CASE(print_string_literals)
BOOST_AUTO_TEST_CASE(print_string_literal_unicode)
{
string source = "{ let x := \"\\u1bac\" }";
string parsed = "object \"object\" {\n code { let x := \"\\xe1\\xae\\xac\" }\n}\n";
std::string source = "{ let x := \"\\u1bac\" }";
std::string parsed = "object \"object\" {\n code { let x := \"\\xe1\\xae\\xac\" }\n}\n";
YulStack stack(
solidity::test::CommonOptions::get().evmVersion(),
solidity::test::CommonOptions::get().eofVersion(),
@ -232,7 +231,7 @@ BOOST_AUTO_TEST_CASE(print_string_literal_unicode)
BOOST_REQUIRE(stack.errors().empty());
BOOST_CHECK_EQUAL(stack.print(), parsed);
string parsedInner = "{ let x := \"\\xe1\\xae\\xac\" }";
std::string parsedInner = "{ let x := \"\\xe1\\xae\\xac\" }";
parsePrintCompare(parsedInner);
}
@ -258,7 +257,7 @@ BOOST_AUTO_TEST_CASE(function_definitions_multiple_args)
BOOST_AUTO_TEST_CASE(function_calls)
{
string source = R"({
std::string source = R"({
function y()
{ }
function f(a) -> b

25
test/libsolidity/LibSolc.cpp
View File

@ -27,7 +27,6 @@
#include <libsolidity/interface/Version.h>
#include <libsolc/libsolc.h>
using namespace std;
namespace solidity::frontend::test
{
@ -37,7 +36,7 @@ namespace
/// TODO: share this between StandardCompiler.cpp
/// Helper to match a specific error type and message
bool containsError(Json::Value const& _compilerResult, string const& _type, string const& _message)
bool containsError(Json::Value const& _compilerResult, std::string const& _type, std::string const& _message)
{
if (!_compilerResult.isMember("errors"))
return false;
@ -54,10 +53,10 @@ bool containsError(Json::Value const& _compilerResult, string const& _type, stri
return false;
}
Json::Value compile(string const& _input, CStyleReadFileCallback _callback = nullptr)
Json::Value compile(std::string const& _input, CStyleReadFileCallback _callback = nullptr)
{
char* output_ptr = solidity_compile(_input.c_str(), _callback, nullptr);
string output(output_ptr);
std::string output(output_ptr);
solidity_free(output_ptr);
solidity_reset();
Json::Value ret;
@ -65,7 +64,7 @@ Json::Value compile(string const& _input, CStyleReadFileCallback _callback = nul
return ret;
}
char* stringToSolidity(string const& _input)
char* stringToSolidity(std::string const& _input)
{
char* ptr = solidity_alloc(_input.length());
BOOST_REQUIRE(ptr != nullptr);
@ -79,14 +78,14 @@ BOOST_AUTO_TEST_SUITE(LibSolc)
BOOST_AUTO_TEST_CASE(read_version)
{
string output(solidity_version());
std::string output(solidity_version());
BOOST_CHECK(output.find(VersionString) == 0);
}
BOOST_AUTO_TEST_CASE(read_license)
{
string output(solidity_license());
BOOST_CHECK(output.find("GNU GENERAL PUBLIC LICENSE") != string::npos);
std::string output(solidity_license());
BOOST_CHECK(output.find("GNU GENERAL PUBLIC LICENSE") != std::string::npos);
}
BOOST_AUTO_TEST_CASE(standard_compilation)
@ -148,16 +147,16 @@ BOOST_AUTO_TEST_CASE(with_callback)
// Passed in a nullptr in the compile() helper above.
BOOST_REQUIRE(_context == nullptr);
// Caller frees the pointers.
BOOST_REQUIRE(string(_kind) == ReadCallback::kindString(ReadCallback::Kind::ReadFile));
if (string(_path) == "found.sol")
BOOST_REQUIRE(std::string(_kind) == ReadCallback::kindString(ReadCallback::Kind::ReadFile));
if (std::string(_path) == "found.sol")
{
static string content{"import \"missing.sol\"; contract B {}"};
static std::string content{"import \"missing.sol\"; contract B {}"};
*o_contents = stringToSolidity(content);
*o_error = nullptr;
}
else if (string(_path) == "missing.sol")
else if (std::string(_path) == "missing.sol")
{
static string errorMsg{"Missing file."};
static std::string errorMsg{"Missing file."};
*o_error = stringToSolidity(errorMsg);
*o_contents = nullptr;
}

7
test/libsolidity/MemoryGuardTest.cpp
View File

@ -28,7 +28,6 @@
#include <memory>
#include <stdexcept>
using namespace std;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::util::formatting;
@ -37,7 +36,7 @@ using namespace solidity::frontend;
using namespace solidity::frontend::test;
using namespace yul;
TestCase::TestResult MemoryGuardTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
TestCase::TestResult MemoryGuardTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
{
compiler().reset();
compiler().setSources(StringMap{{"", m_source}});
@ -50,7 +49,7 @@ TestCase::TestResult MemoryGuardTest::run(ostream& _stream, string const& _lineP
}
m_obtainedResult.clear();
for (string contractName: compiler().contractNames())
for (std::string contractName: compiler().contractNames())
{
ErrorList errors;
auto [object, analysisInfo] = yul::test::parse(
@ -61,7 +60,7 @@ TestCase::TestResult MemoryGuardTest::run(ostream& _stream, string const& _lineP
if (!object || !analysisInfo || Error::containsErrors(errors))
{
AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing IR." << endl;
AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing IR." << std::endl;
return TestResult::FatalError;
}

55
test/libsolidity/Metadata.cpp
View File

@ -29,7 +29,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::frontend::test
{
@ -37,13 +36,13 @@ namespace solidity::frontend::test
namespace
{
map<string, string> requireParsedCBORMetadata(bytes const& _bytecode, CompilerStack::MetadataFormat _metadataFormat)
std::map<std::string, std::string> requireParsedCBORMetadata(bytes const& _bytecode, CompilerStack::MetadataFormat _metadataFormat)
{
bytes cborMetadata = solidity::test::onlyMetadata(_bytecode);
if (_metadataFormat != CompilerStack::MetadataFormat::NoMetadata)
{
BOOST_REQUIRE(!cborMetadata.empty());
std::optional<map<string, string>> tmp = solidity::test::parseCBORMetadata(cborMetadata);
std::optional<std::map<std::string, std::string>> tmp = solidity::test::parseCBORMetadata(cborMetadata);
BOOST_REQUIRE(tmp);
return *tmp;
}
@ -51,13 +50,13 @@ map<string, string> requireParsedCBORMetadata(bytes const& _bytecode, CompilerSt
return {};
}
optional<string> compileAndCheckLicenseMetadata(string const& _contractName, char const* _sourceCode)
std::optional<std::string> compileAndCheckLicenseMetadata(std::string const& _contractName, char const* _sourceCode)
{
CompilerStack compilerStack;
compilerStack.setSources({{"A.sol", _sourceCode}});
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
string const& serialisedMetadata = compilerStack.metadata(_contractName);
std::string const& serialisedMetadata = compilerStack.metadata(_contractName);
Json::Value metadata;
BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
@ -71,7 +70,7 @@ optional<string> compileAndCheckLicenseMetadata(string const& _contractName, cha
return metadata["sources"]["A.sol"]["license"].asString();
}
else
return nullopt;
return std::nullopt;
}
}
@ -93,7 +92,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp)
CompilerStack::MetadataFormat::WithReleaseVersionTag,
CompilerStack::MetadataFormat::WithPrereleaseVersionTag
})
for (auto metadataHash: set<CompilerStack::MetadataHash>{
for (auto metadataHash: std::set<CompilerStack::MetadataHash>{
CompilerStack::MetadataHash::IPFS,
CompilerStack::MetadataHash::Bzzr1,
CompilerStack::MetadataHash::None
@ -107,7 +106,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp)
compilerStack.setMetadataHash(metadataHash);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
bytes const& bytecode = compilerStack.runtimeObject("test").bytecode;
string const& metadata = compilerStack.metadata("test");
std::string const& metadata = compilerStack.metadata("test");
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
auto const cborMetadata = requireParsedCBORMetadata(bytecode, metadataFormat);
@ -116,7 +115,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp)
else
{
bytes hash;
string hashMethod;
std::string hashMethod;
if (metadataHash == CompilerStack::MetadataHash::IPFS)
{
hash = util::ipfsHash(metadata);
@ -166,7 +165,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp_experimental)
CompilerStack::MetadataFormat::WithReleaseVersionTag,
CompilerStack::MetadataFormat::WithPrereleaseVersionTag
})
for (auto metadataHash: set<CompilerStack::MetadataHash>{
for (auto metadataHash: std::set<CompilerStack::MetadataHash>{
CompilerStack::MetadataHash::IPFS,
CompilerStack::MetadataHash::Bzzr1,
CompilerStack::MetadataHash::None
@ -180,7 +179,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp_experimental)
compilerStack.setMetadataHash(metadataHash);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
bytes const& bytecode = compilerStack.runtimeObject("test").bytecode;
string const& metadata = compilerStack.metadata("test");
std::string const& metadata = compilerStack.metadata("test");
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
auto const cborMetadata = requireParsedCBORMetadata(bytecode, metadataFormat);
@ -189,7 +188,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp_experimental)
else
{
bytes hash;
string hashMethod;
std::string hashMethod;
if (metadataHash == CompilerStack::MetadataHash::IPFS)
{
hash = util::ipfsHash(metadata);
@ -250,7 +249,7 @@ BOOST_AUTO_TEST_CASE(metadata_eof_experimental)
compilerStack.setOptimiserSettings(true);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
bytes const& bytecode = compilerStack.runtimeObject("test").bytecode;
string const& metadata = compilerStack.metadata("test");
std::string const& metadata = compilerStack.metadata("test");
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
auto const cborMetadata = requireParsedCBORMetadata(bytecode, metadataFormat);
@ -288,7 +287,7 @@ BOOST_AUTO_TEST_CASE(metadata_relevant_sources)
compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
string const& serialisedMetadata = compilerStack.metadata("A");
std::string const& serialisedMetadata = compilerStack.metadata("A");
Json::Value metadata;
BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
@ -329,7 +328,7 @@ BOOST_AUTO_TEST_CASE(metadata_relevant_sources_imports)
compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
string const& serialisedMetadata = compilerStack.metadata("C");
std::string const& serialisedMetadata = compilerStack.metadata("C");
Json::Value metadata;
BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
@ -357,7 +356,7 @@ BOOST_AUTO_TEST_CASE(metadata_useLiteralContent)
compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
compilerStack.useMetadataLiteralSources(_literal);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
string metadata_str = compilerStack.metadata("test");
std::string metadata_str = compilerStack.metadata("test");
Json::Value metadata;
BOOST_REQUIRE(util::jsonParseStrict(metadata_str, metadata));
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
@ -407,7 +406,7 @@ BOOST_AUTO_TEST_CASE(metadata_viair)
BOOST_CHECK(compilerStack.cborMetadata("test") == compilerStack.cborMetadata("test", _viaIR));
BOOST_CHECK(compilerStack.cborMetadata("test") != compilerStack.cborMetadata("test", !_viaIR));
map<string, string> const parsedCBORMetadata = requireParsedCBORMetadata(
std::map<std::string, std::string> const parsedCBORMetadata = requireParsedCBORMetadata(
compilerStack.runtimeObject("test").bytecode,
CompilerStack::MetadataFormat::WithReleaseVersionTag
);
@ -431,7 +430,7 @@ BOOST_AUTO_TEST_CASE(metadata_revert_strings)
compilerStack.setRevertStringBehaviour(RevertStrings::Strip);
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
string const& serialisedMetadata = compilerStack.metadata("A");
std::string const& serialisedMetadata = compilerStack.metadata("A");
Json::Value metadata;
BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
@ -447,7 +446,7 @@ BOOST_AUTO_TEST_CASE(metadata_optimiser_sequence)
}
)";
vector<tuple<string, string>> sequences =
std::vector<std::tuple<std::string, std::string>> sequences =
{
// {"<optimizer sequence>", "<optimizer cleanup sequence>"}
{"", ""},
@ -456,7 +455,7 @@ BOOST_AUTO_TEST_CASE(metadata_optimiser_sequence)
{"dhfoDgvulfnTUtnIf", "fDn"}
};
auto check = [sourceCode](string const& _optimizerSequence, string const& _optimizerCleanupSequence)
auto check = [sourceCode](std::string const& _optimizerSequence, std::string const& _optimizerCleanupSequence)
{
OptimiserSettings optimizerSettings = OptimiserSettings::minimal();
optimizerSettings.runYulOptimiser = true;
@ -469,7 +468,7 @@ BOOST_AUTO_TEST_CASE(metadata_optimiser_sequence)
BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
string const& serialisedMetadata = compilerStack.metadata("C");
std::string const& serialisedMetadata = compilerStack.metadata("C");
Json::Value metadata;
BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
BOOST_CHECK(solidity::test::isValidMetadata(metadata));
@ -477,8 +476,8 @@ BOOST_AUTO_TEST_CASE(metadata_optimiser_sequence)
BOOST_CHECK(metadata["settings"]["optimizer"]["details"].isMember("yulDetails"));
BOOST_CHECK(metadata["settings"]["optimizer"]["details"]["yulDetails"].isMember("optimizerSteps"));
string const metadataOptimizerSteps = metadata["settings"]["optimizer"]["details"]["yulDetails"]["optimizerSteps"].asString();
string const expectedMetadataOptimiserSteps = _optimizerSequence + ":" + _optimizerCleanupSequence;
std::string const metadataOptimizerSteps = metadata["settings"]["optimizer"]["details"]["yulDetails"]["optimizerSteps"].asString();
std::string const expectedMetadataOptimiserSteps = _optimizerSequence + ":" + _optimizerCleanupSequence;
BOOST_CHECK_EQUAL(metadataOptimizerSteps, expectedMetadataOptimiserSteps);
};
@ -493,7 +492,7 @@ BOOST_AUTO_TEST_CASE(metadata_license_missing)
contract C {
}
)";
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == nullopt);
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
}
BOOST_AUTO_TEST_CASE(metadata_license_gpl3)
@ -544,7 +543,7 @@ BOOST_AUTO_TEST_CASE(metadata_license_bidi_marks)
"// NOTE: The text above is reversed using Unicode directional marks. In raw form it would look like this:\n"
"// <LRO>0.3-LPG :reifitnedI-esneciL-XDPS<PDF>\n"
"contract C {}\n";
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == nullopt);
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
}
BOOST_AUTO_TEST_CASE(metadata_license_bottom)
@ -579,7 +578,7 @@ BOOST_AUTO_TEST_CASE(metadata_license_in_string)
bytes license = "// SPDX-License-Identifier: GPL-3.0";
}
)";
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == nullopt);
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
}
BOOST_AUTO_TEST_CASE(metadata_license_in_contract)
@ -589,7 +588,7 @@ BOOST_AUTO_TEST_CASE(metadata_license_in_contract)
// SPDX-License-Identifier: GPL-3.0
}
)";
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == nullopt);
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
}
BOOST_AUTO_TEST_CASE(metadata_license_missing_colon)
@ -598,7 +597,7 @@ BOOST_AUTO_TEST_CASE(metadata_license_missing_colon)
// SPDX-License-Identifier GPL-3.0
contract C {}
)";
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == nullopt);
BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
}
BOOST_AUTO_TEST_CASE(metadata_license_multiline)

31
test/libsolidity/SMTCheckerTest.cpp
View File

@ -21,13 +21,12 @@
#include <range/v3/action/remove_if.hpp>
using namespace std;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace solidity::frontend::test;
SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, EVMVersion{})
SMTCheckerTest::SMTCheckerTest(std::string const& _filename): SyntaxTest(_filename, EVMVersion{})
{
auto contract = m_reader.stringSetting("SMTContract", "");
if (!contract.empty())
@ -37,7 +36,7 @@ SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, E
if (extCallsMode)
m_modelCheckerSettings.externalCalls = *extCallsMode;
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT external calls mode."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT external calls mode."));
auto const& showUnproved = m_reader.stringSetting("SMTShowUnproved", "yes");
if (showUnproved == "no")
@ -45,7 +44,7 @@ SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, E
else if (showUnproved == "yes")
m_modelCheckerSettings.showUnproved = true;
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT \"show unproved\" choice."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT \"show unproved\" choice."));
auto const& showUnsupported = m_reader.stringSetting("SMTShowUnsupported", "yes");
if (showUnsupported == "no")
@ -53,14 +52,14 @@ SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, E
else if (showUnsupported == "yes")
m_modelCheckerSettings.showUnsupported = true;
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT \"show unsupported\" choice."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT \"show unsupported\" choice."));
m_modelCheckerSettings.solvers = smtutil::SMTSolverChoice::None();
auto const& choice = m_reader.stringSetting("SMTSolvers", "z3");
if (choice == "none")
m_modelCheckerSettings.solvers = smtutil::SMTSolverChoice::None();
else if (!m_modelCheckerSettings.solvers.setSolver(choice))
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT solver choice."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT solver choice."));
m_modelCheckerSettings.solvers &= ModelChecker::availableSolvers();
@ -71,13 +70,13 @@ SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, E
if (targets)
m_modelCheckerSettings.targets = *targets;
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT targets."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT targets."));
auto engine = ModelCheckerEngine::fromString(m_reader.stringSetting("SMTEngine", "all"));
if (engine)
m_modelCheckerSettings.engine = *engine;
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT engine choice."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT engine choice."));
if (m_modelCheckerSettings.solvers.none() || m_modelCheckerSettings.engine.none())
m_shouldRun = false;
@ -88,10 +87,10 @@ SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, E
else if (ignoreCex == "yes")
m_ignoreCex = true;
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT counterexample choice."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT counterexample choice."));
static auto removeInv = [](vector<SyntaxTestError>&& errors) {
vector<SyntaxTestError> filtered;
static auto removeInv = [](std::vector<SyntaxTestError>&& errors) {
std::vector<SyntaxTestError> filtered;
for (auto&& e: errors)
if (e.errorId != 1180_error)
filtered.emplace_back(e);
@ -106,10 +105,10 @@ SMTCheckerTest::SMTCheckerTest(string const& _filename): SyntaxTest(_filename, E
else if (ignoreInv == "yes")
m_modelCheckerSettings.invariants = ModelCheckerInvariants::None();
else
BOOST_THROW_EXCEPTION(runtime_error("Invalid SMT invariant choice."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT invariant choice."));
auto const& ignoreOSSetting = m_reader.stringSetting("SMTIgnoreOS", "none");
for (string const& os: ignoreOSSetting | ranges::views::split(',') | ranges::to<vector<string>>())
for (std::string const& os: ignoreOSSetting | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
{
#ifdef __APPLE__
if (os == "macos")
@ -139,11 +138,11 @@ void SMTCheckerTest::filterObtainedErrors()
SyntaxTest::filterObtainedErrors();
m_unfilteredErrorList = m_errorList;
static auto removeCex = [](vector<SyntaxTestError>& errors) {
static auto removeCex = [](std::vector<SyntaxTestError>& errors) {
for (auto& e: errors)
if (
auto cexPos = e.message.find("\\nCounterexample");
cexPos != string::npos
cexPos != std::string::npos
)
e.message = e.message.substr(0, cexPos);
};
@ -155,7 +154,7 @@ void SMTCheckerTest::filterObtainedErrors()
}
}
void SMTCheckerTest::printUpdatedExpectations(ostream &_stream, const string &_linePrefix) const {
void SMTCheckerTest::printUpdatedExpectations(std::ostream &_stream, const std::string &_linePrefix) const {
if (!m_unfilteredErrorList.empty())
printErrorList(_stream, m_unfilteredErrorList, _linePrefix, false);
else

13
test/libsolidity/SemVerMatcher.cpp
View File

@ -31,7 +31,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity::langutil;
namespace solidity::frontend::test
@ -42,16 +41,16 @@ BOOST_AUTO_TEST_SUITE(SemVerMatcher)
namespace
{
SemVerMatchExpression parseExpression(string const& _input)
SemVerMatchExpression parseExpression(std::string const& _input)
{
CharStream stream(_input, "");
Scanner scanner{stream};
vector<string> literals;
vector<Token> tokens;
std::vector<std::string> literals;
std::vector<Token> tokens;
while (scanner.currentToken() != Token::EOS)
{
auto token = scanner.currentToken();
string literal = scanner.currentLiteral();
std::string literal = scanner.currentLiteral();
if (literal.empty() && TokenTraits::toString(token))
literal = TokenTraits::toString(token);
literals.push_back(literal);
@ -100,7 +99,7 @@ BOOST_AUTO_TEST_CASE(exception_on_invalid_version_in_semverversion_constructor)
BOOST_AUTO_TEST_CASE(positive_range)
{
// Positive range tests
vector<pair<string, string>> tests = {
std::vector<std::pair<std::string, std::string>> tests = {
{"*", "1.2.3-foo"},
{"1.0.0 - 2.0.0", "1.2.3"},
{"1.0.0", "1.0.0"},
@ -198,7 +197,7 @@ BOOST_AUTO_TEST_CASE(positive_range)
BOOST_AUTO_TEST_CASE(negative_range)
{
// Negative range tests
vector<pair<string, string>> tests = {
std::vector<std::pair<std::string, std::string>> tests = {
{"^0^1", "0.0.0"},
{"^0^1", "1.0.0"},
{"1.0.0 - 2.0.0", "2.2.3"},

146
test/libsolidity/SemanticTest.cpp
View File

@ -34,7 +34,6 @@
#include <string>
#include <utility>
using namespace std;
using namespace solidity;
using namespace solidity::yul;
using namespace solidity::langutil;
@ -43,9 +42,10 @@ using namespace solidity::util::formatting;
using namespace solidity::frontend::test;
using namespace boost::algorithm;
using namespace boost::unit_test;
using namespace std::string_literals;
namespace fs = boost::filesystem;
ostream& solidity::frontend::test::operator<<(ostream& _output, RequiresYulOptimizer _requiresYulOptimizer)
std::ostream& solidity::frontend::test::operator<<(std::ostream& _output, RequiresYulOptimizer _requiresYulOptimizer)
{
switch (_requiresYulOptimizer)
{
@ -57,10 +57,10 @@ ostream& solidity::frontend::test::operator<<(ostream& _output, RequiresYulOptim
}
SemanticTest::SemanticTest(
string const& _filename,
std::string const& _filename,
langutil::EVMVersion _evmVersion,
optional<uint8_t> _eofVersion,
vector<boost::filesystem::path> const& _vmPaths,
std::optional<uint8_t> _eofVersion,
std::vector<boost::filesystem::path> const& _vmPaths,
bool _enforceGasCost,
u256 _enforceGasCostMinValue
):
@ -73,9 +73,9 @@ SemanticTest::SemanticTest(
m_enforceGasCost(_enforceGasCost),
m_enforceGasCostMinValue(std::move(_enforceGasCostMinValue))
{
static set<string> const compileViaYulAllowedValues{"also", "true", "false"};
static set<string> const yulRunTriggers{"also", "true"};
static set<string> const legacyRunTriggers{"also", "false", "default"};
static std::set<std::string> const compileViaYulAllowedValues{"also", "true", "false"};
static std::set<std::string> const yulRunTriggers{"also", "true"};
static std::set<std::string> const legacyRunTriggers{"also", "false", "default"};
m_requiresYulOptimizer = m_reader.enumSetting<RequiresYulOptimizer>(
"requiresYulOptimizer",
@ -91,14 +91,14 @@ SemanticTest::SemanticTest(
if (m_runWithABIEncoderV1Only && !solidity::test::CommonOptions::get().useABIEncoderV1)
m_shouldRun = false;
string compileViaYul = m_reader.stringSetting("compileViaYul", "also");
std::string compileViaYul = m_reader.stringSetting("compileViaYul", "also");
if (m_runWithABIEncoderV1Only && compileViaYul != "false")
BOOST_THROW_EXCEPTION(runtime_error(
BOOST_THROW_EXCEPTION(std::runtime_error(
"ABIEncoderV1Only tests cannot be run via yul, "
"so they need to also specify ``compileViaYul: false``"
));
if (!util::contains(compileViaYulAllowedValues, compileViaYul))
BOOST_THROW_EXCEPTION(runtime_error("Invalid compileViaYul value: " + compileViaYul + "."));
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid compileViaYul value: " + compileViaYul + "."));
m_testCaseWantsYulRun = util::contains(yulRunTriggers, compileViaYul);
m_testCaseWantsLegacyRun = util::contains(legacyRunTriggers, compileViaYul);
@ -118,19 +118,19 @@ SemanticTest::SemanticTest(
}
}
map<string, Builtin> SemanticTest::makeBuiltins()
std::map<std::string, Builtin> SemanticTest::makeBuiltins()
{
return {
{
"isoltest_builtin_test",
[](FunctionCall const&) -> optional<bytes>
[](FunctionCall const&) -> std::optional<bytes>
{
return toBigEndian(u256(0x1234));
}
},
{
"isoltest_side_effects_test",
[](FunctionCall const& _call) -> optional<bytes>
[](FunctionCall const& _call) -> std::optional<bytes>
{
if (_call.arguments.parameters.empty())
return toBigEndian(0);
@ -140,7 +140,7 @@ map<string, Builtin> SemanticTest::makeBuiltins()
},
{
"balance",
[this](FunctionCall const& _call) -> optional<bytes>
[this](FunctionCall const& _call) -> std::optional<bytes>
{
soltestAssert(_call.arguments.parameters.size() <= 1, "Account address expected.");
h160 address;
@ -153,7 +153,7 @@ map<string, Builtin> SemanticTest::makeBuiltins()
},
{
"storageEmpty",
[this](FunctionCall const& _call) -> optional<bytes>
[this](FunctionCall const& _call) -> std::optional<bytes>
{
soltestAssert(_call.arguments.parameters.empty(), "No arguments expected.");
return toBigEndian(u256(storageEmpty(m_contractAddress) ? 1 : 0));
@ -161,7 +161,7 @@ map<string, Builtin> SemanticTest::makeBuiltins()
},
{
"account",
[this](FunctionCall const& _call) -> optional<bytes>
[this](FunctionCall const& _call) -> std::optional<bytes>
{
soltestAssert(_call.arguments.parameters.size() == 1, "Account number expected.");
size_t accountNumber = static_cast<size_t>(stoi(_call.arguments.parameters.at(0).rawString));
@ -172,15 +172,15 @@ map<string, Builtin> SemanticTest::makeBuiltins()
};
}
vector<SideEffectHook> SemanticTest::makeSideEffectHooks() const
std::vector<SideEffectHook> SemanticTest::makeSideEffectHooks() const
{
using namespace std::placeholders;
return {
[](FunctionCall const& _call) -> vector<string>
[](FunctionCall const& _call) -> std::vector<std::string>
{
if (_call.signature == "isoltest_side_effects_test")
{
vector<string> result;
std::vector<std::string> result;
for (auto const& argument: _call.arguments.parameters)
result.emplace_back(util::toHex(argument.rawBytes));
return result;
@ -191,7 +191,7 @@ vector<SideEffectHook> SemanticTest::makeSideEffectHooks() const
};
}
string SemanticTest::formatEventParameter(optional<AnnotatedEventSignature> _signature, bool _indexed, size_t _index, bytes const& _data)
std::string SemanticTest::formatEventParameter(std::optional<AnnotatedEventSignature> _signature, bool _indexed, size_t _index, bytes const& _data)
{
auto isPrintableASCII = [](bytes const& s)
{
@ -214,7 +214,7 @@ string SemanticTest::formatEventParameter(optional<AnnotatedEventSignature> _sig
abiType = ABIType(ABIType::Type::String);
if (_signature.has_value())
{
vector<string> const& types = _indexed ? _signature->indexedTypes : _signature->nonIndexedTypes;
std::vector<std::string> const& types = _indexed ? _signature->indexedTypes : _signature->nonIndexedTypes;
if (_index < types.size())
{
if (types.at(_index) == "bool")
@ -224,16 +224,16 @@ string SemanticTest::formatEventParameter(optional<AnnotatedEventSignature> _sig
return BytesUtils::formatBytes(_data, abiType);
}
vector<string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
std::vector<std::string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
{
vector<string> sideEffects;
vector<LogRecord> recordedLogs = ExecutionFramework::recordedLogs();
std::vector<std::string> sideEffects;
std::vector<LogRecord> recordedLogs = ExecutionFramework::recordedLogs();
for (LogRecord const& log: recordedLogs)
{
optional<AnnotatedEventSignature> eventSignature;
std::optional<AnnotatedEventSignature> eventSignature;
if (!log.topics.empty())
eventSignature = matchEvent(log.topics[0]);
stringstream sideEffect;
std::stringstream sideEffect;
sideEffect << "emit ";
if (eventSignature.has_value())
sideEffect << eventSignature.value().signature;
@ -243,7 +243,7 @@ vector<string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
if (m_contractAddress != log.creator)
sideEffect << " from 0x" << log.creator;
vector<string> eventStrings;
std::vector<std::string> eventStrings;
size_t index{0};
for (h256 const& topic: log.topics)
{
@ -268,10 +268,10 @@ vector<string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
return sideEffects;
}
optional<AnnotatedEventSignature> SemanticTest::matchEvent(util::h256 const& hash) const
std::optional<AnnotatedEventSignature> SemanticTest::matchEvent(util::h256 const& hash) const
{
optional<AnnotatedEventSignature> result;
for (string& contractName: m_compiler.contractNames())
std::optional<AnnotatedEventSignature> result;
for (std::string& contractName: m_compiler.contractNames())
{
ContractDefinition const& contract = m_compiler.contractDefinition(contractName);
for (EventDefinition const* event: contract.events())
@ -312,7 +312,7 @@ frontend::OptimiserSettings SemanticTest::optimizerSettingsFor(RequiresYulOptimi
unreachable();
}
TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
TestCase::TestResult SemanticTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
{
TestResult result = TestResult::Success;
@ -338,8 +338,8 @@ TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePref
}
TestCase::TestResult SemanticTest::runTest(
ostream& _stream,
string const& _linePrefix,
std::ostream& _stream,
std::string const& _linePrefix,
bool _formatted,
bool _isYulRun
)
@ -354,12 +354,12 @@ TestCase::TestResult SemanticTest::runTest(
m_compileViaYul = _isYulRun;
if (_isYulRun)
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Running via Yul: " << endl;
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Running via Yul: " << std::endl;
for (TestFunctionCall& test: m_tests)
test.reset();
map<string, solidity::test::Address> libraries;
std::map<std::string, solidity::test::Address> libraries;
bool constructed = false;
@ -416,7 +416,7 @@ TestCase::TestResult SemanticTest::runTest(
output = callLowLevel(test.call().arguments.rawBytes(), test.call().value.value);
else if (test.call().kind == FunctionCall::Kind::Builtin)
{
optional<bytes> builtinOutput = m_builtins.at(test.call().signature)(test.call());
std::optional<bytes> builtinOutput = m_builtins.at(test.call().signature)(test.call());
if (builtinOutput.has_value())
{
m_transactionSuccessful = true;
@ -460,7 +460,7 @@ TestCase::TestResult SemanticTest::runTest(
test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName(m_sources.mainSourceFile)));
}
vector<string> effects;
std::vector<std::string> effects;
for (SideEffectHook const& hook: m_sideEffectHooks)
effects += hook(test.call());
test.setSideEffects(std::move(effects));
@ -470,7 +470,7 @@ TestCase::TestResult SemanticTest::runTest(
if (!success)
{
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Expected result:" << endl;
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Expected result:" << std::endl;
for (TestFunctionCall const& test: m_tests)
{
ErrorReporter errorReporter;
@ -480,11 +480,11 @@ TestCase::TestResult SemanticTest::runTest(
TestFunctionCall::RenderMode::ExpectedValuesExpectedGas,
_formatted,
/* _interactivePrint */ true
) << endl;
) << std::endl;
_stream << errorReporter.format(_linePrefix, _formatted);
}
_stream << endl;
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Obtained result:" << endl;
_stream << std::endl;
AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Obtained result:" << std::endl;
for (TestFunctionCall const& test: m_tests)
{
ErrorReporter errorReporter;
@ -494,22 +494,22 @@ TestCase::TestResult SemanticTest::runTest(
m_gasCostFailure ? TestFunctionCall::RenderMode::ExpectedValuesActualGas : TestFunctionCall::RenderMode::ActualValuesExpectedGas,
_formatted,
/* _interactivePrint */ true
) << endl;
) << std::endl;
_stream << errorReporter.format(_linePrefix, _formatted);
}
AnsiColorized(_stream, _formatted, {BOLD, RED})
<< _linePrefix << endl
<< _linePrefix << "Attention: Updates on the test will apply the detected format displayed." << endl;
<< _linePrefix << std::endl
<< _linePrefix << "Attention: Updates on the test will apply the detected format displayed." << std::endl;
if (_isYulRun && m_testCaseWantsLegacyRun)
{
_stream << _linePrefix << endl << _linePrefix;
_stream << _linePrefix << std::endl << _linePrefix;
AnsiColorized(_stream, _formatted, {RED_BACKGROUND}) << "Note that the test passed without Yul.";
_stream << endl;
_stream << std::endl;
}
else if (!_isYulRun && m_testCaseWantsYulRun)
AnsiColorized(_stream, _formatted, {BOLD, YELLOW})
<< _linePrefix << endl
<< _linePrefix << "Note that the test also has to pass via Yul." << endl;
<< _linePrefix << std::endl
<< _linePrefix << "Note that the test also has to pass via Yul." << std::endl;
return TestResult::Failure;
}
@ -551,9 +551,9 @@ TestCase::TestResult SemanticTest::tryRunTestWithYulOptimizer(
soltestAssert(result == TestResult::Success || result == TestResult::Failure);
AnsiColorized(_stream, _formatted, {BOLD, YELLOW})
<< _linePrefix << endl
<< _linePrefix << std::endl
<< _linePrefix << "requiresYulOptimizer is set to " << m_requiresYulOptimizer
<< " but should be " << requiresYulOptimizer << endl;
<< " but should be " << requiresYulOptimizer << std::endl;
m_requiresYulOptimizer = requiresYulOptimizer;
return TestResult::Failure;
}
@ -565,7 +565,7 @@ TestCase::TestResult SemanticTest::tryRunTestWithYulOptimizer(
bool SemanticTest::checkGasCostExpectation(TestFunctionCall& io_test, bool _compileViaYul) const
{
string setting =
std::string setting =
(_compileViaYul ? "ir"s : "legacy"s) +
(m_optimiserSettings == OptimiserSettings::full() ? "Optimized" : "");
@ -592,27 +592,27 @@ bool SemanticTest::checkGasCostExpectation(TestFunctionCall& io_test, bool _comp
m_gasUsed == io_test.call().expectations.gasUsed.at(setting);
}
void SemanticTest::printSource(ostream& _stream, string const& _linePrefix, bool _formatted) const
void SemanticTest::printSource(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const
{
if (m_sources.sources.empty())
return;
bool outputNames = (m_sources.sources.size() - m_sources.externalSources.size() != 1 || !m_sources.sources.begin()->first.empty());
set<string> externals;
std::set<std::string> externals;
for (auto const& [name, path]: m_sources.externalSources)
{
externals.insert(name);
string externalSource;
std::string externalSource;
if (name == path)
externalSource = name;
else
externalSource = name + "=" + path.generic_string();
if (_formatted)
_stream << _linePrefix << formatting::CYAN << "==== ExternalSource: " << externalSource << " ===="s << formatting::RESET << endl;
_stream << _linePrefix << formatting::CYAN << "==== ExternalSource: " << externalSource << " ===="s << formatting::RESET << std::endl;
else
_stream << _linePrefix << "==== ExternalSource: " << externalSource << " ===="s << endl;
_stream << _linePrefix << "==== ExternalSource: " << externalSource << " ===="s << std::endl;
}
for (auto const& [name, source]: m_sources.sources)
@ -625,9 +625,9 @@ void SemanticTest::printSource(ostream& _stream, string const& _linePrefix, bool
if (outputNames)
_stream << _linePrefix << formatting::CYAN << "==== Source: " << name
<< " ====" << formatting::RESET << endl;
<< " ====" << formatting::RESET << std::endl;
vector<char const*> sourceFormatting(source.length(), formatting::RESET);
std::vector<char const*> sourceFormatting(source.length(), formatting::RESET);
_stream << _linePrefix << sourceFormatting.front() << source.front();
for (size_t i = 1; i < source.length(); i++)
{
@ -637,7 +637,7 @@ void SemanticTest::printSource(ostream& _stream, string const& _linePrefix, bool
_stream << source[i];
else
{
_stream << formatting::RESET << endl;
_stream << formatting::RESET << std::endl;
if (i + 1 < source.length())
_stream << _linePrefix << sourceFormatting[i];
}
@ -647,50 +647,50 @@ void SemanticTest::printSource(ostream& _stream, string const& _linePrefix, bool
else
{
if (outputNames)
_stream << _linePrefix << "==== Source: " + name << " ====" << endl;
stringstream stream(source);
string line;
_stream << _linePrefix << "==== Source: " + name << " ====" << std::endl;
std::stringstream stream(source);
std::string line;
while (getline(stream, line))
_stream << _linePrefix << line << endl;
_stream << _linePrefix << line << std::endl;
}
}
}
void SemanticTest::printUpdatedExpectations(ostream& _stream, string const&) const
void SemanticTest::printUpdatedExpectations(std::ostream& _stream, std::string const&) const
{
for (TestFunctionCall const& test: m_tests)
_stream << test.format(
"",
m_gasCostFailure ? TestFunctionCall::RenderMode::ExpectedValuesActualGas : TestFunctionCall::RenderMode::ActualValuesExpectedGas,
/* _highlight = */ false
) << endl;
) << std::endl;
}
void SemanticTest::printUpdatedSettings(ostream& _stream, string const& _linePrefix)
void SemanticTest::printUpdatedSettings(std::ostream& _stream, std::string const& _linePrefix)
{
auto& settings = m_reader.settings();
if (settings.empty() && m_requiresYulOptimizer == RequiresYulOptimizer::False)
return;
_stream << _linePrefix << "// ====" << endl;
_stream << _linePrefix << "// ====" << std::endl;
if (m_requiresYulOptimizer != RequiresYulOptimizer::False)
_stream << _linePrefix << "// requiresYulOptimizer: " << m_requiresYulOptimizer << endl;
_stream << _linePrefix << "// requiresYulOptimizer: " << m_requiresYulOptimizer << std::endl;
for (auto const& [settingName, settingValue]: settings)
if (settingName != "requiresYulOptimizer")
_stream << _linePrefix << "// " << settingName << ": " << settingValue<< endl;
_stream << _linePrefix << "// " << settingName << ": " << settingValue<< std::endl;
}
void SemanticTest::parseExpectations(istream& _stream)
void SemanticTest::parseExpectations(std::istream& _stream)
{
m_tests += TestFileParser{_stream, m_builtins}.parseFunctionCalls(m_lineOffset);
}
bool SemanticTest::deploy(
string const& _contractName,
std::string const& _contractName,
u256 const& _value,
bytes const& _arguments,
map<string, solidity::test::Address> const& _libraries
std::map<std::string, solidity::test::Address> const& _libraries
)
{
auto output = compileAndRunWithoutCheck(m_sources.sources, _value, _contractName, _arguments, _libraries, m_sources.mainSourceFile);

1
test/libsolidity/SolidityCompiler.cpp
View File

@ -24,7 +24,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::frontend::test
{

155
test/libsolidity/SolidityEndToEndTest.cpp
View File

@ -46,7 +46,6 @@
#include <string>
#include <tuple>
using namespace std;
using namespace std::placeholders;
using namespace solidity;
using namespace solidity::util;
@ -90,7 +89,7 @@ BOOST_FIXTURE_TEST_SUITE(SolidityEndToEndTest, SolidityEndToEndTestExecutionFram
BOOST_AUTO_TEST_CASE(creation_code_optimizer)
{
string codeC = R"(
std::string codeC = R"(
contract C {
constructor(uint x) {
if (x == 0xFFFFFFFFFFFFFFFF42)
@ -98,7 +97,7 @@ BOOST_AUTO_TEST_CASE(creation_code_optimizer)
}
}
)";
string codeD = R"(
std::string codeD = R"(
contract D {
function f() public pure returns (bytes memory) {
return type(C).creationCode;
@ -170,7 +169,7 @@ BOOST_AUTO_TEST_CASE(recursive_calls)
)";
ALSO_VIA_YUL(
compileAndRun(sourceCode);
function<u256(u256)> recursive_calls_cpp = [&recursive_calls_cpp](u256 const& n) -> u256
std::function<u256(u256)> recursive_calls_cpp = [&recursive_calls_cpp](u256 const& n) -> u256
{
if (n <= 1)
return 1;
@ -742,7 +741,7 @@ BOOST_AUTO_TEST_CASE(mapping_state_inc_dec)
)";
u256 value;
map<u256, u256> table;
std::map<u256, u256> table;
auto f = [&](u256 const& _x) -> u256
{
value = _x;
@ -775,7 +774,7 @@ BOOST_AUTO_TEST_CASE(multi_level_mapping)
}
}
)";
map<u256, map<u256, u256>> table;
std::map<u256, std::map<u256, u256>> table;
auto f = [&](u256 const& _x, u256 const& _y, u256 const& _z) -> u256
{
if (_z == 0) return table[_x][_y];
@ -810,7 +809,7 @@ BOOST_AUTO_TEST_CASE(constructor)
}
)";
map<u256, uint8_t> data;
std::map<u256, uint8_t> data;
data[7] = 8;
auto get = [&](u256 const& _x) -> u256
{
@ -1069,7 +1068,7 @@ BOOST_AUTO_TEST_CASE(fixed_bytes_in_calls)
compileAndRun(sourceCode, 0, "Main");
BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
ABI_CHECK(callContractFunction("callHelper(bytes2,bool)", string("\0a", 2), true), encodeArgs(string("\0a\0\0\0", 5)));
ABI_CHECK(callContractFunction("callHelper(bytes2,bool)", std::string("\0a", 2), true), encodeArgs(std::string("\0a\0\0\0", 5)));
}
BOOST_AUTO_TEST_CASE(constructor_with_long_arguments)
@ -1085,8 +1084,8 @@ BOOST_AUTO_TEST_CASE(constructor_with_long_arguments)
}
}
)";
string a = "01234567890123gabddunaouhdaoneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012cdef";
string b = "AUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PY";
std::string a = "01234567890123gabddunaouhdaoneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012cdef";
std::string b = "AUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PY";
compileAndRun(sourceCode, 0, "Main", encodeArgs(
u256(0x40),
@ -1141,7 +1140,7 @@ BOOST_AUTO_TEST_CASE(blockhash)
while (blockNumber() < u256(255))
ABI_CHECK(callContractFunction("g()"), encodeArgs(true));
vector<u256> hashes;
std::vector<u256> hashes;
// ``blockhash()`` is only valid for the last 256 blocks, otherwise zero
hashes.emplace_back(0);
for (u256 i = blockNumber() - u256(255); i <= blockNumber(); i++)
@ -1263,7 +1262,7 @@ BOOST_AUTO_TEST_CASE(generic_delegatecall)
for (auto v2: {false, true})
{
string source = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n" + string(sourceCode);
std::string source = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n" + std::string(sourceCode);
compileAndRun(source, 0, "Receiver");
h160 const c_receiverAddress = m_contractAddress;
@ -1354,7 +1353,7 @@ BOOST_AUTO_TEST_CASE(library_call_protection)
ABI_CHECK(callContractFunction("np(Lib.S storage)", 0), encodeArgs());
ABI_CHECK(callContractFunction("v(Lib.S storage)", 0), encodeArgs(m_sender));
ABI_CHECK(callContractFunction("pu()"), encodeArgs(2));
compileAndRun(sourceCode, 0, "Test", bytes(), map<string, h160>{{":Lib", m_contractAddress}});
compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
ABI_CHECK(callContractFunction("s()"), encodeArgs(0));
ABI_CHECK(callContractFunction("np()"), encodeArgs(m_sender));
ABI_CHECK(callContractFunction("s()"), encodeArgs(3));
@ -1420,7 +1419,7 @@ BOOST_AUTO_TEST_CASE(call_forward_bytes_length)
ABI_CHECK(callContractFunction("viaStorage()"), encodeArgs(4));
// Some additional unpadded data
bytes unpadded = asBytes(string("abc"));
bytes unpadded = asBytes(std::string("abc"));
ABI_CHECK(callContractFunctionNoEncoding("viaCalldata()", unpadded), encodeArgs(7));
ABI_CHECK(callContractFunctionNoEncoding("viaMemory()", unpadded), encodeArgs(7));
ABI_CHECK(callContractFunctionNoEncoding("viaStorage()", unpadded), encodeArgs(7));
@ -1535,7 +1534,7 @@ BOOST_AUTO_TEST_CASE(struct_referencing)
compileAndRun(sourceCode, 0, "L");
ABI_CHECK(callContractFunction("f()"), encodeArgs(0, 3));
ABI_CHECK(callContractFunction("g()"), encodeArgs(4));
compileAndRun(sourceCode, 0, "C", bytes(), map<string, h160>{ {":L", m_contractAddress}});
compileAndRun(sourceCode, 0, "C", bytes(), std::map<std::string, h160>{ {":L", m_contractAddress}});
ABI_CHECK(callContractFunction("f()"), encodeArgs(1));
ABI_CHECK(callContractFunction("g()"), encodeArgs(2));
ABI_CHECK(callContractFunction("h()"), encodeArgs(0, 5));
@ -1583,7 +1582,7 @@ BOOST_AUTO_TEST_CASE(enum_referencing)
compileAndRun(sourceCode, 0, "L");
ABI_CHECK(callContractFunction("f()"), encodeArgs(1));
ABI_CHECK(callContractFunction("g()"), encodeArgs(3));
compileAndRun(sourceCode, 0, "C", bytes(), map<string, h160>{{":L", m_contractAddress}});
compileAndRun(sourceCode, 0, "C", bytes(), std::map<std::string, h160>{{":L", m_contractAddress}});
ABI_CHECK(callContractFunction("f()"), encodeArgs(3));
ABI_CHECK(callContractFunction("g()"), encodeArgs(3));
ABI_CHECK(callContractFunction("h()"), encodeArgs(1));
@ -1612,8 +1611,8 @@ BOOST_AUTO_TEST_CASE(bytes_in_arguments)
ALSO_VIA_YUL(
compileAndRun(sourceCode);
string innercalldata1 = asString(util::selectorFromSignatureH32("f(uint256,uint256)").asBytes() + encodeArgs(8, 9));
string innercalldata2 = asString(util::selectorFromSignatureH32("g(uint256)").asBytes() + encodeArgs(3));
std::string innercalldata1 = asString(util::selectorFromSignatureH32("f(uint256,uint256)").asBytes() + encodeArgs(8, 9));
std::string innercalldata2 = asString(util::selectorFromSignatureH32("g(uint256)").asBytes() + encodeArgs(3));
bytes calldata = encodeArgs(
12, 32 * 4, u256(32 * 4 + 32 + (innercalldata1.length() + 31) / 32 * 32), 13,
u256(innercalldata1.length()), innercalldata1,
@ -1765,20 +1764,20 @@ BOOST_AUTO_TEST_CASE(return_multiple_strings_of_various_sizes)
}
)";
compileAndRun(sourceCode, 0, "Main");
string s1(
std::string s1(
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
);
string s2(
std::string s2(
"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
);
vector<size_t> lengths{0, 30, 32, 63, 64, 65, 210, 300};
std::vector<size_t> lengths{0, 30, 32, 63, 64, 65, 210, 300};
for (auto l1: lengths)
for (auto l2: lengths)
{
@ -1813,8 +1812,8 @@ BOOST_AUTO_TEST_CASE(accessor_involving_strings)
}
)";
compileAndRun(sourceCode, 0, "Main");
string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
string s2("ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ");
std::string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
std::string s2("ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ");
bytes s1Data = encodeArgs(u256(s1.length()), s1);
bytes s2Data = encodeArgs(u256(s2.length()), s2);
u256 b = 765;
@ -1846,9 +1845,9 @@ BOOST_AUTO_TEST_CASE(bytes_in_function_calls)
}
)";
compileAndRun(sourceCode, 0, "Main");
string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
string s2("ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ");
vector<size_t> lengths{0, 31, 64, 65};
std::string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
std::string s2("ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ");
std::vector<size_t> lengths{0, 31, 64, 65};
for (auto l1: lengths)
for (auto l2: lengths)
{
@ -1888,8 +1887,8 @@ BOOST_AUTO_TEST_CASE(return_bytes_internal)
}
)";
compileAndRun(sourceCode, 0, "Main");
string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
vector<size_t> lengths{0, 31, 64, 65};
std::string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
std::vector<size_t> lengths{0, 31, 64, 65};
for (auto l1: lengths)
{
bytes dyn1 = encodeArgs(u256(l1), s1.substr(0, l1));
@ -1951,7 +1950,7 @@ BOOST_AUTO_TEST_CASE(calldata_struct_function_type)
BOOST_AUTO_TEST_CASE(calldata_array_dynamic_three_dimensional)
{
vector<vector<vector<u256>>> data {
std::vector<std::vector<std::vector<u256>>> data {
{
{ 0x010A01, 0x010A02, 0x010A03 },
{ 0x010B01, 0x010B02, 0x010B03 }
@ -1970,12 +1969,12 @@ BOOST_AUTO_TEST_CASE(calldata_array_dynamic_three_dimensional)
if (!outerDynamicallySized && !middleDynamicallySized && !innerDynamicallySized)
continue;
string arrayType = "uint256";
std::string arrayType = "uint256";
arrayType += innerDynamicallySized ? "[]" : "[3]";
arrayType += middleDynamicallySized ? "[]" : "[2]";
arrayType += outerDynamicallySized ? "[]" : "[2]";
string sourceCode = R"(
std::string sourceCode = R"(
pragma abicoder v2;
contract C {
function test()" + arrayType + R"( calldata a) external returns (uint256) {
@ -2049,16 +2048,16 @@ BOOST_AUTO_TEST_CASE(literal_strings)
}
)";
compileAndRun(sourceCode, 0, "Test");
string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
string medium = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
string shortStr = "123";
string hello = "Hello, World!";
std::string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
std::string medium = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
std::string shortStr = "123";
std::string hello = "Hello, World!";
ABI_CHECK(callContractFunction("f()"), encodeDyn(hello));
ABI_CHECK(callContractFunction("long()"), encodeDyn(longStr));
ABI_CHECK(callContractFunction("medium()"), encodeDyn(medium));
ABI_CHECK(callContractFunction("short()"), encodeDyn(shortStr));
ABI_CHECK(callContractFunction("empty()"), encodeDyn(string()));
ABI_CHECK(callContractFunction("empty()"), encodeDyn(std::string()));
}
BOOST_AUTO_TEST_CASE(initialise_string_constant)
@ -2070,8 +2069,8 @@ BOOST_AUTO_TEST_CASE(initialise_string_constant)
}
)";
compileAndRun(sourceCode, 0, "Test");
string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
string shortStr = "abcdef";
std::string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
std::string shortStr = "abcdef";
ABI_CHECK(callContractFunction("long()"), encodeDyn(longStr));
ABI_CHECK(callContractFunction("short()"), encodeDyn(shortStr));
@ -2087,7 +2086,7 @@ BOOST_AUTO_TEST_CASE(string_as_mapping_key)
}
)";
vector<string> strings{
std::vector<std::string> strings{
"Hello, World!",
"Hello, World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
"",
@ -2123,7 +2122,7 @@ BOOST_AUTO_TEST_CASE(string_as_public_mapping_key)
}
)";
compileAndRun(sourceCode, 0, "Test");
vector<string> strings{
std::vector<std::string> strings{
"Hello, World!",
"Hello, World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
"",
@ -2156,7 +2155,7 @@ BOOST_AUTO_TEST_CASE(nested_string_as_public_mapping_key)
}
)";
compileAndRun(sourceCode, 0, "Test");
vector<string> strings{
std::vector<std::string> strings{
"Hello, World!",
"Hello, World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
"",
@ -2211,13 +2210,13 @@ BOOST_AUTO_TEST_CASE(nested_mixed_string_as_public_mapping_key)
struct Index
{
string s1;
std::string s1;
int s2;
int s3;
string s4;
std::string s4;
};
vector<Index> data{
std::vector<Index> data{
{ "aabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcbc", 4, 23, "efg" },
{ "tiaron", 456, 63245, "908apzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapz" },
{ "", 2345, 12934, "665i65i65i65i65i65i65i65i65i65i65i65i65i65i65i65i65i65i5iart" },
@ -2264,7 +2263,7 @@ BOOST_AUTO_TEST_CASE(library_call)
)";
ALSO_VIA_YUL(
compileAndRun(sourceCode, 0, "Lib");
compileAndRun(sourceCode, 0, "Test", bytes(), map<string, h160>{{":Lib", m_contractAddress}});
compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
ABI_CHECK(callContractFunction("f(uint256)", u256(33)), encodeArgs(u256(33) * 9));
)
}
@ -2281,7 +2280,7 @@ BOOST_AUTO_TEST_CASE(library_function_external)
)";
ALSO_VIA_YUL(
compileAndRun(sourceCode, 0, "Lib");
compileAndRun(sourceCode, 0, "Test", bytes(), map<string, h160>{{":Lib", m_contractAddress}});
compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
ABI_CHECK(callContractFunction("f(bytes)", u256(0x20), u256(5), "abcde"), encodeArgs("c"));
)
}
@ -2315,9 +2314,9 @@ BOOST_AUTO_TEST_CASE(using_library_mappings_external)
)";
for (auto v2: {false, true})
{
string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n";
std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
compileAndRun(prefix + libSourceCode, 0, "Lib");
compileAndRun(prefix + sourceCode, 0, "Test", bytes(), map<string, h160>{{":Lib", m_contractAddress}});
compileAndRun(prefix + sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
ABI_CHECK(callContractFunction("f()"), encodeArgs(u256(2), u256(0), u256(84), u256(46), u256(0), u256(198)));
}
}
@ -2432,7 +2431,7 @@ BOOST_AUTO_TEST_CASE(short_strings)
)";
ALSO_VIA_YUL(
compileAndRun(sourceCode, 0, "A");
ABI_CHECK(callContractFunction("data1()"), encodeDyn(string("123")));
ABI_CHECK(callContractFunction("data1()"), encodeDyn(std::string("123")));
ABI_CHECK(callContractFunction("lengthChange()"), encodeArgs(u256(0)));
BOOST_CHECK(storageEmpty(m_contractAddress));
ABI_CHECK(callContractFunction("deleteElements()"), encodeArgs(u256(0)));
@ -2458,7 +2457,7 @@ BOOST_AUTO_TEST_CASE(calldata_offset)
}
)";
compileAndRun(sourceCode, 0, "CB", encodeArgs(u256(0x20), u256(0x00)));
ABI_CHECK(callContractFunction("last()", encodeArgs()), encodeDyn(string("nd")));
ABI_CHECK(callContractFunction("last()", encodeArgs()), encodeDyn(std::string("nd")));
}
BOOST_AUTO_TEST_CASE(reject_ether_sent_to_library)
@ -2525,7 +2524,7 @@ BOOST_AUTO_TEST_CASE(inline_long_string_return)
}
)";
string strLong = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
std::string strLong = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f()"), encodeDyn(strLong));
}
@ -2775,8 +2774,8 @@ BOOST_AUTO_TEST_CASE(shift_bytes)
}
)";
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("left(bytes20,uint8)", "12345678901234567890", 8 * 8), encodeArgs("901234567890" + string(8, 0)));
ABI_CHECK(callContractFunction("right(bytes20,uint8)", "12345678901234567890", 8 * 8), encodeArgs(string(8, 0) + "123456789012"));
ABI_CHECK(callContractFunction("left(bytes20,uint8)", "12345678901234567890", 8 * 8), encodeArgs("901234567890" + std::string(8, 0)));
ABI_CHECK(callContractFunction("right(bytes20,uint8)", "12345678901234567890", 8 * 8), encodeArgs(std::string(8, 0) + "123456789012"));
}
BOOST_AUTO_TEST_CASE(contracts_separated_with_comment)
@ -3152,12 +3151,12 @@ BOOST_AUTO_TEST_CASE(bare_call_return_data)
{
if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
{
vector<string> calltypes = {"call", "delegatecall"};
std::vector<std::string> calltypes = {"call", "delegatecall"};
if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
calltypes.emplace_back("staticcall");
for (string const& calltype: calltypes)
for (std::string const& calltype: calltypes)
{
string sourceCode = R"DELIMITER(
std::string sourceCode = R"DELIMITER(
contract A {
constructor() {
}
@ -3256,14 +3255,14 @@ BOOST_AUTO_TEST_CASE(bare_call_return_data)
)DELIMITER";
ALSO_VIA_YUL(
compileAndRun(sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_bool()"))), encodeArgs(true, 0x40, 0x20, true));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_int32()"))), encodeArgs(true, 0x40, 0x20, u256(-32)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_uint32()"))), encodeArgs(true, 0x40, 0x20, u256(0x3232)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_int256()"))), encodeArgs(true, 0x40, 0x20, u256(-256)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_uint256()"))), encodeArgs(true, 0x40, 0x20, u256(0x256256)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_bytes4()"))), encodeArgs(true, 0x40, 0x20, u256(0xabcd0012) << (28*8)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_multi()"))), encodeArgs(true, 0x40, 0x60, false, u256(0x3232), u256(0xabcd0012) << (28*8)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(string("return_bytes()"))), encodeArgs(true, 0x40, 0x60, 0x20, 0x02, encode(bytes{0x42,0x21}, false)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_bool()"))), encodeArgs(true, 0x40, 0x20, true));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_int32()"))), encodeArgs(true, 0x40, 0x20, u256(-32)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_uint32()"))), encodeArgs(true, 0x40, 0x20, u256(0x3232)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_int256()"))), encodeArgs(true, 0x40, 0x20, u256(-256)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_uint256()"))), encodeArgs(true, 0x40, 0x20, u256(0x256256)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_bytes4()"))), encodeArgs(true, 0x40, 0x20, u256(0xabcd0012) << (28*8)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_multi()"))), encodeArgs(true, 0x40, 0x60, false, u256(0x3232), u256(0xabcd0012) << (28*8)));
ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_bytes()"))), encodeArgs(true, 0x40, 0x60, 0x20, 0x02, encode(bytes{0x42,0x21}, false)));
ABI_CHECK(callContractFunction("check_bool()"), encodeArgs(true));
ABI_CHECK(callContractFunction("check_int32()"), encodeArgs(true));
ABI_CHECK(callContractFunction("check_uint32()"), encodeArgs(true));
@ -3315,7 +3314,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked)
for (auto v2: {false, true})
{
ALSO_VIA_YUL(
string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n";
std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
compileAndRun(prefix + sourceCode, 0, "C");
ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 0));
ABI_CHECK(callContractFunction("f1()"), encodeArgs(0x20, 2, "\x01\x02"));
@ -3392,7 +3391,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_from_storage)
for (auto v2: {false, true})
{
ALSO_VIA_YUL(
string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n";
std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
compileAndRun(prefix + sourceCode, 0, "C");
bytes payload = encodeArgs(0xfffff1, 0, 0xfffff2, 0, 0, 0xfffff3, 0, 0, 0xfffff4);
bytes encoded = encodeArgs(0x20, 0x122, "\x01" + asString(payload) + "\x02");
@ -3465,7 +3464,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_from_memory)
for (auto v2: {false, true})
{
ALSO_VIA_YUL(
string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n";
std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
compileAndRun(prefix + sourceCode, 0, "C");
bytes payload = encodeArgs(0xfffff1, 0, 0xfffff2, 0, 0, 0xfffff3, 0, 0, 0xfffff4);
bytes encoded = encodeArgs(0x20, 0x122, "\x01" + asString(payload) + "\x02");
@ -3511,11 +3510,11 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_functionPtr)
for (auto v2: {false, true})
{
ALSO_VIA_YUL(
string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n";
std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
compileAndRun(prefix + sourceCode, 0, "C");
string directEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "02"));
std::string directEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "02"));
ABI_CHECK(callContractFunction("testDirect()"), encodeArgs(0x20, directEncoding.size(), directEncoding));
string arrayEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "0000000000000000" "02"));
std::string arrayEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "0000000000000000" "02"));
ABI_CHECK(callContractFunction("testFixedArray()"), encodeArgs(0x20, arrayEncoding.size(), arrayEncoding));
ABI_CHECK(callContractFunction("testDynamicArray()"), encodeArgs(0x20, arrayEncoding.size(), arrayEncoding));
)
@ -3557,11 +3556,11 @@ BOOST_AUTO_TEST_CASE(abi_encodePackedV2_structs)
bytes structEnc = encodeArgs(int(0x12), u256(-7), int(2), int(3), u256(-7), u256(-8));
ABI_CHECK(callContractFunction("testStorage()"), encodeArgs());
BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(string("E((uint8,int16,uint8[2],int16[]))")));
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E((uint8,int16,uint8[2],int16[]))")));
BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(structEnc)));
ABI_CHECK(callContractFunction("testMemory()"), encodeArgs());
BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(string("E((uint8,int16,uint8[2],int16[]))")));
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E((uint8,int16,uint8[2],int16[]))")));
BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(structEnc)));
)
}
@ -3592,7 +3591,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePackedV2_nestedArray)
bytes structEnc = encodeArgs(1, 2, 3, 0, 0, 0, 0, 4);
ABI_CHECK(callContractFunction("testNestedArrays()"), encodeArgs());
BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(string("E((uint8,int16)[2][][3])")));
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E((uint8,int16)[2][][3])")));
BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(structEnc)));
)
}
@ -3622,11 +3621,11 @@ BOOST_AUTO_TEST_CASE(abi_encodePackedV2_arrayOfStrings)
bytes arrayEncoding = encodeArgs("abc", "0123456789012345678901234567890123456789");
ABI_CHECK(callContractFunction("testStorage()"), encodeArgs());
BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(string("E(string[])")));
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E(string[])")));
BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(arrayEncoding)));
ABI_CHECK(callContractFunction("testMemory()"), encodeArgs());
BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(string("E(string[])")));
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E(string[])")));
BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(arrayEncoding)));
)
}
@ -3712,7 +3711,7 @@ BOOST_AUTO_TEST_CASE(contract_name)
ABI_CHECK(callContractFunction("name()"), argsD);
ABI_CHECK(callContractFunction("name2()"), argsC);
string longName = "ThisIsAVeryLongContractNameExceeding256bits";
std::string longName = "ThisIsAVeryLongContractNameExceeding256bits";
compileAndRun(sourceCode, 0, longName);
bytes argsLong = encodeArgs(u256(0x20), u256(longName.length()), longName);
ABI_CHECK(callContractFunction("name()"), argsLong);
@ -3738,13 +3737,13 @@ BOOST_AUTO_TEST_CASE(event_wrong_abi_name)
)";
ALSO_VIA_YUL(
compileAndRun(sourceCode, 0, "ClientReceipt", bytes());
compileAndRun(sourceCode, 0, "Test", bytes(), map<string, h160>{{":ClientReceipt", m_contractAddress}});
compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":ClientReceipt", m_contractAddress}});
callContractFunction("f()");
BOOST_REQUIRE_EQUAL(numLogs(), 1);
BOOST_CHECK_EQUAL(logAddress(0), m_contractAddress);
BOOST_REQUIRE_EQUAL(numLogTopics(0), 3);
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(string("Deposit(address,bytes32,uint256)")));
BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("Deposit(address,bytes32,uint256)")));
)
}

21
test/libsolidity/SolidityExecutionFramework.cpp
View File

@ -39,13 +39,12 @@ using namespace solidity::frontend;
using namespace solidity::frontend::test;
using namespace solidity::langutil;
using namespace solidity::test;
using namespace std;
bytes SolidityExecutionFramework::multiSourceCompileContract(
map<string, string> const& _sourceCode,
optional<string> const& _mainSourceName,
string const& _contractName,
map<string, Address> const& _libraryAddresses
std::map<std::string, std::string> const& _sourceCode,
std::optional<std::string> const& _mainSourceName,
std::string const& _contractName,
std::map<std::string, Address> const& _libraryAddresses
)
{
if (_mainSourceName.has_value())
@ -81,23 +80,23 @@ bytes SolidityExecutionFramework::multiSourceCompileContract(
.printErrorInformation(m_compiler.errors());
BOOST_ERROR("Compiling contract failed");
}
string contractName(_contractName.empty() ? m_compiler.lastContractName(_mainSourceName) : _contractName);
std::string contractName(_contractName.empty() ? m_compiler.lastContractName(_mainSourceName) : _contractName);
evmasm::LinkerObject obj = m_compiler.object(contractName);
BOOST_REQUIRE(obj.linkReferences.empty());
if (m_showMetadata)
cout << "metadata: " << m_compiler.metadata(contractName) << endl;
std::cout << "metadata: " << m_compiler.metadata(contractName) << std::endl;
return obj.bytecode;
}
bytes SolidityExecutionFramework::compileContract(
string const& _sourceCode,
string const& _contractName,
map<string, Address> const& _libraryAddresses
std::string const& _sourceCode,
std::string const& _contractName,
std::map<std::string, Address> const& _libraryAddresses
)
{
return multiSourceCompileContract(
{{"", _sourceCode}},
nullopt,
std::nullopt,
_contractName,
_libraryAddresses
);

21
test/libsolidity/SolidityExpressionCompiler.cpp
View File

@ -40,7 +40,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity::evmasm;
using namespace solidity::langutil;
@ -78,13 +77,13 @@ private:
Declaration const& resolveDeclaration(
SourceUnit const& _sourceUnit,
vector<string> const& _namespacedName,
std::vector<std::string> const& _namespacedName,
NameAndTypeResolver const& _resolver
)
{
ASTNode const* scope = &_sourceUnit;
// bracers are required, cause msvc couldn't handle this macro in for statement
for (string const& namePart: _namespacedName)
for (std::string const& namePart: _namespacedName)
{
auto declarations = _resolver.resolveName(namePart, scope);
BOOST_REQUIRE(!declarations.empty());
@ -95,12 +94,12 @@ Declaration const& resolveDeclaration(
}
bytes compileFirstExpression(
string const& _sourceCode,
vector<vector<string>> _functions = {},
vector<vector<string>> _localVariables = {}
std::string const& _sourceCode,
std::vector<std::vector<std::string>> _functions = {},
std::vector<std::vector<std::string>> _localVariables = {}
)
{
string sourceCode = "pragma solidity >=0.0; // SPDX-License-Identifier: GPL-3\n" + _sourceCode;
std::string sourceCode = "pragma solidity >=0.0; // SPDX-License-Identifier: GPL-3\n" + _sourceCode;
CharStream stream(sourceCode, "");
ASTPointer<SourceUnit> sourceUnit;
@ -114,12 +113,12 @@ bytes compileFirstExpression(
}
catch (boost::exception const& _e)
{
string msg = "Parsing source code failed with:\n" + boost::diagnostic_information(_e);
std::string msg = "Parsing source code failed with:\n" + boost::diagnostic_information(_e);
BOOST_FAIL(msg);
}
catch (...)
{
string msg = "Parsing source code failed with:\n" + boost::current_exception_diagnostic_information();
std::string msg = "Parsing source code failed with:\n" + boost::current_exception_diagnostic_information();
BOOST_FAIL(msg);
}
@ -151,7 +150,7 @@ bytes compileFirstExpression(
context.setArithmetic(Arithmetic::Wrapping);
size_t parametersSize = _localVariables.size(); // assume they are all one slot on the stack
context.adjustStackOffset(static_cast<int>(parametersSize));
for (vector<string> const& variable: _localVariables)
for (std::vector<std::string> const& variable: _localVariables)
context.addVariable(
dynamic_cast<VariableDeclaration const&>(resolveDeclaration(*sourceUnit, variable, resolver)),
static_cast<unsigned>(parametersSize--)
@ -162,7 +161,7 @@ bytes compileFirstExpression(
solidity::test::CommonOptions::get().optimize
).compile(*extractor.expression());
for (vector<string> const& function: _functions)
for (std::vector<std::string> const& function: _functions)
context << context.functionEntryLabel(dynamic_cast<FunctionDefinition const&>(
resolveDeclaration(*sourceUnit, function, resolver)
));

1
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -32,7 +32,6 @@
#include <string>
using namespace std;
using namespace solidity::langutil;
namespace solidity::frontend::test

7
test/libsolidity/SolidityOptimizer.cpp
View File

@ -35,7 +35,6 @@
#include <memory>
#include <limits>
using namespace std;
using namespace solidity::util;
using namespace solidity::evmasm;
using namespace solidity::test;
@ -79,9 +78,9 @@ public:
size_t optimizedSize = numInstructions(m_optimizedBytecode);
BOOST_CHECK_MESSAGE(
_optimizeRuns < 50 || optimizedSize < nonOptimizedSize,
string("Optimizer did not reduce bytecode size. Non-optimized size: ") +
to_string(nonOptimizedSize) + " - optimized size: " +
to_string(optimizedSize)
std::string("Optimizer did not reduce bytecode size. Non-optimized size: ") +
std::to_string(nonOptimizedSize) + " - optimized size: " +
std::to_string(optimizedSize)
);
m_optimizedContract = m_contractAddress;
}

13
test/libsolidity/ViewPureChecker.cpp
View File

@ -27,7 +27,6 @@
#include <string>
#include <tuple>
using namespace std;
using namespace solidity::langutil;
namespace solidity::frontend::test
@ -37,7 +36,7 @@ BOOST_FIXTURE_TEST_SUITE(ViewPureChecker, AnalysisFramework)
BOOST_AUTO_TEST_CASE(environment_access)
{
vector<string> view{
std::vector<std::string> view{
"block.coinbase",
"block.timestamp",
"block.difficulty",
@ -57,7 +56,7 @@ BOOST_AUTO_TEST_CASE(environment_access)
// ``block.blockhash`` and ``blockhash`` are tested separately below because their usage will
// produce warnings that can't be handled in a generic way.
vector<string> pure{
std::vector<std::string> pure{
"msg.data",
"msg.data[0]",
"msg.sig",
@ -65,7 +64,7 @@ BOOST_AUTO_TEST_CASE(environment_access)
"block",
"tx"
};
for (string const& x: view)
for (std::string const& x: view)
{
CHECK_ERROR(
"contract C { function f() pure public { " + x + "; } }",
@ -73,7 +72,7 @@ BOOST_AUTO_TEST_CASE(environment_access)
"Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires \"view\""
);
}
for (string const& x: pure)
for (std::string const& x: pure)
{
CHECK_WARNING(
"contract C { function f() view public { " + x + "; } }",
@ -97,7 +96,7 @@ BOOST_AUTO_TEST_CASE(environment_access)
BOOST_AUTO_TEST_CASE(address_staticcall)
{
string text = R"(
std::string text = R"(
contract C {
function i() view public returns (bool) {
(bool success,) = address(0x4242).staticcall("");
@ -114,7 +113,7 @@ BOOST_AUTO_TEST_CASE(address_staticcall)
BOOST_AUTO_TEST_CASE(assembly_staticcall)
{
string text = R"(
std::string text = R"(
contract C {
function i() view public {
assembly { pop(staticcall(gas(), 1, 2, 3, 4, 5)) }

454
test/libsolidity/analysis/FunctionCallGraph.cpp
View File

File diff suppressed because it is too large Load Diff

7
test/libsolidity/interface/FileReader.cpp
View File

@ -30,7 +30,6 @@
#include <boost/filesystem.hpp>
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity::util;
using namespace solidity::test;
@ -226,12 +225,12 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_stripping_root_name)
BOOST_CHECK_EQUAL(normalizedPath.root_directory(), "/");
#if defined(_WIN32)
string root = workDir.root_path().string();
std::string root = workDir.root_path().string();
soltestAssert(root.length() == 3 && root[1] == ':' && root[2] == '\\', "");
for (auto convert: {boost::to_lower_copy<string>, boost::to_upper_copy<string>})
for (auto convert: {boost::to_lower_copy<std::string>, boost::to_upper_copy<std::string>})
{
boost::filesystem::path workDirWin = convert(root, locale()) / workDir.relative_path();
boost::filesystem::path workDirWin = convert(root, std::locale()) / workDir.relative_path();
normalizedPath = FileReader::normalizeCLIPathForVFS(
workDirWin,
resolveSymlinks

7
test/libsolutil/Checksum.cpp
View File

@ -26,7 +26,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -47,7 +46,7 @@ BOOST_AUTO_TEST_CASE(calculate)
BOOST_CHECK_THROW(getChecksummedAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaeK"), InvalidAddress);
// the official test suite from EIP-55
vector<string> cases {
std::vector<std::string> cases {
// all upper case
"0x52908400098527886E0F7030069857D2E4169EE7",
"0x8617E340B3D01FA5F11F306F4090FD50E238070D",
@ -103,10 +102,10 @@ BOOST_AUTO_TEST_CASE(homocaps_valid)
BOOST_AUTO_TEST_CASE(homocaps_invalid)
{
string upper = "0x00AA0000000012400000000DDEEFF000000000BB";
std::string upper = "0x00AA0000000012400000000DDEEFF000000000BB";
BOOST_CHECK(passesAddressChecksum(upper, false));
BOOST_CHECK(!passesAddressChecksum(upper, true));
string lower = "0x11aa000000000000000d00cc00000000000000bb";
std::string lower = "0x11aa000000000000000d00cc00000000000000bb";
BOOST_CHECK(passesAddressChecksum(lower, false));
BOOST_CHECK(!passesAddressChecksum(lower, true));
}

1
test/libsolutil/CommonData.cpp
View File

@ -28,7 +28,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
using namespace solidity::frontend;
// TODO: Fix Boost...

11
test/libsolutil/CommonIO.cpp
View File

@ -31,7 +31,6 @@
#include <fstream>
#include <string>
using namespace std;
using namespace solidity::test;
#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)
@ -68,31 +67,31 @@ BOOST_AUTO_TEST_CASE(readFileAsString_symlink)
BOOST_AUTO_TEST_CASE(readUntilEnd_no_ending_newline)
{
istringstream inputStream("ABC\ndef");
std::istringstream inputStream("ABC\ndef");
BOOST_TEST(readUntilEnd(inputStream) == "ABC\ndef");
}
BOOST_AUTO_TEST_CASE(readUntilEnd_with_ending_newline)
{
istringstream inputStream("ABC\ndef\n");
std::istringstream inputStream("ABC\ndef\n");
BOOST_TEST(readUntilEnd(inputStream) == "ABC\ndef\n");
}
BOOST_AUTO_TEST_CASE(readUntilEnd_cr_lf_newline)
{
istringstream inputStream("ABC\r\ndef");
std::istringstream inputStream("ABC\r\ndef");
BOOST_TEST(readUntilEnd(inputStream) == "ABC\r\ndef");
}
BOOST_AUTO_TEST_CASE(readUntilEnd_empty)
{
istringstream inputStream("");
std::istringstream inputStream("");
BOOST_TEST(readUntilEnd(inputStream) == "");
}
BOOST_AUTO_TEST_CASE(readBytes_past_end)
{
istringstream inputStream("abc");
std::istringstream inputStream("abc");
BOOST_CHECK_EQUAL(readBytes(inputStream, 0), "");
BOOST_CHECK_EQUAL(readBytes(inputStream, 1), "a");
BOOST_CHECK_EQUAL(readBytes(inputStream, 20), "bc");

1
test/libsolutil/FixedHash.cpp
View File

@ -25,7 +25,6 @@
#include <cstdint>
#include <sstream>
using namespace std;
namespace solidity::util::test
{

1
test/libsolutil/FunctionSelector.cpp
View File

@ -25,7 +25,6 @@
#include <cstdint>
#include <sstream>
using namespace std;
namespace solidity::util::test
{

1
test/libsolutil/IndentedWriter.cpp
View File

@ -25,7 +25,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{

23
test/libsolutil/IpfsHash.cpp
View File

@ -25,7 +25,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -37,16 +36,16 @@ BOOST_AUTO_TEST_CASE(test_small)
BOOST_CHECK_EQUAL(ipfsHashBase58({}), "QmbFMke1KXqnYyBBWxB74N4c5SBnJMVAiMNRcGu6x1AwQH");
BOOST_CHECK_EQUAL(ipfsHashBase58("x"), "QmULKig5Fxrs2sC4qt9nNduucXfb92AFYQ6Hi3YRqDmrYC");
BOOST_CHECK_EQUAL(ipfsHashBase58("Solidity\n"), "QmSsm9M7PQRBnyiz1smizk8hZw3URfk8fSeHzeTo3oZidS");
BOOST_CHECK_EQUAL(ipfsHashBase58(string(200ul, char(0))), "QmSXR1N23uWzsANi8wpxMPw5dmmhqBVUAb4hUrHVLpNaMr");
BOOST_CHECK_EQUAL(ipfsHashBase58(string(10250ul, char(0))), "QmVJJBB3gKKBWYC9QTywpH8ZL1bDeTDJ17B63Af5kino9i");
BOOST_CHECK_EQUAL(ipfsHashBase58(string(100000ul, char(0))), "QmYgKa25YqEGpQmmZtPPFMNK3kpqqneHk6nMSEUYryEX1C");
BOOST_CHECK_EQUAL(ipfsHashBase58(string(121071ul, char(0))), "QmdMdRshQmqvyc92N82r7AKYdUF5FRh4DJo6GtrmEk3wgj");
BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(200ul, char(0))), "QmSXR1N23uWzsANi8wpxMPw5dmmhqBVUAb4hUrHVLpNaMr");
BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(10250ul, char(0))), "QmVJJBB3gKKBWYC9QTywpH8ZL1bDeTDJ17B63Af5kino9i");
BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(100000ul, char(0))), "QmYgKa25YqEGpQmmZtPPFMNK3kpqqneHk6nMSEUYryEX1C");
BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(121071ul, char(0))), "QmdMdRshQmqvyc92N82r7AKYdUF5FRh4DJo6GtrmEk3wgj");
}
BOOST_AUTO_TEST_CASE(test_medium)
{
size_t length = 131071;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmSxYSToKHsPqqRdRnsM9gmr3EYS6dakhVaHgbFdgYQWi6");
@ -55,7 +54,7 @@ BOOST_AUTO_TEST_CASE(test_medium)
BOOST_AUTO_TEST_CASE(test_largest_unchunked)
{
size_t length = 1024 * 256 - 1;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmbNDspMkzkMFKyS3eCJGedG7GWRQHSCzJCZLjxP7wyVAx");
@ -64,7 +63,7 @@ BOOST_AUTO_TEST_CASE(test_largest_unchunked)
BOOST_AUTO_TEST_CASE(test_smallest_chunked)
{
size_t length = 1024 * 256 + 1;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmbVuw4C4vcmVKqxoWtgDVobvcHrSn51qsmQmyxjk4sB2Q");
@ -73,7 +72,7 @@ BOOST_AUTO_TEST_CASE(test_smallest_chunked)
BOOST_AUTO_TEST_CASE(test_large)
{
size_t length = 1310710;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmNg7BJo8gEMDK8yGQbHEwPtycesnE6FUULX5iVd5TAL9f");
@ -82,7 +81,7 @@ BOOST_AUTO_TEST_CASE(test_large)
BOOST_AUTO_TEST_CASE(test_largest_one_level)
{
size_t length = 45613056; // 1024 * 256 * 174;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmY4HSz1oVGdUzb8poVYPLsoqBZjH6LZrtgnme9wWn2Qko");
@ -91,7 +90,7 @@ BOOST_AUTO_TEST_CASE(test_largest_one_level)
BOOST_AUTO_TEST_CASE(test_smallest_multi_level)
{
size_t length = 45613057; // 1024 * 256 * 174 + 1;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmehMASWcBsX7VcEQqs6rpR5AHoBfKyBVEgmkJHjpPg8jq");
@ -100,7 +99,7 @@ BOOST_AUTO_TEST_CASE(test_smallest_multi_level)
BOOST_AUTO_TEST_CASE(test_multi_level_tree)
{
size_t length = 46661632;
string data;
std::string data;
data.resize(length, 0);
BOOST_REQUIRE_EQUAL(data.size(), length);
BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmaTb1sT9hrSXJLmf8bxJ9NuwndiHuMLsgNLgkS2eXu3Xj");

37
test/libsolutil/IterateReplacing.cpp
View File

@ -25,7 +25,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -34,61 +33,61 @@ BOOST_AUTO_TEST_SUITE(IterateReplacing, *boost::unit_test::label("nooptions"))
BOOST_AUTO_TEST_CASE(no_replacement)
{
vector<string> v{"abc", "def", "ghi"};
function<std::optional<vector<string>>(string&)> f = [](string&) -> std::optional<vector<string>> { return {}; };
std::vector<std::string> v{"abc", "def", "ghi"};
std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string&) -> std::optional<std::vector<std::string>> { return {}; };
iterateReplacing(v, f);
vector<string> expectation{"abc", "def", "ghi"};
std::vector<std::string> expectation{"abc", "def", "ghi"};
BOOST_CHECK(v == expectation);
}
BOOST_AUTO_TEST_CASE(empty_input)
{
vector<string> v;
function<std::optional<vector<string>>(string&)> f = [](string&) -> std::optional<vector<string>> { return {}; };
std::vector<std::string> v;
std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string&) -> std::optional<std::vector<std::string>> { return {}; };
iterateReplacing(v, f);
vector<string> expectation;
std::vector<std::string> expectation;
BOOST_CHECK(v == expectation);
}
BOOST_AUTO_TEST_CASE(delete_some)
{
vector<string> v{"abc", "def", "ghi"};
function<std::optional<vector<string>>(string&)> f = [](string& _s) -> std::optional<vector<string>> {
std::vector<std::string> v{"abc", "def", "ghi"};
std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string& _s) -> std::optional<std::vector<std::string>> {
if (_s == "def")
return vector<string>();
return std::vector<std::string>();
else
return {};
};
iterateReplacing(v, f);
vector<string> expectation{"abc", "ghi"};
std::vector<std::string> expectation{"abc", "ghi"};
BOOST_CHECK(v == expectation);
}
BOOST_AUTO_TEST_CASE(inject_some_start)
{
vector<string> v{"abc", "def", "ghi"};
function<std::optional<vector<string>>(string&)> f = [](string& _s) -> std::optional<vector<string>> {
std::vector<std::string> v{"abc", "def", "ghi"};
std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string& _s) -> std::optional<std::vector<std::string>> {
if (_s == "abc")
return vector<string>{"x", "y"};
return std::vector<std::string>{"x", "y"};
else
return {};
};
iterateReplacing(v, f);
vector<string> expectation{"x", "y", "def", "ghi"};
std::vector<std::string> expectation{"x", "y", "def", "ghi"};
BOOST_CHECK(v == expectation);
}
BOOST_AUTO_TEST_CASE(inject_some_end)
{
vector<string> v{"abc", "def", "ghi"};
function<std::optional<vector<string>>(string&)> f = [](string& _s) -> std::optional<vector<string>> {
std::vector<std::string> v{"abc", "def", "ghi"};
std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string& _s) -> std::optional<std::vector<std::string>> {
if (_s == "ghi")
return vector<string>{"x", "y"};
return std::vector<std::string>{"x", "y"};
else
return {};
};
iterateReplacing(v, f);
vector<string> expectation{"abc", "def", "x", "y"};
std::vector<std::string> expectation{"abc", "def", "x", "y"};
BOOST_CHECK(v == expectation);
}

3
test/libsolutil/JSON.cpp
View File

@ -26,7 +26,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -35,7 +34,7 @@ BOOST_AUTO_TEST_SUITE(JsonTest, *boost::unit_test::label("nooptions"))
BOOST_AUTO_TEST_CASE(json_types)
{
auto check = [](Json::Value value, string const& expectation) {
auto check = [](Json::Value value, std::string const& expectation) {
BOOST_CHECK(jsonCompactPrint(value) == expectation);
};

1
test/libsolutil/Keccak256.cpp
View File

@ -22,7 +22,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{

1
test/libsolutil/LEB128.cpp
View File

@ -23,7 +23,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{

27
test/libsolutil/StringUtils.cpp
View File

@ -29,7 +29,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -75,7 +74,7 @@ BOOST_AUTO_TEST_CASE(test_dldistance)
BOOST_AUTO_TEST_CASE(test_alternatives_list)
{
vector<string> strings;
std::vector<std::string> strings;
BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "");
strings.emplace_back("a");
BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "\"a\"");
@ -89,20 +88,20 @@ BOOST_AUTO_TEST_CASE(test_alternatives_list)
BOOST_AUTO_TEST_CASE(test_human_readable_join)
{
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({})), "");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a"})), "a");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a", "b"})), "a, b");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a", "b", "c"})), "a, b, c");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({})), "");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a"})), "a");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b"})), "a, b");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b", "c"})), "a, b, c");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({}), "; "), "");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a"}), "; "), "a");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a", "b"}), "; "), "a; b");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a", "b", "c"}), "; "), "a; b; c");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({}), "; "), "");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a"}), "; "), "a");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b"}), "; "), "a; b");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b", "c"}), "; "), "a; b; c");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({}), "; ", " or "), "");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a"}), "; ", " or "), "a");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a", "b"}), "; ", " or "), "a or b");
BOOST_CHECK_EQUAL(joinHumanReadable(vector<string>({"a", "b", "c"}), "; ", " or "), "a; b or c");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({}), "; ", " or "), "");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a"}), "; ", " or "), "a");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b"}), "; ", " or "), "a or b");
BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b", "c"}), "; ", " or "), "a; b or c");
}
BOOST_AUTO_TEST_CASE(test_format_number_readable)

27
test/libsolutil/SwarmHash.cpp
View File

@ -27,7 +27,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -37,12 +36,12 @@ BOOST_AUTO_TEST_SUITE(SwarmHash, *boost::unit_test::label("nooptions"))
namespace
{
string bzzr0HashHex(string const& _input)
std::string bzzr0HashHex(std::string const& _input)
{
return toHex(bzzr0Hash(_input).asBytes());
}
string bzzr1HashHex(bytes const& _input)
std::string bzzr1HashHex(bytes const& _input)
{
return toHex(bzzr1Hash(_input).asBytes());
}
@ -59,17 +58,17 @@ bytes sequence(size_t _length)
BOOST_AUTO_TEST_CASE(test_zeros)
{
BOOST_CHECK_EQUAL(bzzr0HashHex(string()), string("011b4d03dd8c01f1049143cf9c4c817e4b167f1d1b83e5c6f0f10d89ba1e7bce"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x1000 - 1, 0)), string("32f0faabc4265ac238cd945087133ce3d7e9bb2e536053a812b5373c54043adb"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x1000, 0)), string("411dd45de7246e94589ff5888362c41e85bd3e582a92d0fda8f0e90b76439bec"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x1000 + 1, 0)), string("69754a0098432bbc2e84fe1205276870748a61a065ab6ef44d6a2e7b13ce044d"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x2000 - 1, 0)), string("69ad3c581043404f775ffa8d6f1b25ad4a9ee812971190e90209c0966116a321"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x2000, 0)), string("f00222373ff82d0a178dc6271c78953e9c88f74130a52d401f5ec51475f63c43"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x2000 + 1, 0)), string("86d6773e79e02fd8145ee1aedba89ace0c15f2566db1249654000039a9a134bf"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x80000, 0)), string("cc0854fe2c6b98e920d5c14b1a88e6d4223e55b8f78883f60939aa2485e361bf"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x80020, 0)), string("ee9ffca246e70d3704740ba4df450fa6988d14a1c2439c7e734c7a77a4eb6fd3"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(0x800020, 0)), string("78b90b20c90559fb904535181a7c28929ea2f30a2329dbc25232de579709f12f"));
BOOST_CHECK_EQUAL(bzzr0HashHex(string(2095104, 0)), string("a9958184589fc11b4027a4c233e777ebe2e99c66f96b74aef2a0638a94dd5439"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string()), std::string("011b4d03dd8c01f1049143cf9c4c817e4b167f1d1b83e5c6f0f10d89ba1e7bce"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x1000 - 1, 0)), std::string("32f0faabc4265ac238cd945087133ce3d7e9bb2e536053a812b5373c54043adb"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x1000, 0)), std::string("411dd45de7246e94589ff5888362c41e85bd3e582a92d0fda8f0e90b76439bec"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x1000 + 1, 0)), std::string("69754a0098432bbc2e84fe1205276870748a61a065ab6ef44d6a2e7b13ce044d"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x2000 - 1, 0)), std::string("69ad3c581043404f775ffa8d6f1b25ad4a9ee812971190e90209c0966116a321"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x2000, 0)), std::string("f00222373ff82d0a178dc6271c78953e9c88f74130a52d401f5ec51475f63c43"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x2000 + 1, 0)), std::string("86d6773e79e02fd8145ee1aedba89ace0c15f2566db1249654000039a9a134bf"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x80000, 0)), std::string("cc0854fe2c6b98e920d5c14b1a88e6d4223e55b8f78883f60939aa2485e361bf"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x80020, 0)), std::string("ee9ffca246e70d3704740ba4df450fa6988d14a1c2439c7e734c7a77a4eb6fd3"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x800020, 0)), std::string("78b90b20c90559fb904535181a7c28929ea2f30a2329dbc25232de579709f12f"));
BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(2095104, 0)), std::string("a9958184589fc11b4027a4c233e777ebe2e99c66f96b74aef2a0638a94dd5439"));
}
BOOST_AUTO_TEST_CASE(bzz_hash_short)

5
test/libsolutil/TemporaryDirectoryTest.cpp
View File

@ -25,7 +25,6 @@
#include <fstream>
using namespace std;
using namespace boost::test_tools;
namespace solidity::util::test
@ -58,8 +57,8 @@ BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_delete_its_directory_even_if_not_
BOOST_TEST(boost::filesystem::is_directory(dirPath));
{
ofstream tmpFile((dirPath / "test-file.txt").string());
tmpFile << "Delete me!" << endl;
std::ofstream tmpFile((dirPath / "test-file.txt").string());
tmpFile << "Delete me!" << std::endl;
}
soltestAssert(boost::filesystem::is_regular_file(dirPath / "test-file.txt"), "");
}

7
test/libsolutil/UTF8.cpp
View File

@ -26,7 +26,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -35,13 +34,13 @@ BOOST_AUTO_TEST_SUITE(UTF8, *boost::unit_test::label("nooptions"))
namespace {
bool isValidUTF8(string const& _value)
bool isValidUTF8(std::string const& _value)
{
size_t pos;
return validateUTF8(asString(fromHex(_value)), pos);
}
bool isInvalidUTF8(string const& _value, size_t _expectedPos)
bool isInvalidUTF8(std::string const& _value, size_t _expectedPos)
{
size_t pos;
if (validateUTF8(asString(fromHex(_value)), pos))
@ -94,7 +93,7 @@ BOOST_AUTO_TEST_CASE(invalid)
BOOST_AUTO_TEST_CASE(corpus)
{
string source = R"(
std::string source = R"(
κόσμε
hélló

71
test/libsolutil/Whiskers.cpp
View File

@ -25,7 +25,6 @@
#include <boost/test/unit_test.hpp>
using namespace std;
namespace solidity::util::test
{
@ -34,14 +33,14 @@ BOOST_AUTO_TEST_SUITE(WhiskersTest, *boost::unit_test::label("nooptions"))
BOOST_AUTO_TEST_CASE(no_templates)
{
string templ = "this text does not contain templates";
std::string templ = "this text does not contain templates";
BOOST_CHECK_EQUAL(Whiskers(templ).render(), templ);
}
BOOST_AUTO_TEST_CASE(basic_replacement)
{
string templ = "a <b> x <c> -> <d>.";
string result = Whiskers(templ)
std::string templ = "a <b> x <c> -> <d>.";
std::string result = Whiskers(templ)
("b", "BE")
("c", "CE")
("d", "DE")
@ -51,43 +50,43 @@ BOOST_AUTO_TEST_CASE(basic_replacement)
BOOST_AUTO_TEST_CASE(tag_unavailable)
{
string templ = "<b>";
std::string templ = "<b>";
Whiskers m(templ);
BOOST_CHECK_THROW(m.render(), WhiskersError);
}
BOOST_AUTO_TEST_CASE(list_unavailable)
{
string templ = "<#b></b>";
std::string templ = "<#b></b>";
Whiskers m(templ);
BOOST_CHECK_THROW(m.render(), WhiskersError);
}
BOOST_AUTO_TEST_CASE(name_type_collision)
{
string templ = "<b><#b></b>";
std::string templ = "<b><#b></b>";
Whiskers m(templ);
m("b", "x");
BOOST_CHECK_THROW(m("b", vector<map<string, string>>{}), WhiskersError);
BOOST_CHECK_THROW(m("b", std::vector<std::map<std::string, std::string>>{}), WhiskersError);
}
BOOST_AUTO_TEST_CASE(conditional)
{
string templ = "<?b>X</b>";
std::string templ = "<?b>X</b>";
BOOST_CHECK_EQUAL(Whiskers(templ)("b", true).render(), "X");
BOOST_CHECK_EQUAL(Whiskers(templ)("b", false).render(), "");
}
BOOST_AUTO_TEST_CASE(conditional_with_else)
{
string templ = "<?b>X<!b>Y</b>";
std::string templ = "<?b>X<!b>Y</b>";
BOOST_CHECK_EQUAL(Whiskers(templ)("b", true).render(), "X");
BOOST_CHECK_EQUAL(Whiskers(templ)("b", false).render(), "Y");
}
BOOST_AUTO_TEST_CASE(broken_conditional_with_else)
{
string templ = "<?b>X<!bY</b>";
std::string templ = "<?b>X<!bY</b>";
BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
templ = "<?bX<!b>Y</b>";
@ -99,7 +98,7 @@ BOOST_AUTO_TEST_CASE(broken_conditional_with_else)
BOOST_AUTO_TEST_CASE(broken_conditional_value_with_else)
{
string templ = "<?+b>X<!+bY</+b>";
std::string templ = "<?+b>X<!+bY</+b>";
BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
templ = "<?+bX<!+b>Y</+b>";
@ -111,7 +110,7 @@ BOOST_AUTO_TEST_CASE(broken_conditional_value_with_else)
BOOST_AUTO_TEST_CASE(broken_list_parameter)
{
string templ = "<#b><a></b";
std::string templ = "<#b><a></b";
BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
templ = "<#b<a></b>";
@ -120,7 +119,7 @@ BOOST_AUTO_TEST_CASE(broken_list_parameter)
BOOST_AUTO_TEST_CASE(conditional_plus_params)
{
string templ = " - <?b>_<r><!b>^<t></b> - ";
std::string templ = " - <?b>_<r><!b>^<t></b> - ";
Whiskers m1(templ);
m1("b", true);
m1("r", "R");
@ -136,10 +135,10 @@ BOOST_AUTO_TEST_CASE(conditional_plus_params)
BOOST_AUTO_TEST_CASE(conditional_plus_list)
{
string templ = " - <?b>_<#l><x></l><!b><#l><y></l></b> - ";
std::string templ = " - <?b>_<#l><x></l><!b><#l><y></l></b> - ";
Whiskers m(templ);
m("b", false);
vector<map<string, string>> list(2);
std::vector<std::map<std::string, std::string>> list(2);
list[0]["x"] = "1";
list[0]["y"] = "a";
list[1]["x"] = "2";
@ -150,21 +149,21 @@ BOOST_AUTO_TEST_CASE(conditional_plus_list)
BOOST_AUTO_TEST_CASE(string_as_conditional)
{
string templ = "<?+b>+<b><!+b>-</+b>";
std::string templ = "<?+b>+<b><!+b>-</+b>";
BOOST_CHECK_EQUAL(Whiskers(templ)("b", "abc").render(), "+abc");
BOOST_CHECK_EQUAL(Whiskers(templ)("b", "").render(), "-");
}
BOOST_AUTO_TEST_CASE(string_as_conditional_wrong)
{
string templ = "<?+b>+<b></b>";
std::string templ = "<?+b>+<b></b>";
BOOST_CHECK_EQUAL(Whiskers(templ)("b", "abc").render(), "<?+b>+abc</b>");
}
BOOST_AUTO_TEST_CASE(complicated_replacement)
{
string templ = "a <b> x <complicated> \n <nested>>.";
string result = Whiskers(templ)
std::string templ = "a <b> x <complicated> \n <nested>>.";
std::string result = Whiskers(templ)
("b", "BE")
("complicated", "CO<M>PL")
("nested", "NEST")
@ -174,53 +173,53 @@ BOOST_AUTO_TEST_CASE(complicated_replacement)
BOOST_AUTO_TEST_CASE(non_existing_list)
{
string templ = "a <#b></b>";
std::string templ = "a <#b></b>";
Whiskers m(templ);
BOOST_CHECK_THROW(m.render(), WhiskersError);
}
BOOST_AUTO_TEST_CASE(empty_list)
{
string templ = "a <#b></b>x";
string result = Whiskers(templ)("b", vector<Whiskers::StringMap>{}).render();
std::string templ = "a <#b></b>x";
std::string result = Whiskers(templ)("b", std::vector<Whiskers::StringMap>{}).render();
BOOST_CHECK_EQUAL(result, "a x");
}
BOOST_AUTO_TEST_CASE(list)
{
string templ = "a<#b>( <g> - <h> )</b>x";
vector<map<string, string>> list(2);
std::string templ = "a<#b>( <g> - <h> )</b>x";
std::vector<std::map<std::string, std::string>> list(2);
list[0]["g"] = "GE";
list[0]["h"] = "H";
list[1]["g"] = "2GE";
list[1]["h"] = "2H";
string result = Whiskers(templ)("b", list).render();
std::string result = Whiskers(templ)("b", list).render();
BOOST_CHECK_EQUAL(result, "a( GE - H )( 2GE - 2H )x");
}
BOOST_AUTO_TEST_CASE(recursive_list)
{
// Check that templates resulting from lists are not expanded again
string templ = "a<#b> 1<g>3 </b><x>";
vector<map<string, string>> list(1);
std::string templ = "a<#b> 1<g>3 </b><x>";
std::vector<std::map<std::string, std::string>> list(1);
list[0]["g"] = "<x>";
string result = Whiskers(templ)("x", "X")("b", list).render();
std::string result = Whiskers(templ)("x", "X")("b", list).render();
BOOST_CHECK_EQUAL(result, "a 1<x>3 X");
}
BOOST_AUTO_TEST_CASE(list_can_access_upper)
{
string templ = "<#b>(<a>)</b>";
vector<map<string, string>> list(2);
std::string templ = "<#b>(<a>)</b>";
std::vector<std::map<std::string, std::string>> list(2);
Whiskers m(templ);
string result = m("a", "A")("b", list).render();
std::string result = m("a", "A")("b", list).render();
BOOST_CHECK_EQUAL(result, "(A)(A)");
}
BOOST_AUTO_TEST_CASE(parameter_collision)
{
string templ = "a <#b></b>";
vector<map<string, string>> list(1);
std::string templ = "a <#b></b>";
std::vector<std::map<std::string, std::string>> list(1);
list[0]["a"] = "x";
Whiskers m(templ);
BOOST_CHECK_THROW(m("a", "X")("b", list), WhiskersError);
@ -229,14 +228,14 @@ BOOST_AUTO_TEST_CASE(parameter_collision)
BOOST_AUTO_TEST_CASE(invalid_param)
{
string templ = "a <b >";
std::string templ = "a <b >";
Whiskers m(templ);
BOOST_CHECK_THROW(m("b ", "X"), WhiskersError);
}
BOOST_AUTO_TEST_CASE(invalid_param_rendered)
{
string templ = "a <b >";
std::string templ = "a <b >";
Whiskers m(templ);
BOOST_CHECK_EQUAL(m.render(), templ);
}