Merge pull request #11686 from ethereum/temporary-directory-extra-features

cameel · web-flow · commit 327571db884b · 2021-08-27T16:06:53.000+02:00
Convenience features in `TemporaryDirectory`
diff --git a/test/TemporaryDirectory.cpp b/test/TemporaryDirectory.cpp
@@ -18,9 +18,11 @@
 
 #include <test/TemporaryDirectory.h>
 
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
 
-#include <cassert>
 #include <regex>
 #include <iostream>
 
@@ -31,21 +33,39 @@ using namespace solidity::test;
 namespace fs = boost::filesystem;
 
 TemporaryDirectory::TemporaryDirectory(std::string const& _prefix):
-	m_path(fs::temp_directory_path() / fs::unique_path(_prefix + "%%%%-%%%%-%%%%-%%%%"))
+	m_path(fs::temp_directory_path() / fs::unique_path(_prefix + "-%%%%-%%%%-%%%%-%%%%"))
 {
 	// Prefix should just be a file name and not contain anything that would make us step out of /tmp.
-	assert(fs::path(_prefix) == fs::path(_prefix).stem());
+	soltestAssert(fs::path(_prefix) == fs::path(_prefix).stem(), "");
 
 	fs::create_directory(m_path);
 }
 
+TemporaryDirectory::TemporaryDirectory(
+	vector<boost::filesystem::path> const& _subdirectories,
+	string const& _prefix
+):
+	TemporaryDirectory(_prefix)
+{
+	for (boost::filesystem::path const& subdirectory: _subdirectories)
+	{
+		soltestAssert(!subdirectory.is_absolute() && subdirectory.root_path() != "/", "");
+		soltestAssert(
+			m_path.lexically_relative(subdirectory).empty() ||
+			*m_path.lexically_relative(subdirectory).begin() != "..",
+			""
+		);
+		boost::filesystem::create_directories(m_path / subdirectory);
+	}
+}
+
 TemporaryDirectory::~TemporaryDirectory()
 {
 	// A few paranoid sanity checks just to be extra sure we're not deleting someone's homework.
-	assert(m_path.string().find(fs::temp_directory_path().string()) == 0);
-	assert(!fs::equivalent(m_path, fs::temp_directory_path()));
-	assert(!fs::equivalent(m_path, m_path.root_path()));
-	assert(!m_path.empty());
+	soltestAssert(m_path.string().find(fs::temp_directory_path().string()) == 0, "");
+	soltestAssert(!fs::equivalent(m_path, fs::temp_directory_path()), "");
+	soltestAssert(!fs::equivalent(m_path, m_path.root_path()), "");
+	soltestAssert(!m_path.empty(), "");
 
 	boost::system::error_code errorCode;
 	uintmax_t numRemoved = fs::remove_all(m_path, errorCode);
diff --git a/test/TemporaryDirectory.h b/test/TemporaryDirectory.h
@@ -25,6 +25,7 @@
 #include <boost/filesystem.hpp>
 
 #include <string>
+#include <vector>
 
 namespace solidity::test
 {
@@ -40,10 +41,15 @@ namespace solidity::test
 class TemporaryDirectory
 {
 public:
-	TemporaryDirectory(std::string const& _prefix = "solidity-test-");
+	TemporaryDirectory(std::string const& _prefix = "solidity-test");
+	TemporaryDirectory(
+		std::vector<boost::filesystem::path> const& _subdirectories,
+		std::string const& _prefix = "solidity-test"
+	);
 	~TemporaryDirectory();
 
 	boost::filesystem::path const& path() const { return m_path; }
+	operator boost::filesystem::path() const { return m_path; }
 
 private:
 	boost::filesystem::path m_path;
@@ -59,6 +65,7 @@ class TemporaryWorkingDirectory
 	~TemporaryWorkingDirectory();
 
 	boost::filesystem::path const& originalWorkingDirectory() const { return m_originalWorkingDirectory; }
+	operator boost::filesystem::path() const { return boost::filesystem::current_path(); }
 
 private:
 	boost::filesystem::path m_originalWorkingDirectory;
diff --git a/test/TemporaryDirectoryTest.cpp b/test/TemporaryDirectoryTest.cpp
@@ -18,6 +18,8 @@
 
 #include <test/TemporaryDirectory.h>
 
+#include <test/libsolidity/util/SoltestErrors.h>
+
 #include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -26,68 +28,79 @@
 using namespace std;
 using namespace boost::test_tools;
 
-namespace fs = boost::filesystem;
-
 namespace solidity::test
 {
 
 BOOST_AUTO_TEST_SUITE(TemporaryDirectoryTest)
 
 BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_create_and_delete_a_unique_and_empty_directory)
 {
-	fs::path dirPath;
+	boost::filesystem::path dirPath;
 	{
-		TemporaryDirectory tempDir("temporary-directory-test-");
+		TemporaryDirectory tempDir("temporary-directory-test");
 		dirPath = tempDir.path();
 
-		BOOST_TEST(dirPath.stem().string().find("temporary-directory-test-") == 0);
-		BOOST_TEST(fs::equivalent(dirPath.parent_path(), fs::temp_directory_path()));
-		BOOST_TEST(fs::is_directory(dirPath));
-		BOOST_TEST(fs::is_empty(dirPath));
+		BOOST_TEST(dirPath.stem().string().find("temporary-directory-test") == 0);
+		BOOST_TEST(boost::filesystem::equivalent(dirPath.parent_path(), boost::filesystem::temp_directory_path()));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath));
+		BOOST_TEST(boost::filesystem::is_empty(dirPath));
 	}
-	BOOST_TEST(!fs::exists(dirPath));
+	BOOST_TEST(!boost::filesystem::exists(dirPath));
 }
 
 BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_delete_its_directory_even_if_not_empty)
 {
-	fs::path dirPath;
+	boost::filesystem::path dirPath;
 	{
-		TemporaryDirectory tempDir("temporary-directory-test-");
+		TemporaryDirectory tempDir("temporary-directory-test");
 		dirPath = tempDir.path();
 
-		BOOST_TEST(fs::is_directory(dirPath));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath));
 
 		{
 			ofstream tmpFile((dirPath / "test-file.txt").string());
 			tmpFile << "Delete me!" << endl;
 		}
