Skip to content

Commit 3dbdea9

Browse files
aarltaarlt
committed
[isoltest] Add support for generic expectation updates.
1 parent 48083f6 commit 3dbdea9

13 files changed

+264
-34
lines changed

‎test/CMakeLists.txt

+3
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,9 @@ set(liblangutil_sources
5858
detect_stray_source_files("${liblangutil_sources}" "liblangutil/")
5959

6060
set(libsolidity_sources
61+
libsolidity/Builtin.h
62+
libsolidity/TestHook.h
63+
libsolidity/hooks/SmokeHook.h
6164
libsolidity/ABIDecoderTests.cpp
6265
libsolidity/ABIEncoderTests.cpp
6366
libsolidity/ABIJsonTest.cpp

‎test/libsolidity/Builtin.h

+55
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
/*
2+
This file is part of solidity.
3+
solidity is free software: you can redistribute it and/or modify
4+
it under the terms of the GNU General Public License as published by
5+
the Free Software Foundation, either version 3 of the License, or
6+
(at your option) any later version.
7+
solidity is distributed in the hope that it will be useful,
8+
but WITHOUT ANY WARRANTY; without even the implied warranty of
9+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10+
GNU General Public License for more details.
11+
You should have received a copy of the GNU General Public License
12+
along with solidity. If not, see <http://www.gnu.org/licenses/>.
13+
*/
14+
15+
#pragma once
16+
17+
#include <functional>
18+
#include <map>
19+
#include <optional>
20+
#include <test/libsolidity/util/SoltestErrors.h>
21+
#include <test/libsolidity/util/SoltestTypes.h>
22+
#include <utility>
23+
#include <vector>
24+
#include <memory>
25+
26+
namespace solidity::frontend::test
27+
{
28+
29+
class TestFunctionCall;
30+
31+
class Builtin
32+
{
33+
/// This is the actual implementation of the builtin function.
34+
std::function<std::optional<bytes>(FunctionCall const&)> m_builtin = nullptr;
35+
36+
public:
37+
Builtin() = default;
38+
virtual ~Builtin() = default;
39+
40+
explicit Builtin(std::function<std::optional<bytes>(FunctionCall const&)> _builtin)
41+
{
42+
m_builtin = std::move(_builtin);
43+
}
44+
45+
virtual std::optional<bytes> builtin(FunctionCall const& _call)
46+
{
47+
if (m_builtin != nullptr)
48+
return m_builtin(_call);
49+
return std::nullopt;
50+
}
51+
};
52+
53+
using Builtins = std::map<std::string, std::map<std::string, std::shared_ptr<Builtin>>>;
54+
55+
} // namespace solidity::frontend::test

‎test/libsolidity/SemanticTest.cpp

+75-17
Original file line numberDiff line numberDiff line change
@@ -12,15 +12,19 @@
1212
along with solidity. If not, see <http://www.gnu.org/licenses/>.
1313
*/
1414

15-
#include <test/libsolidity/SemanticTest.h>
16-
#include <test/libsolidity/util/BytesUtils.h>
17-
#include <libsolutil/Whiskers.h>
18-
#include <libyul/Exceptions.h>
19-
#include <test/Common.h>
2015
#include <boost/algorithm/string.hpp>
2116
#include <boost/algorithm/string/predicate.hpp>
2217
#include <boost/algorithm/string/trim.hpp>
2318
#include <boost/throw_exception.hpp>
19+
#include <libsolutil/Whiskers.h>
20+
#include <libyul/Exceptions.h>
21+
#include <test/Common.h>
22+
#include <test/libsolidity/SemanticTest.h>
23+
#include <test/libsolidity/util/BytesUtils.h>
24+
25+
#include <test/libsolidity/Builtin.h>
26+
#include <test/libsolidity/TestHook.h>
27+
#include <test/libsolidity/hooks/SmokeHook.h>
2428

2529
#include <algorithm>
2630
#include <cctype>
@@ -50,13 +54,23 @@ SemanticTest::SemanticTest(string const& _filename, langutil::EVMVersion _evmVer
5054
m_enforceViaYul(enforceViaYul)
5155
{
5256
using namespace std::placeholders;
53-
m_builtins
54-
= {{"smoke",
55-
{
56-
{"test0", {std::bind(&SemanticTest::builtinSmokeTest, this, _1)}},
57-
{"test1", {std::bind(&SemanticTest::builtinSmokeTest, this, _1)}},
58-
{"test2", {std::bind(&SemanticTest::builtinSmokeTest, this, _1)}},
59-
}}};
57+
// clang-format off
58+
auto simpleSmokeBuiltin = std::make_shared<Builtin>(
59+
std::bind(&SemanticTest::builtinSmokeTest, this, _1)
60+
);
61+
m_builtins =
62+
{
63+
{"smoke",
64+
{{"test0", simpleSmokeBuiltin},
65+
{"test1", simpleSmokeBuiltin},
66+
{"test2", simpleSmokeBuiltin}}
67+
}
68+
};
69+
m_testHooks =
70+
{
71+
std::make_shared<SmokeHook>()
72+
};
73+
// clang-format on
6074

6175
string choice = m_reader.stringSetting("compileViaYul", "default");
6276
if (choice == "also")
@@ -130,7 +144,13 @@ TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePref
130144
return result;
131145
}
132146

133-
TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm)
147+
void SemanticTest::addBuiltin(std::string _module, std::string _function, std::shared_ptr<Builtin> _builtin)
148+
{
149+
m_builtins[_module][_function] = _builtin;
150+
}
151+
152+
TestCase::TestResult SemanticTest::runTest(
153+
ostream& _stream, string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm)
134154
{
135155
bool success = true;
136156

@@ -160,11 +180,28 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
160180

161181
bool constructed = false;
162182

183+
// Iterate through the test calls and set the previous call.
184+
TestFunctionCall* previousCall{nullptr};
185+
for (auto& test: m_tests)
186+
{
187+
test.setPreviousCall(previousCall);
188+
test.setTestHooks(&m_testHooks);
189+
previousCall = &test;
190+
}
191+
192+
for (auto& hook: m_testHooks)
193+
hook->beginTestCase();
194+
163195
for (auto& test: m_tests)
164196
{
197+
for (auto& hook: m_testHooks)
198+
hook->beforeFunctionCall(test);
199+
165200
if (constructed)
166201
{
167-
soltestAssert(test.call().kind != FunctionCall::Kind::Library, "Libraries have to be deployed before any other call.");
202+
soltestAssert(
203+
test.call().kind != FunctionCall::Kind::Library,
204+
"Libraries have to be deployed before any other call.");
168205
soltestAssert(
169206
test.call().kind != FunctionCall::Kind::Constructor,
170207
"Constructor has to be the first function call expect for library deployments.");
@@ -214,7 +251,7 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
214251
boost::split(builtinPath, test.call().signature, boost::is_any_of("."));
215252
soltestAssert(builtinPath.size() == 2, "");
216253
auto builtin = m_builtins[builtinPath.front()][builtinPath.back()];
217-
std::optional<bytes> builtinOutput{builtin.function(test.call())};
254+
std::optional<bytes> builtinOutput{builtin->builtin(test.call())};
218255
if (builtinOutput.has_value())
219256
{
220257
test.setFailure(false);
@@ -243,9 +280,9 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
243280
{
244281
std::vector<string> builtinPath;
245282
boost::split(builtinPath, test.call().expectations.builtin->signature, boost::is_any_of("."));
246-
assert(builtinPath.size() == 2);
283+
soltestAssert(builtinPath.size() == 2, "");
247284
auto builtin = m_builtins[builtinPath.front()][builtinPath.back()];
248-
std::optional<bytes> builtinResult = builtin.function(*test.call().expectations.builtin);
285+
std::optional<bytes> builtinResult = builtin->builtin(*test.call().expectations.builtin);
249286
if (builtinResult.has_value())
250287
expectationOutput = builtinResult.value();
251288
else
@@ -273,8 +310,29 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
273310
test.setRawBytes(std::move(output));
274311
test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName()));
275312
}
313+
314+
for (auto& hook: m_testHooks)
315+
hook->afterFunctionCall(test);
316+
}
317+
318+
// The artificialFunctionCall is an artificially created function call,
319+
// where it's previous call is pointing to the last call of the test.
320+
TestFunctionCall artificialFunctionCall(FunctionCall{});
321+
artificialFunctionCall.setTestHooks(&m_testHooks);
322+
artificialFunctionCall.setPreviousCall(previousCall);
323+
for (auto& hook: m_testHooks)
324+
{
325+
hook->beforeFunctionCall(artificialFunctionCall);
326+
hook->afterFunctionCall(artificialFunctionCall);
276327
}
277328

329+
for (auto& hook: m_testHooks)
330+
hook->endTestCase();
331+
332+
for (auto& test: m_tests)
333+
for (auto& hook: m_testHooks)
334+
success &= hook->verifyFunctionCall(test);
335+
278336
if (!m_runWithYul && _compileViaYul)
279337
{
280338
m_compileViaYulCanBeSet = success;

‎test/libsolidity/SemanticTest.h

+11-6
Original file line numberDiff line numberDiff line change
@@ -14,13 +14,15 @@
1414

1515
#pragma once
1616

17-
#include <test/libsolidity/util/TestFileParser.h>
18-
#include <test/libsolidity/util/TestFunctionCall.h>
19-
#include <test/libsolidity/SolidityExecutionFramework.h>
20-
#include <test/libsolidity/AnalysisFramework.h>
21-
#include <test/TestCase.h>
2217
#include <liblangutil/Exceptions.h>
2318
#include <libsolutil/AnsiColorized.h>
19+
#include <test/TestCase.h>
20+
#include <test/libsolidity/AnalysisFramework.h>
21+
#include <test/libsolidity/Builtin.h>
22+
#include <test/libsolidity/SolidityExecutionFramework.h>
23+
#include <test/libsolidity/TestHook.h>
24+
#include <test/libsolidity/util/TestFileParser.h>
25+
#include <test/libsolidity/util/TestFunctionCall.h>
2426

2527
#include <iosfwd>
2628
#include <string>
@@ -59,6 +61,8 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
5961
/// Returns true if deployment was successful, false otherwise.
6062
bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments, std::map<std::string, solidity::test::Address> const& _libraries = {});
6163

64+
void addBuiltin(std::string _module, std::string _function, std::shared_ptr<Builtin> _builtin);
65+
6266
private:
6367
// builtin functions
6468
std::optional<bytes> builtinSmokeTest(FunctionCall const& call);
@@ -74,7 +78,8 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
7478
bool m_runWithABIEncoderV1Only = false;
7579
bool m_allowNonExistingFunctions = false;
7680
bool m_compileViaYulCanBeSet = false;
77-
BuiltinFunctions m_builtins;
81+
Builtins m_builtins;
82+
TestHooks m_testHooks;
7883
};
7984

8085
}

‎test/libsolidity/TestHook.h

+52
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
/*
2+
This file is part of solidity.
3+
solidity is free software: you can redistribute it and/or modify
4+
it under the terms of the GNU General Public License as published by
5+
the Free Software Foundation, either version 3 of the License, or
6+
(at your option) any later version.
7+
solidity is distributed in the hope that it will be useful,
8+
but WITHOUT ANY WARRANTY; without even the implied warranty of
9+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10+
GNU General Public License for more details.
11+
You should have received a copy of the GNU General Public License
12+
along with solidity. If not, see <http://www.gnu.org/licenses/>.
13+
*/
14+
15+
#pragma once
16+
17+
#include "Builtin.h"
18+
#include <memory>
19+
#include <vector>
20+
21+
namespace solidity::frontend::test
22+
{
23+
24+
class TestFunctionCall;
25+
26+
class TestHook
27+
{
28+
public:
29+
TestHook() = default;
30+
virtual ~TestHook() = default;
31+
32+
virtual void beginTestCase() {}
33+
virtual void beforeFunctionCall(TestFunctionCall const& /* _call */) {}
34+
virtual void afterFunctionCall(TestFunctionCall const& /* _call */) {}
35+
virtual void endTestCase() {}
36+
37+
virtual bool verifyFunctionCall(TestFunctionCall const& /* _call */) { return true; }
38+
39+
virtual std::string formatFunctionCall(
40+
const TestFunctionCall& /* _call */,
41+
ErrorReporter& /*_errorReporter */,
42+
std::string const& /* _linePrefix */,
43+
bool const /* _renderResult */,
44+
bool const /* _highlight */) const
45+
{
46+
return "";
47+
}
48+
};
49+
50+
using TestHooks = std::vector<std::shared_ptr<TestHook>>;
51+
52+
} // namespace solidity::frontend::test

‎test/libsolidity/hooks/SmokeHook.h

+46
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
/*
2+
This file is part of solidity.
3+
solidity is free software: you can redistribute it and/or modify
4+
it under the terms of the GNU General Public License as published by
5+
the Free Software Foundation, either version 3 of the License, or
6+
(at your option) any later version.
7+
solidity is distributed in the hope that it will be useful,
8+
but WITHOUT ANY WARRANTY; without even the implied warranty of
9+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10+
GNU General Public License for more details.
11+
You should have received a copy of the GNU General Public License
12+
along with solidity. If not, see <http://www.gnu.org/licenses/>.
13+
*/
14+
15+
#pragma once
16+
17+
#include <iostream>
18+
#include <test/libsolidity/TestHook.h>
19+
20+
namespace solidity::frontend::test
21+
{
22+
class SmokeHook: public TestHook
23+
{
24+
public:
25+
SmokeHook() = default;
26+
~SmokeHook() override = default;
27+
28+
void beginTestCase() override {}
29+
void beforeFunctionCall([[maybe_unused]] TestFunctionCall const& _call) override {}
30+
void afterFunctionCall([[maybe_unused]] TestFunctionCall const& _call) override {}
31+
void endTestCase() override {}
32+
33+
bool verifyFunctionCall([[maybe_unused]] TestFunctionCall const& _call) override { return true; }
34+
35+
std::string formatFunctionCall(
36+
[[maybe_unused]] TestFunctionCall const& _call,
37+
[[maybe_unused]] ErrorReporter& _errorReporter,
38+
[[maybe_unused]] std::string const& _linePrefix,
39+
[[maybe_unused]] const bool _renderResult,
40+
[[maybe_unused]] const bool _highlight) const override
41+
{
42+
return "";
43+
}
44+
};
45+
46+
} // namespace solidity::frontend::test

‎test/libsolidity/semanticTests/builtins/smoke.sol

+1
Original file line numberDiff line numberDiff line change
@@ -11,3 +11,4 @@ contract ClientReceipt {
1111
// smoke.test2: 2, 3 -> smoke.test2: 2, 3
1212
// smoke.test2: 2, 3, 4 -> FAILURE
1313
// smoke.test2: 2, 3, 4 -> smoke.test2: 2, 3, 4
14+
// smoke.test0 ->

‎test/libsolidity/util/SoltestTypes.h

-5
Original file line numberDiff line numberDiff line change
@@ -303,9 +303,4 @@ struct FunctionCall
303303
bool omitsArrow = true;
304304
};
305305

306-
struct BuiltinFunction {
307-
std::function<std::optional<bytes>(FunctionCall const&)> function;
308-
};
309-
using BuiltinFunctions = std::map<std::string, std::map<std::string, BuiltinFunction>>;
310-
311306
}

‎test/libsolidity/util/TestFileParser.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -180,8 +180,7 @@ void TestFileParser::checkBuiltinFunction(std::string const& signature)
180180
auto builtin = module->second.find(builtinPath.back());
181181
if (builtin == module->second.end())
182182
throw TestParserError(
183-
"builtin function '" + builtinPath.back() + "' not found in module '"
184-
+ builtinPath.front() + "'");
183+
"builtin function '" + builtinPath.back() + "' not found in module '" + builtinPath.front() + "'");
185184
}
186185

187186
bool TestFileParser::accept(Token _token, bool const _expect)

0 commit comments

Comments
 (0)