Use more R string literals in tests

2 files changed, 936 insertions, 719 deletions

diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp
index 98ea92ca..c5f79758 100644
--- a/test/libsolidity/SolidityEndToEndTest.cpp
+++ b/test/libsolidity/SolidityEndToEndTest.cpp
@@ -44,17 +44,20 @@ BOOST_FIXTURE_TEST_SUITE(SolidityEndToEndTest, SolidityExecutionFramework)
 
 BOOST_AUTO_TEST_CASE(smoke_test)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint a) returns(uint d) { return a * 7; }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a) returns(uint d) { return a * 7; }
+		}
+	)";
 	compileAndRun(sourceCode);
 	testContractAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return a * 7; }, 0, 100);
 }
 
 BOOST_AUTO_TEST_CASE(empty_contract)
 {
-	char const* sourceCode = "contract test {\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test { }
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("i_am_not_there()", bytes()).empty());
 }
@@ -64,7 +67,8 @@ BOOST_AUTO_TEST_CASE(exp_operator)
 	char const* sourceCode = R"(
 		contract test {
 			function f(uint a) returns(uint d) { return 2 ** a; }
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	testContractAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return u256(1 << a.convert_to<int>()); }, 0, 16);
 }
@@ -74,7 +78,8 @@ 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)));
 }
@@ -84,7 +89,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)));
 }
@@ -95,8 +101,9 @@ BOOST_AUTO_TEST_CASE(conditional_expression_true_literal)
 		contract test {
 			function f() returns(uint d) {
 				return true ? 5 : 10;
- 			}
-		})";
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("f()", bytes()) == toBigEndian(u256(5)));
 }
@@ -107,8 +114,9 @@ BOOST_AUTO_TEST_CASE(conditional_expression_false_literal)
 		contract test {
 			function f() returns(uint d) {
 				return false ? 5 : 10;
- 			}
-		})";
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("f()", bytes()) == toBigEndian(u256(10)));
 }
@@ -118,12 +126,13 @@ BOOST_AUTO_TEST_CASE(conditional_expression_multiple)
 	char const* sourceCode = R"(
 		contract test {
 			function f(uint x) returns(uint d) {
-				return x > 100 ? 
+				return x > 100 ?
 							x > 1000 ? 1000 : 100
 							:
 							x > 50 ? 50 : 10;
- 			}
-		})";
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("f(uint256)", u256(1001)) == toBigEndian(u256(1000)));
 	BOOST_CHECK(callContractFunction("f(uint256)", u256(500)) == toBigEndian(u256(100)));
@@ -137,7 +146,7 @@ BOOST_AUTO_TEST_CASE(conditional_expression_with_return_values)
 		contract test {
 			function f(bool cond, uint v) returns (uint a, uint b) {
 				cond ? a = v : b = v;
- 			}
+			}
 		})";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("f(bool,uint256)", true, u256(20)) == encodeArgs(u256(20), u256(0)));
@@ -169,7 +178,7 @@ BOOST_AUTO_TEST_CASE(conditional_expression_storage_memory_1)
 				}
 
 				return ret;
-			}    
+			}
 		}
 	)";
 	compileAndRun(sourceCode);
@@ -203,7 +212,7 @@ BOOST_AUTO_TEST_CASE(conditional_expression_storage_memory_2)
 				}
 
 				return ret;
-			}    
+			}
 		}
 	)";
 	compileAndRun(sourceCode);
@@ -219,7 +228,7 @@ BOOST_AUTO_TEST_CASE(conditional_expression_different_types)
 				uint8 x = 0xcd;
 				uint16 y = 0xabab;
 				return cond ? x : y;
-			}    
+			}
 		}
 	)";
 	compileAndRun(sourceCode);
@@ -277,12 +286,14 @@ BOOST_AUTO_TEST_CASE(conditional_expression_functions)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) returns(uint nfac) {
+				if (n <= 1) return 1;
+				else return n * f(n - 1);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	function<u256(u256)> recursive_calls_cpp = [&recursive_calls_cpp](u256 const& n) -> u256
 	{
@@ -297,12 +308,14 @@ BOOST_AUTO_TEST_CASE(recursive_calls)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function a() returns(uint n) { return 0; }
+			function b() returns(uint n) { return 1; }
+			function c() returns(uint n) { return 2; }
+			function f() returns(uint n) { return 3; }
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("a()", bytes()) == toBigEndian(u256(0)));
 	BOOST_CHECK(callContractFunction("b()", bytes()) == toBigEndian(u256(1)));
@@ -313,33 +326,39 @@ BOOST_AUTO_TEST_CASE(multiple_functions)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+			function b() returns (uint r) { r = a({a: 1, b: 2, c: 3}); }
+		}
+	)";
 	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";
+	char const* sourceCode = R"(
+		contract test {
+			function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+			function b() returns (uint r) { r = a({c: 3, a: 1, b: 2}); }
+		}
+	)";
 	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";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) returns(uint nfac) {
