removed diff file

1 files changed, 0 insertions, 3229 deletions

diff --git a/SolidityEndToEndTest.cpp.orig b/SolidityEndToEndTest.cpp.orig
deleted file mode 100644
index 47d2235d..00000000
--- a/SolidityEndToEndTest.cpp.orig
+++ /dev/null
@@ -1,3229 +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/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @author Gav Wood <g@ethdev.com>
- * @date 2014
- * Unit tests for the solidity expression compiler, testing the behaviour of the code.
- */
-
-#include <string>
-#include <tuple>
-#include <boost/test/unit_test.hpp>
-#include <libdevcrypto/SHA3.h>
-#include <test/solidityExecutionFramework.h>
-
-using namespace std;
-
-namespace dev
-{
-namespace solidity
-{
-namespace test
-{
-
-BOOST_FIXTURE_TEST_SUITE(SolidityEndToEndTest, ExecutionFramework)
-
-BOOST_AUTO_TEST_CASE(smoke_test)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint a) returns(uint d) { return a * 7; }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	testSolidityAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return a * 7; }, 0, 100);
-}
-
-BOOST_AUTO_TEST_CASE(empty_contract)
-{
-	char const* sourceCode = "contract test {\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("i_am_not_there()", bytes()).empty());
-}
-
-BOOST_AUTO_TEST_CASE(exp_operator)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function f(uint a) returns(uint d) { return 2 ** a; }
-		})";
-	compileAndRun(sourceCode);
-	testSolidityAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return u256(1 << a.convert_to<int>()); }, 0, 16);
-}
-
-BOOST_AUTO_TEST_CASE(exp_operator_const)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function f() returns(uint d) { return 2 ** 3; }
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f()", bytes()) == toBigEndian(u256(8)));
-}
-
-BOOST_AUTO_TEST_CASE(exp_operator_const_signed)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function f() returns(int d) { return (-2) ** 3; }
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f()", bytes()) == toBigEndian(u256(-8)));
-}
-
-BOOST_AUTO_TEST_CASE(recursive_calls)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint n) returns(uint nfac) {\n"
-							 "    if (n <= 1) return 1;\n"
-							 "    else return n * f(n - 1);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	function<u256(u256)> recursive_calls_cpp = [&recursive_calls_cpp](u256 const& n) -> u256
-	{
-		if (n <= 1)
-			return 1;
-		else
-			return n * recursive_calls_cpp(n - 1);
-	};
-
-	testSolidityAgainstCppOnRange("f(uint256)", recursive_calls_cpp, 0, 5);
-}
-
-BOOST_AUTO_TEST_CASE(multiple_functions)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a() returns(uint n) { return 0; }\n"
-							 "  function b() returns(uint n) { return 1; }\n"
-							 "  function c() returns(uint n) { return 2; }\n"
-							 "  function f() returns(uint n) { return 3; }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("a()", bytes()) == toBigEndian(u256(0)));
-	BOOST_CHECK(callContractFunction("b()", bytes()) == toBigEndian(u256(1)));
-	BOOST_CHECK(callContractFunction("c()", bytes()) == toBigEndian(u256(2)));
-	BOOST_CHECK(callContractFunction("f()", bytes()) == toBigEndian(u256(3)));
-	BOOST_CHECK(callContractFunction("i_am_not_there()", bytes()) == bytes());
-}
-
-BOOST_AUTO_TEST_CASE(named_args)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }\n"
-							 "  function b() returns (uint r) { r = a({a: 1, b: 2, c: 3}); }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("b()", bytes()) == toBigEndian(u256(123)));
-}
-
-BOOST_AUTO_TEST_CASE(disorder_named_args)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }\n"
-							 "  function b() returns (uint r) { r = a({c: 3, a: 1, b: 2}); }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("b()", bytes()) == toBigEndian(u256(123)));
-}
-
-BOOST_AUTO_TEST_CASE(while_loop)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint n) returns(uint nfac) {\n"
-							 "    nfac = 1;\n"
-							 "    var i = 2;\n"
-							 "    while (i <= n) nfac *= i++;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto while_loop_cpp = [](u256 const& n) -> u256
-	{
-		u256 nfac = 1;
-		u256 i = 2;
-		while (i <= n)
-			nfac *= i++;
-
-		return nfac;
-	};
-
-	testSolidityAgainstCppOnRange("f(uint256)", while_loop_cpp, 0, 5);
-}
-
-BOOST_AUTO_TEST_CASE(break_outside_loop)
-{
-	// break and continue outside loops should be simply ignored
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint x) returns(uint y) {\n"
-							 "    break; continue; return 2;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	testSolidityAgainstCpp("f(uint256)", [](u256 const&) -> u256 { return 2; }, u256(0));
-}
-
-BOOST_AUTO_TEST_CASE(nested_loops)
-{
-	// tests that break and continue statements in nested loops jump to the correct place
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint x) returns(uint y) {\n"
-							 "    while (x > 1) {\n"
-							 "      if (x == 10) break;\n"
-							 "      while (x > 5) {\n"
-							 "        if (x == 8) break;\n"
-							 "        x--;\n"
-							 "        if (x == 6) continue;\n"
-							 "        return x;\n"
-							 "      }\n"
-							 "      x--;\n"
-							 "      if (x == 3) continue;\n"
-							 "      break;\n"
-							 "    }\n"
-							 "    return x;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto nested_loops_cpp = [](u256  n) -> u256
-	{
-		while (n > 1)
-		{
-			if (n == 10)
-				break;
-			while (n > 5)
-			{
-				if (n == 8)
-					break;
-				n--;
-				if (n == 6)
-					continue;
-				return n;
-			}
-			n--;
-			if (n == 3)
-				continue;
-			break;
-		}
-
-		return n;
-	};
-
-	testSolidityAgainstCppOnRange("f(uint256)", nested_loops_cpp, 0, 12);
-}
-
-BOOST_AUTO_TEST_CASE(for_loop)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint n) returns(uint nfac) {\n"
-							 "    nfac = 1;\n"
-							 "    for (var i = 2; i <= n; i++)\n"
-							 "        nfac *= i;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto for_loop_cpp = [](u256 const& n) -> u256
-	{
-		u256 nfac = 1;
-		for (auto i = 2; i <= n; i++)
-			nfac *= i;
-		return nfac;
-	};
-
-	testSolidityAgainstCppOnRange("f(uint256)", for_loop_cpp, 0, 5);
-}
-
-BOOST_AUTO_TEST_CASE(for_loop_empty)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f() returns(uint ret) {\n"
-							 "    ret = 1;\n"
-							 "    for (;;)\n"
-							 "    {\n"
-							 "        ret += 1;\n"
-							 "        if (ret >= 10) break;\n"
-							 "    }\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto for_loop_empty_cpp = []() -> u256
-	{
-		u256 ret = 1;
-		for (;;)
-		{
-			ret += 1;
-			if (ret >= 10) break;
-		}
-		return ret;
-	};
-
-	testSolidityAgainstCpp("f()", for_loop_empty_cpp);
-}
-
-BOOST_AUTO_TEST_CASE(for_loop_simple_init_expr)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint n) returns(uint nfac) {\n"
-							 "    nfac = 1;\n"
-							 "    uint256 i;\n"
-							 "    for (i = 2; i <= n; i++)\n"
-							 "        nfac *= i;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto for_loop_simple_init_expr_cpp = [](u256 const& n) -> u256
-	{
-		u256 nfac = 1;
-		u256 i;
-		for (i = 2; i <= n; i++)
-			nfac *= i;
-		return nfac;
-	};
-
-	testSolidityAgainstCppOnRange("f(uint256)", for_loop_simple_init_expr_cpp, 0, 5);
-}
-
-BOOST_AUTO_TEST_CASE(calling_other_functions)
-{
-	// note that the index of a function is its index in the sorted sequence of functions
-	char const* sourceCode = "contract collatz {\n"
-							 "  function run(uint x) returns(uint y) {\n"
-							 "    while ((y = x) > 1) {\n"
-							 "      if (x % 2 == 0) x = evenStep(x);\n"
-							 "      else x = oddStep(x);\n"
-							 "    }\n"
-							 "  }\n"
-							 "  function evenStep(uint x) returns(uint y) {\n"
-							 "    return x / 2;\n"
-							 "  }\n"
-							 "  function oddStep(uint x) returns(uint y) {\n"
-							 "    return 3 * x + 1;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto evenStep_cpp = [](u256 const& n) -> u256
-	{
-		return n / 2;
-	};
-
-	auto oddStep_cpp = [](u256 const& n) -> u256
-	{
-		return 3 * n + 1;
-	};
-
-	auto collatz_cpp = [&evenStep_cpp, &oddStep_cpp](u256 n) -> u256
-	{
-		u256 y;
-		while ((y = n) > 1)
-		{
-			if (n % 2 == 0)
-				n = evenStep_cpp(n);
-			else
-				n = oddStep_cpp(n);
-		}
-		return y;
-	};
-
-	testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(0));
-	testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(1));
-	testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(2));
-	testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(8));
-	testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(127));
-}
-
-BOOST_AUTO_TEST_CASE(many_local_variables)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run(uint x1, uint x2, uint x3) returns(uint y) {\n"
-							 "    var a = 0x1; var b = 0x10; var c = 0x100;\n"
-							 "    y = a + b + c + x1 + x2 + x3;\n"
-							 "    y += b + x2;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto f = [](u256 const& x1, u256 const& x2, u256 const& x3) -> u256
-	{
-		u256 a = 0x1;
-		u256 b = 0x10;
-		u256 c = 0x100;
-		u256 y = a + b + c + x1 + x2 + x3;
-		return y + b + x2;
-	};
-	testSolidityAgainstCpp("run(uint256,uint256,uint256)", f, u256(0x1000), u256(0x10000), u256(0x100000));
-}
-
-BOOST_AUTO_TEST_CASE(packing_unpacking_types)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run(bool a, uint32 b, uint64 c) returns(uint256 y) {\n"
-							 "    if (a) y = 1;\n"
-							 "    y = y * 0x100000000 | ~b;\n"
-							 "    y = y * 0x10000000000000000 | ~c;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("run(bool,uint32,uint64)", true, fromHex("0f0f0f0f"), fromHex("f0f0f0f0f0f0f0f0"))
-				== fromHex("00000000000000000000000000000000000000""01""f0f0f0f0""0f0f0f0f0f0f0f0f"));
-}
-
-BOOST_AUTO_TEST_CASE(packing_signed_types)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run() returns(int8 y) {\n"
-							 "    uint8 x = 0xfa;\n"
-							 "    return int8(x);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("run()")
-				== fromHex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa"));
-}
-
-BOOST_AUTO_TEST_CASE(multiple_return_values)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run(bool x1, uint x2) returns(uint y1, bool y2, uint y3) {\n"
-							 "    y1 = x2; y2 = x1;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("run(bool,uint256)", true, 0xcd) == encodeArgs(0xcd, true, 0));
-}
-
-BOOST_AUTO_TEST_CASE(short_circuiting)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run(uint x) returns(uint y) {\n"
-							 "    x == 0 || ((x = 8) > 0);\n"
-							 "    return x;"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	auto short_circuiting_cpp = [](u256 n) -> u256
-	{
-		n == 0 || (n = 8) > 0;
-		return n;
-	};
-
-	testSolidityAgainstCppOnRange("run(uint256)", short_circuiting_cpp, 0, 2);
-}
-
-BOOST_AUTO_TEST_CASE(high_bits_cleaning)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run() returns(uint256 y) {\n"
-							 "    uint32 t = uint32(0xffffffff);\n"
-							 "    uint32 x = t + 10;\n"
-							 "    if (x >= 0xffffffff) return 0;\n"
-							 "    return x;"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto high_bits_cleaning_cpp = []() -> u256
-	{
-		uint32_t t = uint32_t(0xffffffff);
-		uint32_t x = t + 10;
-		if (x >= 0xffffffff)
-			return 0;
-		return x;
-	};
-	testSolidityAgainstCpp("run()", high_bits_cleaning_cpp);
-}
-
-BOOST_AUTO_TEST_CASE(sign_extension)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run() returns(uint256 y) {\n"
-							 "    int64 x = -int32(0xff);\n"
-							 "    if (x >= 0xff) return 0;\n"
-							 "    return -uint256(x);"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto sign_extension_cpp = []() -> u256
-	{
-		int64_t x = -int32_t(0xff);
-		if (x >= 0xff)
-			return 0;
-		return u256(x) * -1;
-	};
-	testSolidityAgainstCpp("run()", sign_extension_cpp);
-}
-
-BOOST_AUTO_TEST_CASE(small_unsigned_types)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run() returns(uint256 y) {\n"
-							 "    uint32 t = uint32(0xffffff);\n"
-							 "    uint32 x = t * 0xffffff;\n"
-							 "    return x / 0x100;"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto small_unsigned_types_cpp = []() -> u256
-	{
-		uint32_t t = uint32_t(0xffffff);
-		uint32_t x = t * 0xffffff;
-		return x / 0x100;
-	};
-	testSolidityAgainstCpp("run()", small_unsigned_types_cpp);
-}
-
-BOOST_AUTO_TEST_CASE(small_signed_types)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run() returns(int256 y) {\n"
-							 "    return -int32(10) * -int64(20);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto small_signed_types_cpp = []() -> u256
-	{
-		return -int32_t(10) * -int64_t(20);
-	};
-	testSolidityAgainstCpp("run()", small_signed_types_cpp);
-}
-
-BOOST_AUTO_TEST_CASE(strings)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function fixed() returns(bytes32 ret) {\n"
-							 "    return \"abc\\x00\\xff__\";\n"
-							 "  }\n"
-							 "  function pipeThrough(bytes2 small, bool one) returns(bytes16 large, bool oneRet) {\n"
-							 "    oneRet = one;\n"
-							 "    large = small;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("fixed()") == encodeArgs(string("abc\0\xff__", 7)));
-	BOOST_CHECK(callContractFunction("pipeThrough(bytes2,bool)", string("\0\x02", 2), true) == encodeArgs(string("\0\x2", 2), true));
-}
-
-BOOST_AUTO_TEST_CASE(empty_string_on_stack)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function run(bytes0 empty, uint8 inp) returns(uint16 a, bytes0 b, bytes4 c) {\n"
-							 "    var x = \"abc\";\n"
-							 "    var y = \"\";\n"
-							 "    var z = inp;\n"
-							 "    a = z; b = y; c = x;"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("run(bytes0,uint8)", string(), byte(0x02)) == encodeArgs(0x2, string(""), string("abc\0")));
-}
-
-BOOST_AUTO_TEST_CASE(state_smoke_test)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  uint256 value1;\n"
-							 "  uint256 value2;\n"
-							 "  function get(uint8 which) returns (uint256 value) {\n"
-							 "    if (which == 0) return value1;\n"
-							 "    else return value2;\n"
-							 "  }\n"
-							 "  function set(uint8 which, uint256 value) {\n"
-							 "    if (which == 0) value1 = value;\n"
-							 "    else value2 = value;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x00)) == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("set(uint8,uint256)", byte(0x00), 0x1234) == encodeArgs());
-	BOOST_CHECK(callContractFunction("set(uint8,uint256)", byte(0x01), 0x8765) == encodeArgs());
-	BOOST_CHECK(callContractFunction("get(uint8)", byte( 0x00)) == encodeArgs(0x1234));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(0x8765));
-	BOOST_CHECK(callContractFunction("set(uint8,uint256)", byte(0x00), 0x3) == encodeArgs());
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x00)) == encodeArgs(0x3));
-}
-
-BOOST_AUTO_TEST_CASE(compound_assign)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  uint value1;\n"
-							 "  uint value2;\n"
-							 "  function f(uint x, uint y) returns (uint w) {\n"
-							 "    uint value3 = y;"
-							 "    value1 += x;\n"
-							 "    value3 *= x;"
-							 "    value2 *= value3 + value1;\n"
-							 "    return value2 += 7;"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	u256 value1;
-	u256 value2;
-	auto f = [&](u256 const& _x, u256 const& _y) -> u256
-	{
-		u256 value3 = _y;
-		value1 += _x;
-		value3 *= _x;
-		value2 *= value3 + value1;
-		return value2 += 7;
-	};
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(0), u256(6));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(1), u256(3));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(2), u256(25));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(3), u256(69));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(4), u256(84));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(5), u256(2));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(6), u256(51));
-	testSolidityAgainstCpp("f(uint256,uint256)", f, u256(7), u256(48));
-}
-
-BOOST_AUTO_TEST_CASE(simple_mapping)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  mapping(uint8 => uint8) table;\n"
-							 "  function get(uint8 k) returns (uint8 v) {\n"
-							 "    return table[k];\n"
-							 "  }\n"
-							 "  function set(uint8 k, uint8 v) {\n"
-							 "    table[k] = v;\n"
-							 "  }\n"
-							 "}";
-	compileAndRun(sourceCode);
-
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0)) == encodeArgs(byte(0x00)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(byte(0x00)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0xa7)) == encodeArgs(byte(0x00)));
-	callContractFunction("set(uint8,uint8)", byte(0x01), byte(0xa1));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x00)) == encodeArgs(byte(0x00)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(byte(0xa1)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0xa7)) == encodeArgs(byte(0x00)));
-	callContractFunction("set(uint8,uint8)", byte(0x00), byte(0xef));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x00)) == encodeArgs(byte(0xef)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(byte(0xa1)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0xa7)) == encodeArgs(byte(0x00)));
-	callContractFunction("set(uint8,uint8)", byte(0x01), byte(0x05));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x00)) == encodeArgs(byte(0xef)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(byte(0x05)));
-	BOOST_CHECK(callContractFunction("get(uint8)", byte(0xa7)) == encodeArgs(byte(0x00)));
-}
-
-BOOST_AUTO_TEST_CASE(mapping_state)
-{
-	char const* sourceCode = "contract Ballot {\n"
-							 "  mapping(address => bool) canVote;\n"
-							 "  mapping(address => uint) voteCount;\n"
-							 "  mapping(address => bool) voted;\n"
-							 "  function getVoteCount(address addr) returns (uint retVoteCount) {\n"
-							 "    return voteCount[addr];\n"
-							 "  }\n"
-							 "  function grantVoteRight(address addr) {\n"
-							 "    canVote[addr] = true;\n"
-							 "  }\n"
-							 "  function vote(address voter, address vote) returns (bool success) {\n"
-							 "    if (!canVote[voter] || voted[voter]) return false;\n"
-							 "    voted[voter] = true;\n"
-							 "    voteCount[vote] = voteCount[vote] + 1;\n"
-							 "    return true;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	class Ballot
-	{
-	public:
-		u256 getVoteCount(u160 _address) { return m_voteCount[_address]; }
-		void grantVoteRight(u160 _address) { m_canVote[_address] = true; }
-		bool vote(u160 _voter, u160 _vote)
-		{
-			if (!m_canVote[_voter] || m_voted[_voter]) return false;
-			m_voted[_voter] = true;
-			m_voteCount[_vote]++;
-			return true;
-		}
-	private:
-		map<u160, bool> m_canVote;
-		map<u160, u256> m_voteCount;
-		map<u160, bool> m_voted;
-	} ballot;
-
-	auto getVoteCount = bind(&Ballot::getVoteCount, &ballot, _1);
-	auto grantVoteRight = bind(&Ballot::grantVoteRight, &ballot, _1);
-	auto vote = bind(&Ballot::vote, &ballot, _1, _2);
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2));
-	// voting without vote right should be rejected
-	testSolidityAgainstCpp("vote(address,address)", vote, u160(0), u160(2));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2));
-	// grant vote rights
-	testSolidityAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(0));
-	testSolidityAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(1));
-	// vote, should increase 2's vote count
-	testSolidityAgainstCpp("vote(address,address)", vote, u160(0), u160(2));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2));
-	// vote again, should be rejected
-	testSolidityAgainstCpp("vote(address,address)", vote, u160(0), u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2));
-	// vote without right to vote
-	testSolidityAgainstCpp("vote(address,address)", vote, u160(2), u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2));
-	// grant vote right and now vote again
-	testSolidityAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(2));
-	testSolidityAgainstCpp("vote(address,address)", vote, u160(2), u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1));
-	testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2));
-}
-
-BOOST_AUTO_TEST_CASE(mapping_state_inc_dec)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  uint value;\n"
-							 "  mapping(uint => uint) table;\n"
-							 "  function f(uint x) returns (uint y) {\n"
-							 "    value = x;\n"
-							 "    if (x > 0) table[++value] = 8;\n"
-							 "    if (x > 1) value--;\n"
-							 "    if (x > 2) table[value]++;\n"
-							 "    return --table[value++];\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	u256 value = 0;
-	map<u256, u256> table;
-	auto f = [&](u256 const& _x) -> u256
-	{
-		value = _x;
-		if (_x > 0)
-			table[++value] = 8;
-		if (_x > 1)
-			value --;
-		if (_x > 2)
-			table[value]++;
-		return --table[value++];
-	};
-	testSolidityAgainstCppOnRange("f(uint256)", f, 0, 5);
-}
-
-BOOST_AUTO_TEST_CASE(multi_level_mapping)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  mapping(uint => mapping(uint => uint)) table;\n"
-							 "  function f(uint x, uint y, uint z) returns (uint w) {\n"
-							 "    if (z == 0) return table[x][y];\n"
-							 "    else return table[x][y] = z;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-
-	map<u256, map<u256, u256>> table;
-	auto f = [&](u256 const& _x, u256 const& _y, u256 const& _z) -> u256
-	{
-		if (_z == 0) return table[_x][_y];
-		else return table[_x][_y] = _z;
-	};
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(9));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(7));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0));
-	testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0));
-}
-
-BOOST_AUTO_TEST_CASE(structs)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  struct s1 {\n"
-							 "    uint8 x;\n"
-							 "    bool y;\n"
-							 "  }\n"
-							 "  struct s2 {\n"
-							 "    uint32 z;\n"
-							 "    s1 s1data;\n"
-							 "    mapping(uint8 => s2) recursive;\n"
-							 "  }\n"
-							 "  s2 data;\n"
-							 "  function check() returns (bool ok) {\n"
-							 "    return data.z == 1 && data.s1data.x == 2 && \n"
-							 "        data.s1data.y == true && \n"
-							 "        data.recursive[3].recursive[4].z == 5 && \n"
-							 "        data.recursive[4].recursive[3].z == 6 && \n"
-							 "        data.recursive[0].s1data.y == false && \n"
-							 "        data.recursive[4].z == 9;\n"
-							 "  }\n"
-							 "  function set() {\n"
-							 "    data.z = 1;\n"
-							 "    data.s1data.x = 2;\n"
-							 "    data.s1data.y = true;\n"
-							 "    data.recursive[3].recursive[4].z = 5;\n"
-							 "    data.recursive[4].recursive[3].z = 6;\n"
-							 "    data.recursive[0].s1data.y = false;\n"
-							 "    data.recursive[4].z = 9;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("check()") == encodeArgs(false));
-	BOOST_CHECK(callContractFunction("set()") == bytes());
-	BOOST_CHECK(callContractFunction("check()") == encodeArgs(true));
-}
-
-BOOST_AUTO_TEST_CASE(struct_reference)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  struct s2 {\n"
-							 "    uint32 z;\n"
-							 "    mapping(uint8 => s2) recursive;\n"
-							 "  }\n"
-							 "  s2 data;\n"
-							 "  function check() returns (bool ok) {\n"
-							 "    return data.z == 2 && \n"
-							 "        data.recursive[0].z == 3 && \n"
-							 "        data.recursive[0].recursive[1].z == 0 && \n"
-							 "        data.recursive[0].recursive[0].z == 1;\n"
-							 "  }\n"
-							 "  function set() {\n"
-							 "    data.z = 2;\n"
-							 "    var map = data.recursive;\n"
-							 "    s2 inner = map[0];\n"
-							 "    inner.z = 3;\n"
-							 "    inner.recursive[0].z = inner.recursive[1].z + 1;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("check()") == encodeArgs(false));
-	BOOST_CHECK(callContractFunction("set()") == bytes());
-	BOOST_CHECK(callContractFunction("check()") == encodeArgs(true));
-}
-
-BOOST_AUTO_TEST_CASE(deleteStruct)
-{
-	char const* sourceCode = R"(
-		contract test {
-			struct topStruct {
-				nestedStruct nstr;
-				emptyStruct empty;
-				uint topValue;
-				mapping (uint => uint) topMapping;
-			}
-			uint toDelete;
-			topStruct str;
-			struct nestedStruct {
-				uint nestedValue;
-				mapping (uint => bool) nestedMapping;
-			}
-			struct emptyStruct{
-			}
-			function test(){
-				toDelete = 5;
-				str.topValue = 1;
-				str.topMapping[0] = 1;
-				str.topMapping[1] = 2;
-
-				str.nstr.nestedValue = 2;
-				str.nstr.nestedMapping[0] = true;
-				str.nstr.nestedMapping[1] = false;
-				delete str;
-				delete toDelete;
-			}
-			function getToDelete() returns (uint res){
-				res = toDelete;
-			}
-			function getTopValue() returns(uint topValue){
-				topValue = str.topValue;
-			}
-			function getNestedValue() returns(uint nestedValue){
-				nestedValue = str.nstr.nestedValue;
-			}
-			function getTopMapping(uint index) returns(uint ret) {
-			   ret = str.topMapping[index];
-			}
-			function getNestedMapping(uint index) returns(bool ret) {
-				return str.nstr.nestedMapping[index];
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getToDelete()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("getTopValue()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("getNestedValue()") == encodeArgs(0));
-	// mapping values should be the same
-	BOOST_CHECK(callContractFunction("getTopMapping(uint256)", 0) == encodeArgs(1));
-	BOOST_CHECK(callContractFunction("getTopMapping(uint256)", 1) == encodeArgs(2));
-	BOOST_CHECK(callContractFunction("getNestedMapping(uint256)", 0) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("getNestedMapping(uint256)", 1) == encodeArgs(false));
-}
-
-BOOST_AUTO_TEST_CASE(deleteLocal)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function delLocal() returns (uint res){
-				uint v = 5;
-				delete v;
-				res = v;
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("delLocal()") == encodeArgs(0));
-}
-
-BOOST_AUTO_TEST_CASE(deleteLocals)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function delLocal() returns (uint res1, uint res2){
-				uint v = 5;
-				uint w = 6;
-				uint x = 7;
-				delete v;
-				res1 = w;
-				res2 = x;
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("delLocal()") == encodeArgs(6, 7));
-}
-
-BOOST_AUTO_TEST_CASE(constructor)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  mapping(uint => uint) data;\n"
-							 "  function test() {\n"
-							 "    data[7] = 8;\n"
-							 "  }\n"
-							 "  function get(uint key) returns (uint value) {\n"
-							 "    return data[key];"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	map<u256, byte> data;
-	data[7] = 8;
-	auto get = [&](u256 const& _x) -> u256
-	{
-		return data[_x];
-	};
-	testSolidityAgainstCpp("get(uint256)", get, u256(6));
-	testSolidityAgainstCpp("get(uint256)", get, u256(7));
-}
-
-BOOST_AUTO_TEST_CASE(simple_accessor)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  uint256 public data;\n"
-							 "  function test() {\n"
-							 "    data = 8;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("data()") == encodeArgs(8));
-}
-
-BOOST_AUTO_TEST_CASE(multiple_elementary_accessors)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  uint256 public data;\n"
-							 "  bytes6 public name;\n"
-							 "  bytes32 public a_hash;\n"
-							 "  address public an_address;\n"
-							 "  function test() {\n"
-							 "    data = 8;\n"
-							 "    name = \"Celina\";\n"
-							 "    a_hash = sha3(123);\n"
-							 "    an_address = address(0x1337);\n"
-							 "    super_secret_data = 42;\n"
-							 "  }\n"
-							 "  uint256 super_secret_data;"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("data()") == encodeArgs(8));
-	BOOST_CHECK(callContractFunction("name()") == encodeArgs("Celina"));
-	BOOST_CHECK(callContractFunction("a_hash()") == encodeArgs(dev::sha3(bytes(1, 0x7b))));
-	BOOST_CHECK(callContractFunction("an_address()") == encodeArgs(toBigEndian(u160(0x1337))));
-	BOOST_CHECK(callContractFunction("super_secret_data()") == bytes());
-}
-
-BOOST_AUTO_TEST_CASE(complex_accessors)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  mapping(uint256 => bytes4) public to_string_map;\n"
-							 "  mapping(uint256 => bool) public to_bool_map;\n"
-							 "  mapping(uint256 => uint256) public to_uint_map;\n"
-							 "  mapping(uint256 => mapping(uint256 => uint256)) public to_multiple_map;\n"
-							 "  function test() {\n"
-							 "    to_string_map[42] = \"24\";\n"
-							 "    to_bool_map[42] = false;\n"
-							 "    to_uint_map[42] = 12;\n"
-							 "    to_multiple_map[42][23] = 31;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("to_string_map(uint256)", 42) == encodeArgs("24"));
-	BOOST_CHECK(callContractFunction("to_bool_map(uint256)", 42) == encodeArgs(false));
-	BOOST_CHECK(callContractFunction("to_uint_map(uint256)", 42) == encodeArgs(12));
-	BOOST_CHECK(callContractFunction("to_multiple_map(uint256,uint256)", 42, 23) == encodeArgs(31));
-}
-
-BOOST_AUTO_TEST_CASE(struct_accessor)
-{
-	char const* sourceCode = R"(
-		contract test {
-			struct Data { uint a; uint8 b; mapping(uint => uint) c; bool d; }
-			mapping(uint => Data) public data;
-			function test() {
-				data[7].a = 1;
-				data[7].b = 2;
-				data[7].c[0] = 3;
-				data[7].d = true;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("data(uint256)", 7) == encodeArgs(1, 2, true));
-}
-
-BOOST_AUTO_TEST_CASE(balance)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function getBalance() returns (uint256 balance) {\n"
-							 "    return address(this).balance;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode, 23);
-	BOOST_CHECK(callContractFunction("getBalance()") == encodeArgs(23));
-}
-
-BOOST_AUTO_TEST_CASE(blockchain)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function someInfo() returns (uint256 value, address coinbase, uint256 blockNumber) {\n"
-							 "    value = msg.value;\n"
-							 "    coinbase = block.coinbase;\n"
-							 "    blockNumber = block.number;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode, 27);
-	BOOST_CHECK(callContractFunctionWithValue("someInfo()", 28) == encodeArgs(28, 0, 1));
-}
-
-BOOST_AUTO_TEST_CASE(now)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function someInfo() returns (bool success) {\n"
-							 "    return block.timestamp == now && now > 0;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("someInfo()") == encodeArgs(true));
-}
-
-BOOST_AUTO_TEST_CASE(function_types)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(bool selector) returns (uint b) {\n"
-							 "    var f = fun1;\n"
-							 "    if (selector) f = fun2;\n"
-							 "    return f(9);\n"
-							 "  }\n"
-							 "  function fun1(uint x) returns (uint b) {\n"
-							 "    return 11;\n"
-							 "  }\n"
-							 "  function fun2(uint x) returns (uint b) {\n"
-							 "    return 12;\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("a(bool)", false) == encodeArgs(11));
-	BOOST_CHECK(callContractFunction("a(bool)", true) == encodeArgs(12));
-}
-
-BOOST_AUTO_TEST_CASE(type_conversions_cleanup)
-{
-	// 22-byte integer converted to a contract (i.e. address, 20 bytes), converted to a 32 byte
-	// integer should drop the first two bytes
-	char const* sourceCode = R"(
-		contract Test {
-			function test() returns (uint ret) { return uint(address(Test(address(0x11223344556677889900112233445566778899001122)))); }
-		})";
-	compileAndRun(sourceCode);
-	BOOST_REQUIRE(callContractFunction("test()") == bytes({0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-														   0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0x11, 0x22,
-														   0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0x11, 0x22}));
-}
-
-BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_fixed_bytes_smaller_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function pipeTrough(bytes3 input) returns (bytes2 ret) {
-				return bytes2(input);
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("pipeTrough(bytes3)", "abc") == encodeArgs("ab"));
-}
-
-BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_same_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function uintToBytes(uint256 h) returns (bytes32 s) {
-				return bytes32(h);
-			}
-		})";
-	compileAndRun(sourceCode);
-	u256 a("0x6162630000000000000000000000000000000000000000000000000000000000");
-	BOOST_CHECK(callContractFunction("uintToBytes(uint256)", a) == encodeArgs(a));
-}
-
-BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_different_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function uintToBytes(uint160 h) returns (bytes20 s) {
-				return bytes20(h);
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("uintToBytes(uint160)",
-			u160("0x6161626361626361626361616263616263616263")) == encodeArgs(string("aabcabcabcaabcabcabc")));
-}
-
-BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_same_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function bytesToUint(bytes32 s) returns (uint256 h) {
-				return uint(s);
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("bytesToUint(bytes32)", string("abc2")) ==
-		encodeArgs(u256("0x6162633200000000000000000000000000000000000000000000000000000000")));
-}
-
-BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_different_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function bytesToUint(bytes20 s) returns (uint160 h) {
-				return uint160(s);
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("bytesToUint(bytes20)", string("aabcabcabcaabcabcabc")) ==
-		encodeArgs(u160("0x6161626361626361626361616263616263616263")));
-}
-
-
-BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_different_min_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function bytesToUint(bytes1 s) returns (uint8 h) {
-				return uint8(s);
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("bytesToUint(bytes1)", string("a")) ==
-		encodeArgs(u256("0x61")));
-}
-
-
-BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_different_min_size)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			function UintToBytes(uint8 h) returns (bytes1 s) {
-				return bytes1(h);
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("UintToBytes(uint8)", u256("0x61")) ==
-		encodeArgs(string("a")));
-}
-
-BOOST_AUTO_TEST_CASE(send_ether)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(address addr, uint amount) returns (uint ret) {\n"
-							 "    addr.send(amount);\n"
-							 "    return address(this).balance;\n"
-							 "  }\n"
-							 "}\n";
-	u256 amount(130);
-	compileAndRun(sourceCode, amount + 1);
-	u160 address(23);
-	BOOST_CHECK(callContractFunction("a(address,uint256)", address, amount) == encodeArgs(1));
-	BOOST_CHECK_EQUAL(m_state.balance(address), amount);
-}
-
-BOOST_AUTO_TEST_CASE(log0)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log0(1);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	callContractFunction("a()");
-	BOOST_CHECK_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(1)));
-	BOOST_CHECK_EQUAL(m_logs[0].topics.size(), 0);
-}
-
-BOOST_AUTO_TEST_CASE(log1)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log1(1, 2);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	callContractFunction("a()");
-	BOOST_CHECK_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(1)));
-	BOOST_CHECK_EQUAL(m_logs[0].topics.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].topics[0], h256(u256(2)));
-}
-
-BOOST_AUTO_TEST_CASE(log2)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log2(1, 2, 3);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	callContractFunction("a()");
-	BOOST_CHECK_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(1)));
-	BOOST_CHECK_EQUAL(m_logs[0].topics.size(), 2);
-	for (unsigned i = 0; i < 2; ++i)
-		BOOST_CHECK_EQUAL(m_logs[0].topics[i], h256(u256(i + 2)));
-}
-
-BOOST_AUTO_TEST_CASE(log3)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log3(1, 2, 3, 4);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	callContractFunction("a()");
-	BOOST_CHECK_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(1)));
-	BOOST_CHECK_EQUAL(m_logs[0].topics.size(), 3);
-	for (unsigned i = 0; i < 3; ++i)
-		BOOST_CHECK_EQUAL(m_logs[0].topics[i], h256(u256(i + 2)));
-}
-
-BOOST_AUTO_TEST_CASE(log4)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log4(1, 2, 3, 4, 5);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	callContractFunction("a()");
-	BOOST_CHECK_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(1)));
-	BOOST_CHECK_EQUAL(m_logs[0].topics.size(), 4);
-	for (unsigned i = 0; i < 4; ++i)
-		BOOST_CHECK_EQUAL(m_logs[0].topics[i], h256(u256(i + 2)));
-}
-
-BOOST_AUTO_TEST_CASE(log_in_constructor)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function test() {\n"
-							 "    log1(1, 2);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	BOOST_CHECK_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(1)));
-	BOOST_CHECK_EQUAL(m_logs[0].topics.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].topics[0], h256(u256(2)));
-}
-
-BOOST_AUTO_TEST_CASE(suicide)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(address receiver) returns (uint ret) {\n"
-							 "    suicide(receiver);\n"
-							 "    return 10;\n"
-							 "  }\n"
-							 "}\n";
-	u256 amount(130);
-	compileAndRun(sourceCode, amount);
-	u160 address(23);
-	BOOST_CHECK(callContractFunction("a(address)", address) == bytes());
-	BOOST_CHECK(!m_state.addressHasCode(m_contractAddress));
-	BOOST_CHECK_EQUAL(m_state.balance(address), amount);
-}
-
-BOOST_AUTO_TEST_CASE(sha3)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(bytes32 input) returns (bytes32 sha3hash) {\n"
-							 "    return sha3(input);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto f = [&](u256 const& _x) -> u256
-	{
-		return dev::sha3(toBigEndian(_x));
-	};
-	testSolidityAgainstCpp("a(bytes32)", f, u256(4));
-	testSolidityAgainstCpp("a(bytes32)", f, u256(5));
-	testSolidityAgainstCpp("a(bytes32)", f, u256(-1));
-}
-
-BOOST_AUTO_TEST_CASE(sha256)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(bytes32 input) returns (bytes32 sha256hash) {\n"
-							 "    return sha256(input);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto f = [&](u256 const& _input) -> u256
-	{
-		h256 ret;
-		dev::sha256(dev::ref(toBigEndian(_input)), bytesRef(&ret[0], 32));
-		return ret;
-	};
-	testSolidityAgainstCpp("a(bytes32)", f, u256(4));
-	testSolidityAgainstCpp("a(bytes32)", f, u256(5));
-	testSolidityAgainstCpp("a(bytes32)", f, u256(-1));
-}
-
-BOOST_AUTO_TEST_CASE(ripemd)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(bytes32 input) returns (bytes32 sha256hash) {\n"
-							 "    return ripemd160(input);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	auto f = [&](u256 const& _input) -> u256
-	{
-		h256 ret;
-		dev::ripemd160(dev::ref(toBigEndian(_input)), bytesRef(&ret[0], 32));
-		return u256(ret) >> (256 - 160);
-	};
-	testSolidityAgainstCpp("a(bytes32)", f, u256(4));
-	testSolidityAgainstCpp("a(bytes32)", f, u256(5));
-	testSolidityAgainstCpp("a(bytes32)", f, u256(-1));
-}
-
-BOOST_AUTO_TEST_CASE(ecrecover)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function a(bytes32 h, uint8 v, bytes32 r, bytes32 s) returns (address addr) {\n"
-							 "    return ecrecover(h, v, r, s);\n"
-							 "  }\n"
-							 "}\n";
-	compileAndRun(sourceCode);
-	u256 h("0x18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c");
-	byte v = 28;
-	u256 r("0x73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9aa6a5a75f");
-	u256 s("0xeeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549");
-	u160 addr("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b");
-	BOOST_CHECK(callContractFunction("a(bytes32,uint8,bytes32,bytes32)", h, v, r, s) == encodeArgs(addr));
-}
-
-BOOST_AUTO_TEST_CASE(inter_contract_calls)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			function multiply(uint a, uint b) returns (uint c) {
-				return a * b;
-			}
-		}
-		contract Main {
-			Helper h;
-			function callHelper(uint a, uint b) returns (uint c) {
-				return h.multiply(a, b);
-			}
-			function getHelper() returns (address haddress) {
-				return address(h);
-			}
-			function setHelper(address haddress) {
-				h = Helper(haddress);
-			}
-		})";
-	compileAndRun(sourceCode, 0, "Helper");
-	u160 const c_helperAddress = m_contractAddress;
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
-	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
-	u256 a(3456789);
-	u256 b("0x282837623374623234aa74");
-	BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b));
-}
-
-BOOST_AUTO_TEST_CASE(inter_contract_calls_with_complex_parameters)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			function sel(uint a, bool select, uint b) returns (uint c) {
-				if (select) return a; else return b;
-			}
-		}
-		contract Main {
-			Helper h;
-			function callHelper(uint a, bool select, uint b) returns (uint c) {
-				return h.sel(a, select, b) * 3;
-			}
-			function getHelper() returns (address haddress) {
-				return address(h);
-			}
-			function setHelper(address haddress) {
-				h = Helper(haddress);
-			}
-		})";
-	compileAndRun(sourceCode, 0, "Helper");
-	u160 const c_helperAddress = m_contractAddress;
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
-	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
-	u256 a(3456789);
-	u256 b("0x282837623374623234aa74");
-	BOOST_REQUIRE(callContractFunction("callHelper(uint256,bool,uint256)", a, true, b) == encodeArgs(a * 3));
-	BOOST_REQUIRE(callContractFunction("callHelper(uint256,bool,uint256)", a, false, b) == encodeArgs(b * 3));
-}
-
-BOOST_AUTO_TEST_CASE(inter_contract_calls_accessing_this)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			function getAddress() returns (address addr) {
-				return address(this);
-			}
-		}
-		contract Main {
-			Helper h;
-			function callHelper() returns (address addr) {
-				return h.getAddress();
-			}
-			function getHelper() returns (address addr) {
-				return address(h);
-			}
-			function setHelper(address addr) {
-				h = Helper(addr);
-			}
-		})";
-	compileAndRun(sourceCode, 0, "Helper");
-	u160 const c_helperAddress = m_contractAddress;
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
-	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
-	BOOST_REQUIRE(callContractFunction("callHelper()") == encodeArgs(c_helperAddress));
-}
-
-BOOST_AUTO_TEST_CASE(calls_to_this)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			function invoke(uint a, uint b) returns (uint c) {
-				return this.multiply(a, b, 10);
-			}
-			function multiply(uint a, uint b, uint8 c) returns (uint ret) {
-				return a * b + c;
-			}
-		}
-		contract Main {
-			Helper h;
-			function callHelper(uint a, uint b) returns (uint ret) {
-				return h.invoke(a, b);
-			}
-			function getHelper() returns (address addr) {
-				return address(h);
-			}
-			function setHelper(address addr) {
-				h = Helper(addr);
-			}
-		})";
-	compileAndRun(sourceCode, 0, "Helper");
-	u160 const c_helperAddress = m_contractAddress;
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
-	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
-	u256 a(3456789);
-	u256 b("0x282837623374623234aa74");
-	BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b + 10));
-}
-
-BOOST_AUTO_TEST_CASE(inter_contract_calls_with_local_vars)
-{
-	// note that a reference to another contract's function occupies two stack slots,
-	// so this tests correct stack slot allocation
-	char const* sourceCode = R"(
-		contract Helper {
-			function multiply(uint a, uint b) returns (uint c) {
-				return a * b;
-			}
-		}
-		contract Main {
-			Helper h;
-			function callHelper(uint a, uint b) returns (uint c) {
-				var fu = h.multiply;
-				var y = 9;
-				var ret = fu(a, b);
-				return ret + y;
-			}
-			function getHelper() returns (address haddress) {
-				return address(h);
-			}
-			function setHelper(address haddress) {
-				h = Helper(haddress);
-			}
-		})";
-	compileAndRun(sourceCode, 0, "Helper");
-	u160 const c_helperAddress = m_contractAddress;
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
-	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
-	u256 a(3456789);
-	u256 b("0x282837623374623234aa74");
-	BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b + 9));
-}
-
-BOOST_AUTO_TEST_CASE(fixed_bytes_in_calls)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			function invoke(bytes3 x, bool stop) returns (bytes4 ret) {
-				return x;
-			}
-		}
-		contract Main {
-			Helper h;
-			function callHelper(bytes2 x, bool stop) returns (bytes5 ret) {
-				return h.invoke(x, stop);
-			}
-			function getHelper() returns (address addr) {
-				return address(h);
-			}
-			function setHelper(address addr) {
-				h = Helper(addr);
-			}
-		})";
-	compileAndRun(sourceCode, 0, "Helper");
-	u160 const c_helperAddress = m_contractAddress;
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
-	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
-	BOOST_CHECK(callContractFunction("callHelper(bytes2,bool)", string("\0a", 2), true) == encodeArgs(string("\0a\0\0\0", 5)));
-}
-
-BOOST_AUTO_TEST_CASE(constructor_arguments)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			bytes3 name;
-			bool flag;
-
-			function Helper(bytes3 x, bool f) {
-				name = x;
-				flag = f;
-			}
-			function getName() returns (bytes3 ret) { return name; }
-			function getFlag() returns (bool ret) { return flag; }
-		}
-		contract Main {
-			Helper h;
-			function Main() {
-				h = new Helper("abc", true);
-			}
-			function getFlag() returns (bool ret) { return h.getFlag(); }
-			function getName() returns (bytes3 ret) { return h.getName(); }
-		})";
-	compileAndRun(sourceCode, 0, "Main");
-	BOOST_REQUIRE(callContractFunction("getFlag()") == encodeArgs(true));
-	BOOST_REQUIRE(callContractFunction("getName()") == encodeArgs("abc"));
-}
-
-BOOST_AUTO_TEST_CASE(functions_called_by_constructor)
-{
-	char const* sourceCode = R"(
-		contract Test {
-			bytes3 name;
-			bool flag;
-			function Test() {
-				setName("abc");
-			}
-			function getName() returns (bytes3 ret) { return name; }
-			function setName(bytes3 _name) private { name = _name; }
-		})";
-	compileAndRun(sourceCode);
-	BOOST_REQUIRE(callContractFunction("getName()") == encodeArgs("abc"));
-}
-
-BOOST_AUTO_TEST_CASE(contracts_as_addresses)
-{
-	char const* sourceCode = R"(
-		contract helper {
-		}
-		contract test {
-			helper h;
-			function test() { h = new helper(); h.send(5); }
-			function getBalance() returns (uint256 myBalance, uint256 helperBalance) {
-				myBalance = this.balance;
-				helperBalance = h.balance;
-			}
-		}
-	)";
-	compileAndRun(sourceCode, 20);
-	BOOST_REQUIRE(callContractFunction("getBalance()") == encodeArgs(u256(20 - 5), u256(5)));
-}
-
-BOOST_AUTO_TEST_CASE(gas_and_value_basic)
-{
-	char const* sourceCode = R"(
-		contract helper {
-			bool flag;
-			function getBalance() returns (uint256 myBalance) {
-				return this.balance;
-			}
-			function setFlag() { flag = true; }
-			function getFlag() returns (bool fl) { return flag; }
-		}
-		contract test {
-			helper h;
-			function test() { h = new helper(); }
-			function sendAmount(uint amount) returns (uint256 bal) {
-				return h.getBalance.value(amount)();
-			}
-			function outOfGas() returns (bool ret) {
-				h.setFlag.gas(2)(); // should fail due to OOG
-				return true;
-			}
-			function checkState() returns (bool flagAfter, uint myBal) {
-				flagAfter = h.getFlag();
-				myBal = this.balance;
-			}
-		}
-	)";
-	compileAndRun(sourceCode, 20);
-	BOOST_REQUIRE(callContractFunction("sendAmount(uint256)", 5) == encodeArgs(5));
-	// call to helper should not succeed but amount should be transferred anyway
-	BOOST_REQUIRE(callContractFunction("outOfGas()", 5) == bytes());
-	BOOST_REQUIRE(callContractFunction("checkState()", 5) == encodeArgs(false, 20 - 5));
-}
-
-BOOST_AUTO_TEST_CASE(gas_for_builtin)
-{
-	char const* sourceCode = R"(
-		contract Contract {
-			function test(uint g) returns (bytes32 data, bool flag) {
-				data = ripemd160.gas(g)("abc");
-				flag = true;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test(uint256)", 500) == bytes());
-	BOOST_CHECK(callContractFunction("test(uint256)", 800) == encodeArgs(u256("0x8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"), true));
-}
-
-BOOST_AUTO_TEST_CASE(value_complex)
-{
-	char const* sourceCode = R"(
-		contract helper {
-			function getBalance() returns (uint256 myBalance) {
-				return this.balance;
-			}
-		}
-		contract test {
-			helper h;
-			function test() { h = new helper(); }
-			function sendAmount(uint amount) returns (uint256 bal) {
-				var x1 = h.getBalance.value(amount);
-				uint someStackElement = 20;
-				var x2 = x1.gas(1000);
-				return x2.value(amount + 3)();// overwrite value
-			}
-		}
-	)";
-	compileAndRun(sourceCode, 20);
-	BOOST_REQUIRE(callContractFunction("sendAmount(uint256)", 5) == encodeArgs(8));
-}
-
-BOOST_AUTO_TEST_CASE(value_insane)
-{
-	char const* sourceCode = R"(
-		contract helper {
-			function getBalance() returns (uint256 myBalance) {
-				return this.balance;
-			}
-		}
-		contract test {
-			helper h;
-			function test() { h = new helper(); }
-			function sendAmount(uint amount) returns (uint256 bal) {
-				var x1 = h.getBalance.value;
-				var x2 = x1(amount).gas;
-				var x3 = x2(1000).value;
-				return x3(amount + 3)();// overwrite value
-			}
-		}
-	)";
-	compileAndRun(sourceCode, 20);
-	BOOST_REQUIRE(callContractFunction("sendAmount(uint256)", 5) == encodeArgs(8));
-}
-
-BOOST_AUTO_TEST_CASE(value_for_constructor)
-{
-	char const* sourceCode = R"(
-		contract Helper {
-			bytes3 name;
-			bool flag;
-			function Helper(bytes3 x, bool f) {
-				name = x;
-				flag = f;
-			}
-			function getName() returns (bytes3 ret) { return name; }
-			function getFlag() returns (bool ret) { return flag; }
-		}
-		contract Main {
-			Helper h;
-			function Main() {
-				h = new Helper.value(10)("abc", true);
-			}
-			function getFlag() returns (bool ret) { return h.getFlag(); }
-			function getName() returns (bytes3 ret) { return h.getName(); }
-			function getBalances() returns (uint me, uint them) { me = this.balance; them = h.balance;}
-		})";
-	compileAndRun(sourceCode, 22, "Main");
-	BOOST_REQUIRE(callContractFunction("getFlag()") == encodeArgs(true));
-	BOOST_REQUIRE(callContractFunction("getName()") == encodeArgs("abc"));
-	BOOST_REQUIRE(callContractFunction("getBalances()") == encodeArgs(12, 10));
-}
-
-BOOST_AUTO_TEST_CASE(virtual_function_calls)
-{
-	char const* sourceCode = R"(
-		contract Base {
-			function f() returns (uint i) { return g(); }
-			function g() returns (uint i) { return 1; }
-		}
-		contract Derived is Base {
-			function g() returns (uint i) { return 2; }
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("g()") == encodeArgs(2));
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(2));
-}
-
-BOOST_AUTO_TEST_CASE(access_base_storage)
-{
-	char const* sourceCode = R"(
-		contract Base {
-			uint dataBase;
-			function getViaBase() returns (uint i) { return dataBase; }
-		}
-		contract Derived is Base {
-			uint dataDerived;
-			function setData(uint base, uint derived) returns (bool r) {
-				dataBase = base;
-				dataDerived = derived;
-				return true;
-			}
-			function getViaDerived() returns (uint base, uint derived) {
-				base = dataBase;
-				derived = dataDerived;
-			}
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("setData(uint256,uint256)", 1, 2) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("getViaBase()") == encodeArgs(1));
-	BOOST_CHECK(callContractFunction("getViaDerived()") == encodeArgs(1, 2));
-}
-
-BOOST_AUTO_TEST_CASE(single_copy_with_multiple_inheritance)
-{
-	char const* sourceCode = R"(
-		contract Base {
-			uint data;
-			function setData(uint i) { data = i; }
-			function getViaBase() returns (uint i) { return data; }
-		}
-		contract A is Base { function setViaA(uint i) { setData(i); } }
-		contract B is Base { function getViaB() returns (uint i) { return getViaBase(); } }
-		contract Derived is Base, B, A { }
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("getViaB()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("setViaA(uint256)", 23) == encodeArgs());
-	BOOST_CHECK(callContractFunction("getViaB()") == encodeArgs(23));
-}
-
-BOOST_AUTO_TEST_CASE(explicit_base_cass)
-{
-	char const* sourceCode = R"(
-		contract BaseBase { function g() returns (uint r) { return 1; } }
-		contract Base is BaseBase { function g() returns (uint r) { return 2; } }
-		contract Derived is Base {
-			function f() returns (uint r) { return BaseBase.g(); }
-			function g() returns (uint r) { return 3; }
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("g()") == encodeArgs(3));
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(1));
-}
-
-BOOST_AUTO_TEST_CASE(base_constructor_arguments)
-{
-	char const* sourceCode = R"(
-		contract BaseBase {
-			uint m_a;
-			function BaseBase(uint a) {
-				m_a = a;
-			}
-		}
-		contract Base is BaseBase(7) {
-			function Base() {
-				m_a *= m_a;
-			}
-		}
-		contract Derived is Base() {
-			function getA() returns (uint r) { return m_a; }
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("getA()") == encodeArgs(7 * 7));
-}
-
-BOOST_AUTO_TEST_CASE(function_usage_in_constructor_arguments)
-{
-	char const* sourceCode = R"(
-		contract BaseBase {
-			uint m_a;
-			function BaseBase(uint a) {
-				m_a = a;
-			}
-			function g() returns (uint r) { return 2; }
-		}
-		contract Base is BaseBase(BaseBase.g()) {
-		}
-		contract Derived is Base() {
-			function getA() returns (uint r) { return m_a; }
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("getA()") == encodeArgs(2));
-}
-
-BOOST_AUTO_TEST_CASE(virtual_function_usage_in_constructor_arguments)
-{
-	char const* sourceCode = R"(
-		contract BaseBase {
-			uint m_a;
-			function BaseBase(uint a) {
-				m_a = a;
-			}
-			function overridden() returns (uint r) { return 1; }
-			function g() returns (uint r) { return overridden(); }
-		}
-		contract Base is BaseBase(BaseBase.g()) {
-		}
-		contract Derived is Base() {
-			function getA() returns (uint r) { return m_a; }
-			function overridden() returns (uint r) { return 2; }
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("getA()") == encodeArgs(2));
-}
-
-BOOST_AUTO_TEST_CASE(constructor_argument_overriding)
-{
-	char const* sourceCode = R"(
-		contract BaseBase {
-			uint m_a;
-			function BaseBase(uint a) {
-				m_a = a;
-			}
-		}
-		contract Base is BaseBase(2) { }
-		contract Derived is BaseBase(3), Base {
-			function getA() returns (uint r) { return m_a; }
-		}
-	)";
-	compileAndRun(sourceCode, 0, "Derived");
-	BOOST_CHECK(callContractFunction("getA()") == encodeArgs(3));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier)
-{
-	char const* sourceCode = R"(
-		contract C {
-			function getOne() nonFree returns (uint r) { return 1; }
-			modifier nonFree { if (msg.value > 0) _ }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getOne()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunctionWithValue("getOne()", 1) == encodeArgs(1));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_local_variables)
-{
-	char const* sourceCode = R"(
-		contract C {
-			modifier mod1 { var a = 1; var b = 2; _ }
-			modifier mod2(bool a) { if (a) return; else _ }
-			function f(bool a) mod1 mod2(a) returns (uint r) { return 3; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f(bool)", true) == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("f(bool)", false) == encodeArgs(3));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_loop)
-{
-	char const* sourceCode = R"(
-		contract C {
-			modifier repeat(uint count) { for (var i = 0; i < count; ++i) _ }
-			function f() repeat(10) returns (uint r) { r += 1; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(10));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_multi_invocation)
-{
-	char const* sourceCode = R"(
-		contract C {
-			modifier repeat(bool twice) { if (twice) _ _ }
-			function f(bool twice) repeat(twice) returns (uint r) { r += 1; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f(bool)", false) == encodeArgs(1));
-	BOOST_CHECK(callContractFunction("f(bool)", true) == encodeArgs(2));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_multi_with_return)
-{
-	// Here, the explicit return prevents the second execution
-	char const* sourceCode = R"(
-		contract C {
-			modifier repeat(bool twice) { if (twice) _ _ }
-			function f(bool twice) repeat(twice) returns (uint r) { r += 1; return r; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f(bool)", false) == encodeArgs(1));
-	BOOST_CHECK(callContractFunction("f(bool)", true) == encodeArgs(1));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_overriding)
-{
-	char const* sourceCode = R"(
-		contract A {
-			function f() mod returns (bool r) { return true; }
-			modifier mod { _ }
-		}
-		contract C is A {
-			modifier mod { }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(false));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_calling_functions_in_creation_context)
-{
-	char const* sourceCode = R"(
-		contract A {
-			uint data;
-			function A() mod1 { f1(); }
-			function f1() mod2 { data |= 0x1; }
-			function f2() { data |= 0x20; }
-			function f3() { }
-			modifier mod1 { f2(); _ }
-			modifier mod2 { f3(); }
-			function getData() returns (uint r) { return data; }
-		}
-		contract C is A {
-			modifier mod1 { f4(); _ }
-			function f3() { data |= 0x300; }
-			function f4() { data |= 0x4000; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getData()") == encodeArgs(0x4300));
-}
-
-BOOST_AUTO_TEST_CASE(function_modifier_for_constructor)
-{
-	char const* sourceCode = R"(
-		contract A {
-			uint data;
-			function A() mod1 { data |= 2; }
-			modifier mod1 { data |= 1; _ }
-			function getData() returns (uint r) { return data; }
-		}
-		contract C is A {
-			modifier mod1 { data |= 4; _ }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getData()") == encodeArgs(4 | 2));
-}
-
-BOOST_AUTO_TEST_CASE(use_std_lib)
-{
-	char const* sourceCode = R"(
-		import "mortal";
-		contract Icarus is mortal { }
-	)";
-	m_addStandardSources = true;
-	u256 amount(130);
-	u160 address(23);
-	compileAndRun(sourceCode, amount, "Icarus");
-	u256 balanceBefore = m_state.balance(m_sender);
-	BOOST_CHECK(callContractFunction("kill()") == bytes());
-	BOOST_CHECK(!m_state.addressHasCode(m_contractAddress));
-	BOOST_CHECK(m_state.balance(m_sender) > balanceBefore);
-}
-
-BOOST_AUTO_TEST_CASE(crazy_elementary_typenames_on_stack)
-{
-	char const* sourceCode = R"(
-		contract C {
-			function f() returns (uint r) {
-				uint; uint; uint; uint;
-				int x = -7;
-				var a = uint;
-				return a(x);
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(-7)));
-}
-
-BOOST_AUTO_TEST_CASE(super)
-{
-	char const* sourceCode = R"(
-		contract A { function f() returns (uint r) { return 1; } }
-		contract B is A { function f() returns (uint r) { return super.f() | 2; } }
-		contract C is A { function f() returns (uint r) { return super.f() | 4; } }
-		contract D is B, C { function f() returns (uint r) { return super.f() | 8; } }
-	)";
-	compileAndRun(sourceCode, 0, "D");
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(1 | 2 | 4 | 8));
-}
-
-BOOST_AUTO_TEST_CASE(super_in_constructor)
-{
-	char const* sourceCode = R"(
-		contract A { function f() returns (uint r) { return 1; } }
-		contract B is A { function f() returns (uint r) { return super.f() | 2; } }
-		contract C is A { function f() returns (uint r) { return super.f() | 4; } }
-		contract D is B, C { uint data; function D() { data = super.f() | 8; } function f() returns (uint r) { return data; } }
-	)";
-	compileAndRun(sourceCode, 0, "D");
-	BOOST_CHECK(callContractFunction("f()") == encodeArgs(1 | 2 | 4 | 8));
-}
-
-BOOST_AUTO_TEST_CASE(fallback_function)
-{
-	char const* sourceCode = R"(
-		contract A {
-			uint data;
-			function() returns (uint r) { data = 1; return 2; }
-			function getData() returns (uint r) { return data; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getData()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("") == encodeArgs(2));
-	BOOST_CHECK(callContractFunction("getData()") == encodeArgs(1));
-}
-
-BOOST_AUTO_TEST_CASE(inherited_fallback_function)
-{
-	char const* sourceCode = R"(
-		contract A {
-			uint data;
-			function() returns (uint r) { data = 1; return 2; }
-			function getData() returns (uint r) { return data; }
-		}
-		contract B is A {}
-	)";
-	compileAndRun(sourceCode, 0, "B");
-	BOOST_CHECK(callContractFunction("getData()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("") == encodeArgs(2));
-	BOOST_CHECK(callContractFunction("getData()") == encodeArgs(1));
-}
-
-BOOST_AUTO_TEST_CASE(event)
-{
-	char const* sourceCode = R"(
-		contract ClientReceipt {
-			event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
-			function deposit(bytes32 _id, bool _manually) {
-				if (_manually) {
-					bytes32 s = 0x19dacbf83c5de6658e14cbf7bcae5c15eca2eedecf1c66fbca928e4d351bea0f;
-					log3(bytes32(msg.value), s, bytes32(msg.sender), _id);
-				} else
-					Deposit(msg.sender, _id, msg.value);
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	u256 value(18);
-	u256 id(0x1234);
-	for (bool manually: {true, false})
-	{
-		callContractFunctionWithValue("deposit(bytes32,bool)", value, id, manually);
-		BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
-		BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-		BOOST_CHECK_EQUAL(h256(m_logs[0].data), h256(u256(value)));
-		BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 3);
-		BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit(address,bytes32,uint256)")));
-		BOOST_CHECK_EQUAL(m_logs[0].topics[1], h256(m_sender));
-		BOOST_CHECK_EQUAL(m_logs[0].topics[2], h256(id));
-	}
-}
-
-BOOST_AUTO_TEST_CASE(event_no_arguments)
-{
-	char const* sourceCode = R"(
-		contract ClientReceipt {
-			event Deposit;
-			function deposit() {
-				Deposit();
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	callContractFunction("deposit()");
-	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK(m_logs[0].data.empty());
-	BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit()")));
-}
-
-BOOST_AUTO_TEST_CASE(event_lots_of_data)
-{
-	char const* sourceCode = R"(
-		contract ClientReceipt {
-			event Deposit(address _from, bytes32 _id, uint _value, bool _flag);
-			function deposit(bytes32 _id) {
-				Deposit(msg.sender, _id, msg.value, true);
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	u256 value(18);
-	u256 id(0x1234);
-	callContractFunctionWithValue("deposit(bytes32)", value, id);
-	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
-	BOOST_CHECK(m_logs[0].data == encodeArgs((u160)m_sender, id, value, true));
-	BOOST_REQUIRE_EQUAL(m_logs[0].topics.size(), 1);
-	BOOST_CHECK_EQUAL(m_logs[0].topics[0], dev::sha3(string("Deposit(address,bytes32,uint256,bool)")));
-}
-
-BOOST_AUTO_TEST_CASE(empty_name_input_parameter_with_named_one)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function f(uint, uint k) returns(uint ret_k, uint ret_g){
-				uint g = 8;
-				ret_k = k;
-				ret_g = g;
-			}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f(uint256,uint256)", 5, 9) != encodeArgs(5, 8));
-	BOOST_CHECK(callContractFunction("f(uint256,uint256)", 5, 9) == encodeArgs(9, 8));
-}
-
-BOOST_AUTO_TEST_CASE(empty_name_return_parameter)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function f(uint k) returns(uint){
-				return k;
-		}
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("f(uint256)", 9) == encodeArgs(9));
-}
-
-BOOST_AUTO_TEST_CASE(sha3_multiple_arguments)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function foo(uint a, uint b, uint c) returns (bytes32 d)
-			{
-				d = sha3(a, b, c);
-			}
-		})";
-	compileAndRun(sourceCode);
-
-	BOOST_CHECK(callContractFunction("foo(uint256,uint256,uint256)", 10, 12, 13) == encodeArgs(
-					dev::sha3(
-						toBigEndian(u256(10)) +
-						toBigEndian(u256(12)) +
-						toBigEndian(u256(13)))));
-}
-
-BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_numeric_literals)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function foo(uint a, uint16 b) returns (bytes32 d)
-			{
-				d = sha3(a, b, 145);
-			}
-		})";
-	compileAndRun(sourceCode);
-
-	BOOST_CHECK(callContractFunction("foo(uint256,uint16)", 10, 12) == encodeArgs(
-					dev::sha3(
-						toBigEndian(u256(10)) +
-						bytes{0x0, 0xc} +
-						bytes(1, 0x91))));
-}
-
-BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_string_literals)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function foo() returns (bytes32 d)
-			{
-				d = sha3("foo");
-			}
-			function bar(uint a, uint16 b) returns (bytes32 d)
-			{
-				d = sha3(a, b, 145, "foo");
-			}
-		})";
-	compileAndRun(sourceCode);
-
-	BOOST_CHECK(callContractFunction("foo()") == encodeArgs(dev::sha3("foo")));
-
-	BOOST_CHECK(callContractFunction("bar(uint256,uint16)", 10, 12) == encodeArgs(
-					dev::sha3(
-						toBigEndian(u256(10)) +
-						bytes{0x0, 0xc} +
-						bytes(1, 0x91) +
-						bytes{0x66, 0x6f, 0x6f})));
-}
-
-BOOST_AUTO_TEST_CASE(generic_call)
-{
-	char const* sourceCode = R"**(
-			contract receiver {
-				uint public received;
-				function receive(uint256 x) { received = x; }
-			}
-			contract sender {
-				function doSend(address rec) returns (uint d)
-				{
-					bytes4 signature = bytes4(bytes32(sha3("receive(uint256)")));
-					rec.call.value(2)(signature, 23);
-					return receiver(rec).received();
-				}
-			}
-	)**";
-	compileAndRun(sourceCode, 0, "receiver");
-	u160 const c_receiverAddress = m_contractAddress;
-	compileAndRun(sourceCode, 50, "sender");
-	BOOST_REQUIRE(callContractFunction("doSend(address)", c_receiverAddress) == encodeArgs(23));
-	BOOST_CHECK_EQUAL(m_state.balance(m_contractAddress), 50 - 2);
-}
-
-BOOST_AUTO_TEST_CASE(store_bytes)
-{
-	// this test just checks that the copy loop does not mess up the stack
-	char const* sourceCode = R"(
-		contract C {
-			function save() returns (uint r) {
-				r = 23;
-				savedData = msg.data;
-				r = 24;
-			}
-			bytes savedData;
-		}
-	)";
-	compileAndRun(sourceCode);
-	// empty copy loop
-	BOOST_CHECK(callContractFunction("save()") == encodeArgs(24));
-	BOOST_CHECK(callContractFunction("save()", "abcdefg") == encodeArgs(24));
-}
-
-BOOST_AUTO_TEST_CASE(bytes_from_calldata_to_memory)
-{
-	char const* sourceCode = R"(
-		contract C {
-			function() returns (bytes32) {
-				return sha3("abc", msg.data);
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	bytes calldata1 = bytes(61, 0x22) + bytes(12, 0x12);
-	sendMessage(calldata1, false);
-	BOOST_CHECK(m_output == encodeArgs(dev::sha3(bytes{'a', 'b', 'c'} + calldata1)));
-}
-
-BOOST_AUTO_TEST_CASE(call_forward_bytes)
-{
-	char const* sourceCode = R"(
-		contract receiver {
-			uint public received;
-			function receive(uint x) { received += x + 1; }
-			function() { received = 0x80; }
-		}
-		contract sender {
-			function sender() { rec = new receiver(); }
-			function() { savedData = msg.data; }
-			function forward() returns (bool) { rec.call(savedData); return true; }
-			function clear() returns (bool) { delete savedData; return true; }
-			function val() returns (uint) { return rec.received(); }
-			receiver rec;
-			bytes savedData;
-		}
-	)";
-	compileAndRun(sourceCode, 0, "sender");
-	BOOST_CHECK(callContractFunction("receive(uint256)", 7) == bytes());
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("forward()") == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(8));
-	BOOST_CHECK(callContractFunction("clear()") == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(8));
-	BOOST_CHECK(callContractFunction("forward()") == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(0x80));
-}
-
-BOOST_AUTO_TEST_CASE(copying_bytes_multiassign)
-{
-	char const* sourceCode = R"(
-		contract receiver {
-			uint public received;
-			function receive(uint x) { received += x + 1; }
-			function() { received = 0x80; }
-		}
-		contract sender {
-			function sender() { rec = new receiver(); }
-			function() { savedData1 = savedData2 = msg.data; }
-			function forward(bool selector) returns (bool) {
-				if (selector) { rec.call(savedData1); delete savedData1; }
-				else { rec.call(savedData2); delete savedData2; }
-				return true;
-			}
-			function val() returns (uint) { return rec.received(); }
-			receiver rec;
-			bytes savedData1;
-			bytes savedData2;
-		}
-	)";
-	compileAndRun(sourceCode, 0, "sender");
-	BOOST_CHECK(callContractFunction("receive(uint256)", 7) == bytes());
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("forward(bool)", true) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(8));
-	BOOST_CHECK(callContractFunction("forward(bool)", false) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(16));
-	BOOST_CHECK(callContractFunction("forward(bool)", true) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("val()") == encodeArgs(0x80));
-}
-
-BOOST_AUTO_TEST_CASE(delete_removes_bytes_data)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function() { data = msg.data; }
-			function del() returns (bool) { delete data; return true; }
-			bytes data;
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("---", 7) == bytes());
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("del()", 7) == encodeArgs(true));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(copy_from_calldata_removes_bytes_data)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function set() returns (bool) { data = msg.data; return true; }
-			function() { data = msg.data; }
-			bytes data;
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("set()", 1, 2, 3, 4, 5) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	sendMessage(bytes(), false);
-	BOOST_CHECK(m_output == bytes());
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(copy_removes_bytes_data)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function set() returns (bool) { data1 = msg.data; return true; }
-			function reset() returns (bool) { data1 = data2; return true; }
-			bytes data1;
-			bytes data2;
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("set()", 1, 2, 3, 4, 5) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("reset()") == encodeArgs(true));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(bytes_inside_mappings)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function set(uint key) returns (bool) { data[key] = msg.data; return true; }
-			function copy(uint from, uint to) returns (bool) { data[to] = data[from]; return true; }
-			mapping(uint => bytes) data;
-		}
-	)";
-	compileAndRun(sourceCode);
-	// store a short byte array at 1 and a longer one at 2
-	BOOST_CHECK(callContractFunction("set(uint256)", 1, 2) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("set(uint256)", 2, 2, 3, 4, 5) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	// copy shorter to longer
-	BOOST_CHECK(callContractFunction("copy(uint256,uint256)", 1, 2) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	// copy empty to both
-	BOOST_CHECK(callContractFunction("copy(uint256,uint256)", 99, 1) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("copy(uint256,uint256)", 99, 2) == encodeArgs(true));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(bytes_length_member)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function set() returns (bool) { data = msg.data; return true; }
-			function getLength() returns (uint) { return data.length; }
-			bytes data;
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getLength()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("set()", 1, 2) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("getLength()") == encodeArgs(4+32+32));
-}
-
-BOOST_AUTO_TEST_CASE(struct_copy)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct Nested { uint x; uint y; }
-			struct Struct { uint a; mapping(uint => Struct) b; Nested nested; uint c; }
-			mapping(uint => Struct) public data;
-			function set(uint k) returns (bool) {
-				data[k].a = 1;
-				data[k].nested.x = 3;
-				data[k].nested.y = 4;
-				data[k].c = 2;
-				return true;
-			}
-			function copy(uint from, uint to) returns (bool) {
-				data[to] = data[from];
-				return true;
-			}
-			function retrieve(uint k) returns (uint a, uint x, uint y, uint c)
-			{
-				a = data[k].a;
-				x = data[k].nested.x;
-				y = data[k].nested.y;
-				c = data[k].c;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("set(uint256)", 7) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("retrieve(uint256)", 7) == encodeArgs(1, 3, 4, 2));
-	BOOST_CHECK(callContractFunction("copy(uint256,uint256)", 7, 8) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("retrieve(uint256)", 7) == encodeArgs(1, 3, 4, 2));
-	BOOST_CHECK(callContractFunction("retrieve(uint256)", 8) == encodeArgs(1, 3, 4, 2));
-	BOOST_CHECK(callContractFunction("copy(uint256,uint256)", 0, 7) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("retrieve(uint256)", 7) == encodeArgs(0, 0, 0, 0));
-	BOOST_CHECK(callContractFunction("retrieve(uint256)", 8) == encodeArgs(1, 3, 4, 2));
-	BOOST_CHECK(callContractFunction("copy(uint256,uint256)", 7, 8) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("retrieve(uint256)", 8) == encodeArgs(0, 0, 0, 0));
-}
-
-BOOST_AUTO_TEST_CASE(struct_containing_bytes_copy_and_delete)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct Struct { uint a; bytes data; uint b; }
-			Struct data1;
-			Struct data2;
-			function set(uint _a, bytes _data, uint _b) external returns (bool) {
-				data1.a = _a;
-				data1.b = _b;
-				data1.data = _data;
-				return true;
-			}
-			function copy() returns (bool) {
-				data1 = data2;
-				return true;
-			}
-			function del() returns (bool) {
-				delete data1;
-				return true;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	string data = "123456789012345678901234567890123";
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("set(uint256,bytes,uint256)", 12, u256(data.length()), 13, data) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("copy()") == encodeArgs(true));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("set(uint256,bytes,uint256)", 12, u256(data.length()), 13, data) == encodeArgs(true));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("del()") == encodeArgs(true));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(struct_copy_via_local)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct Struct { uint a; uint b; }
-			Struct data1;
-			Struct data2;
-			function test() returns (bool) {
-				data1.a = 1;
-				data1.b = 2;
-				var x = data1;
-				data2 = x;
-				return data2.a == data1.a && data2.b == data1.b;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test()") == encodeArgs(true));
-}
-
-BOOST_AUTO_TEST_CASE(using_enums)
-{
-	char const* sourceCode = R"(
-			contract test {
-				enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
-				function test()
-				{
-					choices = ActionChoices.GoStraight;
-				}
-				function getChoice() returns (uint d)
-				{
-					d = uint256(choices);
-				}
-				ActionChoices choices;
-			}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getChoice()") == encodeArgs(2));
-}
-
-BOOST_AUTO_TEST_CASE(constructing_enums_from_ints)
-{
-	char const* sourceCode = R"(
-			contract c {
-				enum Truth { False, True }
-				function test() returns (uint)
-				{
-					return uint(Truth(uint8(0x701)));
-				}
-			}
-	)";
-	compileAndRun(sourceCode);
-	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"(
-		contract c {
-			function f(uint a) returns (uint) { return a; }
-			function test(uint a, uint b) external returns (uint r_a, uint r_b) {
-				r_a = f(a + 7);
-				r_b = b;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test(uint256,uint256)", 2, 3) == encodeArgs(2+7, 3));
-}
-
-BOOST_AUTO_TEST_CASE(bytes_in_arguments)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint result;
-			function f(uint a, uint b) { result += a + b; }
-			function g(uint a) { result *= a; }
-			function test(uint a, bytes data1, bytes data2, uint b) external returns (uint r_a, uint r, uint r_b, uint l) {
-				r_a = a;
-				this.call(data1);
-				this.call(data2);
-				r = result;
-				r_b = b;
-				l = data1.length;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	string innercalldata1 = asString(FixedHash<4>(dev::sha3("f(uint256,uint256)")).asBytes() + encodeArgs(8, 9));
-	bytes calldata1 = encodeArgs(u256(innercalldata1.length()), 12, innercalldata1, 13);
-	string innercalldata2 = asString(FixedHash<4>(dev::sha3("g(uint256)")).asBytes() + encodeArgs(3));
-	bytes calldata = encodeArgs(
-		12, u256(innercalldata1.length()), u256(innercalldata2.length()), 13,
-		innercalldata1, innercalldata2);
-	BOOST_CHECK(callContractFunction("test(uint256,bytes,bytes,uint256)", calldata)
-		== encodeArgs(12, (8 + 9) * 3, 13, u256(innercalldata1.length())));
-}
-
-BOOST_AUTO_TEST_CASE(fixed_arrays_in_storage)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct Data { uint x; uint y; }
-			Data[2**10] data;
-			uint[2**10 + 3] ids;
-			function setIDStatic(uint id) { ids[2] = id; }
-			function setID(uint index, uint id) { ids[index] = id; }
-			function setData(uint index, uint x, uint y) { data[index].x = x; data[index].y = y; }
-			function getID(uint index) returns (uint) { return ids[index]; }
-			function getData(uint index) returns (uint x, uint y) { x = data[index].x; y = data[index].y; }
-			function getLengths() returns (uint l1, uint l2) { l1 = data.length; l2 = ids.length; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("setIDStatic(uint256)", 11) == bytes());
-	BOOST_CHECK(callContractFunction("getID(uint256)", 2) == encodeArgs(11));
-	BOOST_CHECK(callContractFunction("setID(uint256,uint256)", 7, 8) == bytes());
-	BOOST_CHECK(callContractFunction("getID(uint256)", 7) == encodeArgs(8));
-	BOOST_CHECK(callContractFunction("setData(uint256,uint256,uint256)", 7, 8, 9) == bytes());
-	BOOST_CHECK(callContractFunction("setData(uint256,uint256,uint256)", 8, 10, 11) == bytes());
-	BOOST_CHECK(callContractFunction("getData(uint256)", 7) == encodeArgs(8, 9));
-	BOOST_CHECK(callContractFunction("getData(uint256)", 8) == encodeArgs(10, 11));
-	BOOST_CHECK(callContractFunction("getLengths()") == encodeArgs(u256(1) << 10, (u256(1) << 10) + 3));
-}
-
-BOOST_AUTO_TEST_CASE(dynamic_arrays_in_storage)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct Data { uint x; uint y; }
-			Data[] data;
-			uint[] ids;
-			function setIDStatic(uint id) { ids[2] = id; }
-			function setID(uint index, uint id) { ids[index] = id; }
-			function setData(uint index, uint x, uint y) { data[index].x = x; data[index].y = y; }
-			function getID(uint index) returns (uint) { return ids[index]; }
-			function getData(uint index) returns (uint x, uint y) { x = data[index].x; y = data[index].y; }
-			function getLengths() returns (uint l1, uint l2) { l1 = data.length; l2 = ids.length; }
-			function setLengths(uint l1, uint l2) { data.length = l1; ids.length = l2; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getLengths()") == encodeArgs(0, 0));
-	BOOST_CHECK(callContractFunction("setLengths(uint256,uint256)", 48, 49) == bytes());
-	BOOST_CHECK(callContractFunction("getLengths()") == encodeArgs(48, 49));
-	BOOST_CHECK(callContractFunction("setIDStatic(uint256)", 11) == bytes());
-	BOOST_CHECK(callContractFunction("getID(uint256)", 2) == encodeArgs(11));
-	BOOST_CHECK(callContractFunction("setID(uint256,uint256)", 7, 8) == bytes());
-	BOOST_CHECK(callContractFunction("getID(uint256)", 7) == encodeArgs(8));
-	BOOST_CHECK(callContractFunction("setData(uint256,uint256,uint256)", 7, 8, 9) == bytes());
-	BOOST_CHECK(callContractFunction("setData(uint256,uint256,uint256)", 8, 10, 11) == bytes());
-	BOOST_CHECK(callContractFunction("getData(uint256)", 7) == encodeArgs(8, 9));
-	BOOST_CHECK(callContractFunction("getData(uint256)", 8) == encodeArgs(10, 11));
-}
-
-BOOST_AUTO_TEST_CASE(fixed_out_of_bounds_array_access)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[4] data;
-			function set(uint index, uint value) returns (bool) { data[index] = value; return true; }
-			function get(uint index) returns (uint) { return data[index]; }
-			function length() returns (uint) { return data.length; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("length()") == encodeArgs(4));
-	BOOST_CHECK(callContractFunction("set(uint256,uint256)", 3, 4) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("set(uint256,uint256)", 4, 5) == bytes());
-	BOOST_CHECK(callContractFunction("set(uint256,uint256)", 400, 5) == bytes());
-	BOOST_CHECK(callContractFunction("get(uint256)", 3) == encodeArgs(4));
-	BOOST_CHECK(callContractFunction("get(uint256)", 4) == bytes());
-	BOOST_CHECK(callContractFunction("get(uint256)", 400) == bytes());
-	BOOST_CHECK(callContractFunction("length()") == encodeArgs(4));
-}
-
-BOOST_AUTO_TEST_CASE(dynamic_out_of_bounds_array_access)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[] data;
-			function enlarge(uint amount) returns (uint) { return data.length += amount; }
-			function set(uint index, uint value) returns (bool) { data[index] = value; return true; }
-			function get(uint index) returns (uint) { return data[index]; }
-			function length() returns (uint) { return data.length; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("length()") == encodeArgs(0));
-	BOOST_CHECK(callContractFunction("get(uint256)", 3) == bytes());
-	BOOST_CHECK(callContractFunction("enlarge(uint256)", 4) == encodeArgs(4));
-	BOOST_CHECK(callContractFunction("length()") == encodeArgs(4));
-	BOOST_CHECK(callContractFunction("set(uint256,uint256)", 3, 4) == encodeArgs(true));
-	BOOST_CHECK(callContractFunction("get(uint256)", 3) == encodeArgs(4));
-	BOOST_CHECK(callContractFunction("length()") == encodeArgs(4));
-	BOOST_CHECK(callContractFunction("set(uint256,uint256)", 4, 8) == bytes());
-	BOOST_CHECK(callContractFunction("length()") == encodeArgs(4));
-}
-
-BOOST_AUTO_TEST_CASE(fixed_array_cleanup)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint spacer1;
-			uint spacer2;
-			uint[20] data;
-			function fill() {
-				for (uint i = 0; i < data.length; ++i) data[i] = i+1;
-			}
-			function clear() { delete data; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("fill()") == bytes());
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("clear()") == bytes());
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(short_fixed_array_cleanup)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint spacer1;
-			uint spacer2;
-			uint[3] data;
-			function fill() {
-				for (uint i = 0; i < data.length; ++i) data[i] = i+1;
-			}
-			function clear() { delete data; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("fill()") == bytes());
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("clear()") == bytes());
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(dynamic_array_cleanup)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[20] spacer;
-			uint[] dynamic;
-			function fill() {
-				dynamic.length = 21;
-				for (uint i = 0; i < dynamic.length; ++i) dynamic[i] = i+1;
-			}
-			function halfClear() { dynamic.length = 5; }
-			function fullClear() { delete dynamic; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("fill()") == bytes());
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("halfClear()") == bytes());
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("fullClear()") == bytes());
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(dynamic_multi_array_cleanup)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct s { uint[][] d; }
-			s[] data;
-			function fill() returns (uint) {
-				data.length = 3;
-				data[2].d.length = 4;
-				data[2].d[3].length = 5;
-				data[2].d[3][4] = 8;
-				return data[2].d[3][4];
-			}
-			function clear() { delete data; }
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("fill()") == encodeArgs(8));
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("clear()") == bytes());
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_storage_storage_dyn_dyn)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[] data1;
-			uint[] data2;
-			function setData1(uint length, uint index, uint value) {
-				data1.length = length; if (index < length) data1[index] = value;
-			}
-			function copyStorageStorage() { data2 = data1; }
-			function getData2(uint index) returns (uint len, uint val) {
-				len = data2.length; if (index < len) val = data2[index];
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("setData1(uint256,uint256,uint256)", 10, 5, 4) == bytes());
-	BOOST_CHECK(callContractFunction("copyStorageStorage()") == bytes());
-	BOOST_CHECK(callContractFunction("getData2(uint256)", 5) == encodeArgs(10, 4));
-	BOOST_CHECK(callContractFunction("setData1(uint256,uint256,uint256)", 0, 0, 0) == bytes());
-	BOOST_CHECK(callContractFunction("copyStorageStorage()") == bytes());
-	BOOST_CHECK(callContractFunction("getData2(uint256)", 0) == encodeArgs(0, 0));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_storage_storage_static_static)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[40] data1;
-			uint[20] data2;
-			function test() returns (uint x, uint y){
-				data1[30] = 4;
-				data1[2] = 7;
-				data1[3] = 9;
-				data2[3] = 8;
-				data1 = data2;
-				x = data1[3];
-				y = data1[30]; // should be cleared
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test()") == encodeArgs(8, 0));
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_storage_storage_static_dynamic)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[9] data1;
-			uint[] data2;
-			function test() returns (uint x, uint y){
-				data1[8] = 4;
-				data2 = data1;
-				x = data2.length;
-				y = data2[8];
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test()") == encodeArgs(9, 4));
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_storage_storage_struct)
-{
-	char const* sourceCode = R"(
-		contract c {
-			struct Data { uint x; uint y; }
-			Data[] data1;
-			Data[] data2;
-			function test() returns (uint x, uint y) {
-				data1.length = 9;
-				data1[8].x = 4;
-				data1[8].y = 5;
-				data2 = data1;
-				x = data2[8].x;
-				y = data2[8].y;
-				data1.length = 0;
-				data2 = data1;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test()") == encodeArgs(4, 5));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(external_array_args)
-{
-	char const* sourceCode = R"(
-		contract c {
-			function test(uint[8] a, uint[] b, uint[5] c, uint a_index, uint b_index, uint c_index)
-					external returns (uint av, uint bv, uint cv) {
-				av = a[a_index];
-				bv = b[b_index];
-				cv = c[c_index];
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	bytes params = encodeArgs(
-		1, 2, 3, 4, 5, 6, 7, 8, // a
-		3, // b.length
-		21, 22, 23, 24, 25, // c
-		0, 1, 2, // (a,b,c)_index
-		11, 12, 13 // b
-		);
-	BOOST_CHECK(callContractFunction("test(uint256[8],uint256[],uint256[5],uint256,uint256,uint256)", params) == encodeArgs(1, 12, 23));
-}
-
-BOOST_AUTO_TEST_CASE(bytes_index_access)
-{
-	char const* sourceCode = R"(
-		contract c {
-			bytes data;
-			function direct(bytes arg, uint index) external returns (uint) {
-				return uint(arg[index]);
-			}
-			function storageCopyRead(bytes arg, uint index) external returns (uint) {
-				data = arg;
-				return uint(data[index]);
-			}
-			function storageWrite() external returns (uint) {
-				data.length = 35;
-				data[31] = 0x77;
-				data[32] = 0x14;
-
-				data[31] = 1;
-				data[31] |= 8;
-				data[30] = 1;
-				data[32] = 3;
-				return uint(data[30]) * 0x100 | uint(data[31]) * 0x10 | uint(data[32]);
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	string array{
-		0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-		10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-		20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-		30, 31, 32, 33};
-	BOOST_CHECK(callContractFunction("direct(bytes,uint256)", u256(array.length()), 32, array) == encodeArgs(32));
-	BOOST_CHECK(callContractFunction("storageCopyRead(bytes,uint256)", u256(array.length()), 32, array) == encodeArgs(32));
-	BOOST_CHECK(callContractFunction("storageWrite()") == encodeArgs(0x193));
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_calldata_storage)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[9] m_data;
-			uint[] m_data_dyn;
-			uint8[][] m_byte_data;
-			function store(uint[9] a, uint8[3][] b) external returns (uint8) {
-				m_data = a;
-				m_data_dyn = a;
-				m_byte_data = b;
-				return b[3][1]; // note that access and declaration are reversed to each other
-			}
-			function retrieve() returns (uint a, uint b, uint c, uint d, uint e, uint f, uint g) {
-				a = m_data.length;
-				b = m_data[7];
-				c = m_data_dyn.length;
-				d = m_data_dyn[7];
-				e = m_byte_data.length;
-				f = m_byte_data[3].length;
-				g = m_byte_data[3][1];
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("store(uint256[9],uint8[3][])", encodeArgs(
-		21, 22, 23, 24, 25, 26, 27, 28, 29, // a
-		4, // size of b
-		1, 2, 3, // b[0]
-		11, 12, 13, // b[1]
-		21, 22, 23, // b[2]
-		31, 32, 33 // b[3]
-	)) == encodeArgs(32));
-	BOOST_CHECK(callContractFunction("retrieve()") == encodeArgs(
-		9, 28, 9, 28,
-		4, 3, 32));
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_nested_array)
-{
-	char const* sourceCode = R"(
-		contract c {
-			uint[4][] a;
-			uint[5][] b;
-			uint[][] c;
-			function test(uint[2][] d) external returns (uint) {
-				a = d;
-				b = a;
-				c = b;
-				return c[1][1] | c[1][2] | c[1][3] | c[1][4];
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test(uint256[2][])", encodeArgs(
-		3,
-		7, 8,
-		9, 10,
-		11, 12
-	)) == encodeArgs(10));
-}
-
-BOOST_AUTO_TEST_CASE(array_copy_including_mapping)
-{
-	char const* sourceCode = R"(
-		contract c {
-			mapping(uint=>uint)[90][] large;
-			mapping(uint=>uint)[3][] small;
-			function test() returns (uint r) {
-				large.length = small.length = 7;
-				large[3][2][0] = 2;
-				large[1] = large[3];
-				small[3][2][0] = 2;
-				small[1] = small[2];
-				r = ((
-					small[3][2][0] * 0x100 |
-					small[1][2][0]) * 0x100 |
-					large[3][2][0]) * 0x100 |
-					large[1][2][0];
-				delete small;
-				delete large;
-			}
-			function clear() returns (uint r) {
-				large.length = small.length = 7;
-				small[3][2][0] = 0;
-				large[3][2][0] = 0;
-				small.length = large.length = 0;
-				return 7;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("test()") == encodeArgs(0x02000200));
-	// storage is not empty because we cannot delete the mappings
-	BOOST_CHECK(!m_state.storage(m_contractAddress).empty());
-	BOOST_CHECK(callContractFunction("clear()") == encodeArgs(7));
-	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
-}
-
-BOOST_AUTO_TEST_CASE(pass_dynamic_arguments_to_the_base)
-{
-	char const* sourceCode = R"(
-		contract Base {
-			function Base(uint i)
-			{
-				m_i = i;
-			}
-			uint public m_i;
-		}
-		contract Derived is Base(2) {
-			function Derived(uint i) Base(i)
-			{}
-		}
-		contract Final is Derived(4) {
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("m_i()") == encodeArgs(4));
-}
-
-BOOST_AUTO_TEST_CASE(pass_dynamic_arguments_to_the_base_base)
-{
-	char const* sourceCode = R"(
-		contract Base {
-			function Base(uint j)
-			{
-				m_i = j;
-			}
-			uint public m_i;
-		}
-		contract Base1 is Base(3) {
-			function Base1(uint k) Base(k*k) {}
-		}
-		contract Derived is Base(3), Base1(2) {
-			function Derived(uint i) Base(i) Base1(i)
-			{}
-		}
-		contract Final is Derived(4) {
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("m_i()") == encodeArgs(4));
-}
-
-BOOST_AUTO_TEST_CASE(pass_dynamic_arguments_to_the_base_base_with_gap)
-{
-	char const* sourceCode = R"(
-		contract Base {
-			function Base(uint i)
-			{
-				m_i = i;
-			}
-			uint public m_i;
-		}
-		contract Base1 is Base(3) {}
-		contract Derived is Base(2), Base1 {
-			function Derived(uint i) Base(i) {}
-		}
-		contract Final is Derived(4) {
-		})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("m_i()") == encodeArgs(4));
-}
-
-<<<<<<< HEAD
-=======
-BOOST_AUTO_TEST_CASE(constant_functions)
-{
-	char const* sourceCode = R"(
-		contract Foo {
-			function getX() constant returns (uint r) { r = x; }
-			uint x = 56;
-	})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getX()") == encodeArgs(56));
-}
-
-BOOST_AUTO_TEST_CASE(const_state_variable)
-{
-	char const* sourceCode = R"(
-		contract Foo {
-			function getX() constant returns (uint r) { return x; }
-			constant uint x = 56;
-	})";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("getX()") == encodeArgs(56));
-}
-
->>>>>>> 0925feb... added parsing for constant variables
-BOOST_AUTO_TEST_SUITE_END()
-
-}
-}
-} // end namespaces
-