lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Conversion changes after renaming Hash/String to Bytes. 

- Almost all end to end tests pass. Still needs a little bit of work
cl-refactor
Lefteris Karapetsas 10 years ago
parent
bb205103c4
commit
d9d792a055
5 changed files with 80 additions and 65 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 49
      libsolidity/ExpressionCompiler.cpp
  2. 2
      libsolidity/GlobalContext.cpp
  3. 8
      libsolidity/LValue.cpp
  4. 20
      libsolidity/Types.cpp
  5. 66
      test/SolidityEndToEndTest.cpp

49
libsolidity/ExpressionCompiler.cpp
View File

@ -123,16 +123,20 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
Type::Category stackTypeCategory = _typeOnStack.getCategory(); Type::Category stackTypeCategory = _typeOnStack.getCategory();
Type::Category targetTypeCategory = _targetType.getCategory(); Type::Category targetTypeCategory = _targetType.getCategory();
if (stackTypeCategory == Type::Category::FixedBytes) switch (stackTypeCategory)
{
case Type::Category::FixedBytes:
{ {
FixedBytesType const& typeOnStack = dynamic_cast<FixedBytesType const&>(_typeOnStack); FixedBytesType const& typeOnStack = dynamic_cast<FixedBytesType const&>(_typeOnStack);
if (targetTypeCategory == Type::Category::Integer) if (targetTypeCategory == Type::Category::Integer)
{ {
// conversion from string to bytes. no need to clean the high bit // conversion from bytes to integer. no need to clean the high bit
// only to shift right because of opposite alignment // only to shift right because of opposite alignment
IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType); IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType);
solAssert(targetIntegerType.getNumBits() == typeOnStack.getNumBytes() * 8, "The size should be the same."); // solAssert(targetIntegerType.getNumBits() == typeOnStack.getNumBytes() * 8, "The size should be the same.");
m_context << (u256(1) << (256 - typeOnStack.getNumBytes() * 8)) << eth::Instruction::SWAP1 << eth::Instruction::DIV; m_context << (u256(1) << (256 - typeOnStack.getNumBytes() * 8)) << eth::Instruction::SWAP1 << eth::Instruction::DIV;
if (targetIntegerType.getNumBits() < typeOnStack.getNumBytes() * 8)
appendTypeConversion(IntegerType(typeOnStack.getNumBytes() * 8), _targetType, _cleanupNeeded);
} }
else else
{ {
@ -150,21 +154,24 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
} }
} }
} }
else if (stackTypeCategory == Type::Category::Enum) break;
solAssert(targetTypeCategory == Type::Category::Integer || case Type::Category::Enum:
targetTypeCategory == Type::Category::Enum, ""); solAssert(targetTypeCategory == Type::Category::Integer || targetTypeCategory == Type::Category::Enum, "");
else if (stackTypeCategory == Type::Category::Integer || break;
stackTypeCategory == Type::Category::Contract || case Type::Category::Integer:
stackTypeCategory == Type::Category::IntegerConstant) case Type::Category::Contract:
{ case Type::Category::IntegerConstant:
if (targetTypeCategory == Type::Category::FixedBytes && stackTypeCategory == Type::Category::Integer) if (targetTypeCategory == Type::Category::FixedBytes)
{ {
solAssert(stackTypeCategory == Type::Category::Integer || stackTypeCategory == Type::Category::IntegerConstant,
"Invalid conversion to FixedBytesType requested.");
// conversion from bytes to string. no need to clean the high bit // conversion from bytes to string. no need to clean the high bit
// only to shift left because of opposite alignment // only to shift left because of opposite alignment
FixedBytesType const& targetBytesType = dynamic_cast<FixedBytesType const&>(_targetType); FixedBytesType const& targetBytesType = dynamic_cast<FixedBytesType const&>(_targetType);
IntegerType const& typeOnStack = dynamic_cast<IntegerType const&>(_typeOnStack); if (auto typeOnStack = dynamic_cast<IntegerType const*>(&_typeOnStack))
solAssert(typeOnStack.getNumBits() == targetBytesType.getNumBytes() * 8, "The size should be the same."); if (targetBytesType.getNumBytes() * 8 > typeOnStack->getNumBits())
m_context << (u256(1) << (256 - typeOnStack.getNumBits())) << eth::Instruction::MUL; appendHighBitsCleanup(*typeOnStack);
m_context << (u256(1) << (256 - targetBytesType.getNumBytes() * 8)) << eth::Instruction::MUL;
} }
else if (targetTypeCategory == Type::Category::Enum) else if (targetTypeCategory == Type::Category::Enum)
// just clean // just clean
@ -174,7 +181,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
solAssert(targetTypeCategory == Type::Category::Integer || targetTypeCategory == Type::Category::Contract, ""); solAssert(targetTypeCategory == Type::Category::Integer || targetTypeCategory == Type::Category::Contract, "");
IntegerType addressType(0, IntegerType::Modifier::Address); IntegerType addressType(0, IntegerType::Modifier::Address);
IntegerType const& targetType = targetTypeCategory == Type::Category::Integer IntegerType const& targetType = targetTypeCategory == Type::Category::Integer
? dynamic_cast<IntegerType const&>(_targetType) : addressType; ? dynamic_cast<IntegerType const&>(_targetType) : addressType;
if (stackTypeCategory == Type::Category::IntegerConstant) if (stackTypeCategory == Type::Category::IntegerConstant)
{ {
IntegerConstantType const& constType = dynamic_cast<IntegerConstantType const&>(_typeOnStack); IntegerConstantType const& constType = dynamic_cast<IntegerConstantType const&>(_typeOnStack);
@ -186,7 +193,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
else else
{ {
IntegerType const& typeOnStack = stackTypeCategory == Type::Category::Integer IntegerType const& typeOnStack = stackTypeCategory == Type::Category::Integer
? dynamic_cast<IntegerType const&>(_typeOnStack) : addressType; ? dynamic_cast<IntegerType const&>(_typeOnStack) : addressType;
// Widening: clean up according to source type width // Widening: clean up according to source type width
// Non-widening and force: clean up according to target type bits // Non-widening and force: clean up according to target type bits
if (targetType.getNumBits() > typeOnStack.getNumBits()) if (targetType.getNumBits() > typeOnStack.getNumBits())
@ -195,10 +202,12 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
appendHighBitsCleanup(targetType); appendHighBitsCleanup(targetType);
} }
} }
} break;
else if (_typeOnStack != _targetType) default:
// All other types should not be convertible to non-equal types. // All other types should not be convertible to non-equal types.
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid type conversion requested.")); solAssert(_typeOnStack == _targetType, "Invalid type conversion requested.");
break;
}
} }
bool ExpressionCompiler::visit(Assignment const& _assignment) bool ExpressionCompiler::visit(Assignment const& _assignment)
@ -773,7 +782,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
// no lvalue, just retrieve the value // no lvalue, just retrieve the value
m_context m_context
<< eth::Instruction::ADD << eth::Instruction::CALLDATALOAD << eth::Instruction::ADD << eth::Instruction::CALLDATALOAD
<< u256(0) << eth::Instruction::BYTE; << ((u256(1) << (256 - 8)) - 1) << eth::Instruction::AND;
break; break;
case ArrayType::Location::Memory: case ArrayType::Location::Memory:
solAssert(false, "Memory lvalues not yet implemented."); solAssert(false, "Memory lvalues not yet implemented.");