+				nfac = 1;
+				var i = 2;
+				while (i <= n) nfac *= i++;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto while_loop_cpp = [](u256 const& n) -> u256
@@ -358,13 +377,15 @@ BOOST_AUTO_TEST_CASE(while_loop)
 
 BOOST_AUTO_TEST_CASE(do_while_loop)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint n) returns(uint nfac) {\n"
-							 "    nfac = 1;\n"
-							 "    var i = 2;\n"
-							 "    do { nfac *= i++; } while (i <= n);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) returns(uint nfac) {
+				nfac = 1;
+				var i = 2;
+				do { nfac *= i++; } while (i <= n);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto do_while_loop_cpp = [](u256 const& n) -> u256
@@ -386,26 +407,28 @@ BOOST_AUTO_TEST_CASE(do_while_loop)
 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
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) returns(uint y) {
+				while (x > 1) {
+					if (x == 10) break;
+					while (x > 5) {
+						if (x == 8) break;
+						x--;
+						if (x == 6) continue;
+						return x;
+					}
+					x--;
+					if (x == 3) continue;
+					break;
+				}
+				return x;
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+
+	auto nested_loops_cpp = [](u256 n) -> u256
 	{
 		while (n > 1)
 		{
@@ -434,13 +457,15 @@ BOOST_AUTO_TEST_CASE(nested_loops)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) returns(uint nfac) {
+				nfac = 1;
+				for (var i = 2; i <= n; i++)
+					nfac *= i;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto for_loop_cpp = [](u256 const& n) -> u256
@@ -456,16 +481,17 @@ BOOST_AUTO_TEST_CASE(for_loop)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function f() returns(uint ret) {
+				ret = 1;
+				for (;;) {
+					ret += 1;
+					if (ret >= 10) break;
+				}
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto for_loop_empty_cpp = []() -> u256
@@ -484,14 +510,16 @@ BOOST_AUTO_TEST_CASE(for_loop_empty)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) returns(uint nfac) {
+				nfac = 1;
+				uint256 i;
+				for (i = 2; i <= n; i++)
+					nfac *= i;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto for_loop_simple_init_expr_cpp = [](u256 const& n) -> u256
@@ -554,20 +582,22 @@ BOOST_AUTO_TEST_CASE(for_loop_break_continue)
 
 BOOST_AUTO_TEST_CASE(calling_other_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";
+	char const* sourceCode = R"(
+		contract collatz {
+			function run(uint x) returns(uint y) {
+				while ((y = x) > 1) {
+					if (x % 2 == 0) x = evenStep(x);
+					else x = oddStep(x);
+				}
+			}
+			function evenStep(uint x) returns(uint y) {
+				return x / 2;
+			}
+			function oddStep(uint x) returns(uint y) {
+				return 3 * x + 1;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto evenStep_cpp = [](u256 const& n) -> u256
@@ -602,13 +632,15 @@ BOOST_AUTO_TEST_CASE(calling_other_functions)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run(uint x1, uint x2, uint x3) returns(uint y) {
+				var a = 0x1; var b = 0x10; var c = 0x100;
+				y = a + b + c + x1 + x2 + x3;
+				y += b + x2;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto f = [](u256 const& x1, u256 const& x2, u256 const& x3) -> u256
 	{
@@ -623,13 +655,15 @@ BOOST_AUTO_TEST_CASE(many_local_variables)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run(bool a, uint32 b, uint64 c) returns(uint256 y) {
+				if (a) y = 1;
+				y = y * 0x100000000 | ~b;
+				y = y * 0x10000000000000000 | ~c;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("run(bool,uint32,uint64)", true, fromHex("0f0f0f0f"), fromHex("f0f0f0f0f0f0f0f0"))
 				== fromHex("00000000000000000000000000000000000000""01""f0f0f0f0""0f0f0f0f0f0f0f0f"));
@@ -637,12 +671,14 @@ BOOST_AUTO_TEST_CASE(packing_unpacking_types)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run() returns(int8 y) {
+				uint8 x = 0xfa;
+				return int8(x);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("run()")
 				== fromHex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa"));
@@ -650,23 +686,27 @@ BOOST_AUTO_TEST_CASE(packing_signed_types)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run(bool x1, uint x2) returns(uint y1, bool y2, uint y3) {
+				y1 = x2; y2 = x1;
+			}
+		}
+	)";
 	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";
+	char const* sourceCode = R"(
+		contract test {
+			function run(uint x) returns(uint y) {
+				x == 0 || ((x = 8) > 0);
+				return x;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	auto short_circuiting_cpp = [](u256 n) -> u256
@@ -680,14 +720,16 @@ BOOST_AUTO_TEST_CASE(short_circuiting)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run() returns(uint256 y) {
+				uint32 t = uint32(0xffffffff);
+				uint32 x = t + 10;
+				if (x >= 0xffffffff) return 0;
+				return x;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto high_bits_cleaning_cpp = []() -> u256
 	{
@@ -702,13 +744,15 @@ BOOST_AUTO_TEST_CASE(high_bits_cleaning)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run() returns(uint256 y) {
+				int64 x = -int32(0xff);
+				if (x >= 0xff) return 0;
+				return -uint256(x);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto sign_extension_cpp = []() -> u256
 	{
@@ -722,13 +766,15 @@ BOOST_AUTO_TEST_CASE(sign_extension)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run() returns(uint256 y) {
+				uint32 t = uint32(0xffffff);
+				uint32 x = t * 0xffffff;
+				return x / 0x100;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto small_unsigned_types_cpp = []() -> u256
 	{
@@ -741,11 +787,13 @@ BOOST_AUTO_TEST_CASE(small_unsigned_types)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function run() returns(int256 y) {
+				return -int32(10) * -int64(20);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto small_signed_types_cpp = []() -> u256
 	{
@@ -756,15 +804,17 @@ BOOST_AUTO_TEST_CASE(small_signed_types)
 
 BOOST_AUTO_TEST_CASE(strings)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function fixedBytes() 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";
+	char const* sourceCode = R"(
+		contract test {
+			function fixedBytes() returns(bytes32 ret) {
+				return "abc\x00\xff__";
+			}
+			function pipeThrough(bytes2 small, bool one) returns(bytes16 large, bool oneRet) {
+				oneRet = one;
+				large = small;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("fixedBytes()") == encodeArgs(string("abc\0\xff__", 7)));
 	BOOST_CHECK(callContractFunction("pipeThrough(bytes2,bool)", string("\0\x02", 2), true) == encodeArgs(string("\0\x2", 2), true));
@@ -809,18 +859,20 @@ BOOST_AUTO_TEST_CASE(bytes_comparison)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			uint256 value1;
+			uint256 value2;
+			function get(uint8 which) returns (uint256 value) {
+				if (which == 0) return value1;
+				else return value2;
+			}
+			function set(uint8 which, uint256 value) {
+				if (which == 0) value1 = value;
+				else value2 = value;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x00)) == encodeArgs(0));
 	BOOST_CHECK(callContractFunction("get(uint8)", byte(0x01)) == encodeArgs(0));
@@ -834,17 +886,19 @@ BOOST_AUTO_TEST_CASE(state_smoke_test)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			uint value1;
+			uint value2;
+			function f(uint x, uint y) returns (uint w) {
+				uint value3 = y;
+				value1 += x;
+				value3 *= x;
+				value2 *= value3 + value1;
+				return value2 += 7;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	u256 value1;
@@ -869,15 +923,17 @@ BOOST_AUTO_TEST_CASE(compound_assign)
 
 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"
-							 "}";
+	char const* sourceCode = R"(
+		contract test {
+			mapping(uint8 => uint8) table;
+			function get(uint8 k) returns (uint8 v) {
+				return table[k];
+			}
+			function set(uint8 k, uint8 v) {
+				table[k] = v;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	BOOST_CHECK(callContractFunction("get(uint8)", byte(0)) == encodeArgs(byte(0x00)));
@@ -899,23 +955,25 @@ BOOST_AUTO_TEST_CASE(simple_mapping)
 
 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";
+	char const* sourceCode = R"(
+		contract Ballot {
+			mapping(address => bool) canVote;
+			mapping(address => uint) voteCount;
+			mapping(address => bool) voted;
+			function getVoteCount(address addr) returns (uint retVoteCount) {
+				return voteCount[addr];
+			}
+			function grantVoteRight(address addr) {
+				canVote[addr] = true;
+			}
+			function vote(address voter, address vote) returns (bool success) {
+				if (!canVote[voter] || voted[voter]) return false;
+				voted[voter] = true;
+				voteCount[vote] = voteCount[vote] + 1;
+				return true;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	class Ballot
 	{
@@ -974,17 +1032,19 @@ BOOST_AUTO_TEST_CASE(mapping_state)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			uint value;
+			mapping(uint => uint) table;
+			function f(uint x) returns (uint y) {
+				value = x;
+				if (x > 0) table[++value] = 8;
+				if (x > 1) value--;
+				if (x > 2) table[value]++;
+				return --table[value++];
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	u256 value = 0;
@@ -1005,13 +1065,15 @@ BOOST_AUTO_TEST_CASE(mapping_state_inc_dec)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			mapping(uint => mapping(uint => uint)) table;
+			function f(uint x, uint y, uint z) returns (uint w) {
+				if (z == 0) return table[x][y];
+				else return table[x][y] = z;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	map<u256, map<u256, u256>> table;
@@ -1032,35 +1094,37 @@ BOOST_AUTO_TEST_CASE(multi_level_mapping)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			struct s1 {
+				uint8 x;
+				bool y;
+			}
+			struct s2 {
+				uint32 z;
+				s1 s1data;
+				mapping(uint8 => s2) recursive;
+			}
+			s2 data;
+			function check() returns (bool ok) {
+				return data.z == 1 && data.s1data.x == 2 &&
+					data.s1data.y == true &&
+					data.recursive[3].recursive[4].z == 5 &&
+					data.recursive[4].recursive[3].z == 6 &&
+					data.recursive[0].s1data.y == false &&
+					data.recursive[4].z == 9;
+			}
+			function set() {
+				data.z = 1;
+				data.s1data.x = 2;
+				data.s1data.y = true;
+				data.recursive[3].recursive[4].z = 5;
+				data.recursive[4].recursive[3].z = 6;
+				data.recursive[0].s1data.y = false;
+				data.recursive[4].z = 9;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("check()") == encodeArgs(false));
 	BOOST_CHECK(callContractFunction("set()") == bytes());
@@ -1069,26 +1133,28 @@ BOOST_AUTO_TEST_CASE(structs)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			struct s2 {
+				uint32 z;
+				mapping(uint8 => s2) recursive;
+			}
+			s2 data;
+			function check() returns (bool ok) {
+				return data.z == 2 &&
+					data.recursive[0].z == 3 &&
+					data.recursive[0].recursive[1].z == 0 &&
+					data.recursive[0].recursive[0].z == 1;
+			}
+			function set() {
+				data.z = 2;
+				var map = data.recursive;
+				s2 inner = map[0];
+				inner.z = 3;
+				inner.recursive[0].z = inner.recursive[1].z + 1;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("check()") == encodeArgs(false));
 	BOOST_CHECK(callContractFunction("set()") == bytes());
@@ -1135,12 +1201,13 @@ BOOST_AUTO_TEST_CASE(deleteStruct)
 				nestedValue = str.nstr.nestedValue;
 			}
 			function getTopMapping(uint index) returns(uint ret) {
-			   ret = str.topMapping[index];
+				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));
@@ -1161,7 +1228,8 @@ BOOST_AUTO_TEST_CASE(deleteLocal)
 				delete v;
 				res = v;
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("delLocal()") == encodeArgs(0));
 }
@@ -1178,22 +1246,25 @@ BOOST_AUTO_TEST_CASE(deleteLocals)
 				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";
+	char const* sourceCode = R"(
+		contract test {
+			mapping(uint => uint) data;
+			function test() {
+				data[7] = 8;
+			}
+			function get(uint key) returns (uint value) {
+				return data[key];
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	map<u256, byte> data;
 	data[7] = 8;
@@ -1207,12 +1278,14 @@ BOOST_AUTO_TEST_CASE(constructor)
 
 BOOST_AUTO_TEST_CASE(simple_accessor)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  uint256 public data;\n"
-							 "  function test() {\n"
-							 "    data = 8;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			uint256 public data;
+			function test() {
+				data = 8;
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("data()") == encodeArgs(8));
 }
@@ -1254,7 +1327,7 @@ BOOST_AUTO_TEST_CASE(array_accessor)
 BOOST_AUTO_TEST_CASE(accessors_mapping_for_array)
 {
 	char const* sourceCode = R"(
-		 contract test {
+		contract test {
 			mapping(uint => uint[8]) public data;
 			mapping(uint => uint[]) public dynamicData;
 			function test() {
@@ -1262,7 +1335,7 @@ BOOST_AUTO_TEST_CASE(accessors_mapping_for_array)
 				dynamicData[2].length = 3;
 				dynamicData[2][2] = 8;
 			}
-		 }
+		}
 	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("data(uint256,uint256)", 2, 2) == encodeArgs(8));
@@ -1273,20 +1346,22 @@ BOOST_AUTO_TEST_CASE(accessors_mapping_for_array)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			uint256 public data;
+			bytes6 public name;
+			bytes32 public a_hash;
+			address public an_address;
+			function test() {
+				data = 8;
+				name = "Celina";
+				a_hash = sha3(123);
+				an_address = address(0x1337);
+				super_secret_data = 42;
+			}
+			uint256 super_secret_data;
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("data()") == encodeArgs(8));
 	BOOST_CHECK(callContractFunction("name()") == encodeArgs("Celina"));
@@ -1338,26 +1413,30 @@ BOOST_AUTO_TEST_CASE(struct_accessor)
 
 BOOST_AUTO_TEST_CASE(balance)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function test() payable {}\n"
-							 "  function getBalance() returns (uint256 balance) {\n"
-							 "    return address(this).balance;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function test() payable {}
+			function getBalance() returns (uint256 balance) {
+				return address(this).balance;
+			}
+		}
+	)";
 	compileAndRun(sourceCode, 23);
 	BOOST_CHECK(callContractFunction("getBalance()") == encodeArgs(23));
 }
 
 BOOST_AUTO_TEST_CASE(blockchain)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function test() payable {}\n"
-							 "  function someInfo() payable returns (uint256 value, address coinbase, uint256 blockNumber) {\n"
-							 "    value = msg.value;\n"
-							 "    coinbase = block.coinbase;\n"
-							 "    blockNumber = block.number;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function test() payable {}
+			function someInfo() payable returns (uint256 value, address coinbase, uint256 blockNumber) {
+				value = msg.value;
+				coinbase = block.coinbase;
+				blockNumber = block.number;
+			}
+		}
+	)";
 	BOOST_CHECK(m_rpc.rpcCall("miner_setEtherbase", {"\"0x1212121212121212121212121212121212121212\""}).asBool() == true);
 	m_rpc.test_mineBlocks(5);
 	compileAndRun(sourceCode, 27);
@@ -1395,12 +1474,14 @@ BOOST_AUTO_TEST_CASE(msg_sig_after_internal_call_is_same)
 
 BOOST_AUTO_TEST_CASE(now)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function someInfo() returns (bool equal, uint val) {\n"
-							 "    equal = block.timestamp == now;\n"
-							 "    val = now;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function someInfo() returns (bool equal, uint val) {
+				equal = block.timestamp == now;
+				val = now;
+			}
+		}
+	)";
 	m_rpc.test_modifyTimestamp(0x776347e2);
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("someInfo()") == encodeArgs(true, 0x776347e3));
@@ -1413,7 +1494,8 @@ BOOST_AUTO_TEST_CASE(type_conversions_cleanup)
 	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,
@@ -1427,7 +1509,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_fixed_bytes_smaller_size)
 			function bytesToBytes(bytes4 input) returns (bytes2 ret) {
 				return bytes2(input);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToBytes(bytes4)", "abcd") == encodeArgs("ab"));
 }
@@ -1439,7 +1522,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_fixed_bytes_greater_size)
 			function bytesToBytes(bytes2 input) returns (bytes4 ret) {
 				return bytes4(input);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToBytes(bytes2)", "ab") == encodeArgs("ab"));
 }
@@ -1451,7 +1535,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_fixed_bytes_same_size)
 			function bytesToBytes(bytes4 input) returns (bytes4 ret) {
 				return bytes4(input);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToBytes(bytes4)", "abcd") == encodeArgs("abcd"));
 }
@@ -1464,7 +1549,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_same_size)
 			function bytesToUint(bytes32 s) returns (uint256 h) {
 				return uint(s);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToUint(bytes32)", string("abc2")) ==
 		encodeArgs(u256("0x6162633200000000000000000000000000000000000000000000000000000000")));
@@ -1477,7 +1563,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_same_min_size)
 			function bytesToUint(bytes1 s) returns (uint8 h) {
 				return uint8(s);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToUint(bytes1)", string("a")) ==
 		encodeArgs(u256("0x61")));
@@ -1490,7 +1577,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_smaller_size)
 			function bytesToUint(bytes4 s) returns (uint16 h) {
 				return uint16(s);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToUint(bytes4)", string("abcd")) ==
 		encodeArgs(u256("0x6364")));
@@ -1503,7 +1591,8 @@ BOOST_AUTO_TEST_CASE(convert_fixed_bytes_to_uint_greater_size)
 			function bytesToUint(bytes4 s) returns (uint64 h) {
 				return uint64(s);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("bytesToUint(bytes4)", string("abcd")) ==
 		encodeArgs(u256("0x61626364")));
@@ -1517,7 +1606,8 @@ BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_same_size)
 			function uintToBytes(uint256 h) returns (bytes32 s) {
 				return bytes32(h);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	u256 a("0x6162630000000000000000000000000000000000000000000000000000000000");
 	BOOST_CHECK(callContractFunction("uintToBytes(uint256)", a) == encodeArgs(a));
@@ -1530,7 +1620,8 @@ BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_same_min_size)
 			function UintToBytes(uint8 h) returns (bytes1 s) {
 				return bytes1(h);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("UintToBytes(uint8)", u256("0x61")) ==
 		encodeArgs(string("a")));
@@ -1543,7 +1634,8 @@ BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_smaller_size)
 			function uintToBytes(uint32 h) returns (bytes2 s) {
 				return bytes2(h);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("uintToBytes(uint32)",
 			u160("0x61626364")) == encodeArgs(string("cd")));
@@ -1556,7 +1648,8 @@ BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_greater_size)
 			function UintToBytes(uint16 h) returns (bytes8 s) {
 				return bytes8(h);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(
 		callContractFunction("UintToBytes(uint16)", u256("0x6162")) ==
@@ -1566,13 +1659,15 @@ BOOST_AUTO_TEST_CASE(convert_uint_to_fixed_bytes_greater_size)
 
 BOOST_AUTO_TEST_CASE(send_ether)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function test() payable {}\n"
-							 "  function a(address addr, uint amount) returns (uint ret) {\n"
-							 "    addr.send(amount);\n"
-							 "    return address(this).balance;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function test() payable {}
+			function a(address addr, uint amount) returns (uint ret) {
+				addr.send(amount);
+				return address(this).balance;
+			}
+		}
+	)";
 	u256 amount(130);
 	compileAndRun(sourceCode, amount + 1);
 	u160 address(23);
@@ -1582,11 +1677,13 @@ BOOST_AUTO_TEST_CASE(send_ether)
 
 BOOST_AUTO_TEST_CASE(log0)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log0(1);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function a() {
+				log0(1);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	callContractFunction("a()");
 	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
@@ -1597,11 +1694,13 @@ BOOST_AUTO_TEST_CASE(log0)
 
 BOOST_AUTO_TEST_CASE(log1)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log1(1, 2);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function a() {
+				log1(1, 2);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	callContractFunction("a()");
 	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
@@ -1613,11 +1712,13 @@ BOOST_AUTO_TEST_CASE(log1)
 
 BOOST_AUTO_TEST_CASE(log2)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log2(1, 2, 3);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function a() {
+				log2(1, 2, 3);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	callContractFunction("a()");
 	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
@@ -1630,11 +1731,13 @@ BOOST_AUTO_TEST_CASE(log2)
 
 BOOST_AUTO_TEST_CASE(log3)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log3(1, 2, 3, 4);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function a() {
+				log3(1, 2, 3, 4);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	callContractFunction("a()");
 	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
@@ -1647,11 +1750,13 @@ BOOST_AUTO_TEST_CASE(log3)
 
 BOOST_AUTO_TEST_CASE(log4)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function a() {\n"
-							 "    log4(1, 2, 3, 4, 5);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function a() {
+				log4(1, 2, 3, 4, 5);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	callContractFunction("a()");
 	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
@@ -1664,11 +1769,13 @@ BOOST_AUTO_TEST_CASE(log4)
 
 BOOST_AUTO_TEST_CASE(log_in_constructor)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function test() {\n"
-							 "    log1(1, 2);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function test() {
+				log1(1, 2);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_REQUIRE_EQUAL(m_logs.size(), 1);
 	BOOST_CHECK_EQUAL(m_logs[0].address, m_contractAddress);
@@ -1679,13 +1786,15 @@ BOOST_AUTO_TEST_CASE(log_in_constructor)
 
 BOOST_AUTO_TEST_CASE(suicide)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function test() payable {}\n"
-							 "  function a(address receiver) returns (uint ret) {\n"
-							 "    suicide(receiver);\n"
-							 "    return 10;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function test() payable {}
+			function a(address receiver) returns (uint ret) {
+				suicide(receiver);
+				return 10;
+			}
+		}
+	)";
 	u256 amount(130);
 	compileAndRun(sourceCode, amount);
 	u160 address(23);
@@ -1696,13 +1805,15 @@ BOOST_AUTO_TEST_CASE(suicide)
 
 BOOST_AUTO_TEST_CASE(selfdestruct)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function test() payable {}\n"
-							 "  function a(address receiver) returns (uint ret) {\n"
-							 "    selfdestruct(receiver);\n"
-							 "    return 10;\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function test() payable {}
+			function a(address receiver) returns (uint ret) {
+				selfdestruct(receiver);
+				return 10;
+			}
+		}
+	)";
 	u256 amount(130);
 	compileAndRun(sourceCode, amount);
 	u160 address(23);
@@ -1713,11 +1824,13 @@ BOOST_AUTO_TEST_CASE(selfdestruct)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function a(bytes32 input) returns (bytes32 sha3hash) {
+				return sha3(input);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto f = [&](u256 const& _x) -> u256
 	{
@@ -1730,11 +1843,13 @@ BOOST_AUTO_TEST_CASE(sha3)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function a(bytes32 input) returns (bytes32 sha256hash) {
+				return sha256(input);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto f = [&](u256 const& _x) -> bytes
 	{
@@ -1753,11 +1868,13 @@ BOOST_AUTO_TEST_CASE(sha256)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function a(bytes32 input) returns (bytes32 sha256hash) {
+				return ripemd160(input);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	auto f = [&](u256 const& _x) -> bytes
 	{
@@ -1776,11 +1893,13 @@ BOOST_AUTO_TEST_CASE(ripemd)
 
 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";
+	char const* sourceCode = R"(
+		contract test {
+			function a(bytes32 h, uint8 v, bytes32 r, bytes32 s) returns (address addr) {
+				return ecrecover(h, v, r, s);
+			}
+		}
+	)";
 	compileAndRun(sourceCode);
 	u256 h("0x18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c");
 	byte v = 28;
@@ -2798,7 +2917,8 @@ BOOST_AUTO_TEST_CASE(empty_name_input_parameter_with_named_one)
 				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));
@@ -2811,7 +2931,8 @@ BOOST_AUTO_TEST_CASE(empty_name_return_parameter)
 			function f(uint k) returns(uint){
 				return k;
 		}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("f(uint256)", 9) == encodeArgs(9));
 }
@@ -2824,7 +2945,8 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments)
 			{
 				d = sha3(a, b, c);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	BOOST_CHECK(callContractFunction("foo(uint256,uint256,uint256)", 10, 12, 13) == encodeArgs(
@@ -2842,7 +2964,8 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_numeric_literals)
 			{
 				d = sha3(a, b, 145);
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	BOOST_CHECK(callContractFunction("foo(uint256,uint16)", 10, 12) == encodeArgs(
@@ -2864,7 +2987,8 @@ BOOST_AUTO_TEST_CASE(sha3_multiple_arguments_with_string_literals)
 			{
 				d = sha3(a, b, 145, "foo");
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 
 	BOOST_CHECK(callContractFunction("foo()") == encodeArgs(dev::keccak256("foo")));
@@ -2890,7 +3014,8 @@ BOOST_AUTO_TEST_CASE(sha3_with_bytes)
 				data[2] = "o";
 				return sha3(data) == sha3("foo");
 			}
-		})";
+		}
+	)";
 	compileAndRun(sourceCode);
 	BOOST_CHECK(callContractFunction("foo()") == encodeArgs(true));
 }
diff --git a/test/libsolidity/SolidityParser.cpp b/test/libsolidity/SolidityParser.cpp
index a3217f08..d260f4b1 100644
--- a/test/libsolidity/SolidityParser.cpp
+++ b/test/libsolidity/SolidityParser.cpp
@@ -88,72 +88,88 @@ BOOST_AUTO_TEST_SUITE(SolidityParser)
 
 BOOST_AUTO_TEST_CASE(smoke_test)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 stateVariable1;\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVariable1;
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(missing_variable_name_in_declaration)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 ;\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 ;
+		}
+	)";
 	BOOST_CHECK(!successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(empty_function)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  function functionName(bytes20 arg1, address addr) constant\n"
-					   "    returns (int id)\n"
-					   "  { }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+		uint256 stateVar;
+			function functionName(bytes20 arg1, address addr) constant
+				returns (int id)
+			{ }
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(no_function_params)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  function functionName() {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			function functionName() {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(single_function_param)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  function functionName(bytes32 input) returns (bytes32 out) {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			function functionName(bytes32 input) returns (bytes32 out) {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(function_no_body)
 {
-	char const* text = "contract test {\n"
-					   "  function functionName(bytes32 input) returns (bytes32 out);\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function functionName(bytes32 input) returns (bytes32 out);
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(missing_parameter_name_in_named_args)
 {
-	char const* text = "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({: 1, : 2, : 3}); }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+			function b() returns (uint r) { r = a({: 1, : 2, : 3}); }
+		}
+	)";
 	BOOST_CHECK(!successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(missing_argument_in_named_args)
 {
-	char const* text = "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: , b: , c: }); }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+			function b() returns (uint r) { r = a({a: , b: , c: }); }
+		}
+	)";
 	BOOST_CHECK(!successParse(text));
 }
 
@@ -184,11 +200,13 @@ BOOST_AUTO_TEST_CASE(overloaded_functions)
 
 BOOST_AUTO_TEST_CASE(function_natspec_documentation)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  /// This is a test function\n"
-					   "  function functionName(bytes32 input) returns (bytes32 out) {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			/// This is a test function
+			function functionName(bytes32 input) returns (bytes32 out) {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -202,11 +220,13 @@ BOOST_AUTO_TEST_CASE(function_natspec_documentation)
 BOOST_AUTO_TEST_CASE(function_normal_comments)
 {
 	FunctionDefinition const* function = nullptr;
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  // We won't see this comment\n"
-					   "  function functionName(bytes32 input) returns (bytes32 out) {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			// We won't see this comment
+			function functionName(bytes32 input) returns (bytes32 out) {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -219,17 +239,19 @@ BOOST_AUTO_TEST_CASE(function_normal_comments)
 BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
 {
 	FunctionDefinition const* function = nullptr;
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  /// This is test function 1\n"
-					   "  function functionName1(bytes32 input) returns (bytes32 out) {}\n"
-					   "  /// This is test function 2\n"
-					   "  function functionName2(bytes32 input) returns (bytes32 out) {}\n"
-					   "  // nothing to see here\n"
-					   "  function functionName3(bytes32 input) returns (bytes32 out) {}\n"
-					   "  /// This is test function 4\n"
-					   "  function functionName4(bytes32 input) returns (bytes32 out) {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			/// This is test function 1
+			function functionName1(bytes32 input) returns (bytes32 out) {}
+			/// This is test function 2
+			function functionName2(bytes32 input) returns (bytes32 out) {}
+			// nothing to see here
+			function functionName3(bytes32 input) returns (bytes32 out) {}
+			/// This is test function 4
+			function functionName4(bytes32 input) returns (bytes32 out) {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -252,12 +274,14 @@ BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
 BOOST_AUTO_TEST_CASE(multiline_function_documentation)
 {
 	FunctionDefinition const* function = nullptr;
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  /// This is a test function\n"
-					   "  /// and it has 2 lines\n"
-					   "  function functionName1(bytes32 input) returns (bytes32 out) {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			/// This is a test function
+			/// and it has 2 lines
+			function functionName1(bytes32 input) returns (bytes32 out) {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -270,19 +294,21 @@ BOOST_AUTO_TEST_CASE(multiline_function_documentation)
 BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
 {
 	FunctionDefinition const* function = nullptr;
-	char const* text = "contract test {\n"
-					   "  /// fun1 description\n"
-					   "  function fun1(uint256 a) {\n"
-					   "    var b;\n"
-					   "    /// I should not interfere with actual natspec comments\n"
-					   "    uint256 c;\n"
-					   "    mapping(address=>bytes32) d;\n"
-					   "    bytes7 name = \"Solidity\";"
-					   "  }\n"
-					   "  /// This is a test function\n"
-					   "  /// and it has 2 lines\n"
-					   "  function fun(bytes32 input) returns (bytes32 out) {}\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			/// fun1 description
+			function fun1(uint256 a) {
+				var b;
+				/// I should not interfere with actual natspec comments
+				uint256 c;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+			}
+			/// This is a test function
+			/// and it has 2 lines
+			function fun(bytes32 input) returns (bytes32 out) {}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -299,17 +325,19 @@ BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
 BOOST_AUTO_TEST_CASE(natspec_docstring_between_keyword_and_signature)
 {
 	FunctionDefinition const* function = nullptr;
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  function ///I am in the wrong place \n"
-					   "  fun1(uint256 a) {\n"
-					   "    var b;\n"
-					   "    /// I should not interfere with actual natspec comments\n"
-					   "    uint256 c;\n"
-					   "    mapping(address=>bytes32) d;\n"
-					   "    bytes7 name = \"Solidity\";"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			function ///I am in the wrong place
+			fun1(uint256 a) {
+				var b;
+				/// I should not interfere with actual natspec comments
+				uint256 c;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -323,17 +351,19 @@ BOOST_AUTO_TEST_CASE(natspec_docstring_between_keyword_and_signature)
 BOOST_AUTO_TEST_CASE(natspec_docstring_after_signature)
 {
 	FunctionDefinition const* function = nullptr;
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  function fun1(uint256 a) {\n"
-					   "  /// I should have been above the function signature\n"
-					   "    var b;\n"
-					   "    /// I should not interfere with actual natspec comments\n"
-					   "    uint256 c;\n"
-					   "    mapping(address=>bytes32) d;\n"
-					   "    bytes7 name = \"Solidity\";"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			function fun1(uint256 a) {
+				/// I should have been above the function signature
+				var b;
+				/// I should not interfere with actual natspec comments
+				uint256 c;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 	ErrorList errors;
 	ASTPointer<ContractDefinition> contract = parseText(text, errors);
@@ -346,71 +376,83 @@ BOOST_AUTO_TEST_CASE(natspec_docstring_after_signature)
 
 BOOST_AUTO_TEST_CASE(struct_definition)
 {
-	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
-					   "  struct MyStructName {\n"
-					   "    address addr;\n"
-					   "    uint256 count;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			struct MyStructName {
+				address addr;
+				uint256 count;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(mapping)
 {
-	char const* text = "contract test {\n"
-					   "  mapping(address => bytes32) names;\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			mapping(address => bytes32) names;
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(mapping_in_struct)
 {
-	char const* text = "contract test {\n"
-					   "  struct test_struct {\n"
-					   "    address addr;\n"
-					   "    uint256 count;\n"
-					   "    mapping(bytes32 => test_struct) self_reference;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			struct test_struct {
+				address addr;
+				uint256 count;
+				mapping(bytes32 => test_struct) self_reference;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(mapping_to_mapping_in_struct)
 {
-	char const* text = "contract test {\n"
-					   "  struct test_struct {\n"
-					   "    address addr;\n"
-					   "    mapping (uint64 => mapping (bytes32 => uint)) complex_mapping;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			struct test_struct {
+				address addr;
+				mapping (uint64 => mapping (bytes32 => uint)) complex_mapping;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(variable_definition)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    var b;\n"
-					   "    uint256 c;\n"
-					   "    mapping(address=>bytes32) d;\n"
-					   "    customtype varname;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				var b;
+				uint256 c;
+				mapping(address=>bytes32) d;
+				customtype varname;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(variable_definition_with_initialization)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    var b = 2;\n"
-					   "    uint256 c = 0x87;\n"
-					   "    mapping(address=>bytes32) d;\n"
-					   "    bytes7 name = \"Solidity\";"
-					   "    customtype varname;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				var b = 2;
+				uint256 c = 0x87;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+				customtype varname;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
@@ -450,21 +492,25 @@ BOOST_AUTO_TEST_CASE(variable_definition_in_function_return)
 
 BOOST_AUTO_TEST_CASE(operator_expression)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    uint256 x = (1 + 4) || false && (1 - 12) + -9;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint256 x = (1 + 4) || false && (1 - 12) + -9;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(complex_expression)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    uint256 x = (1 + 4).member(++67)[a/=9] || true;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint256 x = (1 + 4).member(++67)[a/=9] || true;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
@@ -475,248 +521,294 @@ BOOST_AUTO_TEST_CASE(exp_expression)
 			function fun(uint256 a) {
 				uint256 x = 3 ** a;
 			}
-		})";
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(while_loop)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    while (true) { uint256 x = 1; break; continue; } x = 9;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				while (true) { uint256 x = 1; break; continue; } x = 9;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(for_loop_vardef_initexpr)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    for (uint256 i = 0; i < 10; i++)\n"
-					   "    { uint256 x = i; break; continue; }\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				for (uint256 i = 0; i < 10; i++) {
+					uint256 x = i; break; continue;
+				}
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(for_loop_simple_initexpr)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    uint256 i =0;\n"
-					   "    for (i = 0; i < 10; i++)\n"
-					   "    { uint256 x = i; break; continue; }\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint256 i =0;
+				for (i = 0; i < 10; i++) {
+					uint256 x = i; break; continue;
+				}
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(for_loop_simple_noexpr)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    uint256 i =0;\n"
-					   "    for (;;)\n"
-					   "    { uint256 x = i; break; continue; }\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+				function fun(uint256 a) {
+					uint256 i =0;
+					for (;;) {
+						uint256 x = i; break; continue;
+					}
+				}
+			}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(for_loop_single_stmt_body)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    uint256 i =0;\n"
-					   "    for (i = 0; i < 10; i++)\n"
-					   "        continue;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint256 i = 0;
+				for (i = 0; i < 10; i++)
+					continue;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(if_statement)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) {\n"
-					   "    if (a >= 8) { return 2; } else { var b = 7; }\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				if (a >= 8) { return 2; } else { var b = 7; }
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(else_if_statement)
 {
-	char const* text = "contract test {\n"
-					   "  function fun(uint256 a) returns (address b) {\n"
-					   "    if (a < 0) b = 0x67; else if (a == 0) b = 0x12; else b = 0x78;\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) returns (address b) {
+				if (a < 0) b = 0x67; else if (a == 0) b = 0x12; else b = 0x78;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(statement_starting_with_type_conversion)
 {
-	char const* text = "contract test {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "    uint64[7](3);\n"
-					   "    uint64[](3);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun() {
+				uint64(2);
+				uint64[7](3);
+				uint64[](3);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(type_conversion_to_dynamic_array)
 {
-	char const* text = "contract test {\n"
-					   "  function fun() {\n"
-					   "    var x = uint64[](3);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun() {
+				var x = uint64[](3);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(import_directive)
 {
-	char const* text = "import \"abc\";\n"
-					   "contract test {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		import "abc";
+		contract test {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(multiple_contracts)
 {
-	char const* text = "contract test {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n"
-					   "contract test2 {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract test {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract test2 {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(multiple_contracts_and_imports)
 {
-	char const* text = "import \"abc\";\n"
-					   "contract test {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n"
-					   "import \"def\";\n"
-					   "contract test2 {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n"
-					   "import \"ghi\";\n";
+	char const* text = R"(
+		import "abc";
+		contract test {
+			function fun() {
+				uint64(2);
+			}
+		}
+		import "def";
+		contract test2 {
+			function fun() {
+				uint64(2);
+			}
+		}
+		import "ghi";
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(contract_inheritance)
 {
-	char const* text = "contract base {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n"
-					   "contract derived is base {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract base {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract derived is base {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(contract_multiple_inheritance)
 {
-	char const* text = "contract base {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n"
-					   "contract derived is base, nonExisting {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract base {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract derived is base, nonExisting {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(contract_multiple_inheritance_with_arguments)
 {
-	char const* text = "contract base {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n"
-					   "contract derived is base(2), nonExisting(\"abc\", \"def\", base.fun()) {\n"
-					   "  function fun() {\n"
-					   "    uint64(2);\n"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract base {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract derived is base(2), nonExisting("abc", "def", base.fun()) {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(placeholder_in_function_context)
 {
-	char const* text = "contract c {\n"
-					   "  function fun() returns (uint r) {\n"
-					   "    var _ = 8;\n"
-					   "    return _ + 1;"
-					   "  }\n"
-					   "}\n";
+	char const* text = R"(
+		contract c {
+			function fun() returns (uint r) {
+				var _ = 8;
+				return _ + 1;
+			}
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(modifier)
 {
-	char const* text = "contract c {\n"
-					   "  modifier mod { if (msg.sender == 0) _; }\n"
-					   "}\n";
+	char const* text = R"(
+		contract c {
+			modifier mod { if (msg.sender == 0) _; }
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(modifier_without_semicolon)
 {
-	char const* text = "contract c {\n"
-					   "  modifier mod { if (msg.sender == 0) _ }\n"
-					   "}\n";
+	char const* text = R"(
+		contract c {
+			modifier mod { if (msg.sender == 0) _ }
+		}
+	)";
 	BOOST_CHECK(!successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(modifier_arguments)
 {
-	char const* text = "contract c {\n"
-					   "  modifier mod(uint a) { if (msg.sender == a) _; }\n"
-					   "}\n";
+	char const* text = R"(
+		contract c {
+			modifier mod(uint a) { if (msg.sender == a) _; }
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(modifier_invocation)
 {
-	char const* text = "contract c {\n"
-					   "  modifier mod1(uint a) { if (msg.sender == a) _; }\n"
-					   "  modifier mod2 { if (msg.sender == 2) _; }\n"
-					   "  function f() mod1(7) mod2 { }\n"
-					   "}\n";
+	char const* text = R"(
+		contract c {
+			modifier mod1(uint a) { if (msg.sender == a) _; }
+			modifier mod2 { if (msg.sender == 2) _; }
+			function f() mod1(7) mod2 { }
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }
 
 BOOST_AUTO_TEST_CASE(fallback_function)
 {
-	char const* text = "contract c {\n"
-					   "  function() { }\n"
-					   "}\n";
+	char const* text = R"(
+		contract c {
+			function() { }
+		}
+	)";
 	BOOST_CHECK(successParse(text));
 }