mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
Merge remote-tracking branch 'ethereum/develop' into develop
This commit is contained in:
winsvega
commit
34249753e8
@ -2,6 +2,7 @@ cmake_policy(SET CMP0015 NEW)
|
||||
|
||||
aux_source_directory(. SRC_LIST)
|
||||
list(REMOVE_ITEM SRC_LIST "./createRandomTest.cpp")
|
||||
list(REMOVE_ITEM SRC_LIST "./checkRandomTest.cpp")
|
||||
|
||||
include_directories(${Boost_INCLUDE_DIRS})
|
||||
include_directories(${CRYPTOPP_INCLUDE_DIRS})
|
||||
@ -12,6 +13,7 @@ include_directories(..)
|
||||
file(GLOB HEADERS "*.h")
|
||||
add_executable(testeth ${SRC_LIST} ${HEADERS})
|
||||
add_executable(createRandomTest createRandomTest.cpp vm.cpp TestHelper.cpp)
|
||||
add_executable(checkRandomTest checkRandomTest.cpp vm.cpp TestHelper.cpp)
|
||||
|
||||
target_link_libraries(testeth ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
|
||||
target_link_libraries(testeth ${CURL_LIBRARIES})
|
||||
@ -29,3 +31,7 @@ endif()
|
||||
target_link_libraries(createRandomTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
|
||||
target_link_libraries(createRandomTest ethereum)
|
||||
target_link_libraries(createRandomTest ethcore)
|
||||
target_link_libraries(checkRandomTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
|
||||
target_link_libraries(checkRandomTest ethereum)
|
||||
target_link_libraries(checkRandomTest ethcore)
|
||||
|
||||
|
||||
@ -41,16 +41,12 @@ public:
|
||||
{
|
||||
m_compilerStack.parse(_code);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
catch(boost::exception const& _e)
|
||||
{
|
||||
std::string const* extra = boost::get_error_info<errinfo_comment>(e);
|
||||
std::string msg = std::string("Parsing contract failed with: ") +
|
||||
e.what() + std::string("\n");
|
||||
if (extra)
|
||||
msg += *extra;
|
||||
auto msg = std::string("Parsing contract failed with: ") + boost::diagnostic_information(_e);
|
||||
BOOST_FAIL(msg);
|
||||
}
|
||||
std::string generatedInterfaceString = m_compilerStack.getJsonDocumentation("", DocumentationType::ABI_INTERFACE);
|
||||
std::string generatedInterfaceString = m_compilerStack.getMetadata("", DocumentationType::ABI_INTERFACE);
|
||||
Json::Value generatedInterface;
|
||||
m_reader.parse(generatedInterfaceString, generatedInterface);
|
||||
Json::Value expectedInterface;
|
||||
@ -236,20 +232,6 @@ BOOST_AUTO_TEST_CASE(const_function)
|
||||
"}\n";
|
||||
|
||||
char const* interface = R"([
|
||||
{
|
||||
"name": "boo",
|
||||
"constant": true,
|
||||
"inputs": [{
|
||||
"name": "a",
|
||||
"type": "uint32"
|
||||
}],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "b",
|
||||
"type": "uint256"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "foo",
|
||||
"constant": false,
|
||||
@ -269,6 +251,20 @@ BOOST_AUTO_TEST_CASE(const_function)
|
||||
"type": "uint256"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "boo",
|
||||
"constant": true,
|
||||
"inputs": [{
|
||||
"name": "a",
|
||||
"type": "uint32"
|
||||
}],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "b",
|
||||
"type": "uint256"
|
||||
}
|
||||
]
|
||||
}
|
||||
])";
|
||||
|
||||
|
||||
@ -64,7 +64,7 @@ bytes compileContract(const string& _sourceCode)
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
{
|
||||
Compiler compiler;
|
||||
compiler.compileContract(*contract, {}, map<ContractDefinition const*, bytes const*>{});
|
||||
compiler.compileContract(*contract, map<ContractDefinition const*, bytes const*>{});
|
||||
|
||||
// debug
|
||||
//compiler.streamAssembly(cout);
|
||||
@ -96,7 +96,7 @@ BOOST_AUTO_TEST_CASE(smoke_test)
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned boilerplateSize = 40;
|
||||
unsigned boilerplateSize = 73;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x0, // initialize local variable x
|
||||
byte(Instruction::PUSH1), 0x2,
|
||||
@ -115,9 +115,8 @@ BOOST_AUTO_TEST_CASE(different_argument_numbers)
|
||||
" function g() returns (uint e, uint h) { h = f(1, 2, 3); }\n"
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned shift = 68;
|
||||
unsigned boilerplateSize = 81;
|
||||
unsigned shift = 103;
|
||||
unsigned boilerplateSize = 116;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x0, // initialize return variable d
|
||||
byte(Instruction::DUP3),
|
||||
@ -135,10 +134,10 @@ BOOST_AUTO_TEST_CASE(different_argument_numbers)
|
||||
byte(Instruction::JUMPDEST), // beginning of g
|
||||
byte(Instruction::PUSH1), 0x0,
|
||||
byte(Instruction::PUSH1), 0x0, // initialized e and h
|
||||
byte(Instruction::PUSH1), byte(0x2a + shift), // ret address
|
||||
byte(Instruction::PUSH1), 0x1, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
|
||||
byte(Instruction::PUSH1), 0x2, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
|
||||
byte(Instruction::PUSH1), 0x3, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
|
||||
byte(Instruction::PUSH1), byte(0x21 + shift), // ret address
|
||||
byte(Instruction::PUSH1), 0x1,
|
||||
byte(Instruction::PUSH1), 0x2,
|
||||
byte(Instruction::PUSH1), 0x3,
|
||||
byte(Instruction::PUSH1), byte(0x1 + shift),
|
||||
// stack here: ret e h 0x20 1 2 3 0x1
|
||||
byte(Instruction::JUMP),
|
||||
@ -166,9 +165,8 @@ BOOST_AUTO_TEST_CASE(ifStatement)
|
||||
" function f() { bool x; if (x) 77; else if (!x) 78; else 79; }"
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned shift = 27;
|
||||
unsigned boilerplateSize = 40;
|
||||
unsigned shift = 60;
|
||||
unsigned boilerplateSize = 73;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x0,
|
||||
byte(Instruction::DUP1),
|
||||
@ -208,9 +206,8 @@ BOOST_AUTO_TEST_CASE(loops)
|
||||
" function f() { while(true){1;break;2;continue;3;return;4;} }"
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned shift = 27;
|
||||
unsigned boilerplateSize = 40;
|
||||
unsigned shift = 60;
|
||||
unsigned boilerplateSize = 73;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x1,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -86,13 +86,19 @@ Declaration const& resolveDeclaration(vector<string> const& _namespacedName,
|
||||
}
|
||||
|
||||
bytes compileFirstExpression(const string& _sourceCode, vector<vector<string>> _functions = {},
|
||||
vector<vector<string>> _localVariables = {})
|
||||
vector<vector<string>> _localVariables = {}, vector<shared_ptr<MagicVariableDeclaration const>> _globalDeclarations = {})
|
||||
{
|
||||
Parser parser;
|
||||
ASTPointer<SourceUnit> sourceUnit;
|
||||
BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
|
||||
NameAndTypeResolver resolver({});
|
||||
|
||||
vector<Declaration const*> declarations;
|
||||
declarations.reserve(_globalDeclarations.size() + 1);
|
||||
for (ASTPointer<Declaration const> const& variable: _globalDeclarations)
|
||||
declarations.push_back(variable.get());
|
||||
NameAndTypeResolver resolver(declarations);
|
||||
resolver.registerDeclarations(*sourceUnit);
|
||||
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
{
|
||||
@ -174,8 +180,8 @@ BOOST_AUTO_TEST_CASE(comparison)
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x1,
|
||||
byte(eth::Instruction::PUSH2), 0x11, 0xaa, byte(eth::Instruction::PUSH2), 0xff, 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH2), 0x10, 0xaa, byte(eth::Instruction::PUSH2), 0xff, 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH2), 0x11, 0xaa,
|
||||
byte(eth::Instruction::PUSH2), 0x10, 0xaa,
|
||||
byte(eth::Instruction::LT),
|
||||
byte(eth::Instruction::EQ),
|
||||
byte(eth::Instruction::ISZERO)});
|
||||
@ -189,20 +195,18 @@ BOOST_AUTO_TEST_CASE(short_circuiting)
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0xa,
|
||||
byte(eth::Instruction::PUSH1), 0x8,
|
||||
byte(eth::Instruction::ADD), byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x4, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x12, // 8 + 10
|
||||
byte(eth::Instruction::PUSH1), 0x4,
|
||||
byte(eth::Instruction::GT),
|
||||
byte(eth::Instruction::ISZERO), // after this we have 10 + 8 >= 4
|
||||
byte(eth::Instruction::ISZERO), // after this we have 4 <= 8 + 10
|
||||
byte(eth::Instruction::DUP1),
|
||||
byte(eth::Instruction::PUSH1), 0x20,
|
||||
byte(eth::Instruction::PUSH1), 0x11,
|
||||
byte(eth::Instruction::JUMPI), // short-circuit if it is true
|
||||
byte(eth::Instruction::POP),
|
||||
byte(eth::Instruction::PUSH1), 0x2, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x9, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x2,
|
||||
byte(eth::Instruction::PUSH1), 0x9,
|
||||
byte(eth::Instruction::EQ),
|
||||
byte(eth::Instruction::ISZERO), // after this we have 2 != 9
|
||||
byte(eth::Instruction::ISZERO), // after this we have 9 != 2
|
||||
byte(eth::Instruction::JUMPDEST),
|
||||
byte(eth::Instruction::PUSH1), 0x1,
|
||||
byte(eth::Instruction::EQ),
|
||||
@ -213,28 +217,24 @@ BOOST_AUTO_TEST_CASE(short_circuiting)
|
||||
BOOST_AUTO_TEST_CASE(arithmetics)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function f() { var x = ((((((((9 ^ 8) & 7) | 6) - 5) + 4) % 3) / 2) * 1); }"
|
||||
" function f(uint y) { var x = ((((((((y ^ 8) & 7) | 6) - 5) + 4) % 3) / 2) * 1); }"
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}, {"test", "f", "x"}});
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x1,
|
||||
byte(eth::Instruction::PUSH1), 0x2,
|
||||
byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x3,
|
||||
byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x4,
|
||||
byte(eth::Instruction::PUSH1), 0x5,
|
||||
byte(eth::Instruction::PUSH1), 0x6,
|
||||
byte(eth::Instruction::PUSH1), 0x7,
|
||||
byte(eth::Instruction::PUSH1), 0x8,
|
||||
byte(eth::Instruction::PUSH1), 0x9,
|
||||
byte(eth::Instruction::DUP10),
|
||||
byte(eth::Instruction::XOR),
|
||||
byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::OR),
|
||||
byte(eth::Instruction::SUB),
|
||||
byte(eth::Instruction::ADD),
|
||||
byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::MOD),
|
||||
byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::DIV),
|
||||
byte(eth::Instruction::MUL)});
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
|
||||
@ -243,15 +243,15 @@ BOOST_AUTO_TEST_CASE(arithmetics)
|
||||
BOOST_AUTO_TEST_CASE(unary_operators)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function f() { var x = !(~+- 1 == 2); }"
|
||||
" function f(int y) { var x = !(~+- y == 2); }"
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}, {"test", "f", "x"}});
|
||||
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x2, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x1,
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x2,
|
||||
byte(eth::Instruction::DUP3),
|
||||
byte(eth::Instruction::PUSH1), 0x0,
|
||||
byte(eth::Instruction::SUB),
|
||||
byte(eth::Instruction::NOT), byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::NOT),
|
||||
byte(eth::Instruction::EQ),
|
||||
byte(eth::Instruction::ISZERO)});
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
|
||||
@ -315,7 +315,7 @@ BOOST_AUTO_TEST_CASE(assignment)
|
||||
bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "b"}});
|
||||
|
||||
// Stack: a, b
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x2, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x2,
|
||||
byte(eth::Instruction::DUP2),
|
||||
byte(eth::Instruction::DUP4),
|
||||
byte(eth::Instruction::ADD),
|
||||
@ -338,14 +338,14 @@ BOOST_AUTO_TEST_CASE(function_call)
|
||||
{{"test", "f", "a"}, {"test", "f", "b"}});
|
||||
|
||||
// Stack: a, b
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x02, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
byte(eth::Instruction::PUSH1), 0x12,
|
||||
byte(eth::Instruction::PUSH1), 0x01, byte(eth::Instruction::PUSH1), 0xff, byte(eth::Instruction::AND),
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x02,
|
||||
byte(eth::Instruction::PUSH1), 0x0c,
|
||||
byte(eth::Instruction::PUSH1), 0x01,
|
||||
byte(eth::Instruction::DUP5),
|
||||
byte(eth::Instruction::ADD),
|
||||
// Stack here: a b 2 <ret label> (a+1)
|
||||
byte(eth::Instruction::DUP4),
|
||||
byte(eth::Instruction::PUSH1), 0x19,
|
||||
byte(eth::Instruction::PUSH1), 0x13,
|
||||
byte(eth::Instruction::JUMP),
|
||||
byte(eth::Instruction::JUMPDEST),
|
||||
// Stack here: a b 2 g(a+1, b)
|
||||
@ -363,40 +363,51 @@ BOOST_AUTO_TEST_CASE(function_call)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(negative_literals_8bits)
|
||||
{
|
||||
// these all fit in 8 bits
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function f() { int8 x = -0 + -1 + -0x01 + -127 + -128; }\n"
|
||||
" function f() { int8 x = -0x80; }\n"
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
|
||||
bytes expectation(bytes({byte(eth::Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x80) +
|
||||
bytes({byte(eth::Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x81) +
|
||||
bytes({byte(eth::Instruction::PUSH32)}) + bytes(32, 0xff) +
|
||||
bytes({byte(eth::Instruction::PUSH32)}) + bytes(32, 0xff) +
|
||||
bytes({byte(eth::Instruction::PUSH1), 0x00,
|
||||
byte(eth::Instruction::ADD),
|
||||
byte(eth::Instruction::ADD),
|
||||
byte(eth::Instruction::ADD),
|
||||
byte(eth::Instruction::ADD)}));
|
||||
bytes expectation(bytes({byte(eth::Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x80));
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(negative_literals_16bits)
|
||||
{
|
||||
// -1 should need 8 bits, -129 should need 16 bits, how many bits are used is visible
|
||||
// from the SIGNEXTEND opcodes
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function f() { int64 x = int64(-1 + -129); }\n"
|
||||
" function f() { int64 x = ~0xabc; }\n"
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
|
||||
bytes expectation(bytes({byte(eth::Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x7f) +
|
||||
bytes({byte(eth::Instruction::PUSH32)}) + bytes(32, 0xff) +
|
||||
bytes({byte(eth::Instruction::PUSH1), 0x00,
|
||||
byte(eth::Instruction::SIGNEXTEND),
|
||||
byte(eth::Instruction::ADD),
|
||||
byte(eth::Instruction::PUSH1), 0x01,
|
||||
byte(eth::Instruction::SIGNEXTEND)}));
|
||||
bytes expectation(bytes({byte(eth::Instruction::PUSH32)}) + bytes(30, 0xff) + bytes{0xf5, 0x43});
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(intermediately_overflowing_literals)
|
||||
{
|
||||
// first literal itself is too large for 256 bits but it fits after all constant operations
|
||||
// have been applied
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function f() { var x = (0xffffffffffffffffffffffffffffffffffffffff * 0xffffffffffffffffffffffffff01) & 0xbf; }\n"
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode);
|
||||
|
||||
bytes expectation(bytes({byte(eth::Instruction::PUSH1), 0xbf}));
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(blockhash)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function f() {\n"
|
||||
" block.blockhash(3);\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
bytes code = compileFirstExpression(sourceCode, {}, {},
|
||||
{make_shared<MagicVariableDeclaration>("block", make_shared<MagicType>(MagicType::Kind::BLOCK))});
|
||||
|
||||
bytes expectation({byte(eth::Instruction::PUSH1), 0x03,
|
||||
byte(eth::Instruction::BLOCKHASH)});
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
|
||||
}
|
||||
|
||||
|
||||
@ -38,7 +38,7 @@ namespace test
|
||||
|
||||
namespace
|
||||
{
|
||||
void parseTextAndResolveNames(std::string const& _source)
|
||||
ASTPointer<SourceUnit> parseTextAndResolveNames(std::string const& _source)
|
||||
{
|
||||
Parser parser;
|
||||
ASTPointer<SourceUnit> sourceUnit = parser.parse(std::make_shared<Scanner>(CharStream(_source)));
|
||||
@ -50,6 +50,8 @@ void parseTextAndResolveNames(std::string const& _source)
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
resolver.checkTypeRequirements(*contract);
|
||||
|
||||
return sourceUnit;
|
||||
}
|
||||
}
|
||||
|
||||
@ -321,6 +323,173 @@ BOOST_AUTO_TEST_CASE(comparison_bitop_precedence)
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(function_canonical_signature)
|
||||
{
|
||||
ASTPointer<SourceUnit> sourceUnit;
|
||||
char const* text = "contract Test {\n"
|
||||
" function foo(uint256 arg1, uint64 arg2, bool arg3) returns (uint256 ret) {\n"
|
||||
" ret = arg1 + arg2;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(sourceUnit = parseTextAndResolveNames(text));
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
{
|
||||
auto functions = contract->getDefinedFunctions();
|
||||
BOOST_CHECK_EQUAL("foo(uint256,uint64,bool)", functions[0]->getCanonicalSignature());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(function_canonical_signature_type_aliases)
|
||||
{
|
||||
ASTPointer<SourceUnit> sourceUnit;
|
||||
char const* text = "contract Test {\n"
|
||||
" function boo(uint arg1, hash arg2, address arg3) returns (uint ret) {\n"
|
||||
" ret = 5;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(sourceUnit = parseTextAndResolveNames(text));
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
{
|
||||
auto functions = contract->getDefinedFunctions();
|
||||
BOOST_CHECK_EQUAL("boo(uint256,hash256,address)", functions[0]->getCanonicalSignature());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(hash_collision_in_interface)
|
||||
{
|
||||
char const* text = "contract test {\n"
|
||||
" function gsf() {\n"
|
||||
" }\n"
|
||||
" function tgeo() {\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(inheritance_basic)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract base { uint baseMember; struct BaseType { uint element; } }
|
||||
contract derived is base {
|
||||
BaseType data;
|
||||
function f() { baseMember = 7; }
|
||||
}
|
||||
)";
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(inheritance_diamond_basic)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract root { function rootFunction() {} }
|
||||
contract inter1 is root { function f() {} }
|
||||
contract inter2 is root { function f() {} }
|
||||
contract derived is inter1, inter2, root {
|
||||
function g() { f(); rootFunction(); }
|
||||
}
|
||||
)";
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(cyclic_inheritance)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A is B { }
|
||||
contract B is A { }
|
||||
)";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(illegal_override_direct)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract B { function f() {} }
|
||||
contract C is B { function f(uint i) {} }
|
||||
)";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(illegal_override_indirect)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A { function f(uint a) {} }
|
||||
contract B { function f() {} }
|
||||
contract C is A, B { }
|
||||
)";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(complex_inheritance)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A { function f() { uint8 x = C(0).g(); } }
|
||||
contract B { function f() {} function g() returns (uint8 r) {} }
|
||||
contract C is A, B { }
|
||||
)";
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(constructor_visibility)
|
||||
{
|
||||
// The constructor of a base class should not be visible in the derived class
|
||||
char const* text = R"(
|
||||
contract A { function A() { } }
|
||||
contract B is A { function f() { A x = A(0); } }
|
||||
)";
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(overriding_constructor)
|
||||
{
|
||||
// It is fine to "override" constructor of a base class since it is invisible
|
||||
char const* text = R"(
|
||||
contract A { function A() { } }
|
||||
contract B is A { function A() returns (uint8 r) {} }
|
||||
)";
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(missing_base_constructor_arguments)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A { function A(uint a) { } }
|
||||
contract B is A { }
|
||||
)";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(base_constructor_arguments_override)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A { function A(uint a) { } }
|
||||
contract B is A { }
|
||||
)";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(implicit_derived_to_base_conversion)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A { }
|
||||
contract B is A {
|
||||
function f() { A a = B(1); }
|
||||
}
|
||||
)";
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
BOOST_AUTO_TEST_CASE(implicit_base_to_derived_conversion)
|
||||
{
|
||||
char const* text = R"(
|
||||
contract A { }
|
||||
contract B is A {
|
||||
function f() { B b = A(1); }
|
||||
}
|
||||
)";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
|
||||
@ -45,20 +45,16 @@ public:
|
||||
{
|
||||
m_compilerStack.parse(_code);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
catch(boost::exception const& _e)
|
||||
{
|
||||
std::string const* extra = boost::get_error_info<errinfo_comment>(e);
|
||||
std::string msg = std::string("Parsing contract failed with: ") +
|
||||
e.what() + std::string("\n");
|
||||
if (extra)
|
||||
msg += *extra;
|
||||
auto msg = std::string("Parsing contract failed with: ") + boost::diagnostic_information(_e);
|
||||
BOOST_FAIL(msg);
|
||||
}
|
||||
|
||||
if (_userDocumentation)
|
||||
generatedDocumentationString = m_compilerStack.getJsonDocumentation("", DocumentationType::NATSPEC_USER);
|
||||
generatedDocumentationString = m_compilerStack.getMetadata("", DocumentationType::NATSPEC_USER);
|
||||
else
|
||||
generatedDocumentationString = m_compilerStack.getJsonDocumentation("", DocumentationType::NATSPEC_DEV);
|
||||
generatedDocumentationString = m_compilerStack.getMetadata("", DocumentationType::NATSPEC_DEV);
|
||||
Json::Value generatedDocumentation;
|
||||
m_reader.parse(generatedDocumentationString, generatedDocumentation);
|
||||
Json::Value expectedDocumentation;
|
||||
@ -84,7 +80,7 @@ BOOST_AUTO_TEST_CASE(user_basic_test)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \"notice\": \"Multiplies `a` by 7\"}"
|
||||
" \"mul(uint256)\":{ \"notice\": \"Multiplies `a` by 7\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
@ -100,7 +96,7 @@ BOOST_AUTO_TEST_CASE(dev_and_user_basic_test)
|
||||
|
||||
char const* devNatspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
@ -108,7 +104,7 @@ BOOST_AUTO_TEST_CASE(dev_and_user_basic_test)
|
||||
|
||||
char const* userNatspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \"notice\": \"Multiplies `a` by 7\"}"
|
||||
" \"mul(uint256)\":{ \"notice\": \"Multiplies `a` by 7\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, devNatspec, false);
|
||||
@ -128,7 +124,7 @@ BOOST_AUTO_TEST_CASE(user_multiline_comment)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul_and_add\":{ \"notice\": \"Multiplies `a` by 7 and then adds `b`\"}"
|
||||
" \"mul_and_add(uint256,uint256)\":{ \"notice\": \"Multiplies `a` by 7 and then adds `b`\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
@ -157,9 +153,9 @@ BOOST_AUTO_TEST_CASE(user_multiple_functions)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul_and_add\":{ \"notice\": \"Multiplies `a` by 7 and then adds `b`\"},"
|
||||
" \"divide\":{ \"notice\": \"Divides `input` by `div`\"},"
|
||||
" \"sub\":{ \"notice\": \"Subtracts 3 from `input`\"}"
|
||||
" \"mul_and_add(uint256,uint256)\":{ \"notice\": \"Multiplies `a` by 7 and then adds `b`\"},"
|
||||
" \"divide(uint256,uint256)\":{ \"notice\": \"Divides `input` by `div`\"},"
|
||||
" \"sub(int256)\":{ \"notice\": \"Subtracts 3 from `input`\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
@ -205,7 +201,7 @@ BOOST_AUTO_TEST_CASE(dev_desc_after_nl)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \" Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter\",\n"
|
||||
@ -228,7 +224,7 @@ BOOST_AUTO_TEST_CASE(dev_multiple_params)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter\",\n"
|
||||
@ -252,7 +248,7 @@ BOOST_AUTO_TEST_CASE(dev_mutiline_param_description)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
@ -289,21 +285,21 @@ BOOST_AUTO_TEST_CASE(dev_multiple_functions)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" }\n"
|
||||
" },\n"
|
||||
" \"divide\":{ \n"
|
||||
" \"divide(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Divides 2 numbers\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"input\": \"Documentation for the input parameter\",\n"
|
||||
" \"div\": \"Documentation for the div parameter\"\n"
|
||||
" }\n"
|
||||
" },\n"
|
||||
" \"sub\":{ \n"
|
||||
" \"sub(int256)\":{ \n"
|
||||
" \"details\": \"Subtracts 3 from `input`\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"input\": \"Documentation for the input parameter\"\n"
|
||||
@ -327,7 +323,7 @@ BOOST_AUTO_TEST_CASE(dev_return)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
@ -353,7 +349,7 @@ BOOST_AUTO_TEST_CASE(dev_return_desc_after_nl)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
@ -381,7 +377,7 @@ BOOST_AUTO_TEST_CASE(dev_multiline_return)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
@ -410,7 +406,7 @@ BOOST_AUTO_TEST_CASE(dev_multiline_comment)
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
@ -432,7 +428,7 @@ BOOST_AUTO_TEST_CASE(dev_contract_no_doc)
|
||||
|
||||
char const* natspec = "{"
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Mul function\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
@ -454,7 +450,7 @@ BOOST_AUTO_TEST_CASE(dev_contract_doc)
|
||||
" \"author\": \"Lefteris\","
|
||||
" \"title\": \"Just a test contract\","
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Mul function\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
@ -477,7 +473,7 @@ BOOST_AUTO_TEST_CASE(dev_author_at_function)
|
||||
" \"author\": \"Lefteris\","
|
||||
" \"title\": \"Just a test contract\","
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Mul function\",\n"
|
||||
" \"author\": \"John Doe\",\n"
|
||||
" }\n"
|
||||
@ -501,7 +497,7 @@ BOOST_AUTO_TEST_CASE(dev_title_at_function_error)
|
||||
" \"author\": \"Lefteris\","
|
||||
" \"title\": \"Just a test contract\","
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"mul(uint256,uint256)\":{ \n"
|
||||
" \"details\": \"Mul function\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
@ -510,6 +506,37 @@ BOOST_AUTO_TEST_CASE(dev_title_at_function_error)
|
||||
BOOST_CHECK_THROW(checkNatspec(sourceCode, natspec, false), DocstringParsingError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(natspec_notice_without_tag)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// I do something awesome\n"
|
||||
" function mul(uint a) returns(uint d) { return a * 7; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul(uint256)\":{ \"notice\": \"I do something awesome\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(natspec_multiline_notice_without_tag)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// I do something awesome\n"
|
||||
" /// which requires two lines to explain\n"
|
||||
" function mul(uint a) returns(uint d) { return a * 7; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul(uint256)\":{ \"notice\": \"I do something awesome which requires two lines to explain\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
|
||||
@ -48,19 +48,19 @@ public:
|
||||
m_optimize = true;
|
||||
bytes optimizedBytecode = compileAndRun(_sourceCode, _value, _contractName);
|
||||
int sizeDiff = nonOptimizedBytecode.size() - optimizedBytecode.size();
|
||||
BOOST_CHECK_MESSAGE(sizeDiff == int(_expectedSizeDecrease), "Bytecode did only shrink by "
|
||||
BOOST_CHECK_MESSAGE(sizeDiff == int(_expectedSizeDecrease), "Bytecode shrank by "
|
||||
+ boost::lexical_cast<string>(sizeDiff) + " bytes, expected: "
|
||||
+ boost::lexical_cast<string>(_expectedSizeDecrease));
|
||||
m_optimizedContract = m_contractAddress;
|
||||
}
|
||||
|
||||
template <class... Args>
|
||||
void compareVersions(byte _index, Args const&... _arguments)
|
||||
void compareVersions(std::string _sig, Args const&... _arguments)
|
||||
{
|
||||
m_contractAddress = m_nonOptimizedContract;
|
||||
bytes nonOptimizedOutput = callContractFunction(_index, _arguments...);
|
||||
bytes nonOptimizedOutput = callContractFunction(_sig, _arguments...);
|
||||
m_contractAddress = m_optimizedContract;
|
||||
bytes optimizedOutput = callContractFunction(_index, _arguments...);
|
||||
bytes optimizedOutput = callContractFunction(_sig, _arguments...);
|
||||
BOOST_CHECK_MESSAGE(nonOptimizedOutput == optimizedOutput, "Computed values do not match."
|
||||
"\nNon-Optimized: " + toHex(nonOptimizedOutput) +
|
||||
"\nOptimized: " + toHex(optimizedOutput));
|
||||
@ -81,8 +81,8 @@ BOOST_AUTO_TEST_CASE(smoke_test)
|
||||
return a;
|
||||
}
|
||||
})";
|
||||
compileBothVersions(4, sourceCode);
|
||||
compareVersions(0, u256(7));
|
||||
compileBothVersions(29, sourceCode);
|
||||
compareVersions("f(uint256)", u256(7));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(large_integers)
|
||||
@ -91,23 +91,23 @@ BOOST_AUTO_TEST_CASE(large_integers)
|
||||
contract test {
|
||||
function f() returns (uint a, uint b) {
|
||||
a = 0x234234872642837426347000000;
|
||||
b = 0x110000000000000000000000002;
|
||||
b = 0x10000000000000000000000002;
|
||||
}
|
||||
})";
|
||||
compileBothVersions(28, sourceCode);
|
||||
compareVersions(0);
|
||||
compileBothVersions(36, sourceCode);
|
||||
compareVersions("f()");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(invariants)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
function f(uint a) returns (uint b) {
|
||||
return (((a + (1 - 1)) ^ 0) | 0) & (uint(0) - 1);
|
||||
function f(int a) returns (int b) {
|
||||
return int(0) | (int(1) * (int(0) ^ (0 + a)));
|
||||
}
|
||||
})";
|
||||
compileBothVersions(28, sourceCode);
|
||||
compareVersions(0, u256(0x12334664));
|
||||
compileBothVersions(41, sourceCode);
|
||||
compareVersions("f(uint256)", u256(0x12334664));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(unused_expressions)
|
||||
@ -120,23 +120,23 @@ BOOST_AUTO_TEST_CASE(unused_expressions)
|
||||
data;
|
||||
}
|
||||
})";
|
||||
compileBothVersions(11, sourceCode);
|
||||
compareVersions(0);
|
||||
compileBothVersions(33, sourceCode);
|
||||
compareVersions("f()");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(constant_folding_both_sides)
|
||||
{
|
||||
// if constants involving the same associative and commutative operator are applied from both
|
||||
// sides, the operator should be applied only once, because the expression compiler
|
||||
// (even in non-optimized mode) pushes literals as late as possible
|
||||
// sides, the operator should be applied only once, because the expression compiler pushes
|
||||
// literals as late as possible
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
function f(uint x) returns (uint y) {
|
||||
return 98 ^ (7 * ((1 | (x | 1000)) * 40) ^ 102);
|
||||
}
|
||||
})";
|
||||
compileBothVersions(31, sourceCode);
|
||||
compareVersions(0);
|
||||
compileBothVersions(37, sourceCode);
|
||||
compareVersions("f(uint256)");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@ -495,6 +495,51 @@ BOOST_AUTO_TEST_CASE(multiple_contracts_and_imports)
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(contract_inheritance)
|
||||
{
|
||||
char const* text = "contract base {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"contract derived is base {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(contract_multiple_inheritance)
|
||||
{
|
||||
char const* text = "contract base {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"contract derived is base, nonExisting {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(contract_multiple_inheritance_with_arguments)
|
||||
{
|
||||
char const* text = "contract base {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"contract derived is base(2), nonExisting(\"abc\", \"def\", base.fun()) {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
|
||||
@ -103,14 +103,17 @@ BOOST_AUTO_TEST_CASE(negative_numbers)
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::VAR);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::IDENTIFIER);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::ASSIGN);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::SUB);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::NUMBER);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), "-.2");
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), ".2");
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::ADD);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::SUB);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::NUMBER);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), "-0x78");
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), "0x78");
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::ADD);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::SUB);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::NUMBER);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), "-7.3");
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), "7.3");
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::ADD);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::NUMBER);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLiteral(), "8.9");
|
||||
@ -130,8 +133,9 @@ BOOST_AUTO_TEST_CASE(locations)
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::SEMICOLON);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLocation().start, 24);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLocation().end, 25);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::SUB);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::NUMBER);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLocation().start, 26);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLocation().start, 27);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLocation().end, 32);
|
||||
BOOST_CHECK_EQUAL(scanner.next(), Token::IDENTIFIER);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentLocation().start, 45);
|
||||
@ -227,6 +231,13 @@ BOOST_AUTO_TEST_CASE(documentation_comment_before_eos)
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), "");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(empty_multiline_comment)
|
||||
{
|
||||
Scanner scanner(CharStream("/**/"));
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentToken(), Token::EOS);
|
||||
BOOST_CHECK_EQUAL(scanner.getCurrentCommentLiteral(), "");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(empty_multiline_documentation_comment_before_eos)
|
||||
{
|
||||
Scanner scanner(CharStream("/***/"));
|
||||
|
||||
@ -115,7 +115,7 @@ void ImportTest::importState(json_spirit::mObject& _o, State& _state)
|
||||
if (code.size())
|
||||
{
|
||||
_state.m_cache[address] = Account(toInt(o["balance"]), Account::ContractConception);
|
||||
_state.m_cache[address].setCode(bytesConstRef(&code));
|
||||
_state.m_cache[address].setCode(code);
|
||||
}
|
||||
else
|
||||
_state.m_cache[address] = Account(toInt(o["balance"]), Account::NormalCreation);
|
||||
@ -357,6 +357,19 @@ void checkLog(LogEntries _resultLogs, LogEntries _expectedLogs)
|
||||
}
|
||||
}
|
||||
|
||||
void checkCallCreates(eth::Transactions _resultCallCreates, eth::Transactions _expectedCallCreates)
|
||||
{
|
||||
BOOST_REQUIRE_EQUAL(_resultCallCreates.size(), _expectedCallCreates.size());
|
||||
|
||||
for (size_t i = 0; i < _resultCallCreates.size(); ++i)
|
||||
{
|
||||
BOOST_CHECK(_resultCallCreates[i].data() == _expectedCallCreates[i].data());
|
||||
BOOST_CHECK(_resultCallCreates[i].receiveAddress() == _expectedCallCreates[i].receiveAddress());
|
||||
BOOST_CHECK(_resultCallCreates[i].gas() == _expectedCallCreates[i].gas());
|
||||
BOOST_CHECK(_resultCallCreates[i].value() == _expectedCallCreates[i].value());
|
||||
}
|
||||
}
|
||||
|
||||
std::string getTestPath()
|
||||
{
|
||||
string testPath;
|
||||
@ -496,4 +509,12 @@ void processCommandLineOptions()
|
||||
}
|
||||
}
|
||||
|
||||
LastHashes lastHashes(u256 _currentBlockNumber)
|
||||
{
|
||||
LastHashes ret;
|
||||
for (u256 i = 1; i <= 256 && i <= _currentBlockNumber; ++i)
|
||||
ret.push_back(sha3(toString(_currentBlockNumber - i)));
|
||||
return ret;
|
||||
}
|
||||
|
||||
} } // namespaces
|
||||
|
||||
@ -74,10 +74,13 @@ json_spirit::mArray exportLog(eth::LogEntries _logs);
|
||||
void checkOutput(bytes const& _output, json_spirit::mObject& _o);
|
||||
void checkStorage(std::map<u256, u256> _expectedStore, std::map<u256, u256> _resultStore, Address _expectedAddr);
|
||||
void checkLog(eth::LogEntries _resultLogs, eth::LogEntries _expectedLogs);
|
||||
void checkCallCreates(eth::Transactions _resultCallCreates, eth::Transactions _expectedCallCreates);
|
||||
|
||||
void executeTests(const std::string& _name, const std::string& _testPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests);
|
||||
std::string getTestPath();
|
||||
void userDefinedTest(std::string testTypeFlag, std::function<void(json_spirit::mValue&, bool)> doTests);
|
||||
void processCommandLineOptions();
|
||||
eth::LastHashes lastHashes(u256 _currentBlockNumber);
|
||||
|
||||
template<typename mapType>
|
||||
void checkAddresses(mapType& _expectedAddrs, mapType& _resultAddrs)
|
||||
|
||||
@ -21,4 +21,8 @@
|
||||
*/
|
||||
|
||||
#define BOOST_TEST_MODULE EthereumTests
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#define BOOST_DISABLE_WIN32 //disables SEH warning
|
||||
#include <boost/test/included/unit_test.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
297
checkRandomTest.cpp
Normal file
297
checkRandomTest.cpp
Normal file
@ -0,0 +1,297 @@
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/** @file checkRandomTest.cpp
|
||||
* @author Christoph Jentzsch <jentzsch.simulationsoftware@gmail.com>
|
||||
* @date 2015
|
||||
* Check a random test and return 0/1 for success or failure. To be used for efficiency in the random test simulation.
|
||||
*/
|
||||
|
||||
#include <libdevcore/Common.h>
|
||||
#include <libdevcore/Exceptions.h>
|
||||
#include <libdevcore/Log.h>
|
||||
#include <libevm/VMFactory.h>
|
||||
#include "vm.h"
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
|
||||
using namespace std;
|
||||
using namespace json_spirit;
|
||||
using namespace dev::test;
|
||||
using namespace dev;
|
||||
|
||||
bool doVMTest(mValue& v);
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
g_logVerbosity = 0;
|
||||
bool ret = false;
|
||||
|
||||
try
|
||||
{
|
||||
mValue v;
|
||||
string s;
|
||||
for (int i = 1; i < argc; ++i)
|
||||
s += argv[i];
|
||||
if (asserts(s.length() > 0))
|
||||
{
|
||||
cout << "Content of argument is empty\n";
|
||||
return 1;
|
||||
}
|
||||
read_string(s, v);
|
||||
ret = doVMTest(v);
|
||||
}
|
||||
catch (Exception const& _e)
|
||||
{
|
||||
cout << "Failed test with Exception: " << diagnostic_information(_e) << endl;
|
||||
ret = false;
|
||||
}
|
||||
catch (std::exception const& _e)
|
||||
{
|
||||
cout << "Failed test with Exception: " << _e.what() << endl;
|
||||
ret = false;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool doVMTest(mValue& v)
|
||||
{
|
||||
eth::VMFactory::setKind(eth::VMKind::JIT);
|
||||
|
||||
for (auto& i: v.get_obj())
|
||||
{
|
||||
cnote << i.first;
|
||||
mObject& o = i.second.get_obj();
|
||||
|
||||
assert(o.count("env") > 0);
|
||||
assert(o.count("pre") > 0);
|
||||
assert(o.count("exec") > 0);
|
||||
|
||||
FakeExtVM fev;
|
||||
fev.importEnv(o["env"].get_obj());
|
||||
fev.importState(o["pre"].get_obj());
|
||||
|
||||
fev.importExec(o["exec"].get_obj());
|
||||
if (fev.code.empty())
|
||||
{
|
||||
fev.thisTxCode = get<3>(fev.addresses.at(fev.myAddress));
|
||||
fev.code = fev.thisTxCode;
|
||||
}
|
||||
|
||||
bytes output;
|
||||
u256 gas;
|
||||
bool vmExceptionOccured = false;
|
||||
try
|
||||
{
|
||||
auto vm = eth::VMFactory::create(fev.gas);
|
||||
output = vm->go(fev, fev.simpleTrace()).toBytes();
|
||||
gas = vm->gas();
|
||||
}
|
||||
catch (eth::VMException)
|
||||
{
|
||||
cnote << "Safe VM Exception";
|
||||
vmExceptionOccured = true;
|
||||
}
|
||||
catch (Exception const& _e)
|
||||
{
|
||||
cnote << "VM did throw an exception: " << diagnostic_information(_e);
|
||||
cnote << "Failed VM Test with Exception: " << _e.what();
|
||||
return 1;
|
||||
}
|
||||
catch (std::exception const& _e)
|
||||
{
|
||||
cnote << "VM did throw an exception: " << _e.what();
|
||||
cnote << "Failed VM Test with Exception: " << _e.what();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// delete null entries in storage for the sake of comparison
|
||||
for (auto &a: fev.addresses)
|
||||
{
|
||||
vector<u256> keystoDelete;
|
||||
for (auto &s: get<2>(a.second))
|
||||
{
|
||||
if (s.second == 0)
|
||||
keystoDelete.push_back(s.first);
|
||||
}
|
||||
for (auto const key: keystoDelete )
|
||||
{
|
||||
get<2>(a.second).erase(key);
|
||||
}
|
||||
}
|
||||
|
||||
if (o.count("post") > 0) // No exceptions expected
|
||||
{
|
||||
if (asserts(!vmExceptionOccured) || asserts(o.count("post") > 0) || asserts(o.count("callcreates") > 0) || asserts(o.count("out") > 0) || asserts(o.count("gas") > 0) || asserts(o.count("logs") > 0))
|
||||
return 1;
|
||||
|
||||
dev::test::FakeExtVM test;
|
||||
test.importState(o["post"].get_obj());
|
||||
test.importCallCreates(o["callcreates"].get_array());
|
||||
test.sub.logs = importLog(o["logs"].get_array());
|
||||
|
||||
//checkOutput(output, o);
|
||||
int j = 0;
|
||||
if (o["out"].type() == array_type)
|
||||
for (auto const& d: o["out"].get_array())
|
||||
{
|
||||
if (asserts(output[j] == toInt(d)))
|
||||
{
|
||||
cout << "Output byte [" << j << "] different!";
|
||||
return 1;
|
||||
}
|
||||
++j;
|
||||
}
|
||||
else if (o["out"].get_str().find("0x") == 0)
|
||||
{
|
||||
if (asserts(output == fromHex(o["out"].get_str().substr(2))))
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (asserts(output == fromHex(o["out"].get_str())))
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (asserts(toInt(o["gas"]) == gas))
|
||||
return 1;
|
||||
|
||||
auto& expectedAddrs = test.addresses;
|
||||
auto& resultAddrs = fev.addresses;
|
||||
for (auto&& expectedPair : expectedAddrs)
|
||||
{
|
||||
auto& expectedAddr = expectedPair.first;
|
||||
auto resultAddrIt = resultAddrs.find(expectedAddr);
|
||||
if (resultAddrIt == resultAddrs.end())
|
||||
{
|
||||
cout << "Missing expected address " << expectedAddr;
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
auto& expectedState = expectedPair.second;
|
||||
auto& resultState = resultAddrIt->second;
|
||||
if (asserts(std::get<0>(expectedState) == std::get<0>(resultState)))
|
||||
{
|
||||
cout << expectedAddr << ": incorrect balance " << std::get<0>(resultState) << ", expected " << std::get<0>(expectedState);
|
||||
return 1;
|
||||
}
|
||||
if (asserts(std::get<1>(expectedState) == std::get<1>(resultState)))
|
||||
{
|
||||
cout << expectedAddr << ": incorrect txCount " << std::get<1>(resultState) << ", expected " << std::get<1>(expectedState);
|
||||
return 1;
|
||||
}
|
||||
if (asserts(std::get<3>(expectedState) == std::get<3>(resultState)))
|
||||
{
|
||||
cout << expectedAddr << ": incorrect code";
|
||||
return 1;
|
||||
}
|
||||
|
||||
//checkStorage(std::get<2>(expectedState), std::get<2>(resultState), expectedAddr);
|
||||
for (auto&& expectedStorePair : std::get<2>(expectedState))
|
||||
{
|
||||
auto& expectedStoreKey = expectedStorePair.first;
|
||||
auto resultStoreIt = std::get<2>(resultState).find(expectedStoreKey);
|
||||
if (resultStoreIt == std::get<2>(resultState).end())
|
||||
{
|
||||
cout << expectedAddr << ": missing store key " << expectedStoreKey << endl;
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
auto& expectedStoreValue = expectedStorePair.second;
|
||||
auto& resultStoreValue = resultStoreIt->second;
|
||||
if (asserts(expectedStoreValue == resultStoreValue))
|
||||
{
|
||||
cout << expectedAddr << ": store[" << expectedStoreKey << "] = " << resultStoreValue << ", expected " << expectedStoreValue << endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (assertsEqual(std::get<2>(resultState).size(), std::get<2>(expectedState).size()))
|
||||
return 1;
|
||||
for (auto&& resultStorePair: std::get<2>(resultState))
|
||||
{
|
||||
if (!std::get<2>(expectedState).count(resultStorePair.first))
|
||||
{
|
||||
cout << expectedAddr << ": unexpected store key " << resultStorePair.first << endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//checkAddresses<std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes> > >(test.addresses, fev.addresses);
|
||||
for (auto& resultPair : fev.addresses)
|
||||
{
|
||||
auto& resultAddr = resultPair.first;
|
||||
auto expectedAddrIt = test.addresses.find(resultAddr);
|
||||
if (expectedAddrIt == test.addresses.end())
|
||||
{
|
||||
cout << "Missing result address " << resultAddr << endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if (asserts(test.addresses == fev.addresses))
|
||||
return 1;
|
||||
|
||||
if (asserts(test.callcreates == fev.callcreates))
|
||||
return 1;
|
||||
|
||||
//checkCallCreates(fev.callcreates, test.callcreates);
|
||||
{
|
||||
if (assertsEqual(test.callcreates.size(), fev.callcreates.size()))
|
||||
return 1;
|
||||
|
||||
for (size_t i = 0; i < test.callcreates.size(); ++i)
|
||||
{
|
||||
if (asserts(test.callcreates[i].data() == fev.callcreates[i].data()))
|
||||
return 1;
|
||||
if (asserts(test.callcreates[i].receiveAddress() == fev.callcreates[i].receiveAddress()))
|
||||
return 1;
|
||||
if (asserts(test.callcreates[i].gas() == fev.callcreates[i].gas()))
|
||||
return 1;
|
||||
if (asserts(test.callcreates[i].value() == fev.callcreates[i].value()))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
//checkLog(fev.sub.logs, test.sub.logs);
|
||||
{
|
||||
if (assertsEqual(fev.sub.logs.size(), test.sub.logs.size()))
|
||||
return 1;
|
||||
|
||||
for (size_t i = 0; i < fev.sub.logs.size(); ++i)
|
||||
{
|
||||
if (assertsEqual(fev.sub.logs[i].address, test.sub.logs[i].address))
|
||||
return 1;
|
||||
if (assertsEqual(fev.sub.logs[i].topics, test.sub.logs[i].topics))
|
||||
return 1;
|
||||
if (asserts(fev.sub.logs[i].data == test.sub.logs[i].data))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
else // Exception expected
|
||||
{
|
||||
if (asserts(vmExceptionOccured))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
// test passed
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -54,18 +54,26 @@ int main(int argc, char *argv[])
|
||||
gen.seed(static_cast<unsigned int>(timeSinceEpoch));
|
||||
boost::random::uniform_int_distribution<> lengthOfCodeDist(2, 16);
|
||||
boost::random::uniform_int_distribution<> opcodeDist(0, 255);
|
||||
boost::random::uniform_int_distribution<> BlockInfoOpcodeDist(0x40, 0x45);
|
||||
boost::random::variate_generator<boost::mt19937&,
|
||||
boost::random::uniform_int_distribution<> > randGen(gen, opcodeDist);
|
||||
boost::random::variate_generator<boost::mt19937&,
|
||||
boost::random::uniform_int_distribution<> > randGenBlockInfoOpcode(gen, BlockInfoOpcodeDist);
|
||||
|
||||
int lengthOfCode = lengthOfCodeDist(gen);
|
||||
string randomCode;
|
||||
|
||||
for (int i = 0; i < lengthOfCode; ++i)
|
||||
{
|
||||
uint8_t opcode = randGen();
|
||||
if (i < 8 && (randGen() < 192))
|
||||
{
|
||||
randomCode += toHex(toCompactBigEndian((uint8_t)randGenBlockInfoOpcode()));
|
||||
continue;
|
||||
}
|
||||
|
||||
// disregard all invalid commands, except of one (0x10)
|
||||
if (dev::eth::isValidInstruction(dev::eth::Instruction(opcode)) || opcode == 0x10)
|
||||
uint8_t opcode = randGen();
|
||||
// disregard all invalid commands, except of one (0x0c)
|
||||
if ((dev::eth::isValidInstruction(dev::eth::Instruction(opcode)) || (randGen() > 250)))
|
||||
randomCode += toHex(toCompactBigEndian(opcode));
|
||||
else
|
||||
i--;
|
||||
@ -76,10 +84,10 @@ int main(int argc, char *argv[])
|
||||
\"randomVMtest\": {\n\
|
||||
\"env\" : {\n\
|
||||
\"previousHash\" : \"5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6\",\n\
|
||||
\"currentNumber\" : \"0\",\n\
|
||||
\"currentNumber\" : \"300\",\n\
|
||||
\"currentGasLimit\" : \"1000000\",\n\
|
||||
\"currentDifficulty\" : \"256\",\n\
|
||||
\"currentTimestamp\" : 1,\n\
|
||||
\"currentDifficulty\" : \"115792089237316195423570985008687907853269984665640564039457584007913129639935\",\n\
|
||||
\"currentTimestamp\" : 2,\n\
|
||||
\"currentCoinbase\" : \"2adc25665018aa1fe0e6bc666dac8fc2697ff9ba\"\n\
|
||||
},\n\
|
||||
\"pre\" : {\n\
|
||||
@ -106,7 +114,7 @@ int main(int argc, char *argv[])
|
||||
read_string(s, v);
|
||||
|
||||
// insert new random code
|
||||
v.get_obj().find("randomVMtest")->second.get_obj().find("pre")->second.get_obj().begin()->second.get_obj()["code"] = "0x" + randomCode;
|
||||
v.get_obj().find("randomVMtest")->second.get_obj().find("pre")->second.get_obj().begin()->second.get_obj()["code"] = "0x" + randomCode + (randGen() > 128 ? "55" : "");
|
||||
|
||||
// execute code in vm
|
||||
doMyTests(v);
|
||||
@ -119,6 +127,8 @@ int main(int argc, char *argv[])
|
||||
|
||||
void doMyTests(json_spirit::mValue& v)
|
||||
{
|
||||
eth::VMFactory::setKind(eth::VMKind::Interpreter);
|
||||
|
||||
for (auto& i: v.get_obj())
|
||||
{
|
||||
cnote << i.first;
|
||||
|
||||
18
jsonrpc.cpp
18
jsonrpc.cpp
@ -74,6 +74,12 @@ struct Setup
|
||||
}
|
||||
};
|
||||
|
||||
string fromAscii(string _s)
|
||||
{
|
||||
bytes b = asBytes(_s);
|
||||
return "0x" + toHex(b);
|
||||
}
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(environment, Setup)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(jsonrpc_defaultBlock)
|
||||
@ -312,6 +318,18 @@ BOOST_AUTO_TEST_CASE(contract_storage)
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(sha3)
|
||||
{
|
||||
cnote << "Testing jsonrpc sha3...";
|
||||
string testString = "multiply(uint256)";
|
||||
h256 expected = dev::sha3(testString);
|
||||
|
||||
auto hexValue = fromAscii(testString);
|
||||
string result = jsonrpcClient->web3_sha3(hexValue);
|
||||
BOOST_CHECK_EQUAL(toJS(expected), result);
|
||||
BOOST_CHECK_EQUAL("0xc6888fa159d67f77c2f3d7a402e199802766bd7e8d4d1ecd2274fc920265d56a", result);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
|
||||
21
kademlia.cpp
Normal file
21
kademlia.cpp
Normal file
@ -0,0 +1,21 @@
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/** @file kademlia.cpp
|
||||
* @author Alex Leverington <nessence@gmail.com>
|
||||
* @date 2014
|
||||
*/
|
||||
|
||||
214
net.cpp
Normal file
214
net.cpp
Normal file
@ -0,0 +1,214 @@
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/** @file net.cpp
|
||||
* @author Alex Leverington <nessence@gmail.com>
|
||||
* @date 2014
|
||||
*/
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <libdevcore/Worker.h>
|
||||
#include <libdevcrypto/Common.h>
|
||||
#include <libp2p/UDP.h>
|
||||
#include <libp2p/NodeTable.h>
|
||||
using namespace std;
|
||||
using namespace dev;
|
||||
using namespace dev::p2p;
|
||||
namespace ba = boost::asio;
|
||||
namespace bi = ba::ip;
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(p2p)
|
||||
|
||||
/**
|
||||
* Only used for testing. Not useful beyond tests.
|
||||
*/
|
||||
class TestHost: public Worker
|
||||
{
|
||||
public:
|
||||
TestHost(): Worker("test",0), m_io() {};
|
||||
virtual ~TestHost() { m_io.stop(); stopWorking(); }
|
||||
void start() { startWorking(); }
|
||||
void doWork() { m_io.run(); }
|
||||
void doneWorking() { m_io.reset(); m_io.poll(); m_io.reset(); }
|
||||
|
||||
protected:
|
||||
ba::io_service m_io;
|
||||
};
|
||||
|
||||
struct TestNodeTable: public NodeTable
|
||||
{
|
||||
/// Constructor
|
||||
TestNodeTable(ba::io_service& _io, KeyPair _alias, uint16_t _port = 30300): NodeTable(_io, _alias, _port) {}
|
||||
|
||||
static std::vector<std::pair<KeyPair,unsigned>> createTestNodes(unsigned _count)
|
||||
{
|
||||
std::vector<std::pair<KeyPair,unsigned>> ret;
|
||||
asserts(_count < 1000);
|
||||
static uint16_t s_basePort = 30500;
|
||||
|
||||
ret.clear();
|
||||
for (unsigned i = 0; i < _count; i++)
|
||||
{
|
||||
KeyPair k = KeyPair::create();
|
||||
ret.push_back(make_pair(k,s_basePort+i));
|
||||
}
|
||||
|
||||
return std::move(ret);
|
||||
}
|
||||
|
||||
void pingTestNodes(std::vector<std::pair<KeyPair,unsigned>> const& _testNodes)
|
||||
{
|
||||
bi::address ourIp = bi::address::from_string("127.0.0.1");
|
||||
for (auto& n: _testNodes)
|
||||
{
|
||||
ping(bi::udp::endpoint(ourIp, n.second));
|
||||
this_thread::sleep_for(chrono::milliseconds(2));
|
||||
}
|
||||
}
|
||||
|
||||
void populateTestNodes(std::vector<std::pair<KeyPair,unsigned>> const& _testNodes, size_t _count = 0)
|
||||
{
|
||||
if (!_count)
|
||||
_count = _testNodes.size();
|
||||
|
||||
bi::address ourIp = bi::address::from_string("127.0.0.1");
|
||||
for (auto& n: _testNodes)
|
||||
if (_count--)
|
||||
noteNode(n.first.pub(), bi::udp::endpoint(ourIp, n.second));
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
Guard l(x_state);
|
||||
for (auto& n: m_state) n.nodes.clear();
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Only used for testing. Not useful beyond tests.
|
||||
*/
|
||||
struct TestNodeTableHost: public TestHost
|
||||
{
|
||||
TestNodeTableHost(unsigned _count = 8): m_alias(KeyPair::create()), nodeTable(new TestNodeTable(m_io, m_alias)), testNodes(TestNodeTable::createTestNodes(_count)) {};
|
||||
~TestNodeTableHost() { m_io.stop(); stopWorking(); }
|
||||
|
||||
void setup() { for (auto n: testNodes) nodeTables.push_back(make_shared<TestNodeTable>(m_io,n.first,n.second)); }
|
||||
|
||||
void pingAll() { for (auto& t: nodeTables) t->pingTestNodes(testNodes); }
|
||||
|
||||
void populateAll(size_t _count = 0) { for (auto& t: nodeTables) t->populateTestNodes(testNodes, _count); }
|
||||
|
||||
void populate(size_t _count = 0) { nodeTable->populateTestNodes(testNodes, _count); }
|
||||
|
||||
KeyPair m_alias;
|
||||
shared_ptr<TestNodeTable> nodeTable;
|
||||
std::vector<std::pair<KeyPair,unsigned>> testNodes; // keypair and port
|
||||
std::vector<shared_ptr<TestNodeTable>> nodeTables;
|
||||
};
|
||||
|
||||
class TestUDPSocket: UDPSocketEvents, public TestHost
|
||||
{
|
||||
public:
|
||||
TestUDPSocket(): m_socket(new UDPSocket<TestUDPSocket, 1024>(m_io, *this, 30300)) {}
|
||||
|
||||
void onDisconnected(UDPSocketFace*) {};
|
||||
void onReceived(UDPSocketFace*, bi::udp::endpoint const&, bytesConstRef _packet) { if (_packet.toString() == "AAAA") success = true; }
|
||||
|
||||
shared_ptr<UDPSocket<TestUDPSocket, 1024>> m_socket;
|
||||
|
||||
bool success = false;
|
||||
};
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_neighbours_packet)
|
||||
{
|
||||
KeyPair k = KeyPair::create();
|
||||
std::vector<std::pair<KeyPair,unsigned>> testNodes(TestNodeTable::createTestNodes(16));
|
||||
bi::udp::endpoint to(boost::asio::ip::address::from_string("127.0.0.1"), 30000);
|
||||
|
||||
Neighbours out(to);
|
||||
for (auto n: testNodes)
|
||||
{
|
||||
Neighbours::Node node;
|
||||
node.ipAddress = boost::asio::ip::address::from_string("127.0.0.1").to_string();
|
||||
node.port = n.second;
|
||||
node.node = n.first.pub();
|
||||
out.nodes.push_back(node);
|
||||
}
|
||||
out.sign(k.sec());
|
||||
|
||||
bytesConstRef packet(out.data.data(), out.data.size());
|
||||
bytesConstRef rlpBytes(packet.cropped(97, packet.size() - 97));
|
||||
Neighbours in = Neighbours::fromBytesConstRef(to, rlpBytes);
|
||||
int count = 0;
|
||||
for (auto n: in.nodes)
|
||||
{
|
||||
BOOST_REQUIRE_EQUAL(testNodes[count].second, n.port);
|
||||
BOOST_REQUIRE_EQUAL(testNodes[count].first.pub(), n.node);
|
||||
BOOST_REQUIRE_EQUAL(sha3(testNodes[count].first.pub()), sha3(n.node));
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_findnode_neighbours)
|
||||
{
|
||||
// Executing findNode should result in a list which is serialized
|
||||
// into Neighbours packet. Neighbours packet should then be deserialized
|
||||
// into the same list of nearest nodes.
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_windows_template)
|
||||
{
|
||||
bi::udp::endpoint ep;
|
||||
PingNode p(ep);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(kademlia)
|
||||
{
|
||||
// Not yet a 'real' test.
|
||||
TestNodeTableHost node(8);
|
||||
node.start();
|
||||
node.nodeTable->join(); // ideally, joining with empty node table logs warning we can check for
|
||||
node.setup();
|
||||
node.populate();
|
||||
clog << "NodeTable:\n" << *node.nodeTable.get() << endl;
|
||||
|
||||
node.populateAll();
|
||||
clog << "NodeTable:\n" << *node.nodeTable.get() << endl;
|
||||
|
||||
node.nodeTable->reset();
|
||||
clog << "NodeTable:\n" << *node.nodeTable.get() << endl;
|
||||
|
||||
node.populate(1);
|
||||
clog << "NodeTable:\n" << *node.nodeTable.get() << endl;
|
||||
|
||||
node.nodeTable->join();
|
||||
this_thread::sleep_for(chrono::milliseconds(2000));
|
||||
clog << "NodeTable:\n" << *node.nodeTable.get() << endl;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_udp_once)
|
||||
{
|
||||
UDPDatagram d(bi::udp::endpoint(boost::asio::ip::address::from_string("127.0.0.1"), 30300), bytes({65,65,65,65}));
|
||||
TestUDPSocket a; a.m_socket->connect(); a.start();
|
||||
a.m_socket->send(d);
|
||||
this_thread::sleep_for(chrono::seconds(1));
|
||||
BOOST_REQUIRE_EQUAL(true, a.success);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
55
network.cpp
55
network.cpp
@ -1,55 +0,0 @@
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/** @file network.cpp
|
||||
* @author Marko Simovic <markobarko@gmail.com>
|
||||
* @date 2014
|
||||
* Basic networking tests
|
||||
*/
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/filesystem/operations.hpp>
|
||||
#include <libethereum/Client.h>
|
||||
#include <libethereum/BlockChain.h>
|
||||
#include <libethereum/EthereumHost.h>
|
||||
#include "TestHelper.h"
|
||||
using namespace std;
|
||||
using namespace dev;
|
||||
using namespace dev::eth;
|
||||
|
||||
// Disabled since tests shouldn't block (not the worst offender, but timeout should be reduced anyway).
|
||||
/*
|
||||
BOOST_AUTO_TEST_CASE(listen_port_busy)
|
||||
{
|
||||
short port = 20000;
|
||||
|
||||
//make use of the port ahead of our client
|
||||
ba::io_service ioService;
|
||||
bi::tcp::endpoint endPoint(bi::tcp::v4(), port);
|
||||
bi::tcp::acceptor acceptor(ioService, endPoint);
|
||||
acceptor.listen(10);
|
||||
|
||||
//prepare client and try to listen on same, used, port
|
||||
Client c1("TestClient1", KeyPair::create().address(),
|
||||
(boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string());
|
||||
|
||||
c1.startNetwork(port);
|
||||
|
||||
BOOST_REQUIRE(c1.haveNetwork());
|
||||
BOOST_REQUIRE(c1.peerServer()->listenPort() != 0);
|
||||
BOOST_REQUIRE(c1.peerServer()->listenPort() != port);
|
||||
}
|
||||
*/
|
||||
@ -32,9 +32,6 @@
|
||||
|
||||
namespace dev
|
||||
{
|
||||
/// Provides additional overloads for toBigEndian to encode arguments and return values.
|
||||
inline bytes toBigEndian(byte _value) { return bytes({_value}); }
|
||||
inline bytes toBigEndian(bool _value) { return bytes({byte(_value)}); }
|
||||
|
||||
namespace solidity
|
||||
{
|
||||
@ -49,57 +46,85 @@ public:
|
||||
bytes const& compileAndRun(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "")
|
||||
{
|
||||
dev::solidity::CompilerStack compiler;
|
||||
try
|
||||
{
|
||||
compiler.compile(_sourceCode, m_optimize);
|
||||
}
|
||||
catch(boost::exception const& _e)
|
||||
{
|
||||
auto msg = std::string("Compiling contract failed with: ") + boost::diagnostic_information(_e);
|
||||
BOOST_FAIL(msg);
|
||||
}
|
||||
|
||||
bytes code = compiler.getBytecode(_contractName);
|
||||
sendMessage(code, true, _value);
|
||||
BOOST_REQUIRE(!m_output.empty());
|
||||
return m_output;
|
||||
}
|
||||
|
||||
bytes const& callContractFunction(byte _index, bytes const& _data = bytes(), u256 const& _value = 0)
|
||||
template <class... Args>
|
||||
bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value,
|
||||
Args const&... _arguments)
|
||||
{
|
||||
sendMessage(bytes(1, _index) + _data, false, _value);
|
||||
|
||||
FixedHash<4> hash(dev::sha3(_sig));
|
||||
sendMessage(hash.asBytes() + encodeArgs(_arguments...), false, _value);
|
||||
return m_output;
|
||||
}
|
||||
|
||||
template <class... Args>
|
||||
bytes const& callContractFunction(byte _index, Args const&... _arguments)
|
||||
bytes const& callContractFunction(std::string _sig, Args const&... _arguments)
|
||||
{
|
||||
return callContractFunction(_index, argsToBigEndian(_arguments...));
|
||||
return callContractFunctionWithValue(_sig, 0, _arguments...);
|
||||
}
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
void testSolidityAgainstCpp(byte _index, CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
void testSolidityAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
{
|
||||
bytes solidityResult = callContractFunction(_index, _arguments...);
|
||||
bytes solidityResult = callContractFunction(_sig, _arguments...);
|
||||
bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...);
|
||||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match."
|
||||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult));
|
||||
}
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
void testSolidityAgainstCppOnRange(byte _index, CppFunction const& _cppFunction,
|
||||
void testSolidityAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction,
|
||||
u256 const& _rangeStart, u256 const& _rangeEnd)
|
||||
{
|
||||
for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument)
|
||||
{
|
||||
bytes solidityResult = callContractFunction(_index, argument);
|
||||
bytes solidityResult = callContractFunction(_sig, argument);
|
||||
bytes cppResult = callCppAndEncodeResult(_cppFunction, argument);
|
||||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match."
|
||||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult) +
|
||||
"\nArgument: " + toHex(toBigEndian(argument)));
|
||||
"\nArgument: " + toHex(encode(argument)));
|
||||
}
|
||||
}
|
||||
|
||||
static bytes encode(bool _value) { return encode(byte(_value)); }
|
||||
static bytes encode(int _value) { return encode(u256(_value)); }
|
||||
static bytes encode(char const* _value) { return encode(std::string(_value)); }
|
||||
static bytes encode(byte _value) { return bytes(31, 0) + bytes{_value}; }
|
||||
static bytes encode(u256 const& _value) { return toBigEndian(_value); }
|
||||
static bytes encode(h256 const& _value) { return _value.asBytes(); }
|
||||
static bytes encode(bytes const& _value, bool _padLeft = true)
|
||||
{
|
||||
bytes padding = bytes((32 - _value.size() % 32) % 32, 0);
|
||||
return _padLeft ? padding + _value : _value + padding;
|
||||
}
|
||||
static bytes encode(std::string const& _value) { return encode(asBytes(_value), false); }
|
||||
|
||||
template <class FirstArg, class... Args>
|
||||
static bytes encodeArgs(FirstArg const& _firstArg, Args const&... _followingArgs)
|
||||
{
|
||||
return encode(_firstArg) + encodeArgs(_followingArgs...);
|
||||
}
|
||||
static bytes encodeArgs()
|
||||
{
|
||||
return bytes();
|
||||
}
|
||||
|
||||
private:
|
||||
template <class FirstArg, class... Args>
|
||||
bytes argsToBigEndian(FirstArg const& _firstArg, Args const&... _followingArgs) const
|
||||
{
|
||||
return toBigEndian(_firstArg) + argsToBigEndian(_followingArgs...);
|
||||
}
|
||||
|
||||
bytes argsToBigEndian() const { return bytes(); }
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
-> typename std::enable_if<std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
|
||||
@ -111,7 +136,7 @@ private:
|
||||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
-> typename std::enable_if<!std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
|
||||
{
|
||||
return toBigEndian(_cppFunction(_arguments...));
|
||||
return encode(_cppFunction(_arguments...));
|
||||
}
|
||||
|
||||
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
|
||||
@ -143,6 +168,7 @@ private:
|
||||
m_state.noteSending(m_sender);
|
||||
executive.finalize();
|
||||
m_output = executive.out().toVector();
|
||||
m_logs = executive.logs();
|
||||
}
|
||||
|
||||
protected:
|
||||
@ -153,6 +179,7 @@ protected:
|
||||
u256 const m_gasPrice = 100 * eth::szabo;
|
||||
u256 const m_gas = 1000000;
|
||||
bytes m_output;
|
||||
eth::LogEntries m_logs;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
103
stBlockHashTestFiller.json
Normal file
103
stBlockHashTestFiller.json
Normal file
@ -0,0 +1,103 @@
|
||||
{
|
||||
"blockhash0" : {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "5",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 0) [[ 1 ]] (BLOCKHASH 5) [[ 2 ]] (BLOCKHASH 4) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "100000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "8500",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "10",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"blockhashOutOfRange" : {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "257",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 0) [[ 1 ]] (BLOCKHASH 257) [[ 2 ]] (BLOCKHASH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "100000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "8500",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "10",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"blockhashInRange" : {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "257",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 1) [[ 1 ]] (BLOCKHASH 2) [[ 2 ]] (BLOCKHASH 256) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "100000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "8500",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "10",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -12,7 +12,144 @@
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f30060003554156009570060203560003555) [[ 0 ]] (CREATE 23 4 28) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 3 29) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"createNameRegistratorOOG_MemExpansionInsufficientBalance": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "10000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 11000 3 0xffffffffffffffffffffff) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"createNameRegistratorZeroMem": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 3 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"createNameRegistratorZeroMem2": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
"createNameRegistratorZeroMemExpansion": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 0 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
@ -46,7 +183,7 @@
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f30060003554156009570060203560003555) [[ 0 ]] (CREATE 1000 4 28) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 1000 3 29) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
@ -80,7 +217,7 @@
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f30060003554156009570060203560003555) [[ 0 ]] (CREATE 23 0xfffffffffff 28) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 0xfffffffffff 29) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
@ -114,7 +251,41 @@
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f30060003554156009570060203560003555) [[ 0 ]] (CREATE 23 4 0xfffffffffff) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 3 0xfffffffffff) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"balanceInputAddressTooBig": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BALANCE 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0baa ) }",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
@ -153,7 +324,175 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallToNameRegistratorMemOOGAndInsufficientBalance": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALL 0xffffffffff 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 0xffffffffffff 64 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallToNameRegistratorAddressTooBigLeft": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALL 1000 0xaa945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 64 64 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallToNameRegistratorAddressTooBigRight": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5aa 23 0 64 64 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallToNameRegistratorZeorSizeMemExpansion": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 0 0 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -190,12 +529,12 @@
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 64 0 2) }",
|
||||
"code" : "{ [[ 0 ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 0 31 1) [[ 1 ]] @0 }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6001600155603760005360026000f3",
|
||||
"code" : "0x6001600155602a601f536001601ff3",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -206,7 +545,88 @@
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallToReturn1ForDynamicJump0": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "0x6001601f60006000601773945304eb96065b2a98b57a48a06ae28d285a71b56103e8f1600055600051565b6023602355",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6001600155602a601f536001601ff3",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "10000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallToReturn1ForDynamicJump1": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "0x6001601f60006000601773945304eb96065b2a98b57a48a06ae28d285a71b56103e8f160005560005156605b6023602355",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6001600155602b601f536001601ff3",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
@ -364,7 +784,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -406,7 +826,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -447,7 +867,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -488,7 +908,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -530,7 +950,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -571,7 +991,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -714,6 +1134,40 @@
|
||||
}
|
||||
},
|
||||
|
||||
"CallRecursiveBomb0_OOG_atMaxCallDepth": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "20000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (+ (SLOAD 0) 1) [[ 2 ]] (MUL (DIV @@0 0x0402) 0xfffffffffffffffffff) [[ 1 ]] (CALL (- (GAS) 1024) (ADDRESS) 0 0 (MUL (DIV @@0 0x0402) 0xfffffffffffffffffff) 0 0) } ",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallRecursiveBomb1": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
@ -740,7 +1194,7 @@
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "365223",
|
||||
"gasLimit" : "365243",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
@ -774,7 +1228,7 @@
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "365224",
|
||||
"gasLimit" : "365244",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
@ -850,6 +1304,74 @@
|
||||
}
|
||||
},
|
||||
|
||||
"suicideCallerAddresTooBigLeft": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[0]] (CALLER) (SUICIDE 0xaaa94f5374fce5edbc8e2a8697c15331677e6ebf0b)}",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"suicideCallerAddresTooBigRight": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[0]] (CALLER) (SUICIDE 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0baa)}",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"suicideOrigin": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
@ -1109,7 +1631,130 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"callcodeToNameRegistratorAddresTooBigLeft": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALLCODE 1000 0xaa945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 64 64 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"callcodeToNameRegistratorAddresTooBigRight": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALLCODE 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5aa 23 0 64 64 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"callcodeToNameRegistratorZeroMemExpanion": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa ) [[ 0 ]] (CALLCODE 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 0 0 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -1145,7 +1790,7 @@
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "0x60003554156009570060203560003555",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
|
||||
@ -39,8 +39,6 @@ using namespace dev::eth;
|
||||
|
||||
namespace dev { namespace test {
|
||||
|
||||
|
||||
|
||||
void doStateTests(json_spirit::mValue& v, bool _fillin)
|
||||
{
|
||||
processCommandLineOptions();
|
||||
@ -62,7 +60,7 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
|
||||
|
||||
try
|
||||
{
|
||||
theState.execute(LastHashes(), tx, &output);
|
||||
theState.execute(lastHashes(importer.m_environment.currentBlock.number), tx, &output);
|
||||
}
|
||||
catch (Exception const& _e)
|
||||
{
|
||||
@ -157,6 +155,11 @@ BOOST_AUTO_TEST_CASE(stRefundTest)
|
||||
dev::test::executeTests("stRefundTest", "/StateTests", dev::test::doStateTests);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(stBlockHashTest)
|
||||
{
|
||||
dev::test::executeTests("stBlockHashTest", "/StateTests", dev::test::doStateTests);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(stCreateTest)
|
||||
{
|
||||
for (int i = 1; i < boost::unit_test::framework::master_test_suite().argc; ++i)
|
||||
|
||||
65
trie.cpp
65
trie.cpp
@ -50,7 +50,7 @@ static unsigned fac(unsigned _i)
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(TrieTests)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(trie_tests)
|
||||
BOOST_AUTO_TEST_CASE(trie_test_anyorder)
|
||||
{
|
||||
string testPath = test::getTestPath();
|
||||
|
||||
@ -92,6 +92,69 @@ BOOST_AUTO_TEST_CASE(trie_tests)
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(trie_tests_ordered)
|
||||
{
|
||||
string testPath = test::getTestPath();
|
||||
|
||||
testPath += "/TrieTests";
|
||||
|
||||
cnote << "Testing Trie...";
|
||||
js::mValue v;
|
||||
string s = asString(contents(testPath + "/trietest.json"));
|
||||
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'trietest.json' is empty. Have you cloned the 'tests' repo branch develop?");
|
||||
js::read_string(s, v);
|
||||
|
||||
for (auto& i: v.get_obj())
|
||||
{
|
||||
cnote << i.first;
|
||||
js::mObject& o = i.second.get_obj();
|
||||
vector<pair<string, string>> ss;
|
||||
vector<string> keysToBeDeleted;
|
||||
for (auto& i: o["in"].get_array())
|
||||
{
|
||||
vector<string> values;
|
||||
for (auto& s: i.get_array())
|
||||
{
|
||||
if (s.type() == json_spirit::str_type)
|
||||
values.push_back(s.get_str());
|
||||
else if (s.type() == json_spirit::null_type)
|
||||
{
|
||||
// mark entry for deletion
|
||||
values.push_back("");
|
||||
if (!values[0].find("0x"))
|
||||
values[0] = asString(fromHex(values[0].substr(2)));
|
||||
keysToBeDeleted.push_back(values[0]);
|
||||
}
|
||||
else
|
||||
BOOST_FAIL("Bad type (expected string)");
|
||||
}
|
||||
|
||||
BOOST_REQUIRE(values.size() == 2);
|
||||
ss.push_back(make_pair(values[0], values[1]));
|
||||
if (!ss.back().first.find("0x"))
|
||||
ss.back().first = asString(fromHex(ss.back().first.substr(2)));
|
||||
if (!ss.back().second.find("0x"))
|
||||
ss.back().second = asString(fromHex(ss.back().second.substr(2)));
|
||||
}
|
||||
|
||||
MemoryDB m;
|
||||
GenericTrieDB<MemoryDB> t(&m);
|
||||
t.init();
|
||||
BOOST_REQUIRE(t.check(true));
|
||||
for (auto const& k: ss)
|
||||
{
|
||||
if (find(keysToBeDeleted.begin(), keysToBeDeleted.end(), k.first) != keysToBeDeleted.end() && k.second.empty())
|
||||
t.remove(k.first);
|
||||
else
|
||||
t.insert(k.first, k.second);
|
||||
BOOST_REQUIRE(t.check(true));
|
||||
}
|
||||
|
||||
BOOST_REQUIRE(!o["root"].is_null());
|
||||
BOOST_CHECK_EQUAL(o["root"].get_str(), "0x" + toHex(t.root().asArray()));
|
||||
}
|
||||
}
|
||||
|
||||
inline h256 stringMapHash256(StringMap const& _s)
|
||||
{
|
||||
return hash256(_s);
|
||||
|
||||
37
vm.cpp
37
vm.cpp
@ -33,7 +33,7 @@ using namespace dev::eth;
|
||||
using namespace dev::test;
|
||||
|
||||
FakeExtVM::FakeExtVM(eth::BlockInfo const& _previousBlock, eth::BlockInfo const& _currentBlock, unsigned _depth): /// TODO: XXX: remove the default argument & fix.
|
||||
ExtVMFace(Address(), Address(), Address(), 0, 1, bytesConstRef(), bytes(), _previousBlock, _currentBlock, LastHashes(), _depth) {}
|
||||
ExtVMFace(Address(), Address(), Address(), 0, 1, bytesConstRef(), bytes(), _previousBlock, _currentBlock, test::lastHashes(_currentBlock.number), _depth) {}
|
||||
|
||||
h160 FakeExtVM::create(u256 _endowment, u256& io_gas, bytesConstRef _init, OnOpFunc const&)
|
||||
{
|
||||
@ -117,6 +117,7 @@ void FakeExtVM::importEnv(mObject& _o)
|
||||
|
||||
previousBlock.hash = h256(_o["previousHash"].get_str());
|
||||
currentBlock.number = toInt(_o["currentNumber"]);
|
||||
lastHashes = test::lastHashes(currentBlock.number);
|
||||
currentBlock.gasLimit = toInt(_o["currentGasLimit"]);
|
||||
currentBlock.difficulty = toInt(_o["currentDifficulty"]);
|
||||
currentBlock.timestamp = toInt(_o["currentTimestamp"]);
|
||||
@ -231,13 +232,13 @@ void FakeExtVM::importCallCreates(mArray& _callcreates)
|
||||
for (mValue& v: _callcreates)
|
||||
{
|
||||
auto tx = v.get_obj();
|
||||
BOOST_REQUIRE(tx.count("data") > 0);
|
||||
BOOST_REQUIRE(tx.count("value") > 0);
|
||||
BOOST_REQUIRE(tx.count("destination") > 0);
|
||||
BOOST_REQUIRE(tx.count("gasLimit") > 0);
|
||||
assert(tx.count("data") > 0);
|
||||
assert(tx.count("value") > 0);
|
||||
assert(tx.count("destination") > 0);
|
||||
assert(tx.count("gasLimit") > 0);
|
||||
Transaction t = tx["destination"].get_str().empty() ?
|
||||
Transaction(toInt(tx["value"]), 0, toInt(tx["gasLimit"]), data.toBytes()) :
|
||||
Transaction(toInt(tx["value"]), 0, toInt(tx["gasLimit"]), Address(tx["destination"].get_str()), data.toBytes());
|
||||
Transaction(toInt(tx["value"]), 0, toInt(tx["gasLimit"]), fromHex(tx["data"].get_str())) :
|
||||
Transaction(toInt(tx["value"]), 0, toInt(tx["gasLimit"]), Address(tx["destination"].get_str()), fromHex(tx["data"].get_str()));
|
||||
callcreates.push_back(t);
|
||||
}
|
||||
}
|
||||
@ -344,7 +345,7 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
|
||||
output = vm->go(fev, fev.simpleTrace()).toBytes();
|
||||
gas = vm->gas();
|
||||
}
|
||||
catch (VMException const& _e)
|
||||
catch (VMException const&)
|
||||
{
|
||||
cnote << "Safe VM Exception";
|
||||
vmExceptionOccured = true;
|
||||
@ -447,7 +448,8 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
|
||||
}
|
||||
|
||||
checkAddresses<std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes> > >(test.addresses, fev.addresses);
|
||||
BOOST_CHECK(test.callcreates == fev.callcreates);
|
||||
|
||||
checkCallCreates(fev.callcreates, test.callcreates);
|
||||
|
||||
checkLog(fev.sub.logs, test.sub.logs);
|
||||
}
|
||||
@ -506,23 +508,28 @@ BOOST_AUTO_TEST_CASE(vmLogTest)
|
||||
dev::test::executeTests("vmLogTest", "/VMTests", dev::test::doVMTests);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(vmPerformanceTest)
|
||||
BOOST_AUTO_TEST_CASE(vmSystemOperationsTest)
|
||||
{
|
||||
dev::test::executeTests("vmSystemOperationsTest", "/VMTests", dev::test::doVMTests);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(vmInputLimitsTest1)
|
||||
{
|
||||
for (int i = 1; i < boost::unit_test::framework::master_test_suite().argc; ++i)
|
||||
{
|
||||
string arg = boost::unit_test::framework::master_test_suite().argv[i];
|
||||
if (arg == "--performance")
|
||||
dev::test::executeTests("vmPerformanceTest", "/VMTests", dev::test::doVMTests);
|
||||
if (arg == "--inputlimits")
|
||||
dev::test::executeTests("vmInputLimitsTest1", "/VMTests", dev::test::doVMTests);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(vmArithPerformanceTest)
|
||||
BOOST_AUTO_TEST_CASE(vmInputLimitsTest2)
|
||||
{
|
||||
for (int i = 1; i < boost::unit_test::framework::master_test_suite().argc; ++i)
|
||||
{
|
||||
string arg = boost::unit_test::framework::master_test_suite().argv[i];
|
||||
if (arg == "--performance")
|
||||
dev::test::executeTests("vmArithPerformanceTest", "/VMTests", dev::test::doVMTests);
|
||||
if (arg == "--inputlimits")
|
||||
dev::test::executeTests("vmInputLimitsTest2", "/VMTests", dev::test::doVMTests);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,8 +1,8 @@
|
||||
{
|
||||
"prevhash": {
|
||||
"blockhashNotExistingBlock": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentNumber" : "1",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
@ -12,7 +12,147 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (PREVHASH) }",
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 2) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "100000000000000",
|
||||
"gas" : "10000"
|
||||
}
|
||||
},
|
||||
|
||||
"blockhashMyBlock": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "1",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 1) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "100000000000000",
|
||||
"gas" : "10000"
|
||||
}
|
||||
},
|
||||
|
||||
"blockhash258Block": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "258",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 1) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "100000000000000",
|
||||
"gas" : "10000"
|
||||
}
|
||||
},
|
||||
|
||||
"blockhash257Block": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "257",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 0) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "100000000000000",
|
||||
"gas" : "10000"
|
||||
}
|
||||
},
|
||||
|
||||
"blockhashInRange": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "257",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 1) [[ 1 ]] (BLOCKHASH 2) [[ 2 ]] (BLOCKHASH 256) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "100000000000000",
|
||||
"gas" : "10000"
|
||||
}
|
||||
},
|
||||
|
||||
"blockhashOutOfRange": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "257",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BLOCKHASH 0) [[ 1 ]] (BLOCKHASH 257) [[ 2 ]] (BLOCKHASH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
|
||||
@ -83,6 +83,91 @@
|
||||
}
|
||||
},
|
||||
|
||||
"balanceAddressInputTooBig": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BALANCE 0xcd1722f3947def4cf144679da39c4c32bdc35681aa )}",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"balanceAddressInputTooBigRightMyAddress": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BALANCE 0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6aa )}",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"balanceAddressInputTooBigLeftMyAddress": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (BALANCE 0xaa0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6 )}",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
"balance1": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
@ -478,6 +563,34 @@
|
||||
}
|
||||
},
|
||||
|
||||
"calldatacopyZeroMemExpansion": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (CALLDATACOPY 0 0 0 ) [[ 0 ]] @0}",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "0x1234567890abcdef01234567890abcdef",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"calldatacopy_DataIndexTooHigh": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
@ -674,7 +787,7 @@
|
||||
}
|
||||
},
|
||||
|
||||
"codecopy1": {
|
||||
"codecopy0": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
@ -687,7 +800,35 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (CODECOPY 0 0 (CODESIZE) ) [[ 0 ]] @0 }",
|
||||
"code" : "{ (CODECOPY 0 0 5 ) [[ 0 ]] @0 }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "0x1234567890abcdef01234567890abcdef",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"codecopyZeroMemExpansion": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (CODECOPY 0 0 0 ) [[ 0 ]] @0 }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
@ -730,6 +871,63 @@
|
||||
}
|
||||
},
|
||||
|
||||
"ExtCodeSizeAddressInputTooBigRightMyAddress": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (EXTCODESIZE 0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6aa )}",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"ExtCodeSizeAddressInputTooBigLeftMyAddress": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] (EXTCODESIZE 0xaa0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6 )}",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "1000000000",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
"extcodesize0": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
@ -825,6 +1023,40 @@
|
||||
}
|
||||
},
|
||||
|
||||
"extcodecopyZeroMemExpansion": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (EXTCODECOPY (CALLER) 0 0 0 ) ) [[ 0 ]] @0 }",
|
||||
"storage": {}
|
||||
},
|
||||
"cd1722f3947def4cf144679da39c4c32bdc35681" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] 5 }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "0x1234567890abcdef01234567890abcdef",
|
||||
"gasPrice" : "123456789",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
"extcodecopy0": {
|
||||
"env" : {
|
||||
@ -858,6 +1090,74 @@
|
||||
"gasPrice" : "123456789",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"extcodecopy0AddressTooBigLeft": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (EXTCODECOPY 0xaacd1722f3947def4cf144679da39c4c32bdc35681 0 0 (EXTCODESIZE (CALLER) ) ) [[ 0 ]] @0 }",
|
||||
"storage": {}
|
||||
},
|
||||
"cd1722f3947def4cf144679da39c4c32bdc35681" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] 5 }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "0x1234567890abcdef01234567890abcdef",
|
||||
"gasPrice" : "123456789",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
},
|
||||
|
||||
"extcodecopy0AddressTooBigRight": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (EXTCODECOPY 0xcd1722f3947def4cf144679da39c4c32bdc35681aa 0 0 (EXTCODESIZE (CALLER) ) ) [[ 0 ]] @0 }",
|
||||
"storage": {}
|
||||
},
|
||||
"cd1722f3947def4cf144679da39c4c32bdc35681" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ [[ 0 ]] 5 }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "0x1234567890abcdef01234567890abcdef",
|
||||
"gasPrice" : "123456789",
|
||||
"gas" : "100000000000"
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -12,7 +12,7 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f200600035560f6009590060203560003557) [[ 0 ]] (CREATE 23 4 28) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 3 29) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
@ -40,7 +40,7 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "100",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f200600035560f6009590060203560003557) [[ 0 ]] (CREATE 230 4 28) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 230 3 29) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
@ -68,7 +68,7 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "100",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f200600035560f6009590060203560003557) [[ 0 ]] (CREATE 23 0xfffffffffff 28) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 0xfffffffffff 29) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
@ -96,7 +96,7 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "100",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f200600035560f6009590060203560003557) [[ 0 ]] (CREATE 23 4 0xffffffff) }",
|
||||
"code" : "{ (MSTORE 0 0x601080600c6000396000f3006000355415600957005b60203560003555) [[ 0 ]] (CREATE 23 3 0xffffffff) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
@ -129,7 +129,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -147,6 +147,36 @@
|
||||
}
|
||||
},
|
||||
|
||||
"CallToPrecompiledContract" : {
|
||||
"env" : {
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
|
||||
"currentDifficulty" : "115792089237316195423570985008687907853269984665640564039457584007913129639935",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentNumber" : "0",
|
||||
"currentTimestamp" : "2",
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"code" : "0x4243434242434243f14555",
|
||||
"data" : "0x",
|
||||
"gas" : "10000",
|
||||
"gasPrice" : "100000000000000",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"code" : "0x4243434242434243f14555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
"CallToReturn1": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
@ -310,7 +340,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -346,7 +376,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -382,7 +412,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -418,7 +448,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -455,7 +485,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -491,7 +521,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -645,7 +675,7 @@
|
||||
},
|
||||
"cd1722f3947def4cf144679da39c4c32bdc35681" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -681,7 +711,7 @@
|
||||
},
|
||||
"cd1722f3947def4cf144679da39c4c32bdc35681" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -717,7 +747,7 @@
|
||||
},
|
||||
"cd1722f3947def4cf144679da39c4c32bdc35681" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -843,7 +873,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -879,7 +909,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -915,7 +945,7 @@
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "23",
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"nonce" : "0",
|
||||
"storage" : {
|
||||
}
|
||||
@ -946,7 +976,7 @@
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "0x600035560f600a59005d60203560003557",
|
||||
"code" : "0x6000355415600957005b60203560003555",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
|
||||
@ -12,6 +12,16 @@ class WebThreeStubClient : public jsonrpc::Client
|
||||
public:
|
||||
WebThreeStubClient(jsonrpc::IClientConnector &conn) : jsonrpc::Client(conn) {}
|
||||
|
||||
std::string web3_sha3(const std::string& param1) throw (jsonrpc::JsonRpcException)
|
||||
{
|
||||
Json::Value p;
|
||||
p.append(param1);
|
||||
Json::Value result = this->CallMethod("web3_sha3",p);
|
||||
if (result.isString())
|
||||
return result.asString();
|
||||
else
|
||||
throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
|
||||
}
|
||||
std::string eth_coinbase() throw (jsonrpc::JsonRpcException)
|
||||
{
|
||||
Json::Value p;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user