Add SMTChecker tests for standard JSON

libdevcore/JSON.cpp

@@ -21,6 +21,8 @@
 
 #include "JSON.h"
 
+#include "CommonIO.h"
+
 #include <sstream>
 #include <map>
 #include <memory>
@@ -111,4 +113,10 @@ bool jsonParse(string const& _input, Json::Value& _json, string *_errs /* = null
 	return parse(readerBuilder, _input, _json, _errs);
 }
 
+bool jsonParseFile(string const& _fileName, Json::Value& _json, string *_errs /* = nullptr */)
+{
+	return jsonParse(readFileAsString(_fileName), _json, _errs);
+}
+
+
 } // namespace dev

libdevcore/JSON.h

@@ -48,4 +48,11 @@ bool jsonParseStrict(std::string const& _input, Json::Value& _json, std::string*
 /// \return \c true if the document was successfully parsed, \c false if an error occurred.
 bool jsonParse(std::string const& _input, Json::Value& _json, std::string* _errs = nullptr);
 
+/// Parse a JSON string (@a _input) and writes resulting JSON object to (@a _json)
+/// \param _input file containing JSON input
+/// \param _json [out] resulting JSON object
+/// \param _errs [out] Formatted error messages
+/// \return \c true if the document was successfully parsed, \c false if an error occurred.
+bool jsonParseFile(std::string const& _fileName, Json::Value& _json, std::string* _errs = nullptr);
+
 }

test/boostTest.cpp

@@ -38,6 +38,7 @@
 #include <test/Options.h>
 #include <test/libsolidity/ASTJSONTest.h>
 #include <test/libsolidity/SyntaxTest.h>
+#include <test/libsolidity/SMTCheckerJSONTest.h>
 #include <test/libyul/YulOptimizerTest.h>
 
 #include <boost/algorithm/string.hpp>
@@ -146,12 +147,21 @@ test_suite* init_unit_test_suite( int /*argc*/, char* /*argv*/[] )
 		dev::yul::test::YulOptimizerTest::create
 	) > 0, "no Yul Optimizer tests found");
 	if (!dev::test::Options::get().disableSMT)
