diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/libsolidity/SolidityEndToEndTest.cpp | 113 | ||||
| -rw-r--r-- | test/libsolidity/SolidityNameAndTypeResolution.cpp | 124 |
2 files changed, 229 insertions, 8 deletions
diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp index 2f627fc2..34c5dffc 100644 --- a/test/libsolidity/SolidityEndToEndTest.cpp +++ b/test/libsolidity/SolidityEndToEndTest.cpp @@ -6107,6 +6107,119 @@ BOOST_AUTO_TEST_CASE(bound_function_to_string) BOOST_CHECK(callContractFunction("g()") == encodeArgs(u256(3))); } +BOOST_AUTO_TEST_CASE(inline_array_storage_to_memory_conversion_strings) +{ + char const* sourceCode = R"( + contract C { + string s = "doh"; + function f() returns (string, string) { + string memory t = "ray"; + string[3] memory x = [s, t, "mi"]; + return (x[1], x[2]); + } + } + )"; + compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(0x40), u256(0x80), u256(3), string("ray"), u256(2), string("mi"))); +} + +BOOST_AUTO_TEST_CASE(inline_array_strings_from_document) +{ + char const* sourceCode = R"( + contract C { + function f(uint i) returns (string) { + string[4] memory x = ["This", "is", "an", "array"]; + return (x[i]); + } + } + )"; + compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("f(uint256)", u256(0)) == encodeArgs(u256(0x20), u256(4), string("This"))); + BOOST_CHECK(callContractFunction("f(uint256)", u256(1)) == encodeArgs(u256(0x20), u256(2), string("is"))); + BOOST_CHECK(callContractFunction("f(uint256)", u256(2)) == encodeArgs(u256(0x20), u256(2), string("an"))); + BOOST_CHECK(callContractFunction("f(uint256)", u256(3)) == encodeArgs(u256(0x20), u256(5), string("array"))); +} + +BOOST_AUTO_TEST_CASE(inline_array_storage_to_memory_conversion_ints) +{ + char const* sourceCode = R"( + contract C { + function f() returns (uint x, uint y) { + x = 3; + y = 6; + uint[2] memory z = [x, y]; + return (z[0], z[1]); + } + } + )"; + compileAndRun(sourceCode, 0, "C"); + BOOST_CHECK(callContractFunction("f()") == encodeArgs(3, 6)); +} + +BOOST_AUTO_TEST_CASE(inline_array_index_access_ints) +{ + char const* sourceCode = R"( + contract C { + function f() returns (uint) { + return ([1, 2, 3, 4][2]); + } + } + )"; + compileAndRun(sourceCode, 0, "C"); + BOOST_CHECK(callContractFunction("f()") == encodeArgs(3)); +} + +BOOST_AUTO_TEST_CASE(inline_array_index_access_strings) +{ + char const* sourceCode = R"( + contract C { + string public tester; + function f() returns (string) { + return (["abc", "def", "g"][0]); + } + function test() { + tester = f(); + } + } + )"; + compileAndRun(sourceCode, 0, "C"); + BOOST_CHECK(callContractFunction("test()") == encodeArgs()); + BOOST_CHECK(callContractFunction("tester()") == encodeArgs(u256(0x20), u256(3), string("abc"))); +} + +BOOST_AUTO_TEST_CASE(inline_array_return) +{ + char const* sourceCode = R"( + contract C { + uint8[] tester; + function f() returns (uint8[5]) { + return ([1,2,3,4,5]); + } + function test() returns (uint8, uint8, uint8, uint8, uint8) { + tester = f(); + return (tester[0], tester[1], tester[2], tester[3], tester[4]); + } + + } + )"; + compileAndRun(sourceCode, 0, "C"); + BOOST_CHECK(callContractFunction("f()") == encodeArgs(1, 2, 3, 4, 5)); +} + +BOOST_AUTO_TEST_CASE(inline_long_string_return) +{ + char const* sourceCode = R"( + contract C { + function f() returns (string) { + return (["somethingShort", "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"][1]); + } + } + )"; + + string strLong = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"; + compileAndRun(sourceCode, 0, "C"); + BOOST_CHECK(callContractFunction("f()") == encodeDyn(strLong)); +} BOOST_AUTO_TEST_SUITE_END() } diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp index 70c9eb0d..4697e756 100644 --- a/test/libsolidity/SolidityNameAndTypeResolution.cpp +++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp @@ -2769,15 +2769,98 @@ BOOST_AUTO_TEST_CASE(function_overload_array_type) BOOST_CHECK(success(text)); } -/*BOOST_AUTO_TEST_CASE(inline_array_declaration_and_passing) +BOOST_AUTO_TEST_CASE(inline_array_declaration_and_passing_implicit_conversion) +{ + char const* text = R"( + contract C { + function f() returns (uint) { + uint8 x = 7; + uint16 y = 8; + uint32 z = 9; + uint32[3] memory ending = [x, y, z]; + return (ending[1]); + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(inline_array_declaration_and_passing_implicit_conversion_strings) { char const* text = R"( contract C { - uint[] a; - function f() returns (uint, uint) { - a = [1,2,3]; - return (a[3], [3,4][0]); - } + function f() returns (string) { + string memory x = "Hello"; + string memory y = "World"; + string[2] memory z = [x, y]; + return (z[0]); + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(inline_array_declaration_const_int_conversion) +{ + char const* text = R"( + contract C { + function f() returns (uint) { + uint8[4] memory z = [1,2,3,5]; + return (z[0]); + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(inline_array_declaration_const_string_conversion) +{ + char const* text = R"( + contract C { + function f() returns (string) { + string[2] memory z = ["Hello", "World"]; + return (z[0]); + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(inline_array_declaration_no_type) +{ + char const* text = R"( + contract C { + function f() returns (uint) { + return ([4,5,6][1]); + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(inline_array_declaration_no_type_strings) +{ + char const* text = R"( + contract C { + function f() returns (string) { + return (["foo", "man", "choo"][1]); + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(inline_struct_declaration_arrays) +{ + char const* text = R"( + contract C { + struct S { + uint a; + string b; + } + function f() { + S[2] memory x = [S({a: 1, b: "fish"}), S({a: 2, b: "fish"})]; + } } )"; BOOST_CHECK(success(text)); @@ -2788,12 +2871,37 @@ BOOST_AUTO_TEST_CASE(invalid_types_in_inline_array) char const* text = R"( contract C { function f() { - uint[] x = [45, "foo", true]; + uint[3] x = [45, 'foo', true]; } } )"; BOOST_CHECK(expectError(text) == Error::Type::TypeError); -}*/ +} + +BOOST_AUTO_TEST_CASE(dynamic_inline_array) +{ + char const* text = R"( + contract C { + function f() { + uint8[4][4] memory dyn = [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7]]; + } + } + )"; + BOOST_CHECK(success(text)); +} + +BOOST_AUTO_TEST_CASE(lvalues_as_inline_array) +{ + char const* text = R"( + contract C { + function f() { + [1, 2, 3]++; + [1, 2, 3] = [4, 5, 6]; + } + } + )"; + BOOST_CHECK(expectError(text) == Error::Type::TypeError); +} BOOST_AUTO_TEST_SUITE_END() |