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

Merge pull request #4482 from ethereum/enforceVisibilitySpecifierTests

Browse Source 
Enforce visibility specifier in tests
This commit is contained in:
chriseth 2018-07-16 15:46:40 +02:00 committed by GitHub
commit b38c26bb0c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 155 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
test/contracts/AuctionRegistrar.cpp
View File

@ -43,20 +43,20 @@ static char const* registrarCode = R"DELIMITER(
pragma solidity ^0.4.0; pragma solidity ^0.4.0;
contract NameRegister { contract NameRegister {
function addr(string memory _name) view returns (address o_owner); function addr(string memory _name) public view returns (address o_owner);
function name(address _owner) view returns (string memory o_name); function name(address _owner) public view returns (string memory o_name);
} }
contract Registrar is NameRegister { contract Registrar is NameRegister {
event Changed(string indexed name); event Changed(string indexed name);
event PrimaryChanged(string indexed name, address indexed addr); event PrimaryChanged(string indexed name, address indexed addr);
function owner(string memory _name) view returns (address o_owner); function owner(string memory _name) public view returns (address o_owner);
function addr(string memory _name) view returns (address o_address); function addr(string memory _name) public view returns (address o_address);
function subRegistrar(string memory _name) view returns (address o_subRegistrar); function subRegistrar(string memory _name) public view returns (address o_subRegistrar);
function content(string memory _name) view returns (bytes32 o_content); function content(string memory _name) public view returns (bytes32 o_content);
function name(address _owner) view returns (string memory o_name); function name(address _owner) public view returns (string memory o_name);
} }
contract AuctionSystem { contract AuctionSystem {
@ -112,7 +112,7 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
uint constant c_renewalInterval = 365 days; uint constant c_renewalInterval = 365 days;
uint constant c_freeBytes = 12; uint constant c_freeBytes = 12;
function Registrar() { function Registrar() public {
// TODO: Populate with hall-of-fame. // TODO: Populate with hall-of-fame.
} }
@ -156,12 +156,12 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
modifier onlyrecordowner(string memory _name) { if (m_toRecord[_name].owner == msg.sender) _; } modifier onlyrecordowner(string memory _name) { if (m_toRecord[_name].owner == msg.sender) _; }
function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) { function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) public {
m_toRecord[_name].owner = _newOwner; m_toRecord[_name].owner = _newOwner;
emit Changed(_name); emit Changed(_name);
} }
function disown(string memory _name) onlyrecordowner(_name) { function disown(string memory _name) onlyrecordowner(_name) public {
if (stringsEqual(m_toName[m_toRecord[_name].primary], _name)) if (stringsEqual(m_toName[m_toRecord[_name].primary], _name))
{ {
emit PrimaryChanged(_name, m_toRecord[_name].primary); emit PrimaryChanged(_name, m_toRecord[_name].primary);
@ -171,7 +171,7 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
emit Changed(_name); emit Changed(_name);
} }
function setAddress(string memory _name, address _a, bool _primary) onlyrecordowner(_name) { function setAddress(string memory _name, address _a, bool _primary) onlyrecordowner(_name) public {
m_toRecord[_name].primary = _a; m_toRecord[_name].primary = _a;
if (_primary) if (_primary)
{ {
@ -180,11 +180,11 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
} }
emit Changed(_name); emit Changed(_name);
} }
function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) { function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) public {
m_toRecord[_name].subRegistrar = _registrar; m_toRecord[_name].subRegistrar = _registrar;
emit Changed(_name); emit Changed(_name);
} }
function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) { function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) public {
m_toRecord[_name].content = _content; m_toRecord[_name].content = _content;
emit Changed(_name); emit Changed(_name);
} }
@ -201,11 +201,11 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
return true; return true;
} }
function owner(string memory _name) view returns (address) { return m_toRecord[_name].owner; } function owner(string memory _name) public view returns (address) { return m_toRecord[_name].owner; }
function addr(string memory _name) view returns (address) { return m_toRecord[_name].primary; } function addr(string memory _name) public view returns (address) { return m_toRecord[_name].primary; }
function subRegistrar(string memory _name) view returns (address) { return m_toRecord[_name].subRegistrar; } function subRegistrar(string memory _name) public view returns (address) { return m_toRecord[_name].subRegistrar; }
function content(string memory _name) view returns (bytes32) { return m_toRecord[_name].content; } function content(string memory _name) public view returns (bytes32) { return m_toRecord[_name].content; }
function name(address _addr) view returns (string memory o_name) { return m_toName[_addr]; } function name(address _addr) public view returns (string memory o_name) { return m_toName[_addr]; }
mapping (address => string) m_toName; mapping (address => string) m_toName;
mapping (string => Record) m_toRecord; mapping (string => Record) m_toRecord;

30
test/contracts/FixedFeeRegistrar.cpp
View File

