Merge branch 'develop' of https://github.com/ethereum/cpp-ethereum into develop

AccountHolder.cpp

@@ -0,0 +1,74 @@
+/*
+	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/>.
+ */
+/**
+ * @author Christian R <c@ethdev.com>
+ * @date 2015
+ * Unit tests for the account holder used by the WebThreeStubServer.
+ */
+
+#include <boost/test/unit_test.hpp>
+#include <libweb3jsonrpc/AccountHolder.h>
+
+namespace dev
+{
+namespace test
+{
+
+BOOST_AUTO_TEST_SUITE(AccountHolderTest)
+
+BOOST_AUTO_TEST_CASE(ProxyAccountUseCase)
+{
+	AccountHolder h = AccountHolder(std::function<eth::Interface*()>());
+	BOOST_CHECK(h.getAllAccounts().empty());
+	BOOST_CHECK(h.getRealAccounts().empty());
+	Address addr("abababababababababababababababababababab");
+	Address addr2("abababababababababababababababababababab");
+	int id = h.addProxyAccount(addr);
+	BOOST_CHECK(h.getQueuedTransactions(id).empty());
+	// register it again
+	int secondID = h.addProxyAccount(addr);
+	BOOST_CHECK(h.getQueuedTransactions(secondID).empty());
+
+	eth::TransactionSkeleton t1;
+	eth::TransactionSkeleton t2;
+	t1.from = addr;
+	t1.data = fromHex("12345678");
+	t2.from = addr;
+	t2.data = fromHex("abcdef");
+	BOOST_CHECK(h.getQueuedTransactions(id).empty());
+	h.queueTransaction(t1);
+	BOOST_CHECK_EQUAL(1, h.getQueuedTransactions(id).size());
+	h.queueTransaction(t2);
+	BOOST_REQUIRE_EQUAL(2, h.getQueuedTransactions(id).size());
+
+	// second proxy should not see transactions
+	BOOST_CHECK(h.getQueuedTransactions(secondID).empty());
+
+	BOOST_CHECK(h.getQueuedTransactions(id)[0].data == t1.data);
+	BOOST_CHECK(h.getQueuedTransactions(id)[1].data == t2.data);
+
+	h.clearQueue(id);
+	BOOST_CHECK(h.getQueuedTransactions(id).empty());
+	// removing fails because it never existed
+	BOOST_CHECK(!h.removeProxyAccount(secondID));
+	BOOST_CHECK(h.removeProxyAccount(id));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
+}

SolidityEndToEndTest.cpp

@@ -1669,7 +1669,6 @@ BOOST_AUTO_TEST_CASE(value_insane)
 			function test() { h = new helper(); }
 			function sendAmount(uint amount) returns (uint256 bal) {
 				var x1 = h.getBalance.value;
-				uint someStackElement = 20;
 				var x2 = x1(amount).gas;
 				var x3 = x2(1000).value;
 				return x3(amount + 3)();// overwrite value
@@ -2570,6 +2569,61 @@ BOOST_AUTO_TEST_CASE(constructing_enums_from_ints)
 	BOOST_CHECK(callContractFunction("test()") == encodeArgs(1));
 }
 
+BOOST_AUTO_TEST_CASE(inline_member_init)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function test(){
+				m_b = 6;
+				m_c = 8;
+			}
+			uint m_a = 5;
+			uint m_b;
+			uint m_c = 7;
+			function get() returns (uint a, uint b, uint c){
+				a = m_a;
+				b = m_b;
+				c = m_c;
+			}
+		})";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("get()") == encodeArgs(5, 6, 8));
+}
+
+BOOST_AUTO_TEST_CASE(inline_member_init_inheritence)
+{
+	char const* sourceCode = R"(
+		contract Base {
+			function Base(){}
+			uint m_base = 5;
+			function getBMember() returns (uint i) { return m_base; }
+		}
+		contract Derived is Base {
+			function Derived(){}
+			uint m_derived = 6;
+			function getDMember() returns (uint i) { return m_derived; }
+		})";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("getBMember()") == encodeArgs(5));
+	BOOST_CHECK(callContractFunction("getDMember()") == encodeArgs(6));
+}
+
+BOOST_AUTO_TEST_CASE(inline_member_init_inheritence_without_constructor)
+{
+	char const* sourceCode = R"(
+		contract Base {
+			uint m_base = 5;
+			function getBMember() returns (uint i) { return m_base; }
+		}
+		contract Derived is Base {
+			uint m_derived = 6;
+			function getDMember() returns (uint i) { return m_derived; }
+		})";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("getBMember()") == encodeArgs(5));
+	BOOST_CHECK(callContractFunction("getDMember()") == encodeArgs(6));
+}
+
 BOOST_AUTO_TEST_CASE(external_function)
 {
 	char const* sourceCode = R"(

SolidityNameAndTypeResolution.cpp

@@ -470,7 +470,7 @@ BOOST_AUTO_TEST_CASE(illegal_override_indirect)
 BOOST_AUTO_TEST_CASE(illegal_override_visibility)
 {
 	char const* text = R"(
-		contract B { function f() inheritable {} }
+		contract B { function f() internal {} }
 		contract C is B { function f() public {} }
 	)";
 	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
@@ -706,7 +706,7 @@ BOOST_AUTO_TEST_CASE(private_state_variable)
 					   "    uint64(2);\n"
 					   "  }\n"
 					   "uint256 private foo;\n"
-					   "uint256 inheritable bar;\n"
+					   "uint256 internal bar;\n"
 					   "}\n";
 
 	ASTPointer<SourceUnit> source;
@@ -717,7 +717,7 @@ BOOST_AUTO_TEST_CASE(private_state_variable)
 	function = retrieveFunctionBySignature(contract, "foo()");
 	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of a private variable should not exist");
 	function = retrieveFunctionBySignature(contract, "bar()");
-	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of an inheritable variable should not exist");
+	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of an internal variable should not exist");
 }
 
 BOOST_AUTO_TEST_CASE(fallback_function)