-		assert(fs::is_regular_file(dirPath / "test-file.txt"));
+		soltestAssert(boost::filesystem::is_regular_file(dirPath / "test-file.txt"), "");
+	}
+	BOOST_TEST(!boost::filesystem::exists(dirPath / "test-file.txt"));
+}
+
+BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_create_subdirectories)
+{
+	boost::filesystem::path dirPath;
+	{
+		TemporaryDirectory tempDir({"a", "a/", "a/b/c", "x.y/z"}, "temporary-directory-test");
+		dirPath = tempDir.path();
+
+		BOOST_TEST(boost::filesystem::is_directory(dirPath / "a"));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath / "a/b/c"));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath / "x.y/z"));
 	}
-	BOOST_TEST(!fs::exists(dirPath / "test-file.txt"));
 }
 
 BOOST_AUTO_TEST_CASE(TemporaryWorkingDirectory_should_change_and_restore_working_directory)
 {
-	fs::path originalWorkingDirectory = fs::current_path();
+	boost::filesystem::path originalWorkingDirectory = boost::filesystem::current_path();
 
 	try
 	{
 		{
-			TemporaryDirectory tempDir("temporary-directory-test-");
-			assert(fs::equivalent(fs::current_path(), originalWorkingDirectory));
-			assert(!fs::equivalent(tempDir.path(), originalWorkingDirectory));
+			TemporaryDirectory tempDir("temporary-directory-test");
+			soltestAssert(boost::filesystem::equivalent(boost::filesystem::current_path(), originalWorkingDirectory), "");
+			soltestAssert(!boost::filesystem::equivalent(tempDir.path(), originalWorkingDirectory), "");
 
 			TemporaryWorkingDirectory tempWorkDir(tempDir.path());
 
-			BOOST_TEST(fs::equivalent(fs::current_path(), tempDir.path()));
+			BOOST_TEST(boost::filesystem::equivalent(boost::filesystem::current_path(), tempDir.path()));
 		}
-		BOOST_TEST(fs::equivalent(fs::current_path(), originalWorkingDirectory));
+		BOOST_TEST(boost::filesystem::equivalent(boost::filesystem::current_path(), originalWorkingDirectory));
 
-		fs::current_path(originalWorkingDirectory);
+		boost::filesystem::current_path(originalWorkingDirectory);
 	}
 	catch (...)
 	{
-		fs::current_path(originalWorkingDirectory);
+		boost::filesystem::current_path(originalWorkingDirectory);
 	}
 }
 
