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

Added default data locations to parameters for end to end tests.

Browse Source
This commit is contained in:
Chase McDermott 2018-07-11 23:18:50 -05:00 committed by chriseth
parent c5ff173431
commit f48d01d066
11 changed files with 240 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
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 _name) view returns (address o_owner); function addr(string memory _name) view returns (address o_owner);
function name(address _owner) view returns (string o_name); function name(address _owner) 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 _name) view returns (address o_owner); function owner(string memory _name) view returns (address o_owner);
function addr(string _name) view returns (address o_address); function addr(string memory _name) view returns (address o_address);
function subRegistrar(string _name) view returns (address o_subRegistrar); function subRegistrar(string memory _name) view returns (address o_subRegistrar);
function content(string _name) view returns (bytes32 o_content); function content(string memory _name) view returns (bytes32 o_content);
function name(address _owner) view returns (string o_name); function name(address _owner) view returns (string memory o_name);
} }
contract AuctionSystem { contract AuctionSystem {
@ -64,9 +64,9 @@ contract AuctionSystem {
event NewBid(string indexed _name, address _bidder, uint _value); event NewBid(string indexed _name, address _bidder, uint _value);
/// Function that is called once an auction ends. /// Function that is called once an auction ends.
function onAuctionEnd(string _name) internal; function onAuctionEnd(string memory _name) internal;
function bid(string _name, address _bidder, uint _value) internal { function bid(string memory _name, address _bidder, uint _value) internal {
Auction storage auction = m_auctions[_name]; Auction storage auction = m_auctions[_name];
if (auction.endDate > 0 && now > auction.endDate) if (auction.endDate > 0 && now > auction.endDate)
{ {
@ -116,7 +116,7 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
// TODO: Populate with hall-of-fame. // TODO: Populate with hall-of-fame.
} }
function onAuctionEnd(string _name) internal { function onAuctionEnd(string memory _name) internal {
Auction storage auction = m_auctions[_name]; Auction storage auction = m_auctions[_name];
Record storage record = m_toRecord[_name]; Record storage record = m_toRecord[_name];
address previousOwner = record.owner; address previousOwner = record.owner;
@ -150,18 +150,18 @@ contract GlobalRegistrar is Registrar, AuctionSystem {
} }
} }
function requiresAuction(string _name) internal returns (bool) { function requiresAuction(string memory _name) internal returns (bool) {
return bytes(_name).length < c_freeBytes; return bytes(_name).length < c_freeBytes;
} }
modifier onlyrecordowner(string _name) { if (m_toRecord[_name].owner == msg.sender) _; } modifier onlyrecordowner(string memory _name) { if (m_toRecord[_name].owner == msg.sender) _; }
function transfer(string _name, address _newOwner) onlyrecordowner(_name) { function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) {
m_toRecord[_name].owner = _newOwner; m_toRecord[_name].owner = _newOwner;
emit Changed(_name); emit Changed(_name);
} }
function disown(string _name) onlyrecordowner(_name) { function disown(string memory _name) onlyrecordowner(_name) {
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 _name, address _a, bool _primary) onlyrecordowner(_name) { function setAddress(string memory _name, address _a, bool _primary) onlyrecordowner(_name) {
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 _name, address _registrar) onlyrecordowner(_name) { function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) {
m_toRecord[_name].subRegistrar = _registrar; m_toRecord[_name].subRegistrar = _registrar;
emit Changed(_name); emit Changed(_name);
} }
function setContent(string _name, bytes32 _content) onlyrecordowner(_name) { function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) {
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 _name) view returns (address) { return m_toRecord[_name].owner; } function owner(string memory _name) view returns (address) { return m_toRecord[_name].owner; }
function addr(string _name) view returns (address) { return m_toRecord[_name].primary; } function addr(string memory _name) view returns (address) { return m_toRecord[_name].primary; }
function subRegistrar(string _name) view returns (address) { return m_toRecord[_name].subRegistrar; } function subRegistrar(string memory _name) view returns (address) { return m_toRecord[_name].subRegistrar; }
function content(string _name) view returns (bytes32) { return m_toRecord[_name].content; } function content(string memory _name) view returns (bytes32) { return m_toRecord[_name].content; }
function name(address _addr) view returns (string o_name) { return m_toName[_addr]; } function name(address _addr) 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;

34
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 _name) view returns (address o_owner); function owner(string memory _name) view returns (address o_owner);
function addr(string _name) view returns (address o_address); function addr(string memory _name) view returns (address o_address);
function subRegistrar(string _name) view returns (address o_subRegistrar); function subRegistrar(string memory _name) view returns (address o_subRegistrar);
function content(string _name) view returns (bytes32 o_content); function content(string memory _name) view returns (bytes32 o_content);
} }
contract FixedFeeRegistrar is Registrar { contract FixedFeeRegistrar is Registrar {
@ -72,52 +72,52 @@ contract FixedFeeRegistrar is Registrar {
address owner; address owner;
} }
modifier onlyrecordowner(string _name) { if (m_record(_name).owner == msg.sender) _; } modifier onlyrecordowner(string memory _name) { if (m_record(_name).owner == msg.sender) _; }
function reserve(string _name) payable { function reserve(string memory _name) 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 _name, address _refund) onlyrecordowner(_name) { function disown(string memory _name, address _refund) onlyrecordowner(_name) {
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 _name, address _newOwner) onlyrecordowner(_name) { function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) {
m_record(_name).owner = _newOwner; m_record(_name).owner = _newOwner;
emit Changed(_name); emit Changed(_name);
} }
function setAddr(string _name, address _a) onlyrecordowner(_name) { function setAddr(string memory _name, address _a) onlyrecordowner(_name) {
m_record(_name).addr = _a; m_record(_name).addr = _a;
emit Changed(_name); emit Changed(_name);
} }
function setSubRegistrar(string _name, address _registrar) onlyrecordowner(_name) { function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) {
m_record(_name).subRegistrar = _registrar; m_record(_name).subRegistrar = _registrar;
emit Changed(_name); emit Changed(_name);
} }
function setContent(string _name, bytes32 _content) onlyrecordowner(_name) { function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) {
m_record(_name).content = _content; m_record(_name).content = _content;
emit Changed(_name); emit Changed(_name);
} }
function record(string _name) view returns (address o_addr, address o_subRegistrar, bytes32 o_content, address o_owner) { function record(string memory _name) 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 _name) view returns (address) { return m_record(_name).addr; } function addr(string memory _name) view returns (address) { return m_record(_name).addr; }
function subRegistrar(string _name) view returns (address) { return m_record(_name).subRegistrar; } function subRegistrar(string memory _name) view returns (address) { return m_record(_name).subRegistrar; }
function content(string _name) view returns (bytes32) { return m_record(_name).content; } function content(string memory _name) view returns (bytes32) { return m_record(_name).content; }
function owner(string _name) view returns (address) { return m_record(_name).owner; } function owner(string memory _name) view returns (address) { return m_record(_name).owner; }
Record[2**253] m_recordData; Record[2**253] m_recordData;
function m_record(string _name) view internal returns (Record storage o_record) { function m_record(string memory _name) view internal returns (Record storage o_record) {
return m_recordData[uint(keccak256(bytes(_name))) / 8]; return m_recordData[uint(keccak256(bytes(_name))) / 8];
} }
uint constant c_fee = 69 ether; uint constant c_fee = 69 ether;