@@ -832,11 +832,11 @@ BOOST_AUTO_TEST_CASE(access_to_default_function_visibility)
 	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
 }
 
-BOOST_AUTO_TEST_CASE(access_to_inheritable_function)
+BOOST_AUTO_TEST_CASE(access_to_internal_function)
 {
 	char const* text = R"(
 		contract c {
-			function f() inheritable {}
+			function f() internal {}
 		}
 		contract d {
 			function g() { c(0).f(); }
@@ -856,7 +856,7 @@ BOOST_AUTO_TEST_CASE(access_to_default_state_variable_visibility)
 	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
 }
 
-BOOST_AUTO_TEST_CASE(access_to_inheritable_state_variable)
+BOOST_AUTO_TEST_CASE(access_to_internal_state_variable)
 {
 	char const* text = R"(
 		contract c {

SolidityParser.cpp

@@ -651,13 +651,13 @@ BOOST_AUTO_TEST_CASE(visibility_specifiers)
 	char const* text = R"(
 		contract c {
 			uint private a;
-			uint inheritable b;
+			uint internal b;
 			uint public c;
 			uint d;
 			function f() {}
 			function f_priv() private {}
 			function f_public() public {}
-			function f_inheritable() inheritable {}
+			function f_internal() internal {}
 		})";
 	BOOST_CHECK_NO_THROW(parseText(text));
 }
@@ -666,7 +666,7 @@ BOOST_AUTO_TEST_CASE(multiple_visibility_specifiers)
 {
 	char const* text = R"(
 		contract c {
-			uint private inheritable a;
+			uint private internal a;
 		})";
 	BOOST_CHECK_THROW(parseText(text), ParserError);
 }

TestHelper.cpp

@@ -475,11 +475,11 @@ void executeTests(const string& _name, const string& _testPathAppendix, std::fun
 			}
 			catch (Exception const& _e)
 			{
-				BOOST_ERROR("Failed test with Exception: " << diagnostic_information(_e));
+				BOOST_ERROR("Failed filling test with Exception: " << diagnostic_information(_e));
 			}
 			catch (std::exception const& _e)
 			{
-				BOOST_ERROR("Failed test with Exception: " << _e.what());
+				BOOST_ERROR("Failed filling test with Exception: " << _e.what());
 			}
 			break;
 		}

transaction.cpp

@@ -51,7 +51,7 @@ void doTransactionTests(json_spirit::mValue& _v, bool _fillin)
 			catch(...)
 			{
 				BOOST_CHECK_MESSAGE(o.count("transaction") == 0, "A transaction object should not be defined because the RLP is invalid!");
-				return;
+				continue;
 			}
 
 			BOOST_REQUIRE(o.count("transaction") > 0);
@@ -108,6 +108,11 @@ BOOST_AUTO_TEST_CASE(TransactionTest)
 	dev::test::executeTests("ttTransactionTest", "/TransactionTests", dev::test::doTransactionTests);
 }
 
+BOOST_AUTO_TEST_CASE(ttWrongRLPTransaction)
+{
+	dev::test::executeTests("ttWrongRLPTransaction", "/TransactionTests", dev::test::doTransactionTests);
+}
+
 BOOST_AUTO_TEST_CASE(tt10mbDataField)
 {
 	dev::test::executeTests("tt10mbDataField", "/TransactionTests", dev::test::doTransactionTests);

webthreestubclient.h

@@ -447,6 +447,36 @@ class WebThreeStubClient : public jsonrpc::Client
             else
                 throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
         }
+        int eth_register(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+            Json::Value result = this->CallMethod("eth_register",p);
+            if (result.isInt())
+                return result.asInt();
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+        bool eth_unregister(int param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+            Json::Value result = this->CallMethod("eth_unregister",p);
+            if (result.isBool())
+                return result.asBool();
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+        Json::Value eth_queuedTransactions(int param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+            Json::Value result = this->CallMethod("eth_queuedTransactions",p);
+            if (result.isArray())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
         bool db_put(const std::string& param1, const std::string& param2, const std::string& param3) throw (jsonrpc::JsonRpcException)
         {
             Json::Value p;