Migrate remaining source code in tests to R literals

1 files changed, 76 insertions, 50 deletions

diff --git a/test/libsolidity/SolidityExpressionCompiler.cpp b/test/libsolidity/SolidityExpressionCompiler.cpp
index cab9f09f..0c5a09c3 100644
--- a/test/libsolidity/SolidityExpressionCompiler.cpp
+++ b/test/libsolidity/SolidityExpressionCompiler.cpp
@@ -168,9 +168,11 @@ BOOST_AUTO_TEST_SUITE(SolidityExpressionCompiler)
 
 BOOST_AUTO_TEST_CASE(literal_true)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = true; }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { var x = true; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH1), 0x1});
@@ -179,9 +181,11 @@ BOOST_AUTO_TEST_CASE(literal_true)
 
 BOOST_AUTO_TEST_CASE(literal_false)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = false; }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { var x = false; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH1), 0x0});
@@ -190,9 +194,11 @@ BOOST_AUTO_TEST_CASE(literal_false)
 
 BOOST_AUTO_TEST_CASE(int_literal)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = 0x12345678901234567890; }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+		  function f() { var x = 0x12345678901234567890; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90,
@@ -204,11 +210,11 @@ BOOST_AUTO_TEST_CASE(int_with_wei_ether_subdenomination)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function test ()
-			{
+			function test () {
 				 var x = 1 wei;
 			}
-		})";
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH1), 0x1});
@@ -219,11 +225,11 @@ BOOST_AUTO_TEST_CASE(int_with_szabo_ether_subdenomination)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function test ()
-			{
+			function test () {
 				 var x = 1 szabo;
 			}
-		})";
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH5), 0xe8, 0xd4, 0xa5, 0x10, 0x00});
@@ -249,11 +255,11 @@ BOOST_AUTO_TEST_CASE(int_with_ether_ether_subdenomination)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function test ()
-			{
+			function test () {
 				 var x = 1 ether;
 			}
-		})";
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH8), 0xd, 0xe0, 0xb6, 0xb3, 0xa7, 0x64, 0x00, 0x00});
@@ -262,9 +268,11 @@ BOOST_AUTO_TEST_CASE(int_with_ether_ether_subdenomination)
 
 BOOST_AUTO_TEST_CASE(comparison)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = (0x10aa < 0x11aa) != true; }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { var x = (0x10aa < 0x11aa) != true; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH1), 0x1, byte(Instruction::ISZERO), byte(Instruction::ISZERO),
@@ -278,9 +286,11 @@ BOOST_AUTO_TEST_CASE(comparison)
 
 BOOST_AUTO_TEST_CASE(short_circuiting)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = true != (4 <= 8 + 10 || 9 != 2); }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { var x = true != (4 <= 8 + 10 || 9 != 2); }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation({byte(Instruction::PUSH1), 0x12, // 8 + 10
@@ -305,9 +315,11 @@ BOOST_AUTO_TEST_CASE(short_circuiting)
 
 BOOST_AUTO_TEST_CASE(arithmetics)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint y) { var x = ((((((((y ^ 8) & 7) | 6) - 5) + 4) % 3) / 2) * 1); }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint y) { var x = ((((((((y ^ 8) & 7) | 6) - 5) + 4) % 3) / 2) * 1); }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}, {"test", "f", "x"}});
 	bytes expectation({byte(Instruction::PUSH1), 0x1,
 					   byte(Instruction::PUSH1), 0x2,
@@ -339,9 +351,11 @@ BOOST_AUTO_TEST_CASE(arithmetics)
 
 BOOST_AUTO_TEST_CASE(unary_operators)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f(int y) { var x = !(~+- y == 2); }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f(int y) { var x = !(~+- y == 2); }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}, {"test", "f", "x"}});
 
 	bytes expectation({byte(Instruction::PUSH1), 0x2,
@@ -356,9 +370,11 @@ BOOST_AUTO_TEST_CASE(unary_operators)
 
 BOOST_AUTO_TEST_CASE(unary_inc_dec)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint a) { var x = --a ^ (a-- ^ (++a ^ a++)); }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a) { var x = --a ^ (a-- ^ (++a ^ a++)); }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "x"}});
 
 	// Stack: a, x
@@ -406,9 +422,11 @@ BOOST_AUTO_TEST_CASE(unary_inc_dec)
 
 BOOST_AUTO_TEST_CASE(assignment)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f(uint a, uint b) { (a += b) * 2; }"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a, uint b) { (a += b) * 2; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "b"}});
 
 	// Stack: a, b
@@ -427,9 +445,11 @@ BOOST_AUTO_TEST_CASE(assignment)
 
 BOOST_AUTO_TEST_CASE(negative_literals_8bits)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { int8 x = -0x80; }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { int8 x = -0x80; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation(bytes({byte(Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x80));
@@ -438,9 +458,11 @@ BOOST_AUTO_TEST_CASE(negative_literals_8bits)
 
 BOOST_AUTO_TEST_CASE(negative_literals_16bits)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { int64 x = ~0xabc; }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { int64 x = ~0xabc; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation(bytes({byte(Instruction::PUSH32)}) + bytes(30, 0xff) + bytes{0xf5, 0x43});
@@ -451,9 +473,11 @@ BOOST_AUTO_TEST_CASE(intermediately_overflowing_literals)
 {
 	// first literal itself is too large for 256 bits but it fits after all constant operations
 	// have been applied
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = (0xffffffffffffffffffffffffffffffffffffffff * 0xffffffffffffffffffffffffff01) & 0xbf; }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() { var x = (0xffffffffffffffffffffffffffffffffffffffff * 0xffffffffffffffffffffffffff01) & 0xbf; }
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode);
 
 	bytes expectation(bytes({byte(Instruction::PUSH1), 0xbf}));
@@ -462,11 +486,13 @@ BOOST_AUTO_TEST_CASE(intermediately_overflowing_literals)
 
 BOOST_AUTO_TEST_CASE(blockhash)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() {\n"
-							 "    block.blockhash(3);\n"
-							 "  }\n"
-							 "}\n";
+	char const* sourceCode = R"(
+		contract test {
+			function f() {
+				block.blockhash(3);
+			}
+		}
+	)";
 	bytes code = compileFirstExpression(sourceCode, {}, {},
 										{make_shared<MagicVariableDeclaration>("block", make_shared<MagicType>(MagicType::Kind::Block))});