cerc-io/solidity
11
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleans up test file parser and its tests.

Browse Source
This commit is contained in:
Erik Kundt
2019-02-06 17:22:40 +01:00
parent 7fa167977b
commit 161b22bd13
3 changed files with 320 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/libsolidity/util/TestFileParserTests.cpp
+261 -167
View File
@@ -23,7 +23,7 @@
#include <tuple>
#include <boost/test/unit_test.hpp>
#include <liblangutil/Exceptions.h>
#include <test/libsolidity/SolidityExecutionFramework.h>
#include <test/ExecutionFramework.h>
#include <test/libsolidity/util/TestFileParser.h>
@@ -37,6 +37,9 @@ namespace solidity
namespace test
{
using fmt = ExecutionFramework;
using Mode = FunctionCall::DisplayMode;
vector<FunctionCall> parse(string const& _source)
{
istringstream stream{_source, ios_base::out};
@@ -44,51 +47,44 @@ vector<FunctionCall> parse(string const& _source)
return parser.parseFunctionCalls();
}
void testFunctionCall(
FunctionCall const& _call,
FunctionCall::DisplayMode _mode,
string _signature = "",
bool _failure = true,
bytes _arguments = bytes{},
bytes _expectations = bytes{},
u256 _value = 0,
string _argumentComment = "",
string _expectationComment = ""
)
{
BOOST_REQUIRE_EQUAL(_call.expectations.failure, _failure);
BOOST_REQUIRE_EQUAL(_call.signature, _signature);
ABI_CHECK(_call.arguments.rawBytes(), _arguments);
ABI_CHECK(_call.expectations.rawBytes(), _expectations);
BOOST_REQUIRE_EQUAL(_call.displayMode, _mode);
BOOST_REQUIRE_EQUAL(_call.value, _value);
BOOST_REQUIRE_EQUAL(_call.arguments.comment, _argumentComment);
BOOST_REQUIRE_EQUAL(_call.expectations.comment, _expectationComment);
}
BOOST_AUTO_TEST_SUITE(TestFileParserTest)
BOOST_AUTO_TEST_CASE(smoke_test)
{
char const* source = R"()";
BOOST_CHECK_EQUAL(parse(source).size(), 0);
BOOST_REQUIRE_EQUAL(parse(source).size(), 0);
}
BOOST_AUTO_TEST_CASE(simple_call_succees)
BOOST_AUTO_TEST_CASE(call_succees)
{
char const* source = R"(
// f(uint256, uint256): 1, 1
// ->
// # This call should not return a value, but still succeed. #
// success() ->
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
auto call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "f(uint256,uint256)");
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{1}) + toBigEndian(u256{1}));
ABI_CHECK(call.expectations.rawBytes(), bytes{});
}
BOOST_AUTO_TEST_CASE(simple_single_line_call_success)
{
char const* source = R"(
// f(uint256): 1 -> # Does not expect a value. #
// f(uint256): 1 -> 1 # Expect return value. #
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 2);
auto call = calls.at(0);
BOOST_CHECK_EQUAL(call.signature, "f(uint256)");
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::SingleLine);
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{1}));
ABI_CHECK(call.expectations.rawBytes(), bytes{});
call = calls.at(1);
BOOST_CHECK_EQUAL(call.signature, "f(uint256)");
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::SingleLine);
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{1}));
ABI_CHECK(call.expectations.rawBytes(), toBigEndian(u256{1}));
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(calls.at(0), Mode::SingleLine, "success()", false);
}
BOOST_AUTO_TEST_CASE(non_existent_call_revert_single_line)
@@ -97,31 +93,123 @@ BOOST_AUTO_TEST_CASE(non_existent_call_revert_single_line)
// i_am_not_there() -> FAILURE
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(calls.at(0), Mode::SingleLine, "i_am_not_there()", true);
}
BOOST_AUTO_TEST_CASE(call_arguments_success)
{
char const* source = R"(
// f(uint256): 1
// ->
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(calls.at(0), Mode::MultiLine, "f(uint256)", false, fmt::encodeArgs(u256{1}));
}
BOOST_AUTO_TEST_CASE(call_arguments_comments_success)
{
char const* source = R"(
// f(uint256, uint256): 1, 1
// ->
// # This call should not return a value, but still succeed. #
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(
calls.at(0),
Mode::MultiLine,
"f(uint256,uint256)",
false,
fmt::encodeArgs(1, 1),
fmt::encodeArgs(),
0,
"",
" This call should not return a value, but still succeed. "
);
}
BOOST_AUTO_TEST_CASE(simple_single_line_call_comment_success)
{
char const* source = R"(
// f(uint256): 1 -> # f(uint256) does not return a value. #
// f(uint256): 1 -> 1
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 2);
testFunctionCall(
calls.at(0),
Mode::SingleLine,
"f(uint256)",
false,
fmt::encodeArgs(1),
fmt::encodeArgs(),
0,
"",
" f(uint256) does not return a value. "
);
testFunctionCall(calls.at(1), Mode::SingleLine, "f(uint256)", false, fmt::encode(1), fmt::encode(1));
}
BOOST_AUTO_TEST_CASE(multiple_single_line)
{
char const* source = R"(
// f(uint256): 1 -> 1
// g(uint256): 1 ->
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 2);
testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(1), fmt::encodeArgs(1));
testFunctionCall(calls.at(1), Mode::SingleLine, "g(uint256)", false, fmt::encodeArgs(1));
}
BOOST_AUTO_TEST_CASE(multiple_single_line_swapped)
{
char const* source = R"(
// f(uint256): 1 ->
// g(uint256): 1 -> 1
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 2);
testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(1));
testFunctionCall(calls.at(1), Mode::SingleLine, "g(uint256)", false, fmt::encodeArgs(1), fmt::encodeArgs(1));
auto const& call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::SingleLine);
BOOST_CHECK_EQUAL(call.signature, "i_am_not_there()");
BOOST_CHECK_EQUAL(call.expectations.failure, true);
BOOST_CHECK_EQUAL(call.expectations.parameters.at(0).abiType.type, ABIType::Failure);
ABI_CHECK(call.expectations.rawBytes(), bytes{});
}
BOOST_AUTO_TEST_CASE(non_existent_call_revert)
{
char const* source = R"(
// i_am_not_there()
// -> FAILURE # This is can be either REVERT or a different EVM failure #
// -> FAILURE
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(calls.at(0), Mode::MultiLine, "i_am_not_there()", true);
}
auto const& call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "i_am_not_there()");
BOOST_CHECK_EQUAL(call.expectations.parameters.at(0).abiType.type, ABIType::Failure);
ABI_CHECK(call.expectations.rawBytes(), bytes{});
BOOST_CHECK_EQUAL(call.expectations.failure, true);
BOOST_AUTO_TEST_CASE(call_expectations_empty_single_line)
{
char const* source = R"(
// _exp_() ->
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(calls.at(0), Mode::SingleLine, "_exp_()", false);
}
BOOST_AUTO_TEST_CASE(call_expectations_empty_multiline)
{
char const* source = R"(
// _exp_()
// ->
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(calls.at(0), Mode::MultiLine, "_exp_()", false);
}
BOOST_AUTO_TEST_CASE(call_comments)
@@ -132,18 +220,29 @@ BOOST_AUTO_TEST_CASE(call_comments)
// -> 1 # Expectation comment #
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 2);
BOOST_CHECK_EQUAL(calls.at(0).displayMode, FunctionCall::DisplayMode::SingleLine);
BOOST_CHECK_EQUAL(calls.at(1).displayMode, FunctionCall::DisplayMode::MultiLine);
for (auto const& call: calls)
{
BOOST_CHECK_EQUAL(call.signature, "f()");
BOOST_CHECK_EQUAL(call.arguments.comment, " Parameter comment ");
BOOST_CHECK_EQUAL(call.expectations.comment, " Expectation comment ");
ABI_CHECK(call.expectations.rawBytes(), toBigEndian(u256{1}));
}
BOOST_REQUIRE_EQUAL(calls.size(), 2);
testFunctionCall(
calls.at(0),
Mode::SingleLine,
"f()",
false,
fmt::encodeArgs(),
fmt::encodeArgs(1),
0,
" Parameter comment ",
" Expectation comment "
);
testFunctionCall(
calls.at(1),
Mode::MultiLine,
"f()",
false,
fmt::encodeArgs(),
fmt::encodeArgs(1),
0,
" Parameter comment ",
" Expectation comment "
);
}
BOOST_AUTO_TEST_CASE(call_arguments)
@@ -153,85 +252,17 @@ BOOST_AUTO_TEST_CASE(call_arguments)
// -> 4
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
auto const& call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "f(uint256)");
BOOST_CHECK_EQUAL(call.value, u256{314});
BOOST_CHECK_EQUAL(call.expectations.failure, false);
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{5}));
ABI_CHECK(call.expectations.rawBytes(), toBigEndian(u256{4}));
}
BOOST_AUTO_TEST_CASE(call_expectations_empty_single_line)
{
char const* source = R"(
// _exp_() ->
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
auto call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::SingleLine);
BOOST_CHECK_EQUAL(call.signature, "_exp_()");
ABI_CHECK(call.arguments.rawBytes(), bytes{});
ABI_CHECK(call.expectations.rawBytes(), bytes{});
}
BOOST_AUTO_TEST_CASE(call_expectations_empty_multiline)
{
char const* source = R"(
// _exp_()
// ->
// # This call should not return a value, but still succeed. #
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
auto call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "_exp_()");
ABI_CHECK(call.arguments.rawBytes(), bytes{});
ABI_CHECK(call.expectations.rawBytes(), bytes{});
}
BOOST_AUTO_TEST_CASE(call_expectations_missing)
{
char const* source = R"(
// f())";
BOOST_CHECK_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_ether_value_expectations_missing)
{
char const* source = R"(
// f(), 0)";
BOOST_CHECK_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_arguments_invalid)
{
char const* source = R"(
// f(uint256): abc -> 1
)";
BOOST_CHECK_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_ether_value_invalid)
{
char const* source = R"(
// f(uint256), abc : 1 -> 1
)";
BOOST_CHECK_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_ether_type_invalid)
{
char const* source = R"(
// f(uint256), 2 btc : 1 -> 1
)";
BOOST_CHECK_THROW(parse(source), langutil::Error);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(
calls.at(0),
Mode::MultiLine,
"f(uint256)",
false,
fmt::encodeArgs(5),
fmt::encodeArgs(4),
314,
" optional ether value "
);
}
BOOST_AUTO_TEST_CASE(call_arguments_mismatch)
@@ -243,13 +274,17 @@ BOOST_AUTO_TEST_CASE(call_arguments_mismatch)
// -> 1
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
auto const& call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "f(uint256)");
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{1}) + toBigEndian(u256{2}));
BOOST_CHECK_EQUAL(call.expectations.failure, false);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(
calls.at(0),
Mode::MultiLine,
"f(uint256)",
false,
fmt::encodeArgs(1, 2),
fmt::encodeArgs(1),
0,
" This only throws at runtime "
);
}
BOOST_AUTO_TEST_CASE(call_multiple_arguments)
@@ -262,13 +297,15 @@ BOOST_AUTO_TEST_CASE(call_multiple_arguments)
// 1
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
auto const& call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "test(uint256,uint256)");
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{1}) + toBigEndian(u256{2}));
BOOST_CHECK_EQUAL(call.expectations.failure, false);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(
calls.at(0),
Mode::MultiLine,
"test(uint256,uint256)",
false,
fmt::encodeArgs(1, 2),
fmt::encodeArgs(1, 1)
);
}
BOOST_AUTO_TEST_CASE(call_multiple_arguments_mixed_format)
@@ -279,15 +316,74 @@ BOOST_AUTO_TEST_CASE(call_multiple_arguments_mixed_format)
// -> -1, 2
)";
auto const calls = parse(source);
BOOST_CHECK_EQUAL(calls.size(), 1);
BOOST_REQUIRE_EQUAL(calls.size(), 1);
testFunctionCall(
calls.at(0),
Mode::MultiLine,
"test(uint256,uint256)",
false,
fmt::encodeArgs(1, -2),
fmt::encodeArgs(-1, 2),
314
);
}
auto const& call = calls.at(0);
BOOST_CHECK_EQUAL(call.displayMode, FunctionCall::DisplayMode::MultiLine);
BOOST_CHECK_EQUAL(call.signature, "test(uint256,uint256)");
BOOST_CHECK_EQUAL(call.value, u256{314});
ABI_CHECK(call.arguments.rawBytes(), toBigEndian(u256{1}) + toBigEndian(u256{-2}));
BOOST_CHECK_EQUAL(call.expectations.failure, false);
ABI_CHECK(call.expectations.rawBytes(), toBigEndian(u256{-1}) + toBigEndian(u256{2}));
BOOST_AUTO_TEST_CASE(call_signature)
{
char const* source = R"(
// f(uint256, uint8, string) -> FAILURE
// f(invalid, xyz, foo) -> FAILURE
)";
auto const calls = parse(source);
BOOST_REQUIRE_EQUAL(calls.size(), 2);
testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256,uint8,string)", true);
testFunctionCall(calls.at(1), Mode::SingleLine, "f(invalid,xyz,foo)", true);
}
BOOST_AUTO_TEST_CASE(call_signature_invalid)
{
char const* source = R"(
// f(uint8,) -> FAILURE
)";
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_expectations_missing)
{
char const* source = R"(
// f())";
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_ether_value_expectations_missing)
{
char const* source = R"(
// f(), 0)";
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_arguments_invalid)
{
char const* source = R"(
// f(uint256): abc -> 1
)";
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_ether_value_invalid)
{
char const* source = R"(
// f(uint256), abc : 1 -> 1
)";
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_ether_type_invalid)
{
char const* source = R"(
// f(uint256), 2 btc : 1 -> 1
)";
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_arguments_colon)
@@ -296,7 +392,7 @@ BOOST_AUTO_TEST_CASE(call_arguments_colon)
// h256():
// -> 1
)";
BOOST_CHECK_THROW(parse(source), langutil::Error);
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_CASE(call_arguments_newline_colon)
@@ -306,11 +402,9 @@ BOOST_AUTO_TEST_CASE(call_arguments_newline_colon)
// :
// -> 1
)";
BOOST_CHECK_THROW(parse(source), langutil::Error);
BOOST_REQUIRE_THROW(parse(source), langutil::Error);
}
BOOST_AUTO_TEST_SUITE_END()
}