diff --git a/test/libsolidity/interface/FileReader.cpp b/test/libsolidity/interface/FileReader.cpp
@@ -65,8 +65,7 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_absolute_path)
 
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_relative_path)
 {
-	TemporaryDirectory tempDir(TEST_CASE_NAME);
-	boost::filesystem::create_directories(tempDir.path() / "x/y/z");
+	TemporaryDirectory tempDir({"x/y/z"}, TEST_CASE_NAME);
 	TemporaryWorkingDirectory tempWorkDir(tempDir.path() / "x/y/z");
 
 	// NOTE: If path to work dir contains symlinks (often the case on macOS), boost might resolve
@@ -129,7 +128,7 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_redundant_slashes)
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_unc_path)
 {
 	TemporaryDirectory tempDir(TEST_CASE_NAME);
-	TemporaryWorkingDirectory tempWorkDir(tempDir.path());
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
 
 	// On Windows tempDir.path() normally contains the drive letter while the normalized path should not.
 	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
@@ -157,7 +156,7 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_unc_path)
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_root_name_only)
 {
 	TemporaryDirectory tempDir(TEST_CASE_NAME);
-	TemporaryWorkingDirectory tempWorkDir(tempDir.path());
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
 
 	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
 	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
@@ -187,7 +186,7 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_root_name_only)
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_stripping_root_name)
 {
 	TemporaryDirectory tempDir(TEST_CASE_NAME);
-	TemporaryWorkingDirectory tempWorkDir(tempDir.path());
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
 
 	soltestAssert(boost::filesystem::current_path().is_absolute(), "");
 #if defined(_WIN32)
@@ -234,7 +233,7 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_path_beyond_root)
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_case_sensitivity)
 {
 	TemporaryDirectory tempDir(TEST_CASE_NAME);
-	TemporaryWorkingDirectory tempWorkDir(tempDir.path());
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
 
 	boost::filesystem::path expectedPrefix = "/" / tempDir.path().relative_path();
 	soltestAssert(expectedPrefix.is_absolute() || expectedPrefix.root_path() == "/", "");
@@ -253,9 +252,8 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_path_separators)
 
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_should_not_resolve_symlinks)
 {
-	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryDirectory tempDir({"abc/"}, TEST_CASE_NAME);
 	soltestAssert(tempDir.path().is_absolute(), "");
-	boost::filesystem::create_directories(tempDir.path() / "abc");
 
 	if (!createSymlinkIfSupportedByFilesystem(tempDir.path() / "abc", tempDir.path() / "sym", true))
 		return;
@@ -269,9 +267,8 @@ BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_should_not_resolve_symlinks)
 
 BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_should_resolve_symlinks_in_workdir_when_path_is_relative)
 {
-	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryDirectory tempDir({"abc/"}, TEST_CASE_NAME);
 	soltestAssert(tempDir.path().is_absolute(), "");
-	boost::filesystem::create_directories(tempDir.path() / "abc");
 
 	if (!createSymlinkIfSupportedByFilesystem(tempDir.path() / "abc", tempDir.path() / "sym", true))
 		return;
diff --git a/test/libsolutil/CommonIO.cpp b/test/libsolutil/CommonIO.cpp
@@ -34,28 +34,30 @@
 using namespace std;
 using namespace solidity::test;
 
+#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)
+
 namespace solidity::util::test
 {
 
 BOOST_AUTO_TEST_SUITE(CommonIOTest)
 
 BOOST_AUTO_TEST_CASE(readFileAsString_regular_file)
 {
-	TemporaryDirectory tempDir("common-io-test-");
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
 	createFileWithContent(tempDir.path() / "test.txt", "ABC\ndef\n");
 
 	BOOST_TEST(readFileAsString(tempDir.path() / "test.txt") == "ABC\ndef\n");
 }
 
 BOOST_AUTO_TEST_CASE(readFileAsString_directory)
 {
-	TemporaryDirectory tempDir("common-io-test-");
-	BOOST_CHECK_THROW(readFileAsString(tempDir.path()), NotAFile);
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	BOOST_CHECK_THROW(readFileAsString(tempDir), NotAFile);
 }
 
 BOOST_AUTO_TEST_CASE(readFileAsString_symlink)
 {
-	TemporaryDirectory tempDir("common-io-test-");
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
 	createFileWithContent(tempDir.path() / "test.txt", "ABC\ndef\n");
 
 	if (!createSymlinkIfSupportedByFilesystem("test.txt", tempDir.path() / "symlink.txt", false))
diff --git a/test/solc/CommandLineInterface.cpp b/test/solc/CommandLineInterface.cpp

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,8 @@`
`18`	`18`
`19`	`19`	`#include <test/TemporaryDirectory.h>`
`20`	`20`
	`21`	`+#include <test/libsolidity/util/SoltestErrors.h>`
	`22`	`+`
`21`	`23`	`#include <boost/filesystem.hpp>`
`22`	`24`	`#include <boost/test/unit_test.hpp>`
`23`	`25`
`@@ -26,68 +28,79 @@`
`26`	`28`	`using namespace std;`
`27`	`29`	`using namespace boost::test_tools;`
`28`	`30`
`29`		`-namespace fs = boost::filesystem;`
`30`		`-`
`31`	`31`	`namespace solidity::test`
`32`	`32`	`{`
`33`	`33`
`34`	`34`	`BOOST_AUTO_TEST_SUITE(TemporaryDirectoryTest)`
`35`	`35`
`36`	`36`	`BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_create_and_delete_a_unique_and_empty_directory)`
`37`	`37`	`{`
`38`		`- fs::path dirPath;`
	`38`	`+ boost::filesystem::path dirPath;`
`39`	`39`	`{`
`40`		`- TemporaryDirectory tempDir("temporary-directory-test-");`
	`40`	`+ TemporaryDirectory tempDir("temporary-directory-test");`
`41`	`41`	`dirPath = tempDir.path();`
`42`	`42`
`43`		`- BOOST_TEST(dirPath.stem().string().find("temporary-directory-test-") == 0);`
`44`		`- BOOST_TEST(fs::equivalent(dirPath.parent_path(), fs::temp_directory_path()));`
`45`		`- BOOST_TEST(fs::is_directory(dirPath));`
`46`		`- BOOST_TEST(fs::is_empty(dirPath));`
	`43`	`+ BOOST_TEST(dirPath.stem().string().find("temporary-directory-test") == 0);`
	`44`	`+ BOOST_TEST(boost::filesystem::equivalent(dirPath.parent_path(), boost::filesystem::temp_directory_path()));`
	`45`	`+ BOOST_TEST(boost::filesystem::is_directory(dirPath));`
	`46`	`+ BOOST_TEST(boost::filesystem::is_empty(dirPath));`
`47`	`47`	`}`
`48`		`- BOOST_TEST(!fs::exists(dirPath));`
	`48`	`+ BOOST_TEST(!boost::filesystem::exists(dirPath));`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_delete_its_directory_even_if_not_empty)`
`52`	`52`	`{`
`53`		`- fs::path dirPath;`
	`53`	`+ boost::filesystem::path dirPath;`
`54`	`54`	`{`
`55`		`- TemporaryDirectory tempDir("temporary-directory-test-");`
	`55`	`+ TemporaryDirectory tempDir("temporary-directory-test");`
`56`	`56`	`dirPath = tempDir.path();`
`57`	`57`
`58`		`- BOOST_TEST(fs::is_directory(dirPath));`
	`58`	`+ BOOST_TEST(boost::filesystem::is_directory(dirPath));`
`59`	`59`
`60`	`60`	`{`
`61`	`61`	`ofstream tmpFile((dirPath / "test-file.txt").string());`
`62`	`62`	`tmpFile << "Delete me!" << endl;`
`63`	`63`	`}`
`64`		`- assert(fs::is_regular_file(dirPath / "test-file.txt"));`
	`64`	`+ soltestAssert(boost::filesystem::is_regular_file(dirPath / "test-file.txt"), "");`
	`65`	`+ }`
	`66`	`+ BOOST_TEST(!boost::filesystem::exists(dirPath / "test-file.txt"));`
	`67`	`+}`
	`68`	`+`
	`69`	`+BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_create_subdirectories)`
	`70`	`+{`
	`71`	`+ boost::filesystem::path dirPath;`
	`72`	`+ {`
	`73`	`+ TemporaryDirectory tempDir({"a", "a/", "a/b/c", "x.y/z"}, "temporary-directory-test");`
	`74`	`+ dirPath = tempDir.path();`
	`75`	`+`
	`76`	`+ BOOST_TEST(boost::filesystem::is_directory(dirPath / "a"));`
	`77`	`+ BOOST_TEST(boost::filesystem::is_directory(dirPath / "a/b/c"));`
	`78`	`+ BOOST_TEST(boost::filesystem::is_directory(dirPath / "x.y/z"));`
`65`	`79`	`}`
`66`		`- BOOST_TEST(!fs::exists(dirPath / "test-file.txt"));`
`67`	`80`	`}`
`68`	`81`
`69`	`82`	`BOOST_AUTO_TEST_CASE(TemporaryWorkingDirectory_should_change_and_restore_working_directory)`
`70`	`83`	`{`
`71`		`- fs::path originalWorkingDirectory = fs::current_path();`
	`84`	`+ boost::filesystem::path originalWorkingDirectory = boost::filesystem::current_path();`
`72`	`85`
`73`	`86`	`try`
`74`	`87`	`{`
`75`	`88`	`{`
`76`		`- TemporaryDirectory tempDir("temporary-directory-test-");`
`77`		`- assert(fs::equivalent(fs::current_path(), originalWorkingDirectory));`
`78`		`- assert(!fs::equivalent(tempDir.path(), originalWorkingDirectory));`
	`89`	`+ TemporaryDirectory tempDir("temporary-directory-test");`
	`90`	`+ soltestAssert(boost::filesystem::equivalent(boost::filesystem::current_path(), originalWorkingDirectory), "");`
	`91`	`+ soltestAssert(!boost::filesystem::equivalent(tempDir.path(), originalWorkingDirectory), "");`
`79`	`92`
`80`	`93`	`TemporaryWorkingDirectory tempWorkDir(tempDir.path());`
`81`	`94`
`82`		`- BOOST_TEST(fs::equivalent(fs::current_path(), tempDir.path()));`
	`95`	`+ BOOST_TEST(boost::filesystem::equivalent(boost::filesystem::current_path(), tempDir.path()));`
`83`	`96`	`}`
`84`		`- BOOST_TEST(fs::equivalent(fs::current_path(), originalWorkingDirectory));`
	`97`	`+ BOOST_TEST(boost::filesystem::equivalent(boost::filesystem::current_path(), originalWorkingDirectory));`
`85`	`98`
`86`		`- fs::current_path(originalWorkingDirectory);`
	`99`	`+ boost::filesystem::current_path(originalWorkingDirectory);`
`87`	`100`	`}`
`88`	`101`	`catch (...)`
`89`	`102`	`{`
`90`		`- fs::current_path(originalWorkingDirectory);`
	`103`	`+ boost::filesystem::current_path(originalWorkingDirectory);`
`91`	`104`	`}`
`92`	`105`	`}`
`93`	`106`
Original file line number	Diff line number	Diff line change
`@@ -34,28 +34,30 @@`
`34`	`34`	`using namespace std;`
`35`	`35`	`using namespace solidity::test;`
`36`	`36`
	`37`	`+#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)`
	`38`	`+`
`37`	`39`	`namespace solidity::util::test`
`38`	`40`	`{`
`39`	`41`
`40`	`42`	`BOOST_AUTO_TEST_SUITE(CommonIOTest)`
`41`	`43`
`42`	`44`	`BOOST_AUTO_TEST_CASE(readFileAsString_regular_file)`
`43`	`45`	`{`
`44`		`- TemporaryDirectory tempDir("common-io-test-");`
	`46`	`+ TemporaryDirectory tempDir(TEST_CASE_NAME);`
`45`	`47`	`createFileWithContent(tempDir.path() / "test.txt", "ABC\ndef\n");`
`46`	`48`
`47`	`49`	`BOOST_TEST(readFileAsString(tempDir.path() / "test.txt") == "ABC\ndef\n");`
`48`	`50`	`}`
`49`	`51`
`50`	`52`	`BOOST_AUTO_TEST_CASE(readFileAsString_directory)`
`51`	`53`	`{`
`52`		`- TemporaryDirectory tempDir("common-io-test-");`
`53`		`- BOOST_CHECK_THROW(readFileAsString(tempDir.path()), NotAFile);`
	`54`	`+ TemporaryDirectory tempDir(TEST_CASE_NAME);`
	`55`	`+ BOOST_CHECK_THROW(readFileAsString(tempDir), NotAFile);`
`54`	`56`	`}`
`55`	`57`
`56`	`58`	`BOOST_AUTO_TEST_CASE(readFileAsString_symlink)`
`57`	`59`	`{`
`58`		`- TemporaryDirectory tempDir("common-io-test-");`
	`60`	`+ TemporaryDirectory tempDir(TEST_CASE_NAME);`
`59`	`61`	`createFileWithContent(tempDir.path() / "test.txt", "ABC\ndef\n");`
`60`	`62`
`61`	`63`	`if (!createSymlinkIfSupportedByFilesystem("test.txt", tempDir.path() / "symlink.txt", false))`