2
libsolidity/GlobalContext.cpp
View File

@ -55,7 +55,7 @@ m_magicVariables(vector<shared_ptr<MagicVariableDeclaration const>>{make_shared<
make_shared<MagicVariableDeclaration>("sha256", make_shared<MagicVariableDeclaration>("sha256",
make_shared<FunctionType>(strings(), strings{"bytes32"}, FunctionType::Location::SHA256, true)), make_shared<FunctionType>(strings(), strings{"bytes32"}, FunctionType::Location::SHA256, true)),
make_shared<MagicVariableDeclaration>("ecrecover", make_shared<MagicVariableDeclaration>("ecrecover",
make_shared<FunctionType>(strings{"bytes32", "bytes1", "bytes32", "bytes32"}, strings{"address"}, FunctionType::Location::ECRecover)), make_shared<FunctionType>(strings{"bytes32", "uint8", "bytes32", "bytes32"}, strings{"address"}, FunctionType::Location::ECRecover)),
make_shared<MagicVariableDeclaration>("ripemd160", make_shared<MagicVariableDeclaration>("ripemd160",
make_shared<FunctionType>(strings(), strings{"bytes20"}, FunctionType::Location::RIPEMD160, true))}) make_shared<FunctionType>(strings(), strings{"bytes20"}, FunctionType::Location::RIPEMD160, true))})
{ {

8
libsolidity/LValue.cpp
View File

@ -246,10 +246,11 @@ void StorageByteArrayElement::retrieveValue(SourceLocation const&, bool _remove)
// stack: ref byte_number // stack: ref byte_number
if (_remove) if (_remove)
m_context << eth::Instruction::SWAP1 << eth::Instruction::SLOAD m_context << eth::Instruction::SWAP1 << eth::Instruction::SLOAD
<< eth::Instruction::SWAP1 << eth::Instruction::BYTE; << eth::Instruction::SWAP1 << eth::Instruction::BYTE ;
else else
m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD
<< eth::Instruction::DUP2 << eth::Instruction::BYTE; << eth::Instruction::DUP2 << eth::Instruction::BYTE;
m_context << (u256(1) << (256 - 8)) << eth::Instruction::MUL;
} }
void StorageByteArrayElement::storeValue(Type const&, SourceLocation const&, bool _move) const void StorageByteArrayElement::storeValue(Type const&, SourceLocation const&, bool _move) const
@ -265,8 +266,9 @@ void StorageByteArrayElement::storeValue(Type const&, SourceLocation const&, boo
m_context << eth::Instruction::DUP2 << u256(0xff) << eth::Instruction::MUL m_context << eth::Instruction::DUP2 << u256(0xff) << eth::Instruction::MUL
<< eth::Instruction::NOT << eth::Instruction::AND; << eth::Instruction::NOT << eth::Instruction::AND;
// stack: value ref (1<<(32-byte_number)) old_full_value_with_cleared_byte // stack: value ref (1<<(32-byte_number)) old_full_value_with_cleared_byte
m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP4 << eth::Instruction::MUL m_context << eth::Instruction::SWAP1;
<< eth::Instruction::OR; m_context << (u256(1) << (256 - 8)) << eth::Instruction::DUP5 << eth::Instruction::DIV
<< eth::Instruction::MUL << eth::Instruction::OR;
// stack: value ref new_full_value // stack: value ref new_full_value
m_context << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; m_context << eth::Instruction::SWAP1 << eth::Instruction::SSTORE;
if (_move) if (_move)

20
libsolidity/Types.cpp
View File

@ -175,14 +175,10 @@ bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{ {
if (_convertTo.getCategory() == Category::FixedBytes)
{
FixedBytesType const& convertTo = dynamic_cast<FixedBytesType const&>(_convertTo);
return (m_bits == convertTo.getNumBytes() * 8);
}
return _convertTo.getCategory() == getCategory() || return _convertTo.getCategory() == getCategory() ||
_convertTo.getCategory() == Category::Contract || _convertTo.getCategory() == Category::Contract ||
_convertTo.getCategory() == Category::Enum; _convertTo.getCategory() == Category::Enum ||
_convertTo.getCategory() == Category::FixedBytes;
} }
TypePointer IntegerType::unaryOperatorResult(Token::Value _operator) const TypePointer IntegerType::unaryOperatorResult(Token::Value _operator) const
@ -284,7 +280,15 @@ IntegerConstantType::IntegerConstantType(Literal const& _literal)
bool IntegerConstantType::isImplicitlyConvertibleTo(Type const& _convertTo) const bool IntegerConstantType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{ {
TypePointer integerType = getIntegerType(); auto integerType = getIntegerType();
if (_convertTo.getCategory() == Category::FixedBytes)
{
FixedBytesType const& convertTo = dynamic_cast<FixedBytesType const&>(_convertTo);
if (convertTo.getNumBytes() * 8 >= integerType->getNumBits())
return true;
return false;
}
return integerType && integerType->isImplicitlyConvertibleTo(_convertTo); return integerType && integerType->isImplicitlyConvertibleTo(_convertTo);
} }
@ -461,7 +465,7 @@ bool FixedBytesType::isExplicitlyConvertibleTo(Type const& _convertTo) const
if (_convertTo.getCategory() == Category::Integer) if (_convertTo.getCategory() == Category::Integer)
{ {
IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo); IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
if (m_bytes * 8 == convertTo.getNumBits()) if (m_bytes * 8 <= convertTo.getNumBits())
return true; return true;
} }