4
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[] _owners, uint _required) { constructor(address[] memory _owners, uint _required) {
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;
@ -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[] _owners, uint _required, uint _daylimit) payable constructor(address[] memory _owners, uint _required, uint _daylimit) payable
multiowned(_owners, _required) daylimit(_daylimit) { multiowned(_owners, _required) daylimit(_daylimit) {
} }

58
test/libsolidity/ABIDecoderTests.cpp
View File

@ -128,7 +128,7 @@ BOOST_AUTO_TEST_CASE(fixed_arrays)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function f(uint16[3] a, uint16[2][3] b, uint i, uint j, uint k) function f(uint16[3] memory a, uint16[2][3] memory b, uint i, uint j, uint k)
public pure returns (uint, uint) { public pure returns (uint, uint) {
return (a[i], b[j][k]); return (a[i], b[j][k]);
} }
@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(dynamic_arrays)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function f(uint a, uint16[] b, uint c) function f(uint a, uint16[] memory b, uint c)
public pure returns (uint, uint, uint) { public pure returns (uint, uint, uint) {
return (b.length, b[a], c); return (b.length, b[a], c);
} }
@ -178,7 +178,7 @@ BOOST_AUTO_TEST_CASE(dynamic_nested_arrays)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function f(uint a, uint16[][] b, uint[2][][3] c, uint d) function f(uint a, uint16[][] memory b, uint[2][][3] memory c, uint d)
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);
} }
@ -229,7 +229,7 @@ BOOST_AUTO_TEST_CASE(byte_arrays)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function f(uint a, bytes b, uint c) function f(uint a, bytes memory b, uint c)
public pure returns (uint, uint, byte, uint) { public pure returns (uint, uint, byte, uint) {
return (a, b.length, b[3], c); return (a, b.length, b[3], c);
} }
@ -285,7 +285,7 @@ BOOST_AUTO_TEST_CASE(decode_from_memory_simple)
contract C { contract C {
uint public _a; uint public _a;
uint[] public _b; uint[] public _b;
constructor(uint a, uint[] b) public { constructor(uint a, uint[] memory b) public {
_a = a; _a = a;
_b = b; _b = b;
} }
@ -344,13 +344,13 @@ BOOST_AUTO_TEST_CASE(decode_function_type_array)
string sourceCode = R"( string sourceCode = R"(
contract D { contract D {
function () external returns (uint)[] public _a; function () external returns (uint)[] public _a;
constructor(function () external returns (uint)[] a) public { constructor(function () external returns (uint)[] memory a) public {
_a = a; _a = a;
} }
} }
contract E { contract E {
function () external returns (uint)[3] public _a; function () external returns (uint)[3] public _a;
constructor(function () external returns (uint)[3] a) public { constructor(function () external returns (uint)[3] memory a) public {
_a = a; _a = a;
} }
} }
@ -364,10 +364,10 @@ BOOST_AUTO_TEST_CASE(decode_function_type_array)
function f3() public returns (uint) { function f3() public returns (uint) {
return 3; return 3;
} }
function g(function () external returns (uint)[] _f, uint i) public returns (uint) { function g(function () external returns (uint)[] memory _f, uint i) public returns (uint) {
return _f[i](); return _f[i]();
} }
function h(function () external returns (uint)[3] _f, uint i) public returns (uint) { function h(function () external returns (uint)[3] memory _f, uint i) public returns (uint) {
return _f[i](); return _f[i]();
} }
// uses "decode from memory" // uses "decode from memory"
@ -412,7 +412,7 @@ BOOST_AUTO_TEST_CASE(decode_from_memory_complex)
uint public _a; uint public _a;
uint[] public _b; uint[] public _b;
bytes[2] public _c; bytes[2] public _c;
constructor(uint a, uint[] b, bytes[2] c) public { constructor(uint a, uint[] memory b, bytes[2] memory c) public {
_a = a; _a = a;
_b = b; _b = b;
_c = c; _c = c;
@ -459,7 +459,7 @@ BOOST_AUTO_TEST_CASE(short_input_array)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function f(uint[] a) public pure returns (uint) { return 7; } function f(uint[] memory a) public pure returns (uint) { return 7; }
} }
)"; )";
BOTH_ENCODERS( BOTH_ENCODERS(
@ -476,7 +476,7 @@ BOOST_AUTO_TEST_CASE(short_dynamic_input_array)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function f(bytes[1] a) public pure returns (uint) { return 7; } function f(bytes[1] memory a) public pure returns (uint) { return 7; }
} }
)"; )";
NEW_ENCODER( NEW_ENCODER(
@ -489,8 +489,8 @@ BOOST_AUTO_TEST_CASE(short_input_bytes)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function e(bytes a) public pure returns (uint) { return 7; } function e(bytes memory a) public pure returns (uint) { return 7; }
function f(bytes[] a) public pure returns (uint) { return 7; } function f(bytes[] memory a) public pure returns (uint) { return 7; }
} }
)"; )";
NEW_ENCODER( NEW_ENCODER(
@ -511,9 +511,9 @@ BOOST_AUTO_TEST_CASE(cleanup_int_inside_arrays)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
enum E { A, B } enum E { A, B }
function f(uint16[] a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } } function f(uint16[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
function g(int16[] a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } } function g(int16[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
function h(E[] a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } } function h(E[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
} }
)"; )";
NEW_ENCODER( NEW_ENCODER(
@ -569,7 +569,7 @@ BOOST_AUTO_TEST_CASE(struct_simple)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
struct S { uint a; uint8 b; uint8 c; bytes2 d; } struct S { uint a; uint8 b; uint8 c; bytes2 d; }
function f(S s) public pure returns (uint a, uint b, uint c, uint d) { function f(S memory s) public pure returns (uint a, uint b, uint c, uint d) {
a = s.a; a = s.a;
b = s.b; b = s.b;
c = s.c; c = s.c;
@ -588,7 +588,7 @@ BOOST_AUTO_TEST_CASE(struct_cleanup)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
struct S { int16 a; uint8 b; bytes2 c; } struct S { int16 a; uint8 b; bytes2 c; }
function f(S s) public pure returns (uint a, uint b, uint c) { function f(S memory s) public pure returns (uint a, uint b, uint c) {
assembly { assembly {
a := mload(s) a := mload(s)
b := mload(add(s, 0x20)) b := mload(add(s, 0x20))
@ -611,7 +611,7 @@ BOOST_AUTO_TEST_CASE(struct_short)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
struct S { int a; uint b; bytes16 c; } struct S { int a; uint b; bytes16 c; }
function f(S s) public pure returns (S q) { function f(S memory s) public pure returns (S memory q) {
q = s; q = s;
} }
} }
@ -638,7 +638,7 @@ BOOST_AUTO_TEST_CASE(struct_function)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
struct S { function () external returns (uint) f; uint b; } struct S { function () external returns (uint) f; uint b; }
function f(S s) public returns (uint, uint) { function f(S memory s) public returns (uint, uint) {
return (s.f(), s.b); return (s.f(), s.b);
} }
function test() public returns (uint, uint) { function test() public returns (uint, uint) {
@ -658,7 +658,7 @@ BOOST_AUTO_TEST_CASE(mediocre_struct)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
struct S { C c; } struct S { C c; }
function f(uint a, S[2] s1, uint b) public returns (uint r1, C r2, uint r3) { function f(uint a, S[2] memory s1, uint b) public returns (uint r1, C r2, uint r3) {
r1 = a; r1 = a;
r2 = s1[0].c; r2 = s1[0].c;
r3 = b; r3 = b;
@ -679,7 +679,7 @@ BOOST_AUTO_TEST_CASE(mediocre2_struct)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
struct S { C c; uint[] x; } struct S { C c; uint[] x; }
function f(uint a, S[2] s1, uint b) public returns (uint r1, C r2, uint r3) { function f(uint a, S[2] memory s1, uint b) public returns (uint r1, C r2, uint r3) {
r1 = a; r1 = a;
r2 = s1[0].c; r2 = s1[0].c;
r3 = b; r3 = b;
@ -707,7 +707,7 @@ BOOST_AUTO_TEST_CASE(complex_struct)
enum E {A, B, C} enum E {A, B, C}
struct T { uint x; E e; uint8 y; } struct T { uint x; E e; uint8 y; }
struct S { C c; T[] t;} struct S { C c; T[] t;}
function f(uint a, S[2] s1, S[] s2, uint b) public returns function f(uint a, S[2] memory s1, S[] memory s2, uint b) public returns
(uint r1, C r2, uint r3, uint r4, C r5, uint r6, E r7, uint8 r8) { (uint r1, C r2, uint r3, uint r4, C r5, uint r6, E r7, uint8 r8) {
r1 = a; r1 = a;
r2 = s1[0].c; r2 = s1[0].c;
@ -767,10 +767,10 @@ BOOST_AUTO_TEST_CASE(return_dynamic_types_cross_call_simple)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function dyn() public returns (bytes) { function dyn() public returns (bytes memory) {
return "1234567890123456789012345678901234567890"; return "1234567890123456789012345678901234567890";
} }
function f() public returns (bytes) { function f() public returns (bytes memory) {
return this.dyn(); return this.dyn();
} }
} }
@ -788,7 +788,7 @@ BOOST_AUTO_TEST_CASE(return_dynamic_types_cross_call_advanced)
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function dyn() public returns (bytes a, uint b, bytes20[] c, uint d) { function dyn() public returns (bytes memory a, uint b, bytes20[] memory c, uint d) {
a = "1234567890123456789012345678901234567890"; a = "1234567890123456789012345678901234567890";
b = uint(-1); b = uint(-1);
c = new bytes20[](4); c = new bytes20[](4);
@ -796,7 +796,7 @@ BOOST_AUTO_TEST_CASE(return_dynamic_types_cross_call_advanced)
c[3] = bytes20(6789); c[3] = bytes20(6789);
d = 0x1234; d = 0x1234;
} }
function f() public returns (bytes, uint, bytes20[], uint) { function f() public returns (bytes memory, uint, bytes20[] memory, uint) {
return this.dyn(); return this.dyn();
} }
} }
@ -815,7 +815,7 @@ BOOST_AUTO_TEST_CASE(return_dynamic_types_cross_call_out_of_range)
{ {
string sourceCode = R"( string sourceCode = R"(
contract C { contract C {
function dyn(uint x) public returns (bytes a) { function dyn(uint x) public returns (bytes memory a) {
assembly { assembly {
mstore(0, 0x20) mstore(0, 0x20)
mstore(0x20, 0x21) mstore(0x20, 0x21)

4
test/libsolidity/ABIEncoderTests.cpp
View File

@ -417,7 +417,7 @@ BOOST_AUTO_TEST_CASE(structs)
struct T { uint64[2] x; } struct T { uint64[2] x; }
S s; S s;
event e(uint16, S); event e(uint16, S);
function f() public returns (uint, S) { function f() public returns (uint, S memory) {
uint16 x = 7; uint16 x = 7;
s.a = 8; s.a = 8;
s.b = 9; s.b = 9;
@ -454,7 +454,7 @@ BOOST_AUTO_TEST_CASE(structs2)
enum E {A, B, C} enum E {A, B, C}
struct T { uint x; E e; uint8 y; } struct T { uint x; E e; uint8 y; }
struct S { C c; T[] t;} struct S { C c; T[] t;}
function f() public returns (uint a, S[2] s1, S[] s2, uint b) { function f() public returns (uint a, S[2] memory s1, S[] memory s2, uint b) {
a = 7; a = 7;
b = 8; b = 8;
s1[0].c = this; s1[0].c = this;

2
test/libsolidity/Imports.cpp
View File

@ -138,7 +138,7 @@ BOOST_AUTO_TEST_CASE(complex_import)
CompilerStack c; CompilerStack c;
c.addSource("a", "contract A {} contract B {} contract C { struct S { uint a; } } pragma solidity >=0.0;"); c.addSource("a", "contract A {} contract B {} contract C { struct S { uint a; } } pragma solidity >=0.0;");
c.addSource("b", "import \"a\" as x; import {B as b, C as c, C} from \"a\"; " c.addSource("b", "import \"a\" as x; import {B as b, C as c, C} from \"a\"; "
"contract D is b { function f(c.S var1, x.C.S var2, C.S var3) internal {} } pragma solidity >=0.0;"); "contract D is b { function f(c.S memory var1, x.C.S memory var2, C.S memory var3) internal {} } pragma solidity >=0.0;");
c.setEVMVersion(dev::test::Options::get().evmVersion()); c.setEVMVersion(dev::test::Options::get().evmVersion());
BOOST_CHECK(c.compile()); BOOST_CHECK(c.compile());
} }

2
test/libsolidity/SMTChecker.cpp
View File

@ -91,7 +91,7 @@ BOOST_AUTO_TEST_CASE(warn_on_struct)
pragma experimental ABIEncoderV2; pragma experimental ABIEncoderV2;
contract C { contract C {
struct A { uint a; uint b; } struct A { uint a; uint b; }
function f() public pure returns (A) { function f() public pure returns (A memory) {
return A({ a: 1, b: 2 }); return A({ a: 1, b: 2 });
} }
} }

8
test/libsolidity/SolidityABIJSON.cpp
View File

@ -756,7 +756,7 @@ BOOST_AUTO_TEST_CASE(library_function)
char const* sourceCode = R"( char const* sourceCode = R"(
library test { library test {
struct StructType { uint a; } struct StructType { uint a; }
function f(StructType storage b, uint[] storage c, test d) public returns (uint[] e, StructType storage f) {} function f(StructType storage b, uint[] storage c, test d) public returns (uint[] memory e, StructType storage f) {}
} }
)"; )";
@ -891,7 +891,7 @@ BOOST_AUTO_TEST_CASE(return_structs)
contract C { contract C {
struct S { uint a; T[] sub; } struct S { uint a; T[] sub; }
struct T { uint[2] x; } struct T { uint[2] x; }
function f() public returns (uint x, S s) { function f() public returns (uint x, S memory s) {
} }
} }
)"; )";
@ -940,7 +940,7 @@ BOOST_AUTO_TEST_CASE(return_structs_with_contracts)
pragma experimental ABIEncoderV2; pragma experimental ABIEncoderV2;
contract C { contract C {
struct S { C[] x; C y; } struct S { C[] x; C y; }
function f() public returns (S s, C c) { function f() public returns (S memory s, C c) {
} }
} }
)"; )";
@ -1042,7 +1042,7 @@ BOOST_AUTO_TEST_CASE(structs_in_libraries)
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) {}
function g(L.S s) {} function g(L.S memory s) {}
} }
)"; )";
char const* interface = R"( char const* interface = R"(

318
test/libsolidity/SolidityEndToEndTest.cpp
View File

File diff suppressed because it is too large Load Diff

2
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -350,7 +350,7 @@ BOOST_AUTO_TEST_CASE(dynamic_return_types_not_possible)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract C { contract C {
function f(uint) public returns (string); function f(uint) public returns (string memory);
function g() public { function g() public {
string memory x = this.f(2); string memory x = this.f(2);
// we can assign to x but it is not usable. // we can assign to x but it is not usable.

4
test/libsolidity/SolidityOptimizer.cpp
View File

@ -370,7 +370,7 @@ BOOST_AUTO_TEST_CASE(sequence_number_for_calls)
// to storage), so the sequence number should be incremented. // to storage), so the sequence number should be incremented.
char const* sourceCode = R"( char const* sourceCode = R"(
contract test { contract test {
function f(string a, string b) public returns (bool) { return sha256(bytes(a)) == sha256(bytes(b)); } function f(string memory a, string memory b) public returns (bool) { return sha256(bytes(a)) == sha256(bytes(b)); }
} }
)"; )";
compileBothVersions(sourceCode); compileBothVersions(sourceCode);
@ -619,7 +619,7 @@ BOOST_AUTO_TEST_CASE(optimise_multi_stores)
struct S { uint16 a; uint16 b; uint16[3] c; uint[] dyn; } struct S { uint16 a; uint16 b; uint16[3] c; uint[] dyn; }
uint padding; uint padding;
S[] s; S[] s;
function f() public returns (uint16, uint16, uint16[3], uint) { function f() public returns (uint16, uint16, uint16[3] memory, uint) {
uint16[3] memory c; uint16[3] memory c;
c[0] = 7; c[0] = 7;
c[1] = 8; c[1] = 8;