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

style fixes

cl-refactor
Liana Husikyan 10 years ago
parent
e8148a444f
commit
7512689bec
3 changed files with 144 additions and 146 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      libsolidity/ExpressionCompiler.cpp
  2. 2
      test/libsolidity/SolidityEndToEndTest.cpp
  3. 284
      test/libsolidity/solidityExecutionFramework.h

4
libsolidity/ExpressionCompiler.cpp
View File

@ -1035,7 +1035,7 @@ void ExpressionCompiler::appendHighBitsCleanup(IntegerType const& _typeOnStack)
void ExpressionCompiler::appendExternalFunctionCall( void ExpressionCompiler::appendExternalFunctionCall(
FunctionType const& _functionType, FunctionType const& _functionType,
vector<ASTPointer<Expression const>> const& _arguments vector<ASTPointer<Expression const>> const& _arguments
) )
{ {
solAssert(_functionType.takesArbitraryParameters() || solAssert(_functionType.takesArbitraryParameters() ||
_arguments.size() == _functionType.getParameterTypes().size(), ""); _arguments.size() == _functionType.getParameterTypes().size(), "");
@ -1106,7 +1106,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
//Propagate error condition (if CALL pushes 0 on stack). //Propagate error condition (if CALL pushes 0 on stack).
auto tag = m_context.appendConditionalJump(); auto tag = m_context.appendConditionalJump();
m_context << eth::Instruction::STOP << tag; // STOP if CALL leaves 0.// } m_context << eth::Instruction::STOP << tag; // STOP if CALL leaves 0.
if (_functionType.valueSet()) if (_functionType.valueSet())
m_context << eth::Instruction::POP; m_context << eth::Instruction::POP;

2
test/libsolidity/SolidityEndToEndTest.cpp
View File

@ -4145,7 +4145,7 @@ BOOST_AUTO_TEST_CASE(evm_exceptions_in_constructor_call_fail)
uint public test = 1; uint public test = 1;
function testIt() function testIt()
{ {
A a; A a = new A();
++test; ++test;
} }
} }

284
test/libsolidity/solidityExecutionFramework.h
View File

