aboutsummaryrefslogtreecommitdiffstats
path: root/test/libsolidity
diff options
context:
space:
mode:
Diffstat (limited to 'test/libsolidity')
-rw-r--r--test/libsolidity/ABIDecoderTests.cpp794
-rw-r--r--test/libsolidity/ABIEncoderTests.cpp50
-rw-r--r--test/libsolidity/ABITestsCommon.h43
-rw-r--r--test/libsolidity/InlineAssembly.cpp38
-rw-r--r--test/libsolidity/JSONCompiler.cpp2
-rw-r--r--test/libsolidity/SMTChecker.cpp448
-rw-r--r--test/libsolidity/SolidityABIJSON.cpp3
-rw-r--r--test/libsolidity/SolidityEndToEndTest.cpp36
-rw-r--r--test/libsolidity/SolidityNameAndTypeResolution.cpp206
-rw-r--r--test/libsolidity/StandardCompiler.cpp8
10 files changed, 1571 insertions, 57 deletions
diff --git a/test/libsolidity/ABIDecoderTests.cpp b/test/libsolidity/ABIDecoderTests.cpp
new file mode 100644
index 00000000..15c04b37
--- /dev/null
+++ b/test/libsolidity/ABIDecoderTests.cpp
@@ -0,0 +1,794 @@
+/*
+ This file is part of solidity.
+
+ solidity is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ solidity is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with solidity. If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for Solidity's ABI decoder.
+ */
+
+#include <functional>
+#include <string>
+#include <tuple>
+#include <boost/test/unit_test.hpp>
+#include <libsolidity/interface/Exceptions.h>
+#include <test/libsolidity/SolidityExecutionFramework.h>
+
+#include <test/libsolidity/ABITestsCommon.h>
+
+using namespace std;
+using namespace std::placeholders;
+using namespace dev::test;
+
+namespace dev
+{
+namespace solidity
+{
+namespace test
+{
+
+BOOST_FIXTURE_TEST_SUITE(ABIDecoderTest, SolidityExecutionFramework)
+
+BOOST_AUTO_TEST_CASE(both_encoders_macro)
+{
+ // This tests that the "both decoders macro" at least runs twice and
+ // modifies the source.
+ string sourceCode;
+ int runs = 0;
+ BOTH_ENCODERS(runs++;)
+ BOOST_CHECK(sourceCode == NewEncoderPragma);
+ BOOST_CHECK_EQUAL(runs, 2);
+}
+
+BOOST_AUTO_TEST_CASE(value_types)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint a, uint16 b, uint24 c, int24 d, bytes3 x, bool e, C g) public returns (uint) {
+ if (a != 1) return 1;
+ if (b != 2) return 2;
+ if (c != 3) return 3;
+ if (d != 4) return 4;
+ if (x != "abc") return 5;
+ if (e != true) return 6;
+ if (g != this) return 7;
+ return 20;
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunction(
+ "f(uint256,uint16,uint24,int24,bytes3,bool,address)",
+ 1, 2, 3, 4, string("abc"), true, u160(m_contractAddress)
+ ), encodeArgs(u256(20)));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(enums)
+{
+ string sourceCode = R"(
+ contract C {
+ enum E { A, B }
+ function f(E e) public pure returns (uint x) {
+ assembly { x := e }
+ }
+ }
+ )";
+ bool newDecoder = false;
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunction("f(uint8)", 0), encodeArgs(u256(0)));
+ ABI_CHECK(callContractFunction("f(uint8)", 1), encodeArgs(u256(1)));
+ // The old decoder was not as strict about enums
+ ABI_CHECK(callContractFunction("f(uint8)", 2), (newDecoder ? encodeArgs() : encodeArgs(2)));
+ ABI_CHECK(callContractFunction("f(uint8)", u256(-1)), (newDecoder? encodeArgs() : encodeArgs(u256(0xff))));
+ newDecoder = true;
+ )
+}
+
+BOOST_AUTO_TEST_CASE(cleanup)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint16 a, int16 b, address c, bytes3 d, bool e)
+ public pure returns (uint v, uint w, uint x, uint y, uint z) {
+ assembly { v := a w := b x := c y := d z := e}
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ ABI_CHECK(
+ callContractFunction("f(uint16,int16,address,bytes3,bool)", 1, 2, 3, "a", true),
+ encodeArgs(u256(1), u256(2), u256(3), string("a"), true)
+ );
+ ABI_CHECK(
+ callContractFunction(
+ "f(uint16,int16,address,bytes3,bool)",
+ u256(0xffffff), u256(0x1ffff), u256(-1), string("abcd"), u256(4)
+ ),
+ encodeArgs(u256(0xffff), u256(-1), (u256(1) << 160) - 1, string("abc"), true)
+ );
+ )
+}
+
+BOOST_AUTO_TEST_CASE(fixed_arrays)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint16[3] a, uint16[2][3] b, uint i, uint j, uint k)
+ public pure returns (uint, uint) {
+ return (a[i], b[j][k]);
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ bytes args = encodeArgs(
+ 1, 2, 3,
+ 11, 12,
+ 21, 22,
+ 31, 32,
+ 1, 2, 1
+ );
+ ABI_CHECK(
+ callContractFunction("f(uint16[3],uint16[2][3],uint256,uint256,uint256)", args),
+ encodeArgs(u256(2), u256(32))
+ );
+ )
+}
+
+BOOST_AUTO_TEST_CASE(dynamic_arrays)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint a, uint16[] b, uint c)
+ public pure returns (uint, uint, uint) {
+ return (b.length, b[a], c);
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ bytes args = encodeArgs(
+ 6, 0x60, 9,
+ 7,
+ 11, 12, 13, 14, 15, 16, 17
+ );
+ ABI_CHECK(
+ callContractFunction("f(uint256,uint16[],uint256)", args),
+ encodeArgs(u256(7), u256(17), u256(9))
+ );
+ )
+}
+
+BOOST_AUTO_TEST_CASE(dynamic_nested_arrays)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint a, uint16[][] b, uint[2][][3] c, uint d)
+ public pure returns (uint, uint, uint, uint, uint, uint, uint) {
+ return (a, b.length, b[1].length, b[1][1], c[1].length, c[1][1][1], d);
+ }
+ function test() view returns (uint, uint, uint, uint, uint, uint, uint) {
+ uint16[][] memory b = new uint16[][](3);
+ b[0] = new uint16[](2);
+ b[0][0] = 0x55;
+ b[0][1] = 0x56;
+ b[1] = new uint16[](4);
+ b[1][0] = 0x65;
+ b[1][1] = 0x66;
+ b[1][2] = 0x67;
+ b[1][3] = 0x68;
+
+ uint[2][][3] memory c;
+ c[0] = new uint[2][](1);
+ c[0][0][1] = 0x75;
+ c[1] = new uint[2][](5);
+ c[1][1][1] = 0x85;
+
+ return this.f(0x12, b, c, 0x13);
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode);
+ bytes args = encodeArgs(
+ 0x12, 4 * 0x20, 17 * 0x20, 0x13,
+ // b
+ 3, 3 * 0x20, 6 * 0x20, 11 * 0x20,
+ 2, 85, 86,
+ 4, 101, 102, 103, 104,
+ 0,
+ // c
+ 3 * 0x20, 6 * 0x20, 17 * 0x20,
+ 1, 0, 117,
+ 5, 0, 0, 0, 133, 0, 0, 0, 0, 0, 0,
+ 0
+ );
+
+ bytes expectation = encodeArgs(0x12, 3, 4, 0x66, 5, 0x85, 0x13);
+ ABI_CHECK(callContractFunction("test()"), expectation);
+ ABI_CHECK(callContractFunction("f(uint256,uint16[][],uint256[2][][3],uint256)", args), expectation);
+ )
+}
+
+BOOST_AUTO_TEST_CASE(byte_arrays)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint a, bytes b, uint c)
+ public pure returns (uint, uint, byte, uint) {
+ return (a, b.length, b[3], c);
+ }
+
+ function f_external(uint a, bytes b, uint c)
+ external pure returns (uint, uint, byte, uint) {
+ return (a, b.length, b[3], c);
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ bytes args = encodeArgs(
+ 6, 0x60, 9,
+ 7, "abcdefg"
+ );
+ ABI_CHECK(
+ callContractFunction("f(uint256,bytes,uint256)", args),
+ encodeArgs(u256(6), u256(7), "d", 9)
+ );
+ ABI_CHECK(
+ callContractFunction("f_external(uint256,bytes,uint256)", args),
+ encodeArgs(u256(6), u256(7), "d", 9)
+ );
+ )
+}
+
+BOOST_AUTO_TEST_CASE(calldata_arrays_too_large)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint a, uint[] b, uint c) external pure returns (uint) {
+ return 7;
+ }
+ }
+ )";
+ bool newEncoder = false;
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ bytes args = encodeArgs(
+ 6, 0x60, 9,
+ (u256(1) << 255) + 2, 1, 2
+ );
+ ABI_CHECK(
+ callContractFunction("f(uint256,uint256[],uint256)", args),
+ newEncoder ? encodeArgs() : encodeArgs(7)
+ );
+ newEncoder = true;
+ )
+}
+
+BOOST_AUTO_TEST_CASE(decode_from_memory_simple)
+{
+ string sourceCode = R"(
+ contract C {
+ uint public _a;
+ uint[] public _b;
+ function C(uint a, uint[] b) {
+ _a = a;
+ _b = b;
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode, 0, "C", encodeArgs(
+ 7, 0x40,
+ // b
+ 3, 0x21, 0x22, 0x23
+ ));
+ ABI_CHECK(callContractFunction("_a()"), encodeArgs(7));
+ ABI_CHECK(callContractFunction("_b(uint256)", 0), encodeArgs(0x21));
+ ABI_CHECK(callContractFunction("_b(uint256)", 1), encodeArgs(0x22));
+ ABI_CHECK(callContractFunction("_b(uint256)", 2), encodeArgs(0x23));
+ ABI_CHECK(callContractFunction("_b(uint256)", 3), encodeArgs());
+ )
+}
+
+BOOST_AUTO_TEST_CASE(decode_function_type)
+{
+ string sourceCode = R"(
+ contract D {
+ function () external returns (uint) public _a;
+ function D(function () external returns (uint) a) {
+ _a = a;
+ }
+ }
+ contract C {
+ function f() returns (uint) {
+ return 3;
+ }
+ function g(function () external returns (uint) _f) returns (uint) {
+ return _f();
+ }
+ // uses "decode from memory"
+ function test1() returns (uint) {
+ D d = new D(this.f);
+ return d._a()();
+ }
+ // uses "decode from calldata"
+ function test2() returns (uint) {
+ return this.g(this.f);
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(callContractFunction("test1()"), encodeArgs(3));
+ ABI_CHECK(callContractFunction("test2()"), encodeArgs(3));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(decode_function_type_array)
+{
+ string sourceCode = R"(
+ contract D {
+ function () external returns (uint)[] public _a;
+ function D(function () external returns (uint)[] a) {
+ _a = a;
+ }
+ }
+ contract E {
+ function () external returns (uint)[3] public _a;
+ function E(function () external returns (uint)[3] a) {
+ _a = a;
+ }
+ }
+ contract C {
+ function f1() public returns (uint) {
+ return 1;
+ }
+ function f2() public returns (uint) {
+ return 2;
+ }
+ function f3() public returns (uint) {
+ return 3;
+ }
+ function g(function () external returns (uint)[] _f, uint i) public returns (uint) {
+ return _f[i]();
+ }
+ function h(function () external returns (uint)[3] _f, uint i) public returns (uint) {
+ return _f[i]();
+ }
+ // uses "decode from memory"
+ function test1_dynamic() public returns (uint) {
+ var x = new function() external returns (uint)[](3);
+ x[0] = this.f1;
+ x[1] = this.f2;
+ x[2] = this.f3;
+ D d = new D(x);
+ return d._a(2)();
+ }
+ function test1_static() public returns (uint) {
+ E e = new E([this.f1, this.f2, this.f3]);
+ return e._a(2)();
+ }
+ // uses "decode from calldata"
+ function test2_dynamic() public returns (uint) {
+ var x = new function() external returns (uint)[](3);
+ x[0] = this.f1;
+ x[1] = this.f2;
+ x[2] = this.f3;
+ return this.g(x, 0);
+ }
+ function test2_static() public returns (uint) {
+ return this.h([this.f1, this.f2, this.f3], 0);
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(callContractFunction("test1_static()"), encodeArgs(3));
+ ABI_CHECK(callContractFunction("test1_dynamic()"), encodeArgs(3));
+ ABI_CHECK(callContractFunction("test2_static()"), encodeArgs(1));
+ ABI_CHECK(callContractFunction("test2_dynamic()"), encodeArgs(1));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(decode_from_memory_complex)
+{
+ string sourceCode = R"(
+ contract C {
+ uint public _a;
+ uint[] public _b;
+ bytes[2] public _c;
+ function C(uint a, uint[] b, bytes[2] c) {
+ _a = a;
+ _b = b;
+ _c = c;
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C", encodeArgs(
+ 7, 0x60, 7 * 0x20,
+ // b
+ 3, 0x21, 0x22, 0x23,
+ // c
+ 0x40, 0x80,
+ 8, string("abcdefgh"),
+ 52, string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")
+ ));
+ ABI_CHECK(callContractFunction("_a()"), encodeArgs(7));
+ ABI_CHECK(callContractFunction("_b(uint256)", 0), encodeArgs(0x21));
+ ABI_CHECK(callContractFunction("_b(uint256)", 1), encodeArgs(0x22));
+ ABI_CHECK(callContractFunction("_b(uint256)", 2), encodeArgs(0x23));
+ ABI_CHECK(callContractFunction("_b(uint256)", 3), encodeArgs());
+ ABI_CHECK(callContractFunction("_c(uint256)", 0), encodeArgs(0x20, 8, string("abcdefgh")));
+ ABI_CHECK(callContractFunction("_c(uint256)", 1), encodeArgs(0x20, 52, string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")));
+ ABI_CHECK(callContractFunction("_c(uint256)", 2), encodeArgs());
+ )
+}
+
+BOOST_AUTO_TEST_CASE(short_input_value_type)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint a, uint b) public pure returns (uint) { return a; }
+ }
+ )";
+ bool newDecoder = false;
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunction("f(uint256,uint256)", 1, 2), encodeArgs(1));
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256,uint256)", bytes(64, 0)), encodeArgs(0));
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256,uint256)", bytes(63, 0)), newDecoder ? encodeArgs() : encodeArgs(0));
+ newDecoder = true;
+ )
+}
+
+BOOST_AUTO_TEST_CASE(short_input_array)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(uint[] a) public pure returns (uint) { return 7; }
+ }
+ )";
+ bool newDecoder = false;
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 0)), encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 1)), newDecoder ? encodeArgs() : encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 1) + bytes(31, 0)), newDecoder ? encodeArgs() : encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 1) + bytes(32, 0)), encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 2, 5, 6)), encodeArgs(7));
+ newDecoder = true;
+ )
+}
+
+BOOST_AUTO_TEST_CASE(short_dynamic_input_array)
+{
+ string sourceCode = R"(
+ contract C {
+ function f(bytes[1] a) public pure returns (uint) { return 7; }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunctionNoEncoding("f(bytes[1])", encodeArgs(0x20)), encodeArgs());
+ )
+}
+
+BOOST_AUTO_TEST_CASE(short_input_bytes)
+{
+ string sourceCode = R"(
+ contract C {
+ function e(bytes a) public pure returns (uint) { return 7; }
+ function f(bytes[] a) public pure returns (uint) { return 7; }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(5, 0)), encodeArgs());
+ ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(6, 0)), encodeArgs());
+ ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(7, 0)), encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(8, 0)), encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(5, 0)), encodeArgs());
+ ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(6, 0)), encodeArgs());
+ ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(7, 0)), encodeArgs(7));
+ ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(8, 0)), encodeArgs(7));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(cleanup_int_inside_arrays)
+{
+ string sourceCode = R"(
+ contract C {
+ enum E { A, B }
+ function f(uint16[] a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
+ function g(int16[] a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
+ function h(E[] a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode);
+ ABI_CHECK(callContractFunction("f(uint16[])", 0x20, 1, 7), encodeArgs(7));
+ ABI_CHECK(callContractFunction("g(int16[])", 0x20, 1, 7), encodeArgs(7));
+ ABI_CHECK(callContractFunction("f(uint16[])", 0x20, 1, u256("0xffff")), encodeArgs(u256("0xffff")));
+ ABI_CHECK(callContractFunction("g(int16[])", 0x20, 1, u256("0xffff")), encodeArgs(u256(-1)));
+ ABI_CHECK(callContractFunction("f(uint16[])", 0x20, 1, u256("0x1ffff")), encodeArgs(u256("0xffff")));
+ ABI_CHECK(callContractFunction("g(int16[])", 0x20, 1, u256("0x10fff")), encodeArgs(u256("0x0fff")));
+ ABI_CHECK(callContractFunction("h(uint8[])", 0x20, 1, 0), encodeArgs(u256(0)));
+ ABI_CHECK(callContractFunction("h(uint8[])", 0x20, 1, 1), encodeArgs(u256(1)));
+ ABI_CHECK(callContractFunction("h(uint8[])", 0x20, 1, 2), encodeArgs());
+ )
+}
+
+BOOST_AUTO_TEST_CASE(storage_ptr)
+{
+ string sourceCode = R"(
+ library L {
+ struct S { uint x; uint y; }
+ function f(uint[] storage r, S storage s) public returns (uint, uint, uint, uint) {
+ r[2] = 8;
+ s.x = 7;
+ return (r[0], r[1], s.x, s.y);
+ }
+ }
+ contract C {
+ uint8 x = 3;
+ L.S s;
+ uint[] r;
+ function f() public returns (uint, uint, uint, uint, uint, uint) {
+ r.length = 6;
+ r[0] = 1;
+ r[1] = 2;
+ r[2] = 3;
+ s.x = 11;
+ s.y = 12;
+ var (a, b, c, d) = L.f(r, s);
+ return (r[2], s.x, a, b, c, d);
+ }
+ }
+ )";
+ BOTH_ENCODERS(
+ compileAndRun(sourceCode, 0, "L");
+ compileAndRun(sourceCode, 0, "C", bytes(), map<string, Address>{{"L", m_contractAddress}});
+ ABI_CHECK(callContractFunction("f()"), encodeArgs(8, 7, 1, 2, 7, 12));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(struct_simple)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { uint a; uint8 b; uint8 c; bytes2 d; }
+ function f(S s) public pure returns (uint a, uint b, uint c, uint d) {
+ a = s.a;
+ b = s.b;
+ c = s.c;
+ d = uint(s.d);
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(callContractFunction("f((uint256,uint8,uint8,bytes2))", 1, 2, 3, "ab"), encodeArgs(1, 2, 3, 'a' * 0x100 + 'b'));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(struct_cleanup)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { int16 a; uint8 b; bytes2 c; }
+ function f(S s) public pure returns (uint a, uint b, uint c) {
+ assembly {
+ a := mload(s)
+ b := mload(add(s, 0x20))
+ c := mload(add(s, 0x40))
+ }
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(
+ callContractFunction("f((int16,uint8,bytes2))", 0xff010, 0xff0002, "abcd"),
+ encodeArgs(u256("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff010"), 2, "ab")
+ );
+ )
+}
+
+BOOST_AUTO_TEST_CASE(struct_short)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { int a; uint b; bytes16 c; }
+ function f(S s) public pure returns (S q) {
+ q = s;
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(
+ callContractFunction("f((int256,uint256,bytes16))", 0xff010, 0xff0002, "abcd"),
+ encodeArgs(0xff010, 0xff0002, "abcd")
+ );
+ ABI_CHECK(
+ callContractFunctionNoEncoding("f((int256,uint256,bytes16))", encodeArgs(0xff010, 0xff0002) + bytes(32, 0)),
+ encodeArgs(0xff010, 0xff0002, 0)
+ );
+ ABI_CHECK(
+ callContractFunctionNoEncoding("f((int256,uint256,bytes16))", encodeArgs(0xff010, 0xff0002) + bytes(31, 0)),
+ encodeArgs()
+ );
+ )
+}
+
+BOOST_AUTO_TEST_CASE(struct_function)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { function () external returns (uint) f; uint b; }
+ function f(S s) public returns (uint, uint) {
+ return (s.f(), s.b);
+ }
+ function test() public returns (uint, uint) {
+ return this.f(S(this.g, 3));
+ }
+ function g() public returns (uint) { return 7; }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(callContractFunction("test()"), encodeArgs(7, 3));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(empty_struct)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { }
+ function f(uint a, S s, uint b) public pure returns (uint x, uint y) {
+ assembly { x := a y := b }
+ }
+ function g() public returns (uint, uint) {
+ return this.f(7, S(), 8);
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(callContractFunction("f(uint256,(),uint256)", 7, 8), encodeArgs(7, 8));
+ ABI_CHECK(callContractFunction("g()"), encodeArgs(7, 8));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(mediocre_struct)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { C c; }
+ function f(uint a, S[2] s1, uint b) public returns (uint r1, C r2, uint r3) {
+ r1 = a;
+ r2 = s1[0].c;
+ r3 = b;
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ string sig = "f(uint256,(address)[2],uint256)";
+ ABI_CHECK(callContractFunction(sig,
+ 7, u256(u160(m_contractAddress)), 0, 8
+ ), encodeArgs(7, u256(u160(m_contractAddress)), 8));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(mediocre2_struct)
+{
+ string sourceCode = R"(
+ contract C {
+ struct S { C c; uint[] x; }
+ function f(uint a, S[2] s1, uint b) public returns (uint r1, C r2, uint r3) {
+ r1 = a;
+ r2 = s1[0].c;
+ r3 = b;
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ string sig = "f(uint256,(address,uint256[])[2],uint256)";
+ ABI_CHECK(callContractFunction(sig,
+ 7, 0x60, 8,
+ 0x40, 7 * 0x20,
+ u256(u160(m_contractAddress)), 0x40,
+ 2, 0x11, 0x12,
+ 0x99, 0x40,
+ 4, 0x31, 0x32, 0x34, 0x35
+ ), encodeArgs(7, u256(u160(m_contractAddress)), 8));
+ )
+}
+
+BOOST_AUTO_TEST_CASE(complex_struct)
+{
+ string sourceCode = R"(
+ contract C {
+ enum E {A, B, C}
+ struct T { uint x; E e; uint8 y; }
+ struct S { C c; T[] t;}
+ function f(uint a, S[2] s1, S[] s2, uint b) public returns
+ (uint r1, C r2, uint r3, uint r4, C r5, uint r6, E r7, uint8 r8) {
+ r1 = a;
+ r2 = s1[0].c;
+ r3 = b;
+ r4 = s2.length;
+ r5 = s2[1].c;
+ r6 = s2[1].t.length;
+ r7 = s2[1].t[1].e;
+ r8 = s2[1].t[1].y;
+ }
+ }
+ )";
+ NEW_ENCODER(
+ compileAndRun(sourceCode, 0, "C");
+ string sig = "f(uint256,(address,(uint256,uint8,uint8)[])[2],(address,(uint256,uint8,uint8)[])[],uint256)";
+ bytes args = encodeArgs(
+ 7, 0x80, 0x1e0, 8,
+ // S[2] s1
+ 0x40,
+ 0x100,
+ // S s1[0]
+ u256(u160(m_contractAddress)),
+ 0x40,
+ // T s1[0].t
+ 1, // length
+ // s1[0].t[0]
+ 0x11, 1, 0x12,
+ // S s1[1]
+ 0, 0x40,
+ // T s1[1].t
+ 0,
+ // S[] s2 (0x1e0)
+ 2, // length
+ 0x40, 0xa0,
+ // S s2[0]
+ 0, 0x40, 0,
+ // S s2[1]
+ 0x1234, 0x40,
+ // s2[1].t
+ 3, // length
+ 0, 0, 0,
+ 0x21, 2, 0x22,
+ 0, 0, 0
+ );
+ ABI_CHECK(callContractFunction(sig, args), encodeArgs(7, u256(u160(m_contractAddress)), 8, 2, 0x1234, 3, 2, 0x22));
+ // invalid enum value
+ args.data()[0x20 * 28] = 3;
+ ABI_CHECK(callContractFunction(sig, args), encodeArgs());
+ )
+}
+
+
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
+}
+} // end namespaces
diff --git a/test/libsolidity/ABIEncoderTests.cpp b/test/libsolidity/ABIEncoderTests.cpp
index af51edcc..49db9ce1 100644
--- a/test/libsolidity/ABIEncoderTests.cpp
+++ b/test/libsolidity/ABIEncoderTests.cpp
@@ -25,6 +25,8 @@
#include <libsolidity/interface/Exceptions.h>
#include <test/libsolidity/SolidityExecutionFramework.h>
+#include <test/libsolidity/ABITestsCommon.h>
+
using namespace std;
using namespace std::placeholders;
using namespace dev::test;
@@ -42,20 +44,6 @@ namespace test
BOOST_CHECK_EQUAL(toHex(m_logs[0].data), toHex(DATA)); \
} while (false)
-static string const NewEncoderPragma = "pragma experimental ABIEncoderV2;\n";
-
-#define NEW_ENCODER(CODE) \
-{ \
- sourceCode = NewEncoderPragma + sourceCode; \
- { CODE } \
-}
-
-#define BOTH_ENCODERS(CODE) \
-{ \
- { CODE } \
- NEW_ENCODER(CODE) \
-}
-
BOOST_FIXTURE_TEST_SUITE(ABIEncoderTest, SolidityExecutionFramework)
BOOST_AUTO_TEST_CASE(both_encoders_macro)
@@ -74,7 +62,7 @@ BOOST_AUTO_TEST_CASE(value_types)
string sourceCode = R"(
contract C {
event E(uint a, uint16 b, uint24 c, int24 d, bytes3 x, bool, C);
- function f() {
+ function f() public {
bytes6 x = hex"1bababababa2";
bool b;
assembly { b := 7 }
@@ -98,7 +86,7 @@ BOOST_AUTO_TEST_CASE(string_literal)
string sourceCode = R"(
contract C {
event E(string, bytes20, string);
- function f() {
+ function f() public {
E("abcdef", "abcde", "abcdefabcdefgehabcabcasdfjklabcdefabcedefghabcabcasdfjklabcdefabcdefghabcabcasdfjklabcdeefabcdefghabcabcasdefjklabcdefabcdefghabcabcasdfjkl");
}
}
@@ -120,7 +108,7 @@ BOOST_AUTO_TEST_CASE(enum_type_cleanup)
string sourceCode = R"(
contract C {
enum E { A, B }
- function f(uint x) returns (E en) {
+ function f(uint x) public returns (E en) {
assembly { en := x }
}
}
@@ -138,7 +126,7 @@ BOOST_AUTO_TEST_CASE(conversion)
string sourceCode = R"(
contract C {
event E(bytes4, bytes4, uint16, uint8, int16, int8);
- function f() {
+ function f() public {
bytes2 x; assembly { x := 0xf1f2f3f400000000000000000000000000000000000000000000000000000000 }
uint8 a;
uint16 b = 0x1ff;
@@ -164,7 +152,7 @@ BOOST_AUTO_TEST_CASE(memory_array_one_dim)
string sourceCode = R"(
contract C {
event E(uint a, int16[] b, uint c);
- function f() {
+ function f() public {
int16[] memory x = new int16[](3);
assembly {
for { let i := 0 } lt(i, 3) { i := add(i, 1) } {
@@ -191,7 +179,7 @@ BOOST_AUTO_TEST_CASE(memory_array_two_dim)
string sourceCode = R"(
contract C {
event E(uint a, int16[][2] b, uint c);
- function f() {
+ function f() public {
int16[][2] memory x;
x[0] = new int16[](3);
x[1] = new int16[](2);
@@ -216,7 +204,7 @@ BOOST_AUTO_TEST_CASE(memory_byte_array)
string sourceCode = R"(
contract C {
event E(uint a, bytes[] b, uint c);
- function f() {
+ function f() public {
bytes[] memory x = new bytes[](2);
x[0] = "abcabcdefghjklmnopqrsuvwabcdefgijklmnopqrstuwabcdefgijklmnoprstuvw";
x[1] = "abcdefghijklmnopqrtuvwabcfghijklmnopqstuvwabcdeghijklmopqrstuvw";
@@ -243,7 +231,7 @@ BOOST_AUTO_TEST_CASE(storage_byte_array)
bytes short;
bytes long;
event E(bytes s, bytes l);
- function f() {
+ function f() public {
short = "123456789012345678901234567890a";
long = "ffff123456789012345678901234567890afffffffff123456789012345678901234567890a";
E(short, long);
@@ -267,7 +255,7 @@ BOOST_AUTO_TEST_CASE(storage_array)
contract C {
address[3] addr;
event E(address[3] a);
- function f() {
+ function f() public {
assembly {
sstore(0, sub(0, 1))
sstore(1, sub(0, 2))
@@ -290,7 +278,7 @@ BOOST_AUTO_TEST_CASE(storage_array_dyn)
contract C {
address[] addr;
event E(address[] a);
- function f() {
+ function f() public {
addr.push(1);
addr.push(2);
addr.push(3);
@@ -311,7 +299,7 @@ BOOST_AUTO_TEST_CASE(storage_array_compact)
contract C {
int72[] x;
event E(int72[]);
- function f() {
+ function f() public {
x.push(-1);
x.push(2);
x.push(-3);
@@ -339,7 +327,7 @@ BOOST_AUTO_TEST_CASE(external_function)
contract C {
event E(function(uint) external returns (uint), function(uint) external returns (uint));
function(uint) external returns (uint) g;
- function f(uint) returns (uint) {
+ function f(uint) public returns (uint) {
g = this.f;
E(this.f, g);
}
@@ -347,7 +335,7 @@ BOOST_AUTO_TEST_CASE(external_function)
)";
BOTH_ENCODERS(
compileAndRun(sourceCode);
- callContractFunction("f(uint256)");
+ callContractFunction("f(uint256)", u256(0));
string functionIdF = asString(m_contractAddress.ref()) + asString(FixedHash<4>(dev::keccak256("f(uint256)")).ref());
REQUIRE_LOG_DATA(encodeArgs(functionIdF, functionIdF));
)
@@ -360,7 +348,7 @@ BOOST_AUTO_TEST_CASE(external_function_cleanup)
event E(function(uint) external returns (uint), function(uint) external returns (uint));
// This test relies on the fact that g is stored in slot zero.
function(uint) external returns (uint) g;
- function f(uint) returns (uint) {
+ function f(uint) public returns (uint) {
function(uint) external returns (uint)[1] memory h;
assembly { sstore(0, sub(0, 1)) mstore(h, sub(0, 1)) }
E(h[0], g);
@@ -369,7 +357,7 @@ BOOST_AUTO_TEST_CASE(external_function_cleanup)
)";
BOTH_ENCODERS(
compileAndRun(sourceCode);
- callContractFunction("f(uint256)");
+ callContractFunction("f(uint256)", u256(0));
REQUIRE_LOG_DATA(encodeArgs(string(24, char(-1)), string(24, char(-1))));
)
}
@@ -404,7 +392,7 @@ BOOST_AUTO_TEST_CASE(function_name_collision)
// and by the ABI encoder
string sourceCode = R"(
contract C {
- function f(uint x) returns (uint) {
+ function f(uint x) public returns (uint) {
assembly {
function abi_encode_t_uint256_to_t_uint256() {
mstore(0, 7)
@@ -432,7 +420,7 @@ BOOST_AUTO_TEST_CASE(structs)
struct T { uint64[2] x; }
S s;
event e(uint16, S);
- function f() returns (uint, S) {
+ function f() public returns (uint, S) {
uint16 x = 7;
s.a = 8;
s.b = 9;
diff --git a/test/libsolidity/ABITestsCommon.h b/test/libsolidity/ABITestsCommon.h
new file mode 100644
index 00000000..2ef555f3
--- /dev/null
+++ b/test/libsolidity/ABITestsCommon.h
@@ -0,0 +1,43 @@
+/*
+ This file is part of solidity.
+
+ solidity is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ solidity is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with solidity. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <string>
+
+namespace dev
+{
+namespace solidity
+{
+namespace test
+{
+
+static std::string const NewEncoderPragma = "pragma experimental ABIEncoderV2;\n";
+
+#define NEW_ENCODER(CODE) \
+{ \
+ sourceCode = NewEncoderPragma + sourceCode; \
+ { CODE } \
+}
+
+#define BOTH_ENCODERS(CODE) \
+{ \
+ { CODE } \
+ NEW_ENCODER(CODE) \
+}
+
+}
+}
+} // end namespaces
diff --git a/test/libsolidity/InlineAssembly.cpp b/test/libsolidity/InlineAssembly.cpp
index da3522b4..82bafd49 100644
--- a/test/libsolidity/InlineAssembly.cpp
+++ b/test/libsolidity/InlineAssembly.cpp
@@ -251,6 +251,27 @@ BOOST_AUTO_TEST_CASE(variable_use_before_decl)
CHECK_PARSE_ERROR("{ let x := mul(2, x) }", DeclarationError, "Variable x used before it was declared.");
}
+BOOST_AUTO_TEST_CASE(if_statement)
+{
+ BOOST_CHECK(successParse("{ if 42 {} }"));
+ BOOST_CHECK(successParse("{ if 42 { let x := 3 } }"));
+ BOOST_CHECK(successParse("{ function f() -> x {} if f() { pop(f()) } }"));
+}
+
+BOOST_AUTO_TEST_CASE(if_statement_scope)
+{
+ BOOST_CHECK(successParse("{ let x := 2 if 42 { x := 3 } }"));
+ CHECK_PARSE_ERROR("{ if 32 { let x := 3 } x := 2 }", DeclarationError, "Variable not found or variable not lvalue.");
+}
+
+BOOST_AUTO_TEST_CASE(if_statement_invalid)
+{
+ CHECK_PARSE_ERROR("{ if calldatasize {}", ParserError, "Instructions are not supported as conditions for if");
+ BOOST_CHECK("{ if calldatasize() {}");
+ CHECK_PARSE_ERROR("{ if mstore(1, 1) {} }", ParserError, "Instruction \"mstore\" not allowed in this context");
+ CHECK_PARSE_ERROR("{ if 32 let x := 3 }", ParserError, "Expected token LBrace");
+}
+
BOOST_AUTO_TEST_CASE(switch_statement)
{
BOOST_CHECK(successParse("{ switch 42 default {} }"));
@@ -275,7 +296,7 @@ BOOST_AUTO_TEST_CASE(switch_duplicate_case)
BOOST_AUTO_TEST_CASE(switch_invalid_expression)
{
CHECK_PARSE_ERROR("{ switch {} default {} }", ParserError, "Literal, identifier or instruction expected.");
- CHECK_PARSE_ERROR("{ switch calldatasize default {} }", ParserError, "Instructions are not supported as expressions for switch.");
+ CHECK_PARSE_ERROR("{ switch calldatasize default {} }", ParserError, "Instructions are not supported as expressions for switch");
CHECK_PARSE_ERROR("{ switch mstore(1, 1) default {} }", ParserError, "Instruction \"mstore\" not allowed in this context");
}
@@ -487,6 +508,11 @@ BOOST_AUTO_TEST_CASE(print_string_literal_unicode)
parsePrintCompare(parsed);
}
+BOOST_AUTO_TEST_CASE(print_if)
+{
+ parsePrintCompare("{\n if 2\n {\n pop(mload(0))\n }\n}");
+}
+
BOOST_AUTO_TEST_CASE(print_switch)
{
parsePrintCompare("{\n switch 42\n case 1 {\n }\n case 2 {\n }\n default {\n }\n}");
@@ -628,6 +654,11 @@ BOOST_AUTO_TEST_CASE(for_statement)
BOOST_CHECK(successAssemble("{ let x := calldatasize() for { let i := 0} lt(i, x) { i := add(i, 1) } { mstore(i, 2) } }"));
}
+BOOST_AUTO_TEST_CASE(if_statement)
+{
+ BOOST_CHECK(successAssemble("{ if 1 {} }"));
+ BOOST_CHECK(successAssemble("{ let x := 0 if eq(calldatasize(), 0) { x := 1 } mstore(0, x) }"));
+}
BOOST_AUTO_TEST_CASE(large_constant)
{
@@ -681,8 +712,9 @@ BOOST_AUTO_TEST_CASE(jump_warning)
{
CHECK_PARSE_WARNING("{ 1 jump }", Warning, "Jump instructions");
CHECK_PARSE_WARNING("{ 1 2 jumpi }", Warning, "Jump instructions");
- CHECK_PARSE_WARNING("{ a: jump(a) }", Warning, "Jump instructions");
- CHECK_PARSE_WARNING("{ a: jumpi(a, 2) }", Warning, "Jump instructions");
+ CHECK_PARSE_WARNING("{ jump(44) }", Warning, "Jump instructions");
+ CHECK_PARSE_WARNING("{ jumpi(44, 2) }", Warning, "Jump instructions");
+ CHECK_PARSE_WARNING("{ a: }", Warning, "Jump instructions");
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/libsolidity/JSONCompiler.cpp b/test/libsolidity/JSONCompiler.cpp
index 7dc4808b..0c904c77 100644
--- a/test/libsolidity/JSONCompiler.cpp
+++ b/test/libsolidity/JSONCompiler.cpp
@@ -23,7 +23,7 @@
#include <boost/test/unit_test.hpp>
#include <libdevcore/JSON.h>
#include <libsolidity/interface/Version.h>
-#include <solc/jsonCompiler.h>
+#include <libsolc/libsolc.h>
#include "../Metadata.h"
#include "../TestHelper.h"
diff --git a/test/libsolidity/SMTChecker.cpp b/test/libsolidity/SMTChecker.cpp
index 8d712a80..3a65aa43 100644
--- a/test/libsolidity/SMTChecker.cpp
+++ b/test/libsolidity/SMTChecker.cpp
@@ -94,6 +94,7 @@ BOOST_AUTO_TEST_CASE(warn_on_typecast)
BOOST_AUTO_TEST_CASE(warn_on_struct)
{
string text = R"(
+ pragma experimental ABIEncoderV2;
contract C {
struct A { uint a; uint b; }
function f() public pure returns (A) {
@@ -105,6 +106,453 @@ BOOST_AUTO_TEST_CASE(warn_on_struct)
CHECK_WARNING_ALLOW_MULTI(text, "");
}
+BOOST_AUTO_TEST_CASE(simple_assert)
+{
+ string text = R"(
+ contract C {
+ function f(uint a) public pure { assert(a == 2); }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here for");
+}
+
+BOOST_AUTO_TEST_CASE(simple_assert_with_require)
+{
+ string text = R"(
+ contract C {
+ function f(uint a) public pure { require(a < 10); assert(a < 20); }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(assignment_in_declaration)
+{
+ string text = R"(
+ contract C {
+ function f() public pure { uint a = 2; assert(a == 2); }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(use_before_declaration)
+{
+ string text = R"(
+ contract C {
+ function f() public pure { a = 3; uint a = 2; assert(a == 2); }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f() public pure { assert(a == 0); uint a = 2; assert(a == 2); }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(function_call_does_not_clear_local_vars)
+{
+ string text = R"(
+ contract C {
+ function f() public {
+ uint a = 3;
+ this.f();
+ assert(a == 3);
+ f();
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(branches_clear_variables)
+{
+ // Only clears accessed variables
+ string text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ // It is just a plain clear and will not combine branches.
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ a = 3;
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+ // Clear also works on the else branch
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ } else {
+ a = 3;
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+ // Variable is not cleared, if it is only read.
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ assert(a == 3);
+ } else {
+ assert(a == 3);
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(branches_assert_condition)
+{
+ string text = R"(
+ contract C {
+ function f(uint x) public pure {
+ if (x > 10) {
+ assert(x > 9);
+ }
+ else
+ {
+ assert(x < 11);
+ }
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ if (x > 10) {
+ assert(x > 9);
+ }
+ else if (x > 2)
+ {
+ assert(x <= 10 && x > 2);
+ }
+ else
+ {
+ assert(0 <= x && x <= 2);
+ }
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(ways_to_clear_variables)
+{
+ string text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ a++;
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ ++a;
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ uint a = 3;
+ if (x > 10) {
+ a = 5;
+ }
+ assert(a == 3);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+}
+
+BOOST_AUTO_TEST_CASE(while_loop_simple)
+{
+ // Check that variables are cleared
+ string text = R"(
+ contract C {
+ function f(uint x) public pure {
+ x = 2;
+ while (x > 1) {
+ x = 2;
+ }
+ assert(x == 2);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+ // Check that condition is assumed.
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ while (x == 2) {
+ assert(x == 2);
+ }
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ // Check that condition is not assumed after the body anymore
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ while (x == 2) {
+ }
+ assert(x == 2);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+ // Check that negation of condition is not assumed after the body anymore
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ while (x == 2) {
+ }
+ assert(x != 2);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+ // Check that side-effects of condition are taken into account
+ text = R"(
+ contract C {
+ function f(uint x, uint y) public pure {
+ x = 7;
+ while ((x = y) > 0) {
+ }
+ assert(x == 7);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation happens here");
+}
+
+BOOST_AUTO_TEST_CASE(constant_condition)
+{
+ string text = R"(
+ contract C {
+ function f(uint x) public pure {
+ if (x >= 0) { revert(); }
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Condition is always true");
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ if (x >= 10) { if (x < 10) { revert(); } }
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Condition is always false");
+ // a plain literal constant is fine
+ text = R"(
+ contract C {
+ function f(uint) public pure {
+ if (true) { revert(); }
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+
+BOOST_AUTO_TEST_CASE(for_loop)
+{
+ string text = R"(
+ contract C {
+ function f(uint x) public pure {
+ require(x == 2);
+ for (;;) {}
+ assert(x == 2);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ for (; x == 2; ) {
+ assert(x == 2);
+ }
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ for (uint y = 2; x < 10; ) {
+ assert(y == 2);
+ }
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ for (uint y = 2; x < 10; y = 3) {
+ assert(y == 2);
+ }
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation");
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ for (uint y = 2; x < 10; ) {
+ y = 3;
+ }
+ assert(y == 3);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation");
+ text = R"(
+ contract C {
+ function f(uint x) public pure {
+ for (uint y = 2; x < 10; ) {
+ y = 3;
+ }
+ assert(y == 2);
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Assertion violation");
+}
+
+BOOST_AUTO_TEST_CASE(division)
+{
+ string text = R"(
+ contract C {
+ function f(uint x, uint y) public pure returns (uint) {
+ return x / y;
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Division by zero");
+ text = R"(
+ contract C {
+ function f(uint x, uint y) public pure returns (uint) {
+ require(y != 0);
+ return x / y;
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(int x, int y) public pure returns (int) {
+ require(y != 0);
+ return x / y;
+ }
+ }
+ )";
+ CHECK_WARNING(text, "Overflow");
+ text = R"(
+ contract C {
+ function f(int x, int y) public pure returns (int) {
+ require(y != 0);
+ require(y != -1);
+ return x / y;
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_CASE(division_truncates_correctly)
+{
+ string text = R"(
+ contract C {
+ function f(uint x, uint y) public pure {
+ x = 7;
+ y = 2;
+ assert(x / y == 3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(int x, int y) public pure {
+ x = 7;
+ y = 2;
+ assert(x / y == 3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(int x, int y) public pure {
+ x = -7;
+ y = 2;
+ assert(x / y == -3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(int x, int y) public pure {
+ x = 7;
+ y = -2;
+ assert(x / y == -3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+ text = R"(
+ contract C {
+ function f(int x, int y) public pure {
+ x = -7;
+ y = -2;
+ assert(x / y == 3);
+ }
+ }
+ )";
+ CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
BOOST_AUTO_TEST_SUITE_END()
}
diff --git a/test/libsolidity/SolidityABIJSON.cpp b/test/libsolidity/SolidityABIJSON.cpp
index 33962730..26bfb6d0 100644
--- a/test/libsolidity/SolidityABIJSON.cpp
+++ b/test/libsolidity/SolidityABIJSON.cpp
@@ -942,6 +942,7 @@ BOOST_AUTO_TEST_CASE(function_type)
BOOST_AUTO_TEST_CASE(return_structs)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
contract C {
struct S { uint a; T[] sub; }
struct T { uint[2] x; }
@@ -991,6 +992,7 @@ BOOST_AUTO_TEST_CASE(return_structs)
BOOST_AUTO_TEST_CASE(return_structs_with_contracts)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
contract C {
struct S { C[] x; C y; }
function f() returns (S s, C c) {
@@ -1090,6 +1092,7 @@ BOOST_AUTO_TEST_CASE(event_structs)
BOOST_AUTO_TEST_CASE(structs_in_libraries)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
library L {
struct S { uint a; T[] sub; bytes b; }
struct T { uint[2] x; }
diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp
index 7082b702..f5f7e64a 100644
--- a/test/libsolidity/SolidityEndToEndTest.cpp
+++ b/test/libsolidity/SolidityEndToEndTest.cpp
@@ -2345,6 +2345,24 @@ BOOST_AUTO_TEST_CASE(constructor_static_array_argument)
ABI_CHECK(callContractFunction("b(uint256)", u256(2)), encodeArgs(u256(4)));
}
+BOOST_AUTO_TEST_CASE(constant_var_as_array_length)
+{
+ char const* sourceCode = R"(
+ contract C {
+ uint constant LEN = 3;
+ uint[LEN] public a;
+
+ function C(uint[LEN] _a) {
+ a = _a;
+ }
+ }
+ )";
+ compileAndRun(sourceCode, 0, "C", encodeArgs(u256(1), u256(2), u256(3)));
+ ABI_CHECK(callContractFunction("a(uint256)", u256(0)), encodeArgs(u256(1)));
+ ABI_CHECK(callContractFunction("a(uint256)", u256(1)), encodeArgs(u256(2)));
+ ABI_CHECK(callContractFunction("a(uint256)", u256(2)), encodeArgs(u256(3)));
+}
+
BOOST_AUTO_TEST_CASE(functions_called_by_constructor)
{
char const* sourceCode = R"(
@@ -8014,6 +8032,24 @@ BOOST_AUTO_TEST_CASE(inline_assembly_embedded_function_call)
ABI_CHECK(callContractFunction("f()"), encodeArgs(u256(1), u256(4), u256(7), u256(0x10)));
}
+BOOST_AUTO_TEST_CASE(inline_assembly_if)
+{
+ char const* sourceCode = R"(
+ contract C {
+ function f(uint a) returns (uint b) {
+ assembly {
+ if gt(a, 1) { b := 2 }
+ }
+ }
+ }
+ )";
+ compileAndRun(sourceCode, 0, "C");
+ ABI_CHECK(callContractFunction("f(uint256)", u256(0)), encodeArgs(u256(0)));
+ ABI_CHECK(callContractFunction("f(uint256)", u256(1)), encodeArgs(u256(0)));
+ ABI_CHECK(callContractFunction("f(uint256)", u256(2)), encodeArgs(u256(2)));
+ ABI_CHECK(callContractFunction("f(uint256)", u256(3)), encodeArgs(u256(2)));
+}
+
BOOST_AUTO_TEST_CASE(inline_assembly_switch)
{
char const* sourceCode = R"(
diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp
index 30624260..39dba0de 100644
--- a/test/libsolidity/SolidityNameAndTypeResolution.cpp
+++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp
@@ -602,6 +602,7 @@ BOOST_AUTO_TEST_CASE(enum_external_type)
BOOST_AUTO_TEST_CASE(external_structs)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
contract Test {
enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
struct Empty {}
@@ -629,6 +630,7 @@ BOOST_AUTO_TEST_CASE(external_structs)
BOOST_AUTO_TEST_CASE(external_structs_in_libraries)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
library Test {
enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
struct Empty {}
@@ -1038,7 +1040,7 @@ BOOST_AUTO_TEST_CASE(function_modifier_double_invocation)
modifier mod(uint a) { if (a > 0) _; }
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(base_constructor_double_invocation)
@@ -1392,7 +1394,7 @@ BOOST_AUTO_TEST_CASE(events_with_same_name)
event A(uint i);
}
)";
- BOOST_CHECK(success(text));
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(events_with_same_name_unnamed_arguments)
@@ -2107,7 +2109,7 @@ BOOST_AUTO_TEST_CASE(array_with_nonconstant_length)
function f(uint a) public { uint8[a] x; }
}
)";
- CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal.");
+ CHECK_ERROR(text, TypeError, "Identifier must be declared constant.");
}
BOOST_AUTO_TEST_CASE(array_with_negative_length)
@@ -3511,6 +3513,7 @@ BOOST_AUTO_TEST_CASE(using_for_not_used)
BOOST_AUTO_TEST_CASE(library_memory_struct)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
library c {
struct S { uint x; }
function f() public returns (S ) {}
@@ -4033,7 +4036,7 @@ BOOST_AUTO_TEST_CASE(varM_disqualified_as_keyword)
}
}
)";
- BOOST_CHECK(!success(text));
+ CHECK_ERROR(text, DeclarationError, "Identifier not found or not unique.");
}
BOOST_AUTO_TEST_CASE(modifier_is_not_a_valid_typename)
@@ -4074,7 +4077,7 @@ BOOST_AUTO_TEST_CASE(long_uint_variable_fails)
}
}
)";
- BOOST_CHECK(!success(text));
+ CHECK_ERROR(text, DeclarationError, "Identifier not found or not unique.");
}
BOOST_AUTO_TEST_CASE(bytes10abc_is_identifier)
@@ -4113,7 +4116,7 @@ BOOST_AUTO_TEST_CASE(library_functions_do_not_have_value)
}
}
)";
- BOOST_CHECK(!success(text));
+ CHECK_ERROR(text, TypeError, "Member \"value\" not found or not visible after argument-dependent lookup in function ()");
}
BOOST_AUTO_TEST_CASE(invalid_fixed_types_0x7_mxn)
@@ -5690,12 +5693,13 @@ BOOST_AUTO_TEST_CASE(constructible_internal_constructor)
function D() public { }
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(return_structs)
{
char const* text = R"(
+ pragma experimental ABIEncoderV2;
contract C {
struct S { uint a; T[] sub; }
struct T { uint[] x; }
@@ -5703,7 +5707,7 @@ BOOST_AUTO_TEST_CASE(return_structs)
}
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(return_recursive_structs)
@@ -5753,7 +5757,7 @@ BOOST_AUTO_TEST_CASE(address_checksum_type_deduction)
}
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(invalid_address_checksum)
@@ -5766,7 +5770,7 @@ BOOST_AUTO_TEST_CASE(invalid_address_checksum)
}
}
)";
- CHECK_WARNING(text, "checksum");
+ CHECK_WARNING(text, "This looks like an address but has an invalid checksum.");
}
BOOST_AUTO_TEST_CASE(invalid_address_no_checksum)
@@ -5779,10 +5783,10 @@ BOOST_AUTO_TEST_CASE(invalid_address_no_checksum)
}
}
)";
- CHECK_WARNING(text, "checksum");
+ CHECK_WARNING(text, "This looks like an address but has an invalid checksum.");
}
-BOOST_AUTO_TEST_CASE(invalid_address_length)
+BOOST_AUTO_TEST_CASE(invalid_address_length_short)
{
char const* text = R"(
contract C {
@@ -5792,7 +5796,20 @@ BOOST_AUTO_TEST_CASE(invalid_address_length)
}
}
)";
- CHECK_WARNING(text, "checksum");
+ CHECK_WARNING(text, "This looks like an address but has an invalid checksum.");
+}
+
+BOOST_AUTO_TEST_CASE(invalid_address_length_long)
+{
+ char const* text = R"(
+ contract C {
+ function f() pure public {
+ address x = 0xFA0bFc97E48458494Ccd857e1A85DC91F7F0046E0;
+ x;
+ }
+ }
+ )";
+ CHECK_WARNING_ALLOW_MULTI(text, "This looks like an address but has an invalid checksum.");
}
BOOST_AUTO_TEST_CASE(address_test_for_bug_in_implementation)
@@ -5883,7 +5900,7 @@ BOOST_AUTO_TEST_CASE(interface)
interface I {
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(interface_constructor)
@@ -5904,7 +5921,7 @@ BOOST_AUTO_TEST_CASE(interface_functions)
function f();
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(interface_function_bodies)
@@ -5926,7 +5943,7 @@ BOOST_AUTO_TEST_CASE(interface_function_external)
function f() external;
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(interface_function_public)
@@ -5967,7 +5984,7 @@ BOOST_AUTO_TEST_CASE(interface_events)
event E();
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(interface_inheritance)
@@ -6010,7 +6027,7 @@ BOOST_AUTO_TEST_CASE(interface_function_parameters)
function f(uint a) public returns (bool);
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(interface_enums)
@@ -6034,7 +6051,7 @@ BOOST_AUTO_TEST_CASE(using_interface)
}
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(using_interface_complex)
@@ -6051,7 +6068,7 @@ BOOST_AUTO_TEST_CASE(using_interface_complex)
}
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(warn_about_throw)
@@ -6110,7 +6127,7 @@ BOOST_AUTO_TEST_CASE(pure_statement_check_for_regular_for_loop)
}
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(warn_multiple_storage_storage_copies)
@@ -6226,7 +6243,7 @@ BOOST_AUTO_TEST_CASE(warn_unused_function_parameter)
}
}
)";
- success(text);
+ CHECK_SUCCESS(text);
}
BOOST_AUTO_TEST_CASE(warn_unused_return_parameter)
@@ -7250,6 +7267,151 @@ BOOST_AUTO_TEST_CASE(array_length_not_convertible_to_integer)
CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal.");
}
+BOOST_AUTO_TEST_CASE(array_length_constant_var)
+{
+ char const* text = R"(
+ contract C {
+ uint constant LEN = 10;
+ uint[LEN] ids;
+ }
+ )";
+ CHECK_SUCCESS(text);
+}
+
+BOOST_AUTO_TEST_CASE(array_length_non_integer_constant_var)
+{
+ char const* text = R"(
+ contract C {
+ bool constant LEN = true;
+ uint[LEN] ids;
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal.");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_cannot_be_function)
+{
+ char const* text = R"(
+ contract C {
+ function f() {}
+ uint[f] ids;
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal.");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_can_be_recursive_constant)
+{
+ char const* text = R"(
+ contract C {
+ uint constant L = 5;
+ uint constant LEN = L + 4 * L;
+ uint[LEN] ids;
+ }
+ )";
+ CHECK_SUCCESS(text);
+}
+
+BOOST_AUTO_TEST_CASE(array_length_cannot_be_function_call)
+{
+ char const* text = R"(
+ contract C {
+ function f(uint x) {}
+ uint constant LEN = f();
+ uint[LEN] ids;
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal.");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_const_cannot_be_fractional)
+{
+ char const* text = R"(
+ contract C {
+ fixed constant L = 10.5;
+ uint[L] ids;
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Array with fractional length specified");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_can_be_constant_in_struct)
+{
+ char const* text = R"(
+ contract C {
+ uint constant LEN = 10;
+ struct Test {
+ uint[LEN] ids;
+ }
+ }
+ )";
+ CHECK_SUCCESS(text);
+}
+
+BOOST_AUTO_TEST_CASE(array_length_can_be_constant_in_function)
+{
+ char const* text = R"(
+ contract C {
+ uint constant LEN = 10;
+ function f() {
+ uint[LEN] a;
+ }
+ }
+ )";
+ CHECK_SUCCESS(text);
+}
+
+BOOST_AUTO_TEST_CASE(array_length_cannot_be_constant_function_parameter)
+{
+ char const* text = R"(
+ contract C {
+ function f(uint constant LEN) {
+ uint[LEN] a;
+ }
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Constant identifier declaration must have a constant value.");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_with_cyclic_constant)
+{
+ char const* text = R"(
+ contract C {
+ uint constant LEN = LEN;
+ function f() {
+ uint[LEN] a;
+ }
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Cyclic constant definition (or maximum recursion depth exhausted).");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_with_complex_cyclic_constant)
+{
+ char const* text = R"(
+ contract C {
+ uint constant L2 = LEN - 10;
+ uint constant L1 = L2 / 10;
+ uint constant LEN = 10 + L1 * 5;
+ function f() {
+ uint[LEN] a;
+ }
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Cyclic constant definition (or maximum recursion depth exhausted).");
+}
+
+BOOST_AUTO_TEST_CASE(array_length_with_pure_functions)
+{
+ char const* text = R"(
+ contract C {
+ uint constant LEN = keccak256(ripemd160(33));
+ uint[LEN] ids;
+ }
+ )";
+ CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal.");
+}
+
BOOST_AUTO_TEST_CASE(array_length_invalid_expression)
{
char const* text = R"(
diff --git a/test/libsolidity/StandardCompiler.cpp b/test/libsolidity/StandardCompiler.cpp
index 4504946b..091207e8 100644
--- a/test/libsolidity/StandardCompiler.cpp
+++ b/test/libsolidity/StandardCompiler.cpp
@@ -179,6 +179,14 @@ BOOST_AUTO_TEST_CASE(basic_compilation)
"fileA": {
"content": "contract A { }"
}
+ },
+ "settings": {
+ "outputSelection": {
+ "fileA": {
+ "A": [ "abi", "devdoc", "userdoc", "evm.bytecode", "evm.assembly", "evm.gasEstimates", "metadata" ],
+ "": [ "legacyAST" ]
+ }
+ }
}
}
)";
generated by cgit (git 2.34.1) at 2024-11-17 22:54:14 +0800