66
test/SolidityEndToEndTest.cpp
View File

@ -1357,7 +1357,7 @@ BOOST_AUTO_TEST_CASE(ecrecover)
{ {
char const* sourceCode = "contract test {\n" char const* sourceCode = "contract test {\n"
" function a(bytes32 h, uint8 v, bytes32 r, bytes32 s) returns (address addr) {\n" " function a(bytes32 h, uint8 v, bytes32 r, bytes32 s) returns (address addr) {\n"
" return ecrecover(h, bytes1(v), r, s);\n" " return ecrecover(h, v, r, s);\n"
" }\n" " }\n"
"}\n"; "}\n";
compileAndRun(sourceCode); compileAndRun(sourceCode);
@ -1526,17 +1526,17 @@ BOOST_AUTO_TEST_CASE(inter_contract_calls_with_local_vars)
BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b + 9)); BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b + 9));
} }
BOOST_AUTO_TEST_CASE(strings_in_calls) BOOST_AUTO_TEST_CASE(fixed_bytes_in_calls)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Helper { contract Helper {
function invoke(string3 x, bool stop) returns (string4 ret) { function invoke(bytes3 x, bool stop) returns (bytes4 ret) {
return x; return x;
} }
} }
contract Main { contract Main {
Helper h; Helper h;
function callHelper(string2 x, bool stop) returns (string5 ret) { function callHelper(bytes2 x, bool stop) returns (bytes5 ret) {
return h.invoke(x, stop); return h.invoke(x, stop);
} }
function getHelper() returns (address addr) { function getHelper() returns (address addr) {
@ -1551,21 +1551,21 @@ BOOST_AUTO_TEST_CASE(strings_in_calls)
compileAndRun(sourceCode, 0, "Main"); compileAndRun(sourceCode, 0, "Main");
BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes()); BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress)); BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
BOOST_CHECK(callContractFunction("callHelper(string2,bool)", string("\0a", 2), true) == encodeArgs(string("\0a\0\0\0", 5))); BOOST_CHECK(callContractFunction("callHelper(bytes2,bool)", string("\0a", 2), true) == encodeArgs(string("\0a\0\0\0", 5)));
} }
BOOST_AUTO_TEST_CASE(constructor_arguments) BOOST_AUTO_TEST_CASE(constructor_arguments)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Helper { contract Helper {
string3 name; bytes3 name;
bool flag; bool flag;
function Helper(string3 x, bool f) { function Helper(bytes3 x, bool f) {
name = x; name = x;
flag = f; flag = f;
} }
function getName() returns (string3 ret) { return name; } function getName() returns (bytes3 ret) { return name; }
function getFlag() returns (bool ret) { return flag; } function getFlag() returns (bool ret) { return flag; }
} }
contract Main { contract Main {
@ -1574,7 +1574,7 @@ BOOST_AUTO_TEST_CASE(constructor_arguments)
h = new Helper("abc", true); h = new Helper("abc", true);
} }
function getFlag() returns (bool ret) { return h.getFlag(); } function getFlag() returns (bool ret) { return h.getFlag(); }
function getName() returns (string3 ret) { return h.getName(); } function getName() returns (bytes3 ret) { return h.getName(); }
})"; })";
compileAndRun(sourceCode, 0, "Main"); compileAndRun(sourceCode, 0, "Main");
BOOST_REQUIRE(callContractFunction("getFlag()") == encodeArgs(true)); BOOST_REQUIRE(callContractFunction("getFlag()") == encodeArgs(true));
@ -1585,13 +1585,13 @@ BOOST_AUTO_TEST_CASE(functions_called_by_constructor)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Test { contract Test {
string3 name; bytes3 name;
bool flag; bool flag;
function Test() { function Test() {
setName("abc"); setName("abc");
} }
function getName() returns (string3 ret) { return name; } function getName() returns (bytes3 ret) { return name; }
function setName(string3 _name) private { name = _name; } function setName(bytes3 _name) private { name = _name; }
})"; })";
compileAndRun(sourceCode); compileAndRun(sourceCode);
BOOST_REQUIRE(callContractFunction("getName()") == encodeArgs("abc")); BOOST_REQUIRE(callContractFunction("getName()") == encodeArgs("abc"));
@ -1699,13 +1699,13 @@ BOOST_AUTO_TEST_CASE(value_for_constructor)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract Helper { contract Helper {
string3 name; bytes3 name;
bool flag; bool flag;
function Helper(string3 x, bool f) { function Helper(bytes3 x, bool f) {
name = x; name = x;
flag = f; flag = f;
} }
function getName() returns (string3 ret) { return name; } function getName() returns (bytes3 ret) { return name; }
function getFlag() returns (bool ret) { return flag; } function getFlag() returns (bool ret) { return flag; }
} }
contract Main { contract Main {
@ -1714,7 +1714,7 @@ BOOST_AUTO_TEST_CASE(value_for_constructor)
h = new Helper.value(10)("abc", true); h = new Helper.value(10)("abc", true);
} }
function getFlag() returns (bool ret) { return h.getFlag(); } function getFlag() returns (bool ret) { return h.getFlag(); }
function getName() returns (string3 ret) { return h.getName(); } function getName() returns (bytes3 ret) { return h.getName(); }
function getBalances() returns (uint me, uint them) { me = this.balance; them = h.balance;} function getBalances() returns (uint me, uint them) { me = this.balance; them = h.balance;}
})"; })";
compileAndRun(sourceCode, 22, "Main"); compileAndRun(sourceCode, 22, "Main");
@ -2095,10 +2095,10 @@ BOOST_AUTO_TEST_CASE(event)
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) { function deposit(bytes32 _id, bool _manually) {
if (_manually) { if (_manually) {
bytes32 s = uint(0x50cb9fe53daa9737b786ab3646f04d0150dc50ef4e75f59509d83667ad5adb20); bytes32 s = 0x19dacbf83c5de6658e14cbf7bcae5c15eca2eedecf1c66fbca928e4d351bea0f;
log3(msg.value, s, bytes4(msg.sender), _id); log3(bytes32(msg.value), s, bytes32(msg.sender), _id);
} else } else
Deposit(bytes4(msg.sender), _id, msg.value); Deposit(msg.sender, _id, msg.value);
} }
} }
)"; )";
@ -2107,12 +2107,12 @@ BOOST_AUTO_TEST_CASE(event)
u256 id(0x1234); u256 id(0x1234);
for (bool manually: {true, false}) for (bool manually: {true, false})
{ {
callContractFunctionWithValue("deposit(hash256,bool)", value, id, manually); callContractFunctionWithValue("deposit(bytes32,bool)", value, id, manually);
BOOST_REQUIRE_EQUAL(m_logs.size(), 1); BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress); BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(value))); BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(value)));
BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 3); BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 3);
BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit(address,hash256,uint256)"))); BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit(address,bytes32,uint256)")));
BOOST_CHECK_EQUAL(m_logs[0].topics[1], h256(m_sender)); BOOST_CHECK_EQUAL(m_logs[0].topics[1], h256(m_sender));
BOOST_CHECK_EQUAL(m_logs[0].topics[2], h256(id)); BOOST_CHECK_EQUAL(m_logs[0].topics[2], h256(id));
} }
@ -2141,21 +2141,21 @@ BOOST_AUTO_TEST_CASE(event_lots_of_data)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract ClientReceipt { contract ClientReceipt {
event Deposit(address _from, hash _id, uint _value, bool _flag); event Deposit(address _from, bytes32 _id, uint _value, bool _flag);
function deposit(hash _id) { function deposit(bytes32 _id) {
Deposit(msg.sender, hash32(_id), msg.value, true); Deposit(msg.sender, _id, msg.value, true);
} }
} }
)"; )";
compileAndRun(sourceCode); compileAndRun(sourceCode);
u256 value(18); u256 value(18);
u256 id(0x1234); u256 id(0x1234);
callContractFunctionWithValue("deposit(hash256)", value, id); callContractFunctionWithValue("deposit(bytes32)", value, id);
BOOST_REQUIRE_EQUAL(m_logs.size(), 1); BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress); BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
BOOST_CHECK(m_logs[0].data == encodeArgs((u160)m_sender, id, value, true)); BOOST_CHECK(m_logs[0].data == encodeArgs((u160)m_sender, id, value, true));
BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 1); BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 1);
BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit(address,hash256,uint256,bool)"))); BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit(address,bytes32,uint256,bool)")));
} }
BOOST_AUTO_TEST_CASE(empty_name_input_parameter_with_named_one) BOOST_AUTO_TEST_CASE(empty_name_input_parameter_with_named_one)
@ -2189,7 +2189,7 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract c { contract c {
function foo(uint a, uint b, uint c) returns (hash d) function foo(uint a, uint b, uint c) returns (bytes32 d)
{ {
d = sha3(a, b, c); d = sha3(a, b, c);
} }
@ -2207,7 +2207,7 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_numeric_literals)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract c { contract c {
function foo(uint a, uint16 b) returns (hash d) function foo(uint a, uint16 b) returns (bytes32 d)
{ {
d = sha3(a, b, 145); d = sha3(a, b, 145);
} }
@ -2225,11 +2225,11 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_string_literals)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract c { contract c {
function foo() returns (hash d) function foo() returns (bytes32 d)
{ {
d = sha3("foo"); d = sha3("foo");
} }
function bar(uint a, uint16 b) returns (hash d) function bar(uint a, uint16 b) returns (bytes32 d)
{ {
d = sha3(a, b, 145, "foo"); d = sha3(a, b, 145, "foo");
} }
@ -2256,7 +2256,7 @@ BOOST_AUTO_TEST_CASE(generic_call)
contract sender { contract sender {
function doSend(address rec) returns (uint d) function doSend(address rec) returns (uint d)
{ {
string4 signature = string4(string32(sha3("receive(uint256)"))); bytes4 signature = bytes4(bytes32(sha3("receive(uint256)")));
rec.call.value(2)(signature, 23); rec.call.value(2)(signature, 23);
return receiver(rec).received(); return receiver(rec).received();
} }
@ -2292,7 +2292,7 @@ BOOST_AUTO_TEST_CASE(bytes_from_calldata_to_memory)
{ {
char const* sourceCode = R"( char const* sourceCode = R"(
contract C { contract C {
function() returns (hash) { function() returns (bytes32) {
return sha3("abc", msg.data); return sha3("abc", msg.data);
} }
} }
@ -3016,6 +3016,7 @@ BOOST_AUTO_TEST_CASE(bytes_index_access)
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33}; 30, 31, 32, 33};
cout << toHex(callContractFunction("direct(bytes,uint256)", u256(array.length()), 32, array)) << endl;
BOOST_CHECK(callContractFunction("direct(bytes,uint256)", u256(array.length()), 32, array) == encodeArgs(32)); BOOST_CHECK(callContractFunction("direct(bytes,uint256)", u256(array.length()), 32, array) == encodeArgs(32));
BOOST_CHECK(callContractFunction("storageCopyRead(bytes,uint256)", u256(array.length()), 32, array) == encodeArgs(32)); BOOST_CHECK(callContractFunction("storageCopyRead(bytes,uint256)", u256(array.length()), 32, array) == encodeArgs(32));
BOOST_CHECK(callContractFunction("storageWrite()") == encodeArgs(0x193)); BOOST_CHECK(callContractFunction("storageWrite()") == encodeArgs(0x193));
@ -3183,7 +3184,6 @@ BOOST_AUTO_TEST_CASE(pass_dynamic_arguments_to_the_base_base_with_gap)
BOOST_CHECK(callContractFunction("m_i()") == encodeArgs(4)); BOOST_CHECK(callContractFunction("m_i()") == encodeArgs(4));
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()
} }

Write Preview
Loading…
Cancel
Save