Split up NameAndTypeResolution test cases

1 files changed, 492 insertions, 154 deletions

diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp
index 760139c1..3cb7d1eb 100644
--- a/test/libsolidity/SolidityNameAndTypeResolution.cpp
+++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp
@@ -272,7 +272,7 @@ BOOST_AUTO_TEST_CASE(comparison_bitop_precedence)
 	CHECK_SUCCESS(text);
 }
 
-BOOST_AUTO_TEST_CASE(comparison_of_function_types)
+BOOST_AUTO_TEST_CASE(comparison_of_function_types_lt_1)
 {
 	char const* text = R"(
 		contract C {
@@ -282,7 +282,11 @@ BOOST_AUTO_TEST_CASE(comparison_of_function_types)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Operator < not compatible");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(comparison_of_function_types_lt_2)
+{
+	char const* text = R"(
 		contract C {
 			function f() public returns (bool ret) {
 				return f < f;
@@ -290,7 +294,11 @@ BOOST_AUTO_TEST_CASE(comparison_of_function_types)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Operator < not compatible");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(comparison_of_function_types_gt_1)
+{
+	char const* text = R"(
 		contract C {
 			function f() public returns (bool ret) {
 				return this.f > this.f;
@@ -298,7 +306,11 @@ BOOST_AUTO_TEST_CASE(comparison_of_function_types)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Operator > not compatible");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(comparison_of_function_types_gt_2)
+{
+	char const* text = R"(
 		contract C {
 			function f() public returns (bool ret) {
 				return f > f;
@@ -306,7 +318,11 @@ BOOST_AUTO_TEST_CASE(comparison_of_function_types)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Operator > not compatible");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(comparison_of_function_types_eq)
+{
+	char const* text = R"(
 		contract C {
 			function f() public returns (bool ret) {
 				return f == f;
@@ -1501,9 +1517,9 @@ BOOST_AUTO_TEST_CASE(disallow_declaration_of_void_type)
 	CHECK_ERROR(sourceCode, TypeError, "Not enough components (0) in value to assign all variables (1).");
 }
 
-BOOST_AUTO_TEST_CASE(overflow_caused_by_ether_units)
+BOOST_AUTO_TEST_CASE(no_overflow_with_large_literal)
 {
-	char const* sourceCodeFine = R"(
+	char const* text = R"(
 		contract c {
 			function c () public {
 				a = 115792089237316195423570985008687907853269984665640564039458;
@@ -1511,16 +1527,20 @@ BOOST_AUTO_TEST_CASE(overflow_caused_by_ether_units)
 			uint256 a;
 		}
 	)";
-	CHECK_SUCCESS(sourceCodeFine);
-	char const* sourceCode = R"(
+	CHECK_SUCCESS(text);
+}
+
+BOOST_AUTO_TEST_CASE(overflow_caused_by_ether_units)
+{
+	char const* text = R"(
 		contract c {
 			function c () public {
-				 a = 115792089237316195423570985008687907853269984665640564039458 ether;
+				a = 115792089237316195423570985008687907853269984665640564039458 ether;
 			}
 			uint256 a;
 		}
 	)";
-	CHECK_ERROR(sourceCode, TypeError, "Type int_const 1157...(70 digits omitted)...0000 is not implicitly convertible to expected type uint256.");
+	CHECK_ERROR(text, TypeError, "Type int_const 1157...(70 digits omitted)...0000 is not implicitly convertible to expected type uint256.");
 }
 
 BOOST_AUTO_TEST_CASE(exp_operator_exponent_too_big)
@@ -1533,7 +1553,7 @@ BOOST_AUTO_TEST_CASE(exp_operator_exponent_too_big)
 	CHECK_ERROR(sourceCode, TypeError, "Operator ** not compatible with types int_const 2 and int_const 10000000000");
 }
 
-BOOST_AUTO_TEST_CASE(exp_warn_literal_base)
+BOOST_AUTO_TEST_CASE(exp_warn_literal_base_1)
 {
 	char const* sourceCode = R"(
 		contract test {
@@ -1544,7 +1564,11 @@ BOOST_AUTO_TEST_CASE(exp_warn_literal_base)
 		}
 	)";
 	CHECK_WARNING(sourceCode, "might overflow");
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(exp_warn_literal_base_2)
+{
+	char const* sourceCode = R"(
 		contract test {
 			function f() pure public returns(uint) {
 				uint8 x = 100;
@@ -1553,7 +1577,11 @@ BOOST_AUTO_TEST_CASE(exp_warn_literal_base)
 		}
 	)";
 	CHECK_SUCCESS(sourceCode);
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(exp_warn_literal_base_3)
+{
+	char const* sourceCode = R"(
 		contract test {
 			function f() pure public returns(uint) {
 				return 2**80;
@@ -1563,7 +1591,7 @@ BOOST_AUTO_TEST_CASE(exp_warn_literal_base)
 	CHECK_SUCCESS(sourceCode);
 }
 
-BOOST_AUTO_TEST_CASE(shift_warn_literal_base)
+BOOST_AUTO_TEST_CASE(shift_warn_literal_base_1)
 {
 	char const* sourceCode = R"(
 		contract test {
@@ -1574,7 +1602,11 @@ BOOST_AUTO_TEST_CASE(shift_warn_literal_base)
 		}
 	)";
 	CHECK_WARNING(sourceCode, "might overflow");
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(shift_warn_literal_base_2)
+{
+	const char* sourceCode = R"(
 		contract test {
 			function f() pure public returns(uint) {
 				uint8 x = 100;
@@ -1583,7 +1615,11 @@ BOOST_AUTO_TEST_CASE(shift_warn_literal_base)
 		}
 	)";
 	CHECK_SUCCESS(sourceCode);
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(shift_warn_literal_base_3)
+{
+	const char* sourceCode = R"(
 		contract test {
 			function f() pure public returns(uint) {
 				return 2 << 80;
@@ -1591,7 +1627,11 @@ BOOST_AUTO_TEST_CASE(shift_warn_literal_base)
 		}
 	)";
 	CHECK_SUCCESS(sourceCode);
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(shift_warn_literal_base_4)
+{
+	const char* sourceCode = R"(
 		contract test {
 			function f() pure public returns(uint) {
 				 uint8 x = 100;
@@ -1602,7 +1642,7 @@ BOOST_AUTO_TEST_CASE(shift_warn_literal_base)
 	CHECK_SUCCESS(sourceCode);
 }
 
-BOOST_AUTO_TEST_CASE(warn_var_from_zero)
+BOOST_AUTO_TEST_CASE(warn_var_from_uint8)
 {
 	char const* sourceCode = R"(
 		contract test {
@@ -1616,7 +1656,11 @@ BOOST_AUTO_TEST_CASE(warn_var_from_zero)
 		"uint8, which can hold values between 0 and 255",
 		"Use of the \"var\" keyword is deprecated."
 	}));
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(warn_var_from_uint256)
+{
+	char const* sourceCode = R"(
 		contract test {
 			function f() pure public {
 				var i = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
@@ -1628,7 +1672,11 @@ BOOST_AUTO_TEST_CASE(warn_var_from_zero)
 		"uint256, which can hold values between 0 and 115792089237316195423570985008687907853269984665640564039457584007913129639935",
 		"Use of the \"var\" keyword is deprecated."
 	}));
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(warn_var_from_int8)
+{
+	char const* sourceCode = R"(
 		contract test {
 			function f() pure public {
 				var i = -2;
@@ -1640,7 +1688,11 @@ BOOST_AUTO_TEST_CASE(warn_var_from_zero)
 		"int8, which can hold values between -128 and 127",
 		"Use of the \"var\" keyword is deprecated."
 	}));
-	sourceCode = R"(
+}
+
+BOOST_AUTO_TEST_CASE(warn_var_from_zero)
+{
+	char const* sourceCode = R"(
 		 contract test {
 			 function f() pure public {
 				 for (var i = 0; i < msg.data.length; i++) { }
@@ -1913,7 +1965,7 @@ BOOST_AUTO_TEST_CASE(inheritence_suggestions)
 	CHECK_ERROR(sourceCode, DeclarationError, "Undeclared identifier. Did you mean \"func\"?");
 }
 
-BOOST_AUTO_TEST_CASE(no_spurious_suggestions)
+BOOST_AUTO_TEST_CASE(no_spurious_identifier_suggestions_with_submatch)
 {
 	char const* sourceCode = R"(
 		contract c {
@@ -1924,8 +1976,11 @@ BOOST_AUTO_TEST_CASE(no_spurious_suggestions)
 		}
 	)";
 	CHECK_ERROR(sourceCode, DeclarationError, "Undeclared identifier.");
+}
 
-	sourceCode = R"(
+BOOST_AUTO_TEST_CASE(no_spurious_identifier_suggestions)
+{
+	char const* sourceCode = R"(
 		contract c {
 			function g() public {
 				uint va = 1;
@@ -2154,7 +2209,7 @@ BOOST_AUTO_TEST_CASE(assigning_value_to_const_variable)
 	CHECK_ERROR(text, TypeError, "Cannot assign to a constant variable.");
 }
 
-BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable_0_4_x)
+BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable)
 {
 	char const* text = R"(
 		contract C {
@@ -2164,7 +2219,7 @@ BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable_0_4_x)
 	CHECK_WARNING(text, "Initial value for constant variable has to be compile-time constant.");
 }
 
-BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable)
+BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable_050)
 {
 	char const* text = R"(
 		pragma experimental "v0.5.0";
@@ -2496,48 +2551,68 @@ BOOST_AUTO_TEST_CASE(positive_integers_to_unsigned_out_of_bound)
 	CHECK_ERROR(sourceCode, TypeError, "Type int_const 700 is not implicitly convertible to expected type uint8.");
 }
 
-BOOST_AUTO_TEST_CASE(integer_boolean_operators)
+BOOST_AUTO_TEST_CASE(integer_boolean_or)
 {
-	char const* sourceCode1 = R"(
+	char const* sourceCode = R"(
 		contract test { function() public { uint x = 1; uint y = 2; x || y; } }
 	)";
-	CHECK_ERROR(sourceCode1, TypeError, "Operator || not compatible with types uint256 and uint256");
-	char const* sourceCode2 = R"(
+	CHECK_ERROR(sourceCode, TypeError, "Operator || not compatible with types uint256 and uint256");
+}
+
+BOOST_AUTO_TEST_CASE(integer_boolean_and)
+{
+	char const* sourceCode = R"(
 		contract test { function() public { uint x = 1; uint y = 2; x && y; } }
 	)";
-	CHECK_ERROR(sourceCode2, TypeError, "Operator && not compatible with types uint256 and uint256");
-	char const* sourceCode3 = R"(
+	CHECK_ERROR(sourceCode, TypeError, "Operator && not compatible with types uint256 and uint256");
+}
+
+BOOST_AUTO_TEST_CASE(integer_boolean_not)
+{
+	char const* sourceCode = R"(
 		contract test { function() public { uint x = 1; !x; } }
 	)";
-	CHECK_ERROR(sourceCode3, TypeError, "Unary operator ! cannot be applied to type uint256");
+	CHECK_ERROR(sourceCode, TypeError, "Unary operator ! cannot be applied to type uint256");
 }
 
-BOOST_AUTO_TEST_CASE(exp_signed_variable)
+BOOST_AUTO_TEST_CASE(integer_unsigned_exp_signed)
 {
-	char const* sourceCode1 = R"(
+	char const* sourceCode = R"(
 		contract test { function() public { uint x = 3; int y = -4; x ** y; } }
 	)";
-	CHECK_ERROR(sourceCode1, TypeError, "Operator ** not compatible with types uint256 and int256");
-	char const* sourceCode2 = R"(
+	CHECK_ERROR(sourceCode, TypeError, "Operator ** not compatible with types uint256 and int256");
+}
+
+BOOST_AUTO_TEST_CASE(integer_signed_exp_unsigned)
+{
+	char const* sourceCode = R"(
 		contract test { function() public { uint x = 3; int y = -4; y ** x; } }
 	)";
-	CHECK_ERROR(sourceCode2, TypeError, "Operator ** not compatible with types int256 and uint256");
-	char const* sourceCode3 = R"(
+	CHECK_ERROR(sourceCode, TypeError, "Operator ** not compatible with types int256 and uint256");
+}
+
+BOOST_AUTO_TEST_CASE(integer_signed_exp_signed)
+{
+	char const* sourceCode = R"(
 		contract test { function() public { int x = -3; int y = -4; x ** y; } }
 	)";
-	CHECK_ERROR(sourceCode3, TypeError, "Operator ** not compatible with types int256 and int256");
+	CHECK_ERROR(sourceCode, TypeError, "Operator ** not compatible with types int256 and int256");
 }
 
-BOOST_AUTO_TEST_CASE(reference_compare_operators)
+BOOST_AUTO_TEST_CASE(bytes_reference_compare_operators)
 {
-	char const* sourceCode1 = R"(
+	char const* sourceCode = R"(
 		contract test { bytes a; bytes b; function() public { a == b; } }
 	)";
-	CHECK_ERROR(sourceCode1, TypeError, "Operator == not compatible with types bytes storage ref and bytes storage ref");
-	char const* sourceCode2 = R"(
+	CHECK_ERROR(sourceCode, TypeError, "Operator == not compatible with types bytes storage ref and bytes storage ref");
+}
+
+BOOST_AUTO_TEST_CASE(struct_reference_compare_operators)
+{
+	char const* sourceCode = R"(
 		contract test { struct s {uint a;} s x; s y; function() public { x == y; } }
 	)";
-	CHECK_ERROR(sourceCode2, TypeError, "Operator == not compatible with types struct test.s storage ref and struct test.s storage ref");
+	CHECK_ERROR(sourceCode, TypeError, "Operator == not compatible with types struct test.s storage ref and struct test.s storage ref");
 }
 
 BOOST_AUTO_TEST_CASE(overwrite_memory_location_external)
@@ -2917,8 +2992,7 @@ BOOST_AUTO_TEST_CASE(literal_string_to_storage_pointer)
 BOOST_AUTO_TEST_CASE(non_initialized_references)
 {
 	char const* text = R"(
-		contract c
-		{
+		contract C {
 			struct s {
 				uint a;
 			}
@@ -2936,8 +3010,7 @@ BOOST_AUTO_TEST_CASE(non_initialized_references_050)
 {
 	char const* text = R"(
 		pragma experimental "v0.5.0";
-		contract c
-		{
+		contract C {
 			struct s {
 				uint a;
 			}
@@ -2953,8 +3026,7 @@ BOOST_AUTO_TEST_CASE(non_initialized_references_050)
 BOOST_AUTO_TEST_CASE(keccak256_with_large_integer_constant)
 {
 	char const* text = R"(
-		contract c
-		{
+		contract C {
 			function f() public { keccak256(2**500); }
 		}
 	)";
@@ -4009,7 +4081,7 @@ BOOST_AUTO_TEST_CASE(invalid_int_implicit_conversion_from_fixed)
 	CHECK_ERROR(text, TypeError, "Type fixed128x18 is not implicitly convertible to expected type int256");
 }
 
-BOOST_AUTO_TEST_CASE(rational_unary_operation)
+BOOST_AUTO_TEST_CASE(rational_unary_minus_operation)
 {
 	char const* text = R"(
 		contract test {
@@ -4021,9 +4093,11 @@ BOOST_AUTO_TEST_CASE(rational_unary_operation)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
+}
 
-	// Test deprecation warning under < 0.5.0
-	text = R"(
+BOOST_AUTO_TEST_CASE(rational_unary_plus_operation)
+{
+	char const* text = R"(
 		contract test {
 			function f() pure public {
 				ufixed16x2 a = +3.25;
@@ -4033,7 +4107,11 @@ BOOST_AUTO_TEST_CASE(rational_unary_operation)
 		}
 	)";
 	CHECK_WARNING(text, "Use of unary + is deprecated");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(rational_unary_plus_assignment)
+{
+	char const* text = R"(
 		contract test {
 			function f(uint x) pure public {
 				uint y = +x;
@@ -4041,10 +4119,12 @@ BOOST_AUTO_TEST_CASE(rational_unary_operation)
 			}
 		}
 	)";
-	CHECK_WARNING(text,"Use of unary + is deprecated");
+	CHECK_WARNING(text, "Use of unary + is deprecated");
+}
 
-	// Test syntax error under 0.5.0
-	text = R"(
+BOOST_AUTO_TEST_CASE(rational_unary_plus_operation_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract test {
 			function f() pure public {
@@ -4055,7 +4135,11 @@ BOOST_AUTO_TEST_CASE(rational_unary_operation)
 		}
 	)";
 	CHECK_ERROR(text, SyntaxError, "Use of unary + is deprecated");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(rational_unary_plus_assignment_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract test {
 			function f(uint x) pure public {
@@ -4083,7 +4167,7 @@ BOOST_AUTO_TEST_CASE(leading_zero_rationals_convert)
 	CHECK_SUCCESS(text);
 }
 
-BOOST_AUTO_TEST_CASE(size_capabilities_of_fixed_point_types)
+BOOST_AUTO_TEST_CASE(fixed_type_size_capabilities)
 {
 	char const* text = R"(
 		contract test {
@@ -4101,7 +4185,7 @@ BOOST_AUTO_TEST_CASE(size_capabilities_of_fixed_point_types)
 	CHECK_SUCCESS(text);
 }
 
-BOOST_AUTO_TEST_CASE(zero_handling)
+BOOST_AUTO_TEST_CASE(fixed_type_zero_handling)
 {
 	char const* text = R"(
 		contract test {
@@ -4569,7 +4653,7 @@ BOOST_AUTO_TEST_CASE(unused_return_value_delegatecall)
 	CHECK_WARNING(text, "Return value of low-level calls not used");
 }
 
-BOOST_AUTO_TEST_CASE(warn_about_callcode)
+BOOST_AUTO_TEST_CASE(callcode_deprecated)
 {
 	char const* text = R"(
 		contract test {
@@ -4579,7 +4663,11 @@ BOOST_AUTO_TEST_CASE(warn_about_callcode)
 		}
 	)";
 	CHECK_WARNING(text, "\"callcode\" has been deprecated in favour of \"delegatecall\"");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(callcode_deprecated_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract test {
 			function f() pure public {
@@ -4590,7 +4678,7 @@ BOOST_AUTO_TEST_CASE(warn_about_callcode)
 	CHECK_ERROR(text, TypeError, "\"callcode\" has been deprecated in favour of \"delegatecall\"");
 }
 
-BOOST_AUTO_TEST_CASE(no_warn_about_callcode_as_function)
+BOOST_AUTO_TEST_CASE(callcode_not_deprecated_as_function)
 {
 	char const* text = R"(
 		contract test {
@@ -5382,7 +5470,7 @@ BOOST_AUTO_TEST_CASE(invalid_address_length_long)
 	}));
 }
 
-BOOST_AUTO_TEST_CASE(address_test_for_bug_in_implementation)
+BOOST_AUTO_TEST_CASE(string_literal_not_convertible_to_address_as_assignment)
 {
 	char const* text = R"(
 		// A previous implementation claimed the string would be an address
@@ -5391,7 +5479,11 @@ BOOST_AUTO_TEST_CASE(address_test_for_bug_in_implementation)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "is not implicitly convertible to expected type address");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(string_literal_not_convertible_to_address_as_return_value)
+{
+	char const* text = R"(
 		// A previous implementation claimed the string would be an address
 		contract AddrString {
 			function f() public returns (address) {
@@ -5576,7 +5668,7 @@ BOOST_AUTO_TEST_CASE(interface_implement_public_contract)
 	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
-BOOST_AUTO_TEST_CASE(warn_about_throw)
+BOOST_AUTO_TEST_CASE(throw_is_deprecated)
 {
 	char const* text = R"(
 		contract C {
@@ -5586,8 +5678,12 @@ BOOST_AUTO_TEST_CASE(warn_about_throw)
 		}
 	)";
 	CHECK_WARNING(text, "\"throw\" is deprecated in favour of \"revert()\", \"require()\" and \"assert()\"");
-	text = R"(
-                pragma experimental "v0.5.0";
+}
+
+BOOST_AUTO_TEST_CASE(throw_is_deprecated_v050)
+{
+	char const* text = R"(
+		pragma experimental "v0.5.0";
 		contract C {
 			function f() pure public {
 				throw;
@@ -5625,13 +5721,35 @@ BOOST_AUTO_TEST_CASE(revert_with_reason)
 	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
-BOOST_AUTO_TEST_CASE(bare_others)
+BOOST_AUTO_TEST_CASE(bare_selfdestruct)
+{
+	char const* text = R"(
+		contract C {
+			function f() pure public { selfdestruct; }
+		}
+	)";
+	CHECK_WARNING(text, "Statement has no effect.");
+}
+
+BOOST_AUTO_TEST_CASE(bare_assert)
+{
+	char const* text = R"(
+		contract C {
+			function f() pure public { assert; }
+		}
+	)";
+	CHECK_WARNING(text, "Statement has no effect.");
+}
+
+BOOST_AUTO_TEST_CASE(bare_require)
 {
-	CHECK_WARNING("contract C { function f() pure public { selfdestruct; } }", "Statement has no effect.");
-	CHECK_WARNING("contract C { function f() pure public { assert; } }", "Statement has no effect.");
-	// This is different because it does have overloads.
-	CHECK_ERROR("contract C { function f() pure public { require; } }", TypeError, "No matching declaration found after variable lookup.");
-	CHECK_WARNING("contract C { function f() pure public { selfdestruct; } }", "Statement has no effect.");
+	char const* text = R"(
+		contract C {
+			// This is different because it does have overloads.
+			function f() pure public { require; }
+		}
+	)";
+	CHECK_ERROR(text, TypeError, "No matching declaration found after variable lookup.");
 }
 
 BOOST_AUTO_TEST_CASE(pure_statement_in_for_loop)
@@ -5693,13 +5811,17 @@ BOOST_AUTO_TEST_CASE(warn_unused_function_parameter)
 		}
 	)";
 	CHECK_WARNING(text, "Unused function parameter. Remove or comment out the variable name to silence this warning.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(unused_unnamed_function_parameter)
+{
+	char const* text = R"(
 		contract C {
-			function f(uint a) pure public {
+			function f(uint) pure public {
 			}
 		}
 	)";
-	CHECK_SUCCESS(text);
+	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
 BOOST_AUTO_TEST_CASE(warn_unused_return_parameter)
@@ -5711,7 +5833,11 @@ BOOST_AUTO_TEST_CASE(warn_unused_return_parameter)
 		}
 	)";
 	CHECK_WARNING(text, "Unused function parameter. Remove or comment out the variable name to silence this warning.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(warn_unused_return_parameter_with_explicit_return)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public returns (uint a) {
 				return;
@@ -5719,14 +5845,22 @@ BOOST_AUTO_TEST_CASE(warn_unused_return_parameter)
 		}
 	)";
 	CHECK_WARNING(text, "Unused function parameter. Remove or comment out the variable name to silence this warning.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(unused_unnamed_return_parameter)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public returns (uint) {
 			}
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(named_return_parameter)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public returns (uint a) {
 				a = 1;
@@ -5734,7 +5868,11 @@ BOOST_AUTO_TEST_CASE(warn_unused_return_parameter)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(named_return_parameter_with_explicit_return)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public returns (uint a) {
 				return 1;
@@ -5744,6 +5882,18 @@ BOOST_AUTO_TEST_CASE(warn_unused_return_parameter)
 	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
+BOOST_AUTO_TEST_CASE(unnamed_return_parameter_with_explicit_return)
+{
+	char const* text = R"(
+		contract C {
+			function f() pure public returns (uint) {
+				return 1;
+			}
+		}
+	)";
+	CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
 BOOST_AUTO_TEST_CASE(no_unused_warning_interface_arguments)
 {
 	char const* text = R"(
@@ -6087,7 +6237,7 @@ BOOST_AUTO_TEST_CASE(create2_as_variable)
 	}));
 }
 
-BOOST_AUTO_TEST_CASE(warn_unspecified_storage)
+BOOST_AUTO_TEST_CASE(specified_storage_no_warn)
 {
 	char const* text = R"(
 		contract C {
@@ -6100,7 +6250,11 @@ BOOST_AUTO_TEST_CASE(warn_unspecified_storage)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(unspecified_storage_warn)
+{
+	char const* text = R"(
 		contract C {
 			struct S { uint a; }
 			S x;
@@ -6111,7 +6265,11 @@ BOOST_AUTO_TEST_CASE(warn_unspecified_storage)
 		}
 	)";
 	CHECK_WARNING(text, "Variable is declared as a storage pointer. Use an explicit \"storage\" keyword to silence this warning");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(unspecified_storage_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			struct S { uint a; }
@@ -6160,7 +6318,7 @@ BOOST_AUTO_TEST_CASE(implicit_conversion_disallowed)
 	CHECK_ERROR(text, TypeError, "Return argument type uint32 is not implicitly convertible to expected type (type of first return variable) bytes4.");
 }
 
-BOOST_AUTO_TEST_CASE(too_large_arrays_for_calldata)
+BOOST_AUTO_TEST_CASE(too_large_arrays_for_calldata_external)
 {
 	char const* text = R"(
 		contract C {
@@ -6169,14 +6327,22 @@ BOOST_AUTO_TEST_CASE(too_large_arrays_for_calldata)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Array is too large to be encoded.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(too_large_arrays_for_calldata_internal)
+{
+	char const* text = R"(
 		contract C {
 			function f(uint[85678901234] a) pure internal {
 			}
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Array is too large to be encoded.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(too_large_arrays_for_calldata_public)
+{
+	char const* text = R"(
 		contract C {
 			function f(uint[85678901234] a) pure public {
 			}
@@ -6185,7 +6351,7 @@ BOOST_AUTO_TEST_CASE(too_large_arrays_for_calldata)
 	CHECK_ERROR(text, TypeError, "Array is too large to be encoded.");
 }
 
-BOOST_AUTO_TEST_CASE(explicit_literal_to_storage_string)
+BOOST_AUTO_TEST_CASE(explicit_literal_to_memory_string_assignment)
 {
 	char const* text = R"(
 		contract C {
@@ -6196,7 +6362,11 @@ BOOST_AUTO_TEST_CASE(explicit_literal_to_storage_string)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(explicit_literal_to_storage_string_assignment)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public {
 				string storage x = "abc";
@@ -6204,7 +6374,11 @@ BOOST_AUTO_TEST_CASE(explicit_literal_to_storage_string)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Type literal_string \"abc\" is not implicitly convertible to expected type string storage pointer.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(explicit_literal_to_unspecified_string_assignment)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public {
 				string x = "abc";
@@ -6212,7 +6386,11 @@ BOOST_AUTO_TEST_CASE(explicit_literal_to_storage_string)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Type literal_string \"abc\" is not implicitly convertible to expected type string storage pointer.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(explicit_literal_to_unspecified_string)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure public {
 				string("abc");
@@ -6236,7 +6414,7 @@ BOOST_AUTO_TEST_CASE(modifiers_access_storage_pointer)
 	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
-BOOST_AUTO_TEST_CASE(function_types_sig)
+BOOST_AUTO_TEST_CASE(function_types_selector_1)
 {
 	char const* text = R"(
 		contract C {
@@ -6246,7 +6424,11 @@ BOOST_AUTO_TEST_CASE(function_types_sig)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"selector\" not found");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(function_types_selector_2)
+{
+	char const* text = R"(
 		contract C {
 			function g() pure internal {
 			}
@@ -6256,7 +6438,11 @@ BOOST_AUTO_TEST_CASE(function_types_sig)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"selector\" not found");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(function_types_selector_3)
+{
+	char const* text = R"(
 		contract C {
 			function f() view returns (bytes4) {
 				function () g;
@@ -6265,7 +6451,11 @@ BOOST_AUTO_TEST_CASE(function_types_sig)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"selector\" not found");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(function_types_selector_4)
+{
+	char const* text = R"(
 		contract C {
 			function f() pure external returns (bytes4) {
 				return this.f.selector;
@@ -6273,7 +6463,11 @@ BOOST_AUTO_TEST_CASE(function_types_sig)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(function_types_selector_5)
+{
+	char const* text = R"(
 		contract C {
 			function h() pure external {
 			}
@@ -6284,7 +6478,11 @@ BOOST_AUTO_TEST_CASE(function_types_sig)
 		}
 	)";
 	CHECK_WARNING(text, "Use of the \"var\" keyword is deprecated.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(function_types_selector_6)
+{
+	char const* text = R"(
 		contract C {
 			function h() pure external {
 			}
@@ -6295,7 +6493,11 @@ BOOST_AUTO_TEST_CASE(function_types_sig)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(function_types_selector_7)
+{
+	char const* text = R"(
 		contract C {
 			function h() pure external {
 			}
@@ -6341,7 +6543,7 @@ BOOST_AUTO_TEST_CASE(do_not_crash_on_not_lvalue)
 	}));
 }
 
-BOOST_AUTO_TEST_CASE(builtin_reject_gas)
+BOOST_AUTO_TEST_CASE(builtin_keccak256_reject_gas)
 {
 	char const* text = R"(
 		contract C {
@@ -6351,7 +6553,11 @@ BOOST_AUTO_TEST_CASE(builtin_reject_gas)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"gas\" not found or not visible after argument-dependent lookup");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(builtin_sha256_reject_gas)
+{
+	const char* text = R"(
 		contract C {
 			function f() public {
 				sha256.gas();
@@ -6359,7 +6565,11 @@ BOOST_AUTO_TEST_CASE(builtin_reject_gas)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"gas\" not found or not visible after argument-dependent lookup");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(builtin_ripemd160_reject_gas)
+{
+	const char* text = R"(
 		contract C {
 			function f() public {
 				ripemd160.gas();
@@ -6367,7 +6577,11 @@ BOOST_AUTO_TEST_CASE(builtin_reject_gas)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"gas\" not found or not visible after argument-dependent lookup");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(builtin_ecrecover_reject_gas)
+{
+	const char* text = R"(
 		contract C {
 			function f() public {
 				ecrecover.gas();
@@ -6381,19 +6595,25 @@ BOOST_AUTO_TEST_CASE(gasleft)
 {
 	char const* text = R"(
 		contract C {
-			function f() public view returns (uint256 val) { return msg.gas; }
+			function f() public view returns (uint256 val) { return gasleft(); }
 		}
 	)";
-	CHECK_WARNING(text, "\"msg.gas\" has been deprecated in favor of \"gasleft()\"");
+	CHECK_SUCCESS_NO_WARNINGS(text);
+}
 
-	text = R"(
+BOOST_AUTO_TEST_CASE(msg_gas_deprecated)
+{
+	char const* text = R"(
 		contract C {
-			function f() public view returns (uint256 val) { return gasleft(); }
+			function f() public view returns (uint256 val) { return msg.gas; }
 		}
 	)";
-	CHECK_SUCCESS_NO_WARNINGS(text);
+	CHECK_WARNING(text, "\"msg.gas\" has been deprecated in favor of \"gasleft()\"");
+}
 
-	text = R"(
+BOOST_AUTO_TEST_CASE(msg_gas_deprecated_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			function f() public returns (uint256 val) { return msg.gas; }
@@ -6402,7 +6622,7 @@ BOOST_AUTO_TEST_CASE(gasleft)
 	CHECK_ERROR(text, TypeError, "\"msg.gas\" has been deprecated in favor of \"gasleft()\"");
 }
 
-BOOST_AUTO_TEST_CASE(gasleft_shadowing)
+BOOST_AUTO_TEST_CASE(gasleft_shadowing_1)
 {
 	char const* text = R"(
 		contract C {
@@ -6411,8 +6631,11 @@ BOOST_AUTO_TEST_CASE(gasleft_shadowing)
 		}
 	)";
 	CHECK_WARNING(text, "This declaration shadows a builtin symbol.");
+}
 
-	text = R"(
+BOOST_AUTO_TEST_CASE(gasleft_shadowing_2)
+{
+	char const* text = R"(
 		contract C {
 			uint gasleft;
 			function f() public { gasleft = 42; }
@@ -6421,7 +6644,7 @@ BOOST_AUTO_TEST_CASE(gasleft_shadowing)
 	CHECK_WARNING(text, "This declaration shadows a builtin symbol.");
 }
 
-BOOST_AUTO_TEST_CASE(builtin_reject_value)
+BOOST_AUTO_TEST_CASE(builtin_keccak256_reject_value)
 {
 	char const* text = R"(
 		contract C {
@@ -6431,7 +6654,11 @@ BOOST_AUTO_TEST_CASE(builtin_reject_value)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"value\" not found or not visible after argument-dependent lookup");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(builtin_sha256_reject_value)
+{
+	const char* text = R"(
 		contract C {
 			function f() public {
 				sha256.value();
@@ -6439,7 +6666,11 @@ BOOST_AUTO_TEST_CASE(builtin_reject_value)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"value\" not found or not visible after argument-dependent lookup");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(builtin_ripemd160_reject_value)
+{
+	const char* text = R"(
 		contract C {
 			function f() public {
 				ripemd160.value();
@@ -6447,7 +6678,11 @@ BOOST_AUTO_TEST_CASE(builtin_reject_value)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Member \"value\" not found or not visible after argument-dependent lookup");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(builtin_ecrecover_reject_value)
+{
+	const char* text = R"(
 		contract C {
 			function f() public {
 				ecrecover.value();
@@ -6508,21 +6743,30 @@ BOOST_AUTO_TEST_CASE(large_storage_array_mapping)
 	CHECK_WARNING(text, "covers a large part of storage and thus makes collisions likely");
 }
 
-BOOST_AUTO_TEST_CASE(library_function_without_implementation)
+BOOST_AUTO_TEST_CASE(library_function_without_implementation_public)
 {
 	char const* text = R"(
 		library L {
+			// This can be used as an "interface", hence it is allowed.
 			function f() public;
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(library_function_without_implementation_internal)
+{
+	char const* text = R"(
 		library L {
 			function f() internal;
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Internal library function must be implemented if declared.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(library_function_without_implementation_private)
+{
+	char const* text = R"(
 		library L {
 			function f() private;
 		}
@@ -6545,37 +6789,65 @@ BOOST_AUTO_TEST_CASE(using_for_with_non_library)
 	CHECK_ERROR(text, TypeError, "Library name expected.");
 }
 
-BOOST_AUTO_TEST_CASE(experimental_pragma)
+BOOST_AUTO_TEST_CASE(experimental_pragma_empty)
 {
 	char const* text = R"(
 		pragma experimental;
 	)";
 	CHECK_ERROR(text, SyntaxError, "Experimental feature name is missing.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_unknown_number_literal)
+{
+	char const* text = R"(
 		pragma experimental 123;
 	)";
 	CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_unknown_string_literal)
+{
+	char const* text = R"(
 		pragma experimental unsupportedName;
 	)";
 	CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_unknown_quoted_string_literal)
+{
+	char const* text = R"(
 		pragma experimental "unsupportedName";
 	)";
 	CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_empy_string_literal)
+{
+	char const* text = R"(
 		pragma experimental "";
 	)";
 	CHECK_ERROR(text, SyntaxError, "Empty experimental feature name is invalid.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_multiple_same_line)
+{
+	char const* text = R"(
 		pragma experimental unsupportedName unsupportedName;
 	)";
 	CHECK_ERROR(text, SyntaxError, "Stray arguments.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_test_warning)
+{
+	char const* text = R"(
 		pragma experimental __test;
 	)";
 	CHECK_WARNING(text, "Experimental features are turned on. Do not use experimental features on live deployments.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(experimental_pragma_duplicate)
+{
+	char const* text = R"(
 		pragma experimental __test;
 		pragma experimental __test;
 	)";
@@ -6617,7 +6889,7 @@ BOOST_AUTO_TEST_CASE(reject_interface_constructors)
 	CHECK_ERROR(text, TypeError, "Wrong argument count for constructor call: 1 arguments given but expected 0.");
 }
 
-BOOST_AUTO_TEST_CASE(non_external_fallback)
+BOOST_AUTO_TEST_CASE(fallback_marked_external_v050)
 {
 	char const* text = R"(
 		pragma experimental "v0.5.0";
@@ -6626,21 +6898,33 @@ BOOST_AUTO_TEST_CASE(non_external_fallback)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(fallback_marked_internal_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			function () internal { }
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Fallback function must be defined as \"external\".");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(fallback_marked_private_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			function () private { }
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Fallback function must be defined as \"external\".");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(fallback_marked_public_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			function () public { }
@@ -6649,7 +6933,7 @@ BOOST_AUTO_TEST_CASE(non_external_fallback)
 	CHECK_ERROR(text, TypeError, "Fallback function must be defined as \"external\".");
 }
 
-BOOST_AUTO_TEST_CASE(invalid_literal_in_tuple)
+BOOST_AUTO_TEST_CASE(tuple_invalid_literal_too_large_for_uint)
 {
 	char const* text = R"(
 		contract C {
@@ -6660,7 +6944,11 @@ BOOST_AUTO_TEST_CASE(invalid_literal_in_tuple)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "is not implicitly convertible to expected type");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(tuple_invalid_literal_too_large_unassigned)
+{
+	const char* text = R"(
 		contract C {
 			function f() pure public {
 				uint x;
@@ -6669,7 +6957,11 @@ BOOST_AUTO_TEST_CASE(invalid_literal_in_tuple)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid rational number.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(tuple_invalid_literal_too_large_for_uint_multi)
+{
+	const char* text = R"(
 		contract C {
 			function f() pure public {
 				uint x;
@@ -6678,7 +6970,11 @@ BOOST_AUTO_TEST_CASE(invalid_literal_in_tuple)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid rational number.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(tuple_invalid_literal_too_large_exp)
+{
+	const char* text = R"(
 		contract C {
 			function f() pure public {
 				(2**270, 1);
@@ -6686,7 +6982,11 @@ BOOST_AUTO_TEST_CASE(invalid_literal_in_tuple)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid rational number.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(tuple_invalid_literal_too_large_expression)
+{
+	const char* text = R"(
 		contract C {
 			function f() pure public {
 				((2**270) / 2**100, 1);
@@ -6719,7 +7019,7 @@ BOOST_AUTO_TEST_CASE(address_overload_resolution)
 	CHECK_SUCCESS(text);
 }
 
-BOOST_AUTO_TEST_CASE(array_length_invalid_expression)
+BOOST_AUTO_TEST_CASE(array_length_invalid_expression_negative_bool)
 {
 	char const* text = R"(
 		contract C {
@@ -6727,25 +7027,41 @@ BOOST_AUTO_TEST_CASE(array_length_invalid_expression)
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal or constant expression.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(array_length_invalid_expression_int_divides_bool)
+{
+	char const* text = R"(
 		contract C {
 			uint[true/1] ids;
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal or constant expression.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(array_length_invalid_expression_bool_divides_int)
+{
+	char const* text = R"(
 		contract C {
 			uint[1/true] ids;
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal or constant expression.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(array_length_invalid_expression_scientific_literal)
+{
+	char const* text = R"(
 		contract C {
 			uint[1.111111E1111111111111] ids;
 		}
 	)";
 	CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal or constant expression.");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(array_length_invalid_expression_division_by_zero)
+{
+	char const* text = R"(
 		contract C {
 			uint[3/0] ids;
 		}
@@ -6953,7 +7269,7 @@ BOOST_AUTO_TEST_CASE(no_warning_for_using_members_that_look_like_address_members
 	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
-BOOST_AUTO_TEST_CASE(emit_events)
+BOOST_AUTO_TEST_CASE(event_emit_simple)
 {
 	char const* text = R"(
 		contract C {
@@ -6964,7 +7280,11 @@ BOOST_AUTO_TEST_CASE(emit_events)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(event_emit_complex)
+{
+	char const* text = R"(
 		contract C {
 			event e(uint a, string b);
 			function f() public {
@@ -6974,7 +7294,11 @@ BOOST_AUTO_TEST_CASE(emit_events)
 		}
 	)";
 	CHECK_SUCCESS_NO_WARNINGS(text);
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(event_emit_foreign_class)
+{
+	char const* text = R"(
 		contract A { event e(uint a, string b); }
 		contract C is A {
 			function f() public {
@@ -6986,7 +7310,7 @@ BOOST_AUTO_TEST_CASE(emit_events)
 	CHECK_SUCCESS_NO_WARNINGS(text);
 }
 
-BOOST_AUTO_TEST_CASE(old_style_events_050)
+BOOST_AUTO_TEST_CASE(event_without_emit_deprecated)
 {
 	char const* text = R"(
 		contract C {
@@ -6997,7 +7321,11 @@ BOOST_AUTO_TEST_CASE(old_style_events_050)
 		}
 	)";
 	CHECK_WARNING(text, "without \"emit\" prefix");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(events_without_emit_deprecated_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			event e();
@@ -7037,7 +7365,11 @@ BOOST_AUTO_TEST_CASE(require_visibility_specifiers)
 		}
 	)";
 	CHECK_WARNING(text, "No visibility specified. Defaulting to");
-	text = R"(
+}
+
+BOOST_AUTO_TEST_CASE(require_visibility_specifiers_v050)
+{
+	char const* text = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			function f() pure { }
@@ -7050,21 +7382,27 @@ BOOST_AUTO_TEST_CASE(blockhash)
 {
 	char const* code = R"(
 		contract C {
-			function f() public view returns (bytes32) {
-				return block.blockhash(3);
-			}
+			function f() public view returns (bytes32) { return blockhash(3); }
 		}
 	)";
-	CHECK_WARNING(code, "\"block.blockhash()\" has been deprecated in favor of \"blockhash()\"");
+	CHECK_SUCCESS_NO_WARNINGS(code);
+}
 
-	code = R"(
+BOOST_AUTO_TEST_CASE(block_blockhash_deprecated)
+{
+	char const* code = R"(
 		contract C {
-			function f() public view returns (bytes32) { return blockhash(3); }
+			function f() public view returns (bytes32) {
+				return block.blockhash(3);
+			}
 		}
 	)";
-	CHECK_SUCCESS_NO_WARNINGS(code);
+	CHECK_WARNING(code, "\"block.blockhash()\" has been deprecated in favor of \"blockhash()\"");
+}
 
-	code = R"(
+BOOST_AUTO_TEST_CASE(block_blockhash_deprecated_v050)
+{
+	char const* code = R"(
 		pragma experimental "v0.5.0";
 		contract C {
 			function f() public returns (bytes32) { return block.blockhash(3); }