+	{
 		solAssert(registerTests(
 			master,
 			dev::test::Options::get().testPath / "libsolidity",
 			"smtCheckerTests",
 			SyntaxTest::create
 		) > 0, "no SMT checker tests found");
+
+		solAssert(registerTests(
+			master,
+			dev::test::Options::get().testPath / "libsolidity",
+			"smtCheckerTestsJSON",
+			SMTCheckerTest::create
+		) > 0, "no SMT checker JSON tests found");
+	}
 	if (dev::test::Options::get().disableIPC)
 	{
 		for (auto suite: {

test/libsolidity/SMTCheckerJSONTest.cpp

@@ -0,0 +1,128 @@
+/*
+	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 <test/libsolidity/SMTCheckerJSONTest.h>
+#include <test/Options.h>
+#include <libsolidity/interface/StandardCompiler.h>
+#include <libdevcore/JSON.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/throw_exception.hpp>
+#include <fstream>
+#include <memory>
+#include <stdexcept>
+#include <sstream>
+
+using namespace dev;
+using namespace solidity;
+using namespace dev::solidity::test;
+using namespace dev::solidity::test::formatting;
+using namespace std;
+using namespace boost::unit_test;
+
+SMTCheckerTest::SMTCheckerTest(string const& _filename)
+: SyntaxTest(_filename)
+{
+	BOOST_REQUIRE_MESSAGE(boost::algorithm::ends_with(_filename, ".sol"), "Invalid test contract file name: \"" + _filename + "\".");
+
+	string jsonFilename = _filename.substr(0, _filename.size() - 4) + ".json";
+	BOOST_CHECK(jsonParseFile(jsonFilename, m_smtResponses));
+	BOOST_CHECK(m_smtResponses.isObject());
+}
+
+bool SMTCheckerTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted)
+{
+	StandardCompiler compiler;
+
+	// Run the compiler and retrieve the smtlib2queries (1st run)
+	string versionPragma = "pragma solidity >=0.0;\n";
+	Json::Value input = buildJson(versionPragma);
+	Json::Value result = compiler.compile(input);
+
+	// This is the list of query hashes requested by the 1st run
+	vector<string> outHashes = hashesFromJson(result, "auxiliaryInputRequested", "smtlib2queries");
+
+	// This is the list of responses provided in the test
+	string auxInput("auxiliaryInput");
+	BOOST_CHECK(m_smtResponses.isMember(auxInput));
+	vector<string> inHashes = hashesFromJson(m_smtResponses, auxInput, "smtlib2responses");
+
+	// Ensure that the provided list matches the requested one
+	BOOST_CHECK_MESSAGE(
+		outHashes == inHashes,
+		"SMT query hashes differ: " + boost::algorithm::join(outHashes, ", ") + " x " + boost::algorithm::join(inHashes, ", ")
+	);
+
+	// Rerun the compiler with the provided hashed (2nd run)
+	input[auxInput] = m_smtResponses[auxInput];
+	Json::Value endResult = compiler.compile(input);
+
+	BOOST_CHECK(endResult.isMember("errors"));
+	Json::Value const& errors = endResult["errors"];
+	for (auto const& error: errors)
+	{
+		BOOST_CHECK(error.isMember("type") && error["type"].isString());
+		BOOST_CHECK(error.isMember("message") && error["message"].isString());
+		if (!error.isMember("sourceLocation"))
+			continue;
+		Json::Value const& location = error["sourceLocation"];
+		BOOST_CHECK(location.isMember("start") && location["start"].isInt());
+		BOOST_CHECK(location.isMember("end") && location["end"].isInt());
+		int start = location["start"].asInt();
+		int end = location["end"].asInt();
+		if (start >= static_cast<int>(versionPragma.size()))
+			start -= versionPragma.size();
+		if (end >= static_cast<int>(versionPragma.size()))
+			end -= versionPragma.size();
+		m_errorList.emplace_back(SyntaxTestError{
+			error["type"].asString(),
+			error["message"].asString(),
+			start,
+			end
+		});
+	}
+
+	return printExpectationAndError(_stream, _linePrefix, _formatted);
+}
+
+vector<string> SMTCheckerTest::hashesFromJson(Json::Value const& _jsonObj, string const& _auxInput, string const& _smtlib)
+{
+	vector<string> hashes;
+	Json::Value const& auxInputs = _jsonObj[_auxInput];
+	if (!!auxInputs)
+	{
+		Json::Value const& smtlib = auxInputs[_smtlib];
+		if (!!smtlib)
+			for (auto const& hashString: smtlib.getMemberNames())
+				hashes.push_back(hashString);
+	}
+	return hashes;
+}
+
+Json::Value SMTCheckerTest::buildJson(string const& _extra)
+{
+	string language = "\"language\": \"Solidity\"";
+	string sourceName = "\"A\"";
+	string sourceContent = "\"" + _extra + m_source + "\"";
+	string sourceObj = "{ \"content\": " + sourceContent + "}";
+	string sources = " \"sources\": { " + sourceName + ": " + sourceObj + "}";
+	string input = "{" + language + ", " + sources + "}";
+	Json::Value source;
+	BOOST_REQUIRE(jsonParse(input, source));
+	return source;
+}

test/libsolidity/SMTCheckerJSONTest.h

@@ -0,0 +1,53 @@
+/*
+	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/>.
+*/
+
+#pragma once
+
+#include <test/libsolidity/SyntaxTest.h>
+
+#include <libdevcore/JSON.h>
+
+#include <string>
+
+namespace dev
+{
+namespace solidity
+{
+namespace test
+{
+
+class SMTCheckerTest: public SyntaxTest
+{
+public:
+	static std::unique_ptr<TestCase> create(std::string const& _filename)
+	{
+		return std::unique_ptr<TestCase>(new SMTCheckerTest(_filename));
+	}
+	SMTCheckerTest(std::string const& _filename);
+
+	bool run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+
+private:
+	std::vector<std::string> hashesFromJson(Json::Value const& _jsonObj, std::string const& _auxInput, std::string const& _smtlib);
+	Json::Value buildJson(std::string const& _extra);
+
+	Json::Value m_smtResponses;
+};
+
+}
+}
+}

test/libsolidity/SyntaxTest.cpp

@@ -92,6 +92,11 @@ bool SyntaxTest::run(ostream& _stream, string const& _linePrefix, bool const _fo
 		});
 	}
 
+	return printExpectationAndError(_stream, _linePrefix, _formatted);
+}
+
+bool SyntaxTest::printExpectationAndError(ostream& _stream, string const& _linePrefix, bool const _formatted)
+{
 	if (m_expectations != m_errorList)
 	{
 		string nextIndentLevel = _linePrefix + "  ";

test/libsolidity/SyntaxTest.h

@@ -67,7 +67,7 @@ public:
 	}
 
 	static std::string errorMessage(Exception const& _e);
-private:
+protected:
 	static void printErrorList(
 		std::ostream& _stream,
 		std::vector<SyntaxTestError> const& _errors,
@@ -75,6 +75,8 @@ private:
 		bool const _formatted = false
 	);
 
+	virtual bool printExpectationAndError(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false);
+
 	static std::vector<SyntaxTestError> parseExpectations(std::istream& _stream);
 
 	std::string m_source;

test/libsolidity/smtCheckerTestsJSON/multi.json

@@ -0,0 +1,11 @@
+{
+  "auxiliaryInput":
+  {
+	  "smtlib2responses":
+	  {
+		  "0x0426cd198d1e7123a28ffac2b759a666b86508ad046babf5166500dd6d8ed308": "unsat\n(error \"line 31 column 26: model is not available\")",
+		  "0xa51ca41ae407f5a727f27101cbc079834743cc8955f9f585582034ca634953f6": "sat\n((|EVALEXPR_0| 1))",
+		  "0xe9477f683ff20aa57fcb08682150f86c5917e1d4c0686b278ab9b73446d0682c": "sat\n((|EVALEXPR_0| 0))"
+	  }
+  }
+}

test/libsolidity/smtCheckerTestsJSON/multi.sol

@@ -0,0 +1,13 @@
+pragma experimental SMTChecker;
+
+contract C
+{
+	function f(uint x) public pure {
+		assert(x > 0);
+		assert(x > 100);
+		assert(x >= 0);
+	}
+}
+// ----
+// Warning: (82-95): Assertion violation happens here
+// Warning: (99-114): Assertion violation happens here

test/libsolidity/smtCheckerTestsJSON/simple.json

@@ -0,0 +1,9 @@
+{
+  "auxiliaryInput":
+  {
+	  "smtlib2responses":
+	  {
+		  "0xe9477f683ff20aa57fcb08682150f86c5917e1d4c0686b278ab9b73446d0682c": "sat\n((|EVALEXPR_0| 0))"
+	  }
+  }
+}

test/libsolidity/smtCheckerTestsJSON/simple.sol

@@ -0,0 +1,10 @@
+pragma experimental SMTChecker;
+
+contract C
+{
+	function f(uint x) public pure {
+		assert(x > 0);
+	}
+}
+// ----
+// Warning: (82-95): Assertion violation happens here

test/tools/CMakeLists.txt

@@ -6,5 +6,5 @@ target_link_libraries(yulopti PRIVATE solidity ${Boost_PROGRAM_OPTIONS_LIBRARIES
 
 add_executable(isoltest isoltest.cpp ../Options.cpp ../Common.cpp ../libsolidity/TestCase.cpp ../libsolidity/SyntaxTest.cpp
         ../libsolidity/AnalysisFramework.cpp ../libsolidity/SolidityExecutionFramework.cpp ../ExecutionFramework.cpp
-        ../RPCSession.cpp ../libsolidity/ASTJSONTest.cpp ../libyul/YulOptimizerTest.cpp)
+        ../RPCSession.cpp ../libsolidity/ASTJSONTest.cpp ../libsolidity/SMTCheckerJSONTest.cpp ../libyul/YulOptimizerTest.cpp)
 target_link_libraries(isoltest PRIVATE libsolc solidity evmasm ${Boost_PROGRAM_OPTIONS_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})

test/tools/isoltest.cpp

@@ -21,6 +21,7 @@
 #include <test/libsolidity/AnalysisFramework.h>
 #include <test/libsolidity/SyntaxTest.h>
 #include <test/libsolidity/ASTJSONTest.h>
+#include <test/libsolidity/SMTCheckerJSONTest.h>
 #include <test/libyul/YulOptimizerTest.h>
 
 #include <boost/algorithm/string.hpp>
@@ -412,6 +413,17 @@ Allowed options)",
 			global_stats += *stats;
 		else
 			return 1;
+
+		if (auto stats = runTestSuite(
+			"SMT Checker JSON",
+			testPath / "libsolidity",
+			"smtCheckerTestsJSON",
+			SMTCheckerTest::create,
+			formatted
+		))
+			global_stats += *stats;
+		else
+			return 1;
 	}
 
 	cout << endl << "Summary: ";