@ -40,159 +40,157 @@ namespace test
class ExecutionFramework class ExecutionFramework
{ {
public: public:
ExecutionFramework() { g_logVerbosity = 0; } ExecutionFramework() { g_logVerbosity = 0; }
bytes const& execute(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "") bytes const& execute(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "")
{
m_compiler.reset(false, m_addStandardSources);
m_compiler.addSource("", _sourceCode);
ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize), "Compiling contract failed");
bytes code = m_compiler.getBytecode(_contractName);
sendMessage(code, true, _value);
return m_output;
}
bytes const& compileAndRun(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "")
{
execute(_sourceCode, _value, _contractName);
BOOST_REQUIRE(!m_output.empty());
return m_output;
}
template <class... Args>
bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value, Args const&... _arguments)
{
FixedHash<4> hash(dev::sha3(_sig));
sendMessage(hash.asBytes() + encodeArgs(_arguments...), false, _value);
return m_output;
}
template <class... Args>
bytes const& callContractFunction(std::string _sig, Args const&... _arguments)
{
return callContractFunctionWithValue(_sig, 0, _arguments...);
}
template <class CppFunction, class... Args>
void testSolidityAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _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(
std::string _sig,
CppFunction const& _cppFunction,
u256 const& _rangeStart,
u256 const& _rangeEnd
)
{
for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument)
{ {
bytes solidityResult = callContractFunction(_sig, argument); m_compiler.reset(false, m_addStandardSources);
bytes cppResult = callCppAndEncodeResult(_cppFunction, argument); m_compiler.addSource("", _sourceCode);
BOOST_CHECK_MESSAGE( ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize), "Compiling contract failed");
solidityResult == cppResult, bytes code = m_compiler.getBytecode(_contractName);
"Computed values do not match.\nSolidity: " + sendMessage(code, true, _value);
toHex(solidityResult) + return m_output;
"\nC++: " +
toHex(cppResult) +
"\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: bytes const& compileAndRun(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "")
template <class CppFunction, class... Args> {
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) execute(_sourceCode, _value, _contractName);
-> typename std::enable_if<std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type BOOST_REQUIRE(!m_output.empty());
{ return m_output;
_cppFunction(_arguments...); }
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
{
return encode(_cppFunction(_arguments...));
}
protected: template <class... Args>
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0) bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value, Args const&... _arguments)
{
m_state.addBalance(m_sender, _value); // just in case
eth::Executive executive(m_state, eth::LastHashes(), 0);
eth::Transaction t = _isCreation ? eth::Transaction(
_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec()
) : eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
bytes transactionRLP = t.rlp();
try
{ {
// this will throw since the transaction is invalid, but it should nevertheless store the transaction FixedHash<4> hash(dev::sha3(_sig));
executive.initialize(&transactionRLP); sendMessage(hash.asBytes() + encodeArgs(_arguments...), false, _value);
executive.execute(); return m_output;
} }
catch (...) {}
if (_isCreation) template <class... Args>
bytes const& callContractFunction(std::string _sig, Args const&... _arguments)
{ {
BOOST_REQUIRE(!executive.create(m_sender, _value, m_gasPrice, m_gas, &_data, m_sender)); return callContractFunctionWithValue(_sig, 0, _arguments...);
m_contractAddress = executive.newAddress();
BOOST_REQUIRE(m_contractAddress);
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
} }
else
template <class CppFunction, class... Args>
void testSolidityAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments)
{ {
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress)); bytes solidityResult = callContractFunction(_sig, _arguments...);
BOOST_REQUIRE(!executive.call(m_contractAddress, m_contractAddress, m_sender, _value, m_gasPrice, &_data, m_gas, m_sender)); bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...);
BOOST_CHECK_MESSAGE(
solidityResult == cppResult,
"Computed values do not match.\nSolidity: " +
toHex(solidityResult) +
"\nC++: " +
toHex(cppResult));
} }
BOOST_REQUIRE(executive.go());
m_state.noteSending(m_sender); template <class CppFunction, class... Args>
executive.finalize(); void testSolidityAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction, u256 const& _rangeStart, u256 const& _rangeEnd)
m_gasUsed = executive.gasUsed(); {
m_output = executive.out().toVector(); for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument)
m_logs = executive.logs(); {
} bytes solidityResult = callContractFunction(_sig, argument);
bytes cppResult = callCppAndEncodeResult(_cppFunction, argument);
bool m_optimize = false; BOOST_CHECK_MESSAGE(
bool m_addStandardSources = false; solidityResult == cppResult,
dev::solidity::CompilerStack m_compiler; "Computed values do not match.\nSolidity: " +
Address m_sender; toHex(solidityResult) +
Address m_contractAddress; "\nC++: " +
eth::State m_state; toHex(cppResult) +
u256 const m_gasPrice = 100 * eth::szabo; "\nArgument: " +
u256 const m_gas = 100000000; toHex(encode(argument))
bytes m_output; );
eth::LogEntries m_logs; }
u256 m_gasUsed; }
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 CppFunction, class... Args>
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
-> typename std::enable_if<std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
{
_cppFunction(_arguments...);
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
{
return encode(_cppFunction(_arguments...));
}
protected:
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
{
m_state.addBalance(m_sender, _value); // just in case
eth::Executive executive(m_state, eth::LastHashes(), 0);
eth::Transaction t =
_isCreation ?
eth::Transaction(_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec()) :
eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
bytes transactionRLP = t.rlp();
try
{
// this will throw since the transaction is invalid, but it should nevertheless store the transaction
executive.initialize(&transactionRLP);
executive.execute();
}
catch (...) {}
if (_isCreation)
{
BOOST_REQUIRE(!executive.create(m_sender, _value, m_gasPrice, m_gas, &_data, m_sender));
m_contractAddress = executive.newAddress();
BOOST_REQUIRE(m_contractAddress);
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
}
else
{
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
BOOST_REQUIRE(!executive.call(m_contractAddress, m_contractAddress, m_sender, _value, m_gasPrice, &_data, m_gas, m_sender));
}
BOOST_REQUIRE(executive.go());
m_state.noteSending(m_sender);
executive.finalize();
m_gasUsed = executive.gasUsed();
m_output = executive.out().toVector();
m_logs = executive.logs();
}
bool m_optimize = false;
bool m_addStandardSources = false;
dev::solidity::CompilerStack m_compiler;
Address m_sender;
Address m_contractAddress;
eth::State m_state;
u256 const m_gasPrice = 100 * eth::szabo;
u256 const m_gas = 100000000;
bytes m_output;
eth::LogEntries m_logs;
u256 m_gasUsed;
}; };
} }

Write Preview
Loading…
Cancel
Save