@ -58,10 +58,10 @@ pragma solidity ^0.4.0;
contract Registrar { contract Registrar {
event Changed(string indexed name); event Changed(string indexed name);
function owner(string memory _name) view returns (address o_owner); function owner(string memory _name) public view returns (address o_owner);
function addr(string memory _name) view returns (address o_address); function addr(string memory _name) public view returns (address o_address);
function subRegistrar(string memory _name) view returns (address o_subRegistrar); function subRegistrar(string memory _name) public view returns (address o_subRegistrar);
function content(string memory _name) view returns (bytes32 o_content); function content(string memory _name) public view returns (bytes32 o_content);
} }
contract FixedFeeRegistrar is Registrar { contract FixedFeeRegistrar is Registrar {
@ -74,47 +74,47 @@ contract FixedFeeRegistrar is Registrar {
modifier onlyrecordowner(string memory _name) { if (m_record(_name).owner == msg.sender) _; } modifier onlyrecordowner(string memory _name) { if (m_record(_name).owner == msg.sender) _; }
function reserve(string memory _name) payable { function reserve(string memory _name) public payable {
Record storage rec = m_record(_name); Record storage rec = m_record(_name);
if (rec.owner == 0x0000000000000000000000000000000000000000 && msg.value >= c_fee) { if (rec.owner == 0x0000000000000000000000000000000000000000 && msg.value >= c_fee) {
rec.owner = msg.sender; rec.owner = msg.sender;
emit Changed(_name); emit Changed(_name);
} }
} }
function disown(string memory _name, address _refund) onlyrecordowner(_name) { function disown(string memory _name, address _refund) onlyrecordowner(_name) public {
delete m_recordData[uint(keccak256(bytes(_name))) / 8]; delete m_recordData[uint(keccak256(bytes(_name))) / 8];
if (!_refund.send(c_fee)) if (!_refund.send(c_fee))
throw; throw;
emit Changed(_name); emit Changed(_name);
} }
function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) { function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) public {
m_record(_name).owner = _newOwner; m_record(_name).owner = _newOwner;
emit Changed(_name); emit Changed(_name);
} }
function setAddr(string memory _name, address _a) onlyrecordowner(_name) { function setAddr(string memory _name, address _a) onlyrecordowner(_name) public {
m_record(_name).addr = _a; m_record(_name).addr = _a;
emit Changed(_name); emit Changed(_name);
} }
function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) { function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) public {
m_record(_name).subRegistrar = _registrar; m_record(_name).subRegistrar = _registrar;
emit Changed(_name); emit Changed(_name);
} }
function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) { function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) public {
m_record(_name).content = _content; m_record(_name).content = _content;
emit Changed(_name); emit Changed(_name);
} }
function record(string memory _name) view returns (address o_addr, address o_subRegistrar, bytes32 o_content, address o_owner) { function record(string memory _name) public view returns (address o_addr, address o_subRegistrar, bytes32 o_content, address o_owner) {
Record storage rec = m_record(_name); Record storage rec = m_record(_name);
o_addr = rec.addr; o_addr = rec.addr;
o_subRegistrar = rec.subRegistrar; o_subRegistrar = rec.subRegistrar;
o_content = rec.content; o_content = rec.content;
o_owner = rec.owner; o_owner = rec.owner;
} }
function addr(string memory _name) view returns (address) { return m_record(_name).addr; } function addr(string memory _name) public view returns (address) { return m_record(_name).addr; }
function subRegistrar(string memory _name) view returns (address) { return m_record(_name).subRegistrar; } function subRegistrar(string memory _name) public view returns (address) { return m_record(_name).subRegistrar; }
function content(string memory _name) view returns (bytes32) { return m_record(_name).content; } function content(string memory _name) public view returns (bytes32) { return m_record(_name).content; }
function owner(string memory _name) view returns (address) { return m_record(_name).owner; } function owner(string memory _name) public view returns (address) { return m_record(_name).owner; }
Record[2**253] m_recordData; Record[2**253] m_recordData;
function m_record(string memory _name) view internal returns (Record storage o_record) { function m_record(string memory _name) view internal returns (Record storage o_record) {

14
test/contracts/Wallet.cpp
View File

@ -101,7 +101,7 @@ contract multiowned {
// constructor is given number of sigs required to do protected "onlymanyowners" transactions // constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them. // as well as the selection of addresses capable of confirming them.
constructor(address[] memory _owners, uint _required) { constructor(address[] memory _owners, uint _required) public {
m_numOwners = _owners.length + 1; m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender); m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1; m_ownerIndex[uint(msg.sender)] = 1;
@ -173,11 +173,11 @@ contract multiowned {
emit RequirementChanged(_newRequired); emit RequirementChanged(_newRequired);
} }
function isOwner(address _addr) returns (bool) { function isOwner(address _addr) public returns (bool) {
return m_ownerIndex[uint(_addr)] > 0; return m_ownerIndex[uint(_addr)] > 0;
} }
function hasConfirmed(bytes32 _operation, address _owner) view returns (bool) { function hasConfirmed(bytes32 _operation, address _owner) public view returns (bool) {
PendingState storage pending = m_pending[_operation]; PendingState storage pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)]; uint ownerIndex = m_ownerIndex[uint(_owner)];
@ -288,7 +288,7 @@ contract daylimit is multiowned {
// METHODS // METHODS
// constructor - stores initial daily limit and records the present day's index. // constructor - stores initial daily limit and records the present day's index.
constructor(uint _limit) { constructor(uint _limit) public {
m_dailyLimit = _limit; m_dailyLimit = _limit;
m_lastDay = today(); m_lastDay = today();
} }
@ -348,7 +348,7 @@ contract multisig {
// TODO: document // TODO: document
function changeOwner(address _from, address _to) external; function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32); function execute(address _to, uint _value, bytes _data) external returns (bytes32);
function confirm(bytes32 _h) returns (bool); function confirm(bytes32 _h) public returns (bool);
} }
// usage: // usage:
@ -369,7 +369,7 @@ contract Wallet is multisig, multiowned, daylimit {
// constructor - just pass on the owner array to the multiowned and // constructor - just pass on the owner array to the multiowned and
// the limit to daylimit // the limit to daylimit
constructor(address[] memory _owners, uint _required, uint _daylimit) payable constructor(address[] memory _owners, uint _required, uint _daylimit) public payable
multiowned(_owners, _required) daylimit(_daylimit) { multiowned(_owners, _required) daylimit(_daylimit) {
} }
@ -409,7 +409,7 @@ contract Wallet is multisig, multiowned, daylimit {
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order // confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided. // to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) { function confirm(bytes32 _h) onlymanyowners(_h) public returns (bool) {
if (m_txs[_h].to != 0x0000000000000000000000000000000000000000) { if (m_txs[_h].to != 0x0000000000000000000000000000000000000000) {
m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data); m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data); emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);

2
test/libsolidity/ABIDecoderTests.cpp
View File

@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE(dynamic_nested_arrays)
public pure returns (uint, uint, uint, uint, uint, uint, uint) { public pure returns (uint, uint, uint, uint, uint, uint, uint) {
return (a, b.length, b[1].length, b[1][1], c[1].length, c[1][1][1], d); return (a, b.length, b[1].length, b[1][1], c[1].length, c[1][1][1], d);
} }
function test() view returns (uint, uint, uint, uint, uint, uint, uint) { function test() public view returns (uint, uint, uint, uint, uint, uint, uint) {
uint16[][] memory b = new uint16[][](3); uint16[][] memory b = new uint16[][](3);
b[0] = new uint16[](2); b[0] = new uint16[](2);
b[0][0] = 0x55; b[0][0] = 0x55;

26
test/libsolidity/GasMeter.cpp
View File

@ -119,7 +119,7 @@ BOOST_AUTO_TEST_CASE(non_overlapping_filtered_costs)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
bytes x; bytes x;
function f(uint a) returns (uint b) { function f(uint a) public returns (uint b) {
x.length = a; x.length = a;
for (; a < 200; ++a) { for (; a < 200; ++a) {
x[a] = 9; x[a] = 9;
@ -152,7 +152,7 @@ BOOST_AUTO_TEST_CASE(simple_contract)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
bytes32 public shaValue; bytes32 public shaValue;
function f(uint a) { function f(uint a) public {
shaValue = keccak256(abi.encodePacked(a)); shaValue = keccak256(abi.encodePacked(a));
} }
} }
@ -165,7 +165,7 @@ BOOST_AUTO_TEST_CASE(store_keccak256)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
bytes32 public shaValue; bytes32 public shaValue;
constructor(uint a) { constructor(uint a) public {
shaValue = keccak256(abi.encodePacked(a)); shaValue = keccak256(abi.encodePacked(a));
} }
} }
@ -179,7 +179,7 @@ BOOST_AUTO_TEST_CASE(updating_store)
contract test { contract test {
uint data; uint data;
uint data2; uint data2;
constructor() { constructor() public {
data = 1; data = 1;
data = 2; data = 2;
data2 = 0; data2 = 0;
@ -195,7 +195,7 @@ BOOST_AUTO_TEST_CASE(branches)
contract test { contract test {
uint data; uint data;
uint data2; uint data2;
function f(uint x) { function f(uint x) public {
if (x > 7) if (x > 7)
data2 = 1; data2 = 1;
else else
@ -213,7 +213,7 @@ BOOST_AUTO_TEST_CASE(function_calls)
contract test { contract test {
uint data; uint data;
uint data2; uint data2;
function f(uint x) { function f(uint x) public {
if (x > 7) if (x > 7)
data2 = g(x**8) + 1; data2 = g(x**8) + 1;
else else
@ -234,13 +234,13 @@ BOOST_AUTO_TEST_CASE(multiple_external_functions)
contract test { contract test {
uint data; uint data;
uint data2; uint data2;
function f(uint x) { function f(uint x) public {
if (x > 7) if (x > 7)
data2 = g(x**8) + 1; data2 = g(x**8) + 1;
else else
data = 1; data = 1;
} }
function g(uint x) returns (uint) { function g(uint x) public returns (uint) {
return data2; return data2;
} }
} }
@ -254,10 +254,10 @@ BOOST_AUTO_TEST_CASE(exponent_size)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract A { contract A {
function g(uint x) returns (uint) { function g(uint x) public returns (uint) {
return x ** 0x100; return x ** 0x100;
} }
function h(uint x) returns (uint) { function h(uint x) public returns (uint) {
return x ** 0x10000; return x ** 0x10000;
} }
} }
@ -271,7 +271,7 @@ BOOST_AUTO_TEST_CASE(balance_gas)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract A { contract A {
function lookup_balance(address a) returns (uint) { function lookup_balance(address a) public returns (uint) {
return a.balance; return a.balance;
} }
} }
@ -284,7 +284,7 @@ BOOST_AUTO_TEST_CASE(extcodesize_gas)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract A { contract A {
function f() returns (uint _s) { function f() public returns (uint _s) {
assembly { assembly {
_s := extcodesize(0x30) _s := extcodesize(0x30)
} }
@ -316,7 +316,7 @@ BOOST_AUTO_TEST_CASE(complex_control_flow)
// we previously considered. This of course reduces accuracy. // we previously considered. This of course reduces accuracy.
char const* sourceCode = R"( char const* sourceCode = R"(
contract log { contract log {
function ln(int128 x) pure returns (int128 result) { function ln(int128 x) public pure returns (int128 result) {
int128 t = x / 256; int128 t = x / 256;
int128 y = 5545177; int128 y = 5545177;
x = t; x = t;

14
test/libsolidity/Metadata.cpp
View File

@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp)
pragma solidity >=0.0; pragma solidity >=0.0;
pragma experimental __testOnlyAnalysis; pragma experimental __testOnlyAnalysis;
contract test { contract test {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
CompilerStack compilerStack; CompilerStack compilerStack;
@ -68,7 +68,7 @@ BOOST_AUTO_TEST_CASE(metadata_stamp_experimental)
pragma solidity >=0.0; pragma solidity >=0.0;
pragma experimental __test; pragma experimental __test;
contract test { contract test {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
CompilerStack compilerStack; CompilerStack compilerStack;
@ -97,14 +97,14 @@ BOOST_AUTO_TEST_CASE(metadata_relevant_sources)
char const* sourceCode = R"( char const* sourceCode = R"(
pragma solidity >=0.0; pragma solidity >=0.0;
contract A { contract A {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
compilerStack.addSource("A", std::string(sourceCode)); compilerStack.addSource("A", std::string(sourceCode));
sourceCode = R"( sourceCode = R"(
pragma solidity >=0.0; pragma solidity >=0.0;
contract B { contract B {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
compilerStack.addSource("B", std::string(sourceCode)); compilerStack.addSource("B", std::string(sourceCode));
@ -127,7 +127,7 @@ BOOST_AUTO_TEST_CASE(metadata_relevant_sources_imports)
char const* sourceCode = R"( char const* sourceCode = R"(
pragma solidity >=0.0; pragma solidity >=0.0;
contract A { contract A {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
compilerStack.addSource("A", std::string(sourceCode)); compilerStack.addSource("A", std::string(sourceCode));
@ -135,7 +135,7 @@ BOOST_AUTO_TEST_CASE(metadata_relevant_sources_imports)
pragma solidity >=0.0; pragma solidity >=0.0;
import "./A"; import "./A";
contract B is A { contract B is A {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
compilerStack.addSource("B", std::string(sourceCode)); compilerStack.addSource("B", std::string(sourceCode));
@ -143,7 +143,7 @@ BOOST_AUTO_TEST_CASE(metadata_relevant_sources_imports)
pragma solidity >=0.0; pragma solidity >=0.0;
import "./B"; import "./B";
contract C is B { contract C is B {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
compilerStack.addSource("C", std::string(sourceCode)); compilerStack.addSource("C", std::string(sourceCode));

20
test/libsolidity/SolidityABIJSON.cpp
View File

@ -256,7 +256,7 @@ BOOST_AUTO_TEST_CASE(view_function)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
function foo(uint a, uint b) public returns (uint d) { return a + b; } function foo(uint a, uint b) public returns (uint d) { return a + b; }
function boo(uint32 a) view returns(uint b) { return a * 4; } function boo(uint32 a) public view returns(uint b) { return a * 4; }
} }
)"; )";
@ -311,7 +311,7 @@ BOOST_AUTO_TEST_CASE(pure_function)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
function foo(uint a, uint b) public returns (uint d) { return a + b; } function foo(uint a, uint b) public returns (uint d) { return a + b; }
function boo(uint32 a) pure returns(uint b) { return a * 4; } function boo(uint32 a) public pure returns (uint b) { return a * 4; }
} }
)"; )";
@ -616,7 +616,7 @@ BOOST_AUTO_TEST_CASE(constructor_abi)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
constructor(uint param1, test param2, bool param3) {} constructor(uint param1, test param2, bool param3) public {}
} }
)"; )";
@ -648,7 +648,7 @@ BOOST_AUTO_TEST_CASE(payable_constructor_abi)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
constructor(uint param1, test param2, bool param3) payable {} constructor(uint param1, test param2, bool param3) public payable {}
} }
)"; )";
@ -682,7 +682,7 @@ BOOST_AUTO_TEST_CASE(return_param_in_abi)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
enum ActionChoices { GoLeft, GoRight, GoStraight, Sit } enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
constructor(ActionChoices param) {} constructor(ActionChoices param) public {}
function ret() public returns (ActionChoices) { function ret() public returns (ActionChoices) {
ActionChoices action = ActionChoices.GoLeft; ActionChoices action = ActionChoices.GoLeft;
return action; return action;
@ -807,8 +807,8 @@ BOOST_AUTO_TEST_CASE(payable_function)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
function f() {} function f() public {}
function g() payable {} function g() public payable {}
} }
)"; )";
@ -861,7 +861,7 @@ BOOST_AUTO_TEST_CASE(function_type)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
function g(function(uint) external returns (uint) x) {} function g(function(uint) external returns (uint) x) public {}
} }
)"; )";
@ -1041,8 +1041,8 @@ BOOST_AUTO_TEST_CASE(structs_in_libraries)
library L { library L {
struct S { uint a; T[] sub; bytes b; } struct S { uint a; T[] sub; bytes b; }
struct T { uint[2] x; } struct T { uint[2] x; }
function f(L.S storage s) {} function f(L.S storage s) public {}
function g(L.S memory s) {} function g(L.S memory s) public {}
} }
)"; )";
char const* interface = R"( char const* interface = R"(

150
test/libsolidity/SolidityEndToEndTest.cpp
View File

@ -53,9 +53,9 @@ BOOST_AUTO_TEST_CASE(transaction_status)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
function f() { } function f() public { }
function g() { revert(); } function g() public { revert(); }
function h() { assert(false); } function h() public { assert(false); }
} }
)"; )";
compileAndRun(sourceCode); compileAndRun(sourceCode);
@ -1253,7 +1253,7 @@ BOOST_AUTO_TEST_CASE(state_smoke_test)
if (which == 0) return value1; if (which == 0) return value1;
else return value2; else return value2;
} }
function set(uint8 which, uint256 value) { function set(uint8 which, uint256 value) public {
if (which == 0) value1 = value; if (which == 0) value1 = value;
else value2 = value; else value2 = value;
} }
@ -1315,7 +1315,7 @@ BOOST_AUTO_TEST_CASE(simple_mapping)
function get(uint8 k) public returns (uint8 v) { function get(uint8 k) public returns (uint8 v) {
return table[k]; return table[k];
} }
function set(uint8 k, uint8 v) { function set(uint8 k, uint8 v) public {
table[k] = v; table[k] = v;
} }
} }
@ -1349,7 +1349,7 @@ BOOST_AUTO_TEST_CASE(mapping_state)
function getVoteCount(address addr) public returns (uint retVoteCount) { function getVoteCount(address addr) public returns (uint retVoteCount) {
return voteCount[addr]; return voteCount[addr];
} }
function grantVoteRight(address addr) { function grantVoteRight(address addr) public {
canVote[addr] = true; canVote[addr] = true;
} }
function vote(address voter, address vote) public returns (bool success) { function vote(address voter, address vote) public returns (bool success) {
@ -1562,7 +1562,7 @@ BOOST_AUTO_TEST_CASE(deleteStruct)
uint nestedValue; uint nestedValue;
mapping (uint => bool) nestedMapping; mapping (uint => bool) nestedMapping;
} }
constructor(){ constructor() public {
toDelete = 5; toDelete = 5;
str.topValue = 1; str.topValue = 1;
str.topMapping[0] = 1; str.topMapping[0] = 1;
@ -2085,7 +2085,7 @@ BOOST_AUTO_TEST_CASE(transfer_ether)
addr.transfer(amount); addr.transfer(amount);
return this.balance; return this.balance;
} }
function b(address addr, uint amount) { function b(address addr, uint amount) public {
addr.transfer(amount); addr.transfer(amount);
} }
} }
@ -2477,7 +2477,7 @@ BOOST_AUTO_TEST_CASE(inter_contract_calls)
function getHelper() public returns (address haddress) { function getHelper() public returns (address haddress) {
return address(h); return address(h);
} }
function setHelper(address haddress) { function setHelper(address haddress) public {
h = Helper(haddress); h = Helper(haddress);
} }
} }
@ -2508,7 +2508,7 @@ BOOST_AUTO_TEST_CASE(inter_contract_calls_with_complex_parameters)
function getHelper() public returns (address haddress) { function getHelper() public returns (address haddress) {
return address(h); return address(h);
} }
function setHelper(address haddress) { function setHelper(address haddress) public {
h = Helper(haddress); h = Helper(haddress);
} }
} }
@ -2540,7 +2540,7 @@ BOOST_AUTO_TEST_CASE(inter_contract_calls_accessing_this)
function getHelper() public returns (address addr) { function getHelper() public returns (address addr) {
return address(h); return address(h);
} }
function setHelper(address addr) { function setHelper(address addr) public {
h = Helper(addr); h = Helper(addr);
} }
} }
@ -2572,7 +2572,7 @@ BOOST_AUTO_TEST_CASE(calls_to_this)
function getHelper() public returns (address addr) { function getHelper() public returns (address addr) {
return address(h); return address(h);
} }
function setHelper(address addr) { function setHelper(address addr) public {
h = Helper(addr); h = Helper(addr);
} }
} }
@ -2607,7 +2607,7 @@ BOOST_AUTO_TEST_CASE(inter_contract_calls_with_local_vars)
function getHelper() public returns (address haddress) { function getHelper() public returns (address haddress) {
return address(h); return address(h);
} }
function setHelper(address haddress) { function setHelper(address haddress) public {
h = Helper(haddress); h = Helper(haddress);
} }
} }
@ -2638,7 +2638,7 @@ BOOST_AUTO_TEST_CASE(fixed_bytes_in_calls)
function getHelper() public returns (address addr) { function getHelper() public returns (address addr) {
return address(h); return address(h);
} }
function setHelper(address addr) { function setHelper(address addr) public {
h = Helper(addr); h = Helper(addr);
} }
} }
@ -2847,7 +2847,7 @@ BOOST_AUTO_TEST_CASE(value_complex)
contract test { contract test {
helper h; helper h;
constructor() public payable { h = new helper(); } constructor() public payable { h = new helper(); }
function sendAmount(uint amount) payable returns (uint256 bal) { function sendAmount(uint amount) public payable returns (uint256 bal) {
uint someStackElement = 20; uint someStackElement = 20;
return h.getBalance.value(amount).gas(1000).value(amount + 3)(); return h.getBalance.value(amount).gas(1000).value(amount + 3)();
} }
@ -2883,7 +2883,7 @@ BOOST_AUTO_TEST_CASE(value_for_constructor)
contract Helper { contract Helper {
bytes3 name; bytes3 name;
bool flag; bool flag;
constructor(bytes3 x, bool f) payable { constructor(bytes3 x, bool f) public payable {
name = x; name = x;
flag = f; flag = f;
} }
@ -2892,7 +2892,7 @@ BOOST_AUTO_TEST_CASE(value_for_constructor)
} }
contract Main { contract Main {
Helper h; Helper h;
constructor() payable { constructor() public payable {
h = (new Helper).value(10)("abc", true); h = (new Helper).value(10)("abc", true);
} }
function getFlag() public returns (bool ret) { return h.getFlag(); } function getFlag() public returns (bool ret) { return h.getFlag(); }
@ -2953,10 +2953,10 @@ BOOST_AUTO_TEST_CASE(single_copy_with_multiple_inheritance)
char const* sourceCode = R"( char const* sourceCode = R"(
contract Base { contract Base {
uint data; uint data;
function setData(uint i) { data = i; } function setData(uint i) public { data = i; }
function getViaBase() public returns (uint i) { return data; } function getViaBase() public returns (uint i) { return data; }
} }
contract A is Base { function setViaA(uint i) { setData(i); } } contract A is Base { function setViaA(uint i) public { setData(i); } }
contract B is Base { function getViaB() public returns (uint i) { return getViaBase(); } } contract B is Base { function getViaB() public returns (uint i) { return getViaBase(); } }
contract Derived is Base, B, A { } contract Derived is Base, B, A { }
)"; )";
@ -3165,7 +3165,7 @@ BOOST_AUTO_TEST_CASE(function_modifier_for_constructor)
char const* sourceCode = R"( char const* sourceCode = R"(
contract A { contract A {
uint data; uint data;
constructor() mod1 { data |= 2; } constructor() mod1 public { data |= 2; }
modifier mod1 { data |= 1; _; } modifier mod1 { data |= 1; _; }
function getData() public returns (uint r) { return data; } function getData() public returns (uint r) { return data; }
} }
@ -3375,7 +3375,7 @@ BOOST_AUTO_TEST_CASE(event)
char const* sourceCode = R"( char const* sourceCode = R"(
contract ClientReceipt { contract ClientReceipt {
event Deposit(address indexed _from, bytes32 indexed _id, uint _value); event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
function deposit(bytes32 _id, bool _manually) payable { function deposit(bytes32 _id, bool _manually) public payable {
if (_manually) { if (_manually) {
bytes32 s = 0x19dacbf83c5de6658e14cbf7bcae5c15eca2eedecf1c66fbca928e4d351bea0f; bytes32 s = 0x19dacbf83c5de6658e14cbf7bcae5c15eca2eedecf1c66fbca928e4d351bea0f;
log3(bytes32(msg.value), s, bytes32(uint256(msg.sender)), _id); log3(bytes32(msg.value), s, bytes32(uint256(msg.sender)), _id);
@ -3406,7 +3406,7 @@ BOOST_AUTO_TEST_CASE(event_emit)
char const* sourceCode = R"( char const* sourceCode = R"(
contract ClientReceipt { contract ClientReceipt {
event Deposit(address indexed _from, bytes32 indexed _id, uint _value); event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
function deposit(bytes32 _id) payable { function deposit(bytes32 _id) public payable {
emit Deposit(msg.sender, _id, msg.value); emit Deposit(msg.sender, _id, msg.value);
} }
} }
@ -3584,7 +3584,7 @@ BOOST_AUTO_TEST_CASE(event_anonymous_with_topics)
char const* sourceCode = R"( char const* sourceCode = R"(
contract ClientReceipt { contract ClientReceipt {
event Deposit(address indexed _from, bytes32 indexed _id, uint indexed _value, uint indexed _value2, bytes32 data) anonymous; event Deposit(address indexed _from, bytes32 indexed _id, uint indexed _value, uint indexed _value2, bytes32 data) anonymous;
function deposit(bytes32 _id) payable { function deposit(bytes32 _id) public payable {
emit Deposit(msg.sender, _id, msg.value, 2, "abc"); emit Deposit(msg.sender, _id, msg.value, 2, "abc");
} }
} }
@ -3608,7 +3608,7 @@ BOOST_AUTO_TEST_CASE(event_lots_of_data)
char const* sourceCode = R"( char const* sourceCode = R"(
contract ClientReceipt { contract ClientReceipt {
event Deposit(address _from, bytes32 _id, uint _value, bool _flag); event Deposit(address _from, bytes32 _id, uint _value, bool _flag);
function deposit(bytes32 _id) payable { function deposit(bytes32 _id) public payable {
emit Deposit(msg.sender, _id, msg.value, true); emit Deposit(msg.sender, _id, msg.value, true);
} }
} }
@ -3910,7 +3910,7 @@ BOOST_AUTO_TEST_CASE(generic_call)
char const* sourceCode = R"**( char const* sourceCode = R"**(
contract receiver { contract receiver {
uint public received; uint public received;
function receive(uint256 x) payable { received = x; } function receive(uint256 x) public payable { received = x; }
} }
contract sender { contract sender {
constructor() public payable {} constructor() public payable {}
@ -3936,15 +3936,15 @@ BOOST_AUTO_TEST_CASE(generic_delegatecall)
uint public received; uint public received;
address public sender; address public sender;
uint public value; uint public value;
constructor() payable {} constructor() public payable {}
function receive(uint256 x) payable { received = x; sender = msg.sender; value = msg.value; } function receive(uint256 x) public payable { received = x; sender = msg.sender; value = msg.value; }
} }
contract Sender { contract Sender {
uint public received; uint public received;
address public sender; address public sender;
uint public value; uint public value;
constructor() payable {} constructor() public payable {}
function doSend(address rec) payable function doSend(address rec) public payable
{ {
bytes4 signature = bytes4(bytes32(keccak256("receive(uint256)"))); bytes4 signature = bytes4(bytes32(keccak256("receive(uint256)")));
if (rec.delegatecall(abi.encodeWithSelector(signature, 23))) {} if (rec.delegatecall(abi.encodeWithSelector(signature, 23))) {}
@ -4130,7 +4130,7 @@ BOOST_AUTO_TEST_CASE(copying_bytes_multiassign)
char const* sourceCode = R"( char const* sourceCode = R"(
contract receiver { contract receiver {
uint public received; uint public received;
function receive(uint x) { received += x + 1; } function receive(uint x) public { received += x + 1; }
function() external { received = 0x80; } function() external { received = 0x80; }
} }
contract sender { contract sender {
@ -4349,7 +4349,7 @@ BOOST_AUTO_TEST_CASE(using_enums)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
enum ActionChoices { GoLeft, GoRight, GoStraight, Sit } enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
constructor() constructor() public
{ {
choices = ActionChoices.GoStraight; choices = ActionChoices.GoStraight;
} }
@ -4369,7 +4369,7 @@ BOOST_AUTO_TEST_CASE(enum_explicit_overflow)
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
enum ActionChoices { GoLeft, GoRight, GoStraight } enum ActionChoices { GoLeft, GoRight, GoStraight }
constructor() constructor() public
{ {
} }
function getChoiceExp(uint x) public returns (uint d) function getChoiceExp(uint x) public returns (uint d)
@ -4514,7 +4514,7 @@ BOOST_AUTO_TEST_CASE(inline_member_init)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
constructor(){ constructor() public {
m_b = 6; m_b = 6;
m_c = 8; m_c = 8;
} }
@ -4536,12 +4536,12 @@ BOOST_AUTO_TEST_CASE(inline_member_init_inheritence)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Base { contract Base {
constructor(){} constructor() public {}
uint m_base = 5; uint m_base = 5;
function getBMember() public returns (uint i) { return m_base; } function getBMember() public returns (uint i) { return m_base; }
} }
contract Derived is Base { contract Derived is Base {
constructor(){} constructor() public {}
uint m_derived = 6; uint m_derived = 6;
function getDMember() public returns (uint i) { return m_derived; } function getDMember() public returns (uint i) { return m_derived; }
} }
@ -4588,8 +4588,8 @@ BOOST_AUTO_TEST_CASE(bytes_in_arguments)
char const* sourceCode = R"( char const* sourceCode = R"(
contract c { contract c {
uint result; uint result;
function f(uint a, uint b) { result += a + b; } function f(uint a, uint b) public { result += a + b; }
function g(uint a) { result *= a; } function g(uint a) public { result *= a; }
function test(uint a, bytes data1, bytes data2, uint b) external returns (uint r_a, uint r, uint r_b, uint l) { function test(uint a, bytes data1, bytes data2, uint b) external returns (uint r_a, uint r, uint r_b, uint l) {
r_a = a; r_a = a;
this.call(data1); this.call(data1);
@ -4621,9 +4621,9 @@ BOOST_AUTO_TEST_CASE(fixed_arrays_in_storage)
struct Data { uint x; uint y; } struct Data { uint x; uint y; }
Data[2**10] data; Data[2**10] data;
uint[2**10 + 3] ids; uint[2**10 + 3] ids;
function setIDStatic(uint id) { ids[2] = id; } function setIDStatic(uint id) public { ids[2] = id; }
function setID(uint index, uint id) { ids[index] = id; } function setID(uint index, uint id) public { ids[index] = id; }
function setData(uint index, uint x, uint y) { data[index].x = x; data[index].y = y; } function setData(uint index, uint x, uint y) public { data[index].x = x; data[index].y = y; }
function getID(uint index) public returns (uint) { return ids[index]; } function getID(uint index) public returns (uint) { return ids[index]; }
function getData(uint index) public returns (uint x, uint y) { x = data[index].x; y = data[index].y; } function getData(uint index) public returns (uint x, uint y) { x = data[index].x; y = data[index].y; }
function getLengths() public returns (uint l1, uint l2) { l1 = data.length; l2 = ids.length; } function getLengths() public returns (uint l1, uint l2) { l1 = data.length; l2 = ids.length; }
@ -4648,13 +4648,13 @@ BOOST_AUTO_TEST_CASE(dynamic_arrays_in_storage)
struct Data { uint x; uint y; } struct Data { uint x; uint y; }
Data[] data; Data[] data;
uint[] ids; uint[] ids;
function setIDStatic(uint id) { ids[2] = id; } function setIDStatic(uint id) public { ids[2] = id; }
function setID(uint index, uint id) { ids[index] = id; } function setID(uint index, uint id) public { ids[index] = id; }
function setData(uint index, uint x, uint y) { data[index].x = x; data[index].y = y; } function setData(uint index, uint x, uint y) public { data[index].x = x; data[index].y = y; }
function getID(uint index) public returns (uint) { return ids[index]; } function getID(uint index) public returns (uint) { return ids[index]; }
function getData(uint index) public returns (uint x, uint y) { x = data[index].x; y = data[index].y; } function getData(uint index) public returns (uint x, uint y) { x = data[index].x; y = data[index].y; }
function getLengths() public returns (uint l1, uint l2) { l1 = data.length; l2 = ids.length; } function getLengths() public returns (uint l1, uint l2) { l1 = data.length; l2 = ids.length; }
function setLengths(uint l1, uint l2) { data.length = l1; ids.length = l2; } function setLengths(uint l1, uint l2) public { data.length = l1; ids.length = l2; }
} }
)"; )";
compileAndRun(sourceCode); compileAndRun(sourceCode);
@ -4811,7 +4811,7 @@ BOOST_AUTO_TEST_CASE(array_copy_storage_storage_dyn_dyn)
contract c { contract c {
uint[] data1; uint[] data1;
uint[] data2; uint[] data2;
function setData1(uint length, uint index, uint value) { function setData1(uint length, uint index, uint value) public {
data1.length = length; if (index < length) data1[index] = value; data1.length = length; if (index < length) data1[index] = value;
} }
function copyStorageStorage() public { data2 = data1; } function copyStorageStorage() public { data2 = data1; }
@ -5737,14 +5737,14 @@ BOOST_AUTO_TEST_CASE(pass_dynamic_arguments_to_the_base)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Base { contract Base {
constructor(uint i) constructor(uint i) public
{ {
m_i = i; m_i = i;
} }
uint public m_i; uint public m_i;
} }
contract Derived is Base { contract Derived is Base {
constructor(uint i) Base(i) constructor(uint i) Base(i) public
{} {}
} }
contract Final is Derived(4) { contract Final is Derived(4) {
@ -5782,14 +5782,14 @@ BOOST_AUTO_TEST_CASE(pass_dynamic_arguments_to_the_base_base_with_gap)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Base { contract Base {
constructor(uint i) constructor(uint i) public
{ {
m_i = i; m_i = i;
} }
uint public m_i; uint public m_i;
} }
contract Base1 is Base { contract Base1 is Base {
constructor(uint k) {} constructor(uint k) public {}
} }
contract Derived is Base, Base1 { contract Derived is Base, Base1 {
constructor(uint i) Base(i) Base1(7) public {} constructor(uint i) Base(i) Base1(7) public {}
@ -6368,7 +6368,7 @@ BOOST_AUTO_TEST_CASE(struct_assign_reference_to_struct)
testStruct data1; testStruct data1;
testStruct data2; testStruct data2;
testStruct data3; testStruct data3;
constructor() constructor() public
{ {
data1.m_value = 2; data1.m_value = 2;
} }
@ -6400,7 +6400,7 @@ BOOST_AUTO_TEST_CASE(struct_delete_member)
uint m_value; uint m_value;
} }
testStruct data1; testStruct data1;
constructor() constructor() public
{ {
data1.m_value = 2; data1.m_value = 2;
} }
@ -6427,7 +6427,7 @@ BOOST_AUTO_TEST_CASE(struct_delete_struct_in_mapping)
} }
mapping (uint => testStruct) campaigns; mapping (uint => testStruct) campaigns;
constructor() constructor() public
{ {
campaigns[0].m_value = 2; campaigns[0].m_value = 2;
} }
@ -6470,14 +6470,14 @@ BOOST_AUTO_TEST_CASE(evm_exceptions_in_constructor_call_fail)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract A { contract A {
constructor() constructor() public
{ {
this.call("123"); this.call("123");
} }
} }
contract B { contract B {
uint public test = 1; uint public test = 1;
function testIt() function testIt() public
{ {
A a = new A(); A a = new A();
++test; ++test;
@ -6496,7 +6496,7 @@ BOOST_AUTO_TEST_CASE(evm_exceptions_in_constructor_out_of_baund)
contract A { contract A {
uint public test = 1; uint public test = 1;
uint[3] arr; uint[3] arr;
constructor() constructor() public
{ {
uint index = 5; uint index = 5;
test = arr[index]; test = arr[index];
@ -7038,7 +7038,7 @@ BOOST_AUTO_TEST_CASE(storage_array_ref)
contract Store is BinarySearch { contract Store is BinarySearch {
uint[] data; uint[] data;
function add(uint v) { function add(uint v) public {
data.length++; data.length++;
data[data.length - 1] = v; data[data.length - 1] = v;
} }
@ -7121,7 +7121,7 @@ BOOST_AUTO_TEST_CASE(memory_arrays_index_access_write)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Test { contract Test {
function set(uint24[3][4] memory x) { function set(uint24[3][4] memory x) public {
x[2][2] = 1; x[2][2] = 1;
x[3][2] = 7; x[3][2] = 7;
} }
@ -7458,7 +7458,7 @@ BOOST_AUTO_TEST_CASE(string_as_mapping_key)
char const* sourceCode = R"( char const* sourceCode = R"(
contract Test { contract Test {
mapping(string => uint) data; mapping(string => uint) data;
function set(string memory _s, uint _v) { data[_s] = _v; } function set(string memory _s, uint _v) public { data[_s] = _v; }
function get(string memory _s) public returns (uint) { return data[_s]; } function get(string memory _s) public returns (uint) { return data[_s]; }
} }
)"; )";
@ -7764,7 +7764,7 @@ BOOST_AUTO_TEST_CASE(strings_in_struct)
string last; string last;
} }
constructor(){ constructor() public {
bug = Buggy(10, 20, 30, "asdfghjkl"); bug = Buggy(10, 20, 30, "asdfghjkl");
} }
function getFirst() public returns (uint) function getFirst() public returns (uint)
@ -7856,7 +7856,7 @@ BOOST_AUTO_TEST_CASE(using_library_structs)
char const* sourceCode = R"( char const* sourceCode = R"(
library Lib { library Lib {
struct Data { uint a; uint[] b; } struct Data { uint a; uint[] b; }
function set(Data storage _s) function set(Data storage _s) public
{ {
_s.a = 7; _s.a = 7;
_s.b.length = 20; _s.b.length = 20;
@ -8039,7 +8039,7 @@ BOOST_AUTO_TEST_CASE(calldata_offset)
{ {
address[] _arr; address[] _arr;
string public last = "nd"; string public last = "nd";
constructor(address[] memory guardians) constructor(address[] memory guardians) public
{ {
_arr = guardians; _arr = guardians;
} }
@ -8941,8 +8941,8 @@ BOOST_AUTO_TEST_CASE(inline_assembly_function_access)
char const* sourceCode = R"( char const* sourceCode = R"(
contract C { contract C {
uint public x; uint public x;
function g(uint y) { x = 2 * y; assembly { stop } } function g(uint y) public { x = 2 * y; assembly { stop } }
function f(uint _x) { function f(uint _x) public {
assembly { assembly {
_x _x
jump(g) jump(g)
@ -9416,7 +9416,7 @@ BOOST_AUTO_TEST_CASE(skip_dynamic_types_for_structs)
BOOST_AUTO_TEST_CASE(failed_create) BOOST_AUTO_TEST_CASE(failed_create)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract D { constructor() payable {} } contract D { constructor() public payable {} }
contract C { contract C {
uint public x; uint public x;
constructor() public payable {} constructor() public payable {}
@ -9512,7 +9512,7 @@ BOOST_AUTO_TEST_CASE(break_in_modifier)
break; break;
} }
} }
function f() run { function f() run public {
uint k = x; uint k = x;
uint t = k + 1; uint t = k + 1;
x = t; x = t;
@ -9584,7 +9584,7 @@ BOOST_AUTO_TEST_CASE(stacked_return_with_modifiers)
break; break;
} }
} }
function f() run { function f() run public {
uint k = x; uint k = x;
uint t = k + 1; uint t = k + 1;
x = t; x = t;
@ -9611,8 +9611,8 @@ BOOST_AUTO_TEST_CASE(mutex)
} }
contract Fund is mutexed { contract Fund is mutexed {
uint shares; uint shares;
constructor() payable { shares = msg.value; } constructor() public payable { shares = msg.value; }
function withdraw(uint amount) protected returns (uint) { function withdraw(uint amount) public protected returns (uint) {
// NOTE: It is very bad practice to write this function this way. // NOTE: It is very bad practice to write this function this way.
// Please refer to the documentation of how to do this properly. // Please refer to the documentation of how to do this properly.
if (amount > shares) throw; if (amount > shares) throw;
@ -9633,7 +9633,7 @@ BOOST_AUTO_TEST_CASE(mutex)
Fund public fund; Fund public fund;
uint callDepth; uint callDepth;
bool protected; bool protected;
function setProtected(bool _protected) { protected = _protected; } function setProtected(bool _protected) public { protected = _protected; }
constructor(Fund _fund) public { fund = _fund; } constructor(Fund _fund) public { fund = _fund; }
function attack() public returns (uint) { function attack() public returns (uint) {
callDepth = 0; callDepth = 0;
@ -9730,7 +9730,7 @@ BOOST_AUTO_TEST_CASE(failing_ecrecover_invalid_input_asm)
BOOST_AUTO_TEST_CASE(calling_nonexisting_contract_throws) BOOST_AUTO_TEST_CASE(calling_nonexisting_contract_throws)
{ {
char const* sourceCode = R"YY( char const* sourceCode = R"YY(
contract D { function g(); } contract D { function g() public; }
contract C { contract C {
D d = D(0x1212); D d = D(0x1212);
function f() public returns (uint) { function f() public returns (uint) {
@ -9757,7 +9757,7 @@ BOOST_AUTO_TEST_CASE(payable_constructor)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract C { contract C {
constructor() payable { } constructor() public payable { }
} }
)"; )";
compileAndRun(sourceCode, 27, "C"); compileAndRun(sourceCode, 27, "C");
@ -9792,7 +9792,7 @@ BOOST_AUTO_TEST_CASE(payable_function_calls_library)
function f() public returns (uint) { return 7; } function f() public returns (uint) { return 7; }
} }
contract C { contract C {
function f() payable public returns (uint) { function f() public payable returns (uint) {
return L.f(); return L.f();
} }
} }
@ -10015,7 +10015,7 @@ BOOST_AUTO_TEST_CASE(store_function)
contract C { contract C {
function (function (uint) external returns (uint)) internal returns (uint) ev; function (function (uint) external returns (uint)) internal returns (uint) ev;
function (uint) external returns (uint) x; function (uint) external returns (uint) x;
function store(function(uint) external returns (uint) y) { function store(function(uint) external returns (uint) y) public {
x = y; x = y;
} }
function eval(function(uint) external returns (uint) y) public returns (uint) { function eval(function(uint) external returns (uint) y) public returns (uint) {
@ -11594,7 +11594,7 @@ BOOST_AUTO_TEST_CASE(literal_empty_string)
contract C { contract C {
bytes32 public x; bytes32 public x;
uint public a; uint public a;
function f(bytes32 _x, uint _a) { function f(bytes32 _x, uint _a) public {
x = _x; x = _x;
a = _a; a = _a;
} }
@ -12730,7 +12730,7 @@ BOOST_AUTO_TEST_CASE(senders_balance)
} }
contract D { contract D {
C c = new C(); C c = new C();
constructor() payable { } constructor() public payable { }
function f() public view returns (uint) { function f() public view returns (uint) {
return c.f(); return c.f();
} }

6
test/libsolidity/SolidityOptimizer.cpp
View File

@ -394,12 +394,12 @@ BOOST_AUTO_TEST_CASE(computing_constants)
g(); g();
return 1; return 1;
} }
function g() { function g() public {
m_b = 0x817416927846239487123469187231298734162934871263941234127518276; m_b = 0x817416927846239487123469187231298734162934871263941234127518276;
m_c = 0x817416927846239487123469187231298734162934871263941234127518276; m_c = 0x817416927846239487123469187231298734162934871263941234127518276;
h(); h();
} }
function h() { function h() public {
m_d = 0xff05694900000000000000000000000000000000000000000000000000000000; m_d = 0xff05694900000000000000000000000000000000000000000000000000000000;
} }
function get() public returns (uint ra, uint rb, uint rc, uint rd) { function get() public returns (uint ra, uint rb, uint rc, uint rd) {
@ -600,7 +600,7 @@ BOOST_AUTO_TEST_CASE(init_empty_dynamic_arrays)
// not use any memory. // not use any memory.
char const* sourceCode = R"( char const* sourceCode = R"(
contract Test { contract Test {
function f() pure returns (uint r) { function f() public pure returns (uint r) {
uint[][] memory x = new uint[][](20000); uint[][] memory x = new uint[][](20000);
return x.length; return x.length;
} }

6
test/libsolidity/StandardCompiler.cpp
View File

@ -466,7 +466,7 @@ BOOST_AUTO_TEST_CASE(output_selection_dependent_contract)
}, },
"sources": { "sources": {
"fileA": { "fileA": {
"content": "contract B { } contract A { function f() { new B(); } }" "content": "contract B { } contract A { function f() public { new B(); } }"
} }
} }
} }
@ -495,7 +495,7 @@ BOOST_AUTO_TEST_CASE(output_selection_dependent_contract_with_import)
}, },
"sources": { "sources": {
"fileA": { "fileA": {
"content": "import \"fileB\"; contract A { function f() { new B(); } }" "content": "import \"fileB\"; contract A { function f() public { new B(); } }"
}, },
"fileB": { "fileB": {
"content": "contract B { }" "content": "contract B { }"
@ -712,7 +712,7 @@ BOOST_AUTO_TEST_CASE(library_linking)
"content": "library L { function g() public returns (uint) { return 1; } }" "content": "library L { function g() public returns (uint) { return 1; } }"
}, },
"library2.sol": { "library2.sol": {
"content": "library L2 { function g() { } }" "content": "library L2 { function g() public { } }"
} }
} }
} }

6
test/libsolidity/syntaxTests/array/uninitialized_storage_var.sol
View File

@ -1,9 +1,9 @@
contract C { contract C {
function f() { function f() public {
uint[] storage x; uint[] storage x;
uint[10] storage y; uint[10] storage y;
} }
} }
// ---- // ----
// DeclarationError: (31-47): Uninitialized storage pointer. // DeclarationError: (38-54): Uninitialized storage pointer.
// DeclarationError: (51-69): Uninitialized storage pointer. // DeclarationError: (58-76): Uninitialized storage pointer.