diff options
| author | Andrei Karas <akaras@inbox.ru> | 2017-03-04 00:27:54 +0300 |
|---|---|---|
| committer | Andrei Karas <akaras@inbox.ru> | 2017-03-04 01:12:19 +0300 |
| commit | 79bb654b80d5eb7a65814f80b9ca7ca1ccd62a00 (patch) | |
| tree | f9669ee10e2ea3f2c41abaa84830da9efe7f9411 | |
| parent | a6c70dd1f32c38cc81cfd4b28f929d7c13d86db1 (diff) | |
| download | plus-79bb654b80d5eb7a65814f80b9ca7ca1ccd62a00.tar.gz plus-79bb654b80d5eb7a65814f80b9ca7ca1ccd62a00.tar.bz2 plus-79bb654b80d5eb7a65814f80b9ca7ca1ccd62a00.tar.xz plus-79bb654b80d5eb7a65814f80b9ca7ca1ccd62a00.zip | |
Reimplement VirtFs in correct way. Now all tests should pass.
39 files changed, 2615 insertions, 574 deletions
diff --git a/src/Makefile.am b/src/Makefile.am index be0ca689b..fddf3f101 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1960,6 +1960,7 @@ manaplustests_SOURCES += \ fs/physfs/virtfsphys_unittest.cc else manaplustests_SOURCES += \ + fs/virtfs/virtfs_unittest.cc \ fs/virtfs/virtfsdir_unittest.cc \ fs/virtfs/zip_unittest.cc \ fs/virtfs/virtfszip_unittest.cc diff --git a/src/fs/files_unittest.cc b/src/fs/files_unittest.cc index 69956ddb3..19fd40ec1 100644 --- a/src/fs/files_unittest.cc +++ b/src/fs/files_unittest.cc @@ -37,8 +37,8 @@ TEST_CASE("Files renameFile") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); const int sz = 1234567; char *buf = new char[sz]; @@ -66,8 +66,8 @@ TEST_CASE("Files renameFile") delete [] buf; delete [] buf2; ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -77,14 +77,14 @@ TEST_CASE("Files existsLocal") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); REQUIRE(Files::existsLocal(VirtFs::getPath("help/about.txt")) == true); REQUIRE_FALSE(Files::existsLocal(VirtFs::getPath("help/about1.txt"))); REQUIRE_FALSE(Files::existsLocal(VirtFs::getPath("help1/about.txt"))); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -94,13 +94,13 @@ TEST_CASE("Files loadTextFileString") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); REQUIRE(VirtFs::loadTextFileString("test/simplefile.txt") == "this is test \nfile."); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -110,8 +110,8 @@ TEST_CASE("Files loadTextFile") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); StringVect lines; VirtFs::loadTextFile("test/simplefile.txt", lines); @@ -119,8 +119,8 @@ TEST_CASE("Files loadTextFile") REQUIRE(lines[0] == "this is test "); REQUIRE(lines[1] == "file."); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -130,8 +130,8 @@ TEST_CASE("Files saveTextFile") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); const std::string dir = VirtFs::getPath("test"); REQUIRE(dir.size() > 0); @@ -140,8 +140,8 @@ TEST_CASE("Files saveTextFile") ::remove((dir + "/tempfile.txt").c_str()); REQUIRE(data == "test line\ntext line2\n"); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -151,8 +151,8 @@ TEST_CASE("Files getFilesInDir") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); StringVect list; VirtFs::getFilesInDir("test", @@ -172,8 +172,8 @@ TEST_CASE("Files getFilesInDir") REQUIRE(list[3] == "perserver/default/features.xml"); REQUIRE(list[4] == "perserver/default/weapons.xml"); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/fs/physfs/virtfs.cpp b/src/fs/physfs/virtfs.cpp index 9608dfd28..e678e0224 100644 --- a/src/fs/physfs/virtfs.cpp +++ b/src/fs/physfs/virtfs.cpp @@ -59,7 +59,7 @@ namespace VirtFs return VirtFsPhys::getUserDir(); } - bool exists(const std::string &restrict name) + bool exists(std::string name) { return VirtFsPhys::exists(name); } @@ -89,12 +89,12 @@ namespace VirtFs return VirtFsPhys::openRead(filename); } - VirtFile *openWrite(const std::string &restrict filename) + VirtFile *openWrite(std::string filename) { return VirtFsPhys::openWrite(filename); } - VirtFile *openAppend(const std::string &restrict filename) + VirtFile *openAppend(std::string filename) { return VirtFsPhys::openAppend(filename); } @@ -104,35 +104,35 @@ namespace VirtFs return VirtFsPhys::setWriteDir(newDir); } - bool addDirToSearchPath(const std::string &restrict newDir, + bool addDirToSearchPath(std::string newDir, const Append append) { return VirtFsPhys::addDirToSearchPath(newDir, append); } - bool addDirToSearchPathSilent(const std::string &restrict newDir, + bool addDirToSearchPathSilent(std::string newDir, const Append append) { return VirtFsPhys::addDirToSearchPath(newDir, append); } - bool removeDirFromSearchPath(const std::string &restrict oldDir) + bool removeDirFromSearchPath(std::string oldDir) { return VirtFsPhys::removeDirFromSearchPath(oldDir); } - bool removeDirFromSearchPathSilent(const std::string &restrict oldDir) + bool removeDirFromSearchPathSilent(std::string oldDir) { return VirtFsPhys::removeDirFromSearchPath(oldDir); } - bool addZipToSearchPath(const std::string &restrict newDir, + bool addZipToSearchPath(std::string newDir, const Append append) { return VirtFsPhys::addZipToSearchPath(newDir, append); } - bool removeZipFromSearchPath(const std::string &restrict oldDir) + bool removeZipFromSearchPath(std::string oldDir) { return VirtFsPhys::removeZipFromSearchPath(oldDir); } diff --git a/src/fs/physfs/virtfsphys_unittest.cc b/src/fs/physfs/virtfsphys_unittest.cc index f35dedc7f..df3898221 100644 --- a/src/fs/physfs/virtfsphys_unittest.cc +++ b/src/fs/physfs/virtfsphys_unittest.cc @@ -468,40 +468,6 @@ TEST_CASE("VirtFsPhys getRealDir") delete2(logger); } -TEST_CASE("VirtFsPhys permitLinks") -{ - VirtFsPhys::initFuncs(); - logger = new Logger(); - VirtFsPhys::addDirToSearchPath("data", Append_false); - VirtFsPhys::addDirToSearchPath("../data", Append_false); - - const int cnt1 = VirtFsPhys::exists("test/test2.txt") ? 26 : 25; - const int cnt2 = 26; - - StringVect list; - VirtFsPhys::permitLinks(false); - VirtFsPhys::getFiles("test", list); - removeTemp(list); - const size_t sz = list.size(); - REQUIRE(sz == cnt1); - - list.clear(); - VirtFsPhys::permitLinks(true); - VirtFsPhys::getFiles("test", list); - removeTemp(list); - REQUIRE(list.size() == cnt2); - - list.clear(); - VirtFsPhys::permitLinks(false); - VirtFsPhys::getFiles("test", list); - removeTemp(list); - REQUIRE(list.size() == cnt1); - - VirtFsPhys::removeDirFromSearchPath("data"); - VirtFsPhys::removeDirFromSearchPath("../data"); - delete2(logger); -} - TEST_CASE("VirtFsPhys read") { VirtFsPhys::initFuncs(); diff --git a/src/fs/virtfs.h b/src/fs/virtfs.h index f0876029d..f27afac67 100644 --- a/src/fs/virtfs.h +++ b/src/fs/virtfs.h @@ -18,8 +18,8 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#ifndef UTILS_VIRTFS_H -#define UTILS_VIRTFS_H +#ifndef FS_VIRTFS_H +#define FS_VIRTFS_H #include "enums/simpletypes/append.h" @@ -37,24 +37,24 @@ namespace VirtFs const char *getDirSeparator(); const char *getBaseDir(); const char *getUserDir(); - bool exists(const std::string &restrict name); + bool exists(std::string name); VirtList *enumerateFiles(std::string dir) RETURNS_NONNULL; bool isDirectory(std::string name); bool isSymbolicLink(const std::string &restrict name); void freeList(VirtList *restrict const handle); VirtFile *openRead(std::string filename); - VirtFile *openWrite(const std::string &restrict filename); - VirtFile *openAppend(const std::string &restrict filename); + VirtFile *openWrite(std::string filename); + VirtFile *openAppend(std::string filename); bool setWriteDir(const std::string &restrict newDir); - bool addDirToSearchPath(const std::string &restrict newDir, + bool addDirToSearchPath(std::string newDir, const Append append); - bool addDirToSearchPathSilent(const std::string &restrict newDir, + bool addDirToSearchPathSilent(std::string newDir, const Append append); - bool removeDirFromSearchPath(const std::string &restrict oldDir); - bool removeDirFromSearchPathSilent(const std::string &restrict oldDir); - bool addZipToSearchPath(const std::string &restrict newDir, + bool removeDirFromSearchPath(std::string oldDir); + bool removeDirFromSearchPathSilent(std::string oldDir); + bool addZipToSearchPath(std::string newDir, const Append append); - bool removeZipFromSearchPath(const std::string &restrict oldDir); + bool removeZipFromSearchPath(std::string oldDir); std::string getRealDir(std::string filename); bool mkdir(const std::string &restrict dirName); bool remove(const std::string &restrict filename); @@ -79,4 +79,4 @@ namespace VirtFs extern const char *dirSeparator; -#endif // UTILS_VIRTFS_H +#endif // FS_VIRTFS_H diff --git a/src/fs/virtfs/virtdirentry.cpp b/src/fs/virtfs/virtdirentry.cpp index 7481e2a29..3cf8dd600 100644 --- a/src/fs/virtfs/virtdirentry.cpp +++ b/src/fs/virtfs/virtdirentry.cpp @@ -23,10 +23,11 @@ #include "debug.h" -VirtDirEntry::VirtDirEntry(const std::string &userDir, - const std::string &rootDir) : - VirtFsEntry(FsEntryType::Dir), - mUserDir(userDir) +VirtDirEntry::VirtDirEntry(const std::string &userDir0, + const std::string &rootDir, + VirtFsFuncs *restrict const funcs0) : + VirtFsEntry(FsEntryType::Dir, funcs0), + userDir(userDir0) { root = rootDir; } diff --git a/src/fs/virtfs/virtdirentry.h b/src/fs/virtfs/virtdirentry.h index 013c63a6e..57f4bc22e 100644 --- a/src/fs/virtfs/virtdirentry.h +++ b/src/fs/virtfs/virtdirentry.h @@ -31,13 +31,14 @@ struct VirtDirEntry final : public VirtFsEntry { VirtDirEntry(const std::string &userDir, - const std::string &rootDir); + const std::string &rootDir, + VirtFsFuncs *restrict const funcs); A_DELETE_COPY(VirtDirEntry) ~VirtDirEntry(); - std::string mUserDir; + std::string userDir; }; #endif // USE_PHYSFS diff --git a/src/fs/virtfs/virtfs.cpp b/src/fs/virtfs/virtfs.cpp index aa2f4d57c..2bd59a0a2 100644 --- a/src/fs/virtfs/virtfs.cpp +++ b/src/fs/virtfs/virtfs.cpp @@ -22,17 +22,22 @@ #include "fs/virtfs.h" +#include "fs/files.h" #include "fs/paths.h" #include "fs/virtfile.h" #include "fs/virtfsfuncs.h" #include "fs/virtlist.h" #include "fs/virtfs/virtdirentry.h" -#include "fs/virtfs/virtfsentry.h" +#include "fs/virtfs/virtfs.h" #include "fs/virtfs/virtfsdir.h" #include "fs/virtfs/virtfszip.h" +#include "fs/virtfs/virtzipentry.h" +#include "fs/virtfs/zip.h" #include "utils/checkutils.h" +#include "utils/dtor.h" +#include "utils/stringutils.h" #include "debug.h" @@ -43,6 +48,12 @@ namespace std::vector<VirtFsEntry*> mEntries; } // namespace +#ifdef UNITTESTS +#define reportNonTests logger->log +#else // UNITTESTS +#define reportNonTests reportAlways +#endif // UNITTESTS + namespace VirtFs { void init(const std::string &restrict name) @@ -76,9 +87,57 @@ namespace VirtFs return VirtFsDir::getUserDir(); } - bool exists(const std::string &restrict name) + std::vector<VirtFsEntry*> &getEntries() + { + return mEntries; + } + + VirtFsEntry *searchEntryByRootInternal(const std::string &restrict root) + { + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + if ((*it)->root == root) + return *it; + } + return nullptr; + } + + VirtFsEntry *searchEntryInternal(const std::string &restrict root, + const FsEntryType type) + { + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + if (entry->root == root && + entry->type == type) + { + return *it; + } + } + return nullptr; + } + + bool exists(std::string name) { - return VirtFsDir::exists(name) || VirtFsZip::exists(name); + prepareFsPath(name); + if (checkPath(name) == false) + { + reportAlways("VirtFsDir::exists invalid path: %s", + name.c_str()); + return false; + } + + std::string rootDir = name; + if (findLast(rootDir, std::string(dirSeparator)) == false) + rootDir += dirSeparator; + + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + if (entry->funcs->exists(entry, name, rootDir) == true) + return true; + } + return false; } VirtList *enumerateFiles(std::string dirName) @@ -92,8 +151,17 @@ namespace VirtFs return list; } - VirtFsDir::enumerateFiles(dirName, list); - VirtFsZip::enumerateFiles(dirName, list); + std::string rootDir = dirName; + if (findLast(rootDir, std::string(dirSeparator)) == false) + rootDir += dirSeparator; + StringVect &names = list->names; + + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + entry->funcs->enumerate(entry, rootDir, names); + } + return list; } @@ -106,8 +174,20 @@ namespace VirtFs name.c_str()); return false; } - return VirtFsDir::isDirectoryInternal(name) || - VirtFsZip::isDirectoryInternal(name); + std::string dirName = name; + if (findLast(dirName, std::string(dirSeparator)) == false) + dirName += dirSeparator; + + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + bool isDirFlag(false); + if (entry->funcs->isDirectory(entry, dirName, isDirFlag) == true) + { + return isDirFlag; + } + } + return false; } bool isSymbolicLink(const std::string &restrict name) @@ -129,20 +209,52 @@ namespace VirtFs filename.c_str()); return nullptr; } - VirtDirEntry *const entry = VirtFsDir::searchEntryByPath(filename); - if (entry == nullptr) - return VirtFsZip::openReadInternal(filename); - return VirtFsDir::openReadDirEntry(entry, filename); + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + VirtFile *const file = entry->funcs->openRead(entry, filename); + if (file != nullptr) + return file; + } + return nullptr; } - VirtFile *openWrite(const std::string &restrict filename) + VirtFile *openWrite(std::string filename) { - return VirtFsDir::openWrite(filename); + prepareFsPath(filename); + if (checkPath(filename) == false) + { + reportAlways("VirtFs::openWrite invalid path: %s", + filename.c_str()); + return nullptr; + } + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + VirtFile *const file = entry->funcs->openWrite(entry, filename); + if (file != nullptr) + return file; + } + return nullptr; } - VirtFile *openAppend(const std::string &restrict filename) + VirtFile *openAppend(std::string filename) { - return VirtFsDir::openAppend(filename); + prepareFsPath(filename); + if (checkPath(filename) == false) + { + reportAlways("VirtFs::openAppend invalid path: %s", + filename.c_str()); + return nullptr; + } + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + VirtFile *const file = entry->funcs->openAppend(entry, filename); + if (file != nullptr) + return file; + } + return nullptr; } bool setWriteDir(const std::string &restrict newDir) @@ -150,72 +262,224 @@ namespace VirtFs return VirtFsDir::setWriteDir(newDir); } - bool addDirToSearchPath(const std::string &restrict newDir, + void addEntry(VirtFsEntry *const entry, + const Append append) + { + if (append == Append_true) + mEntries.push_back(entry); + else + mEntries.insert(mEntries.begin(), entry); + } + + bool addDirToSearchPathInternal(const std::string &restrict newDir, + const Append append) + { + if (newDir.find(".zip") != std::string::npos) + { + reportAlways("Called VirtFsDir::addToSearchPath with zip archive"); + return false; + } + std::string rootDir = newDir; + if (findLast(rootDir, std::string(dirSeparator)) == false) + rootDir += dirSeparator; + VirtFsEntry *const entry = searchEntryByRootInternal(rootDir); + if (entry != nullptr) + { + reportAlways("VirtFs::addToSearchPath already exists: %s", + newDir.c_str()); + return false; + } + logger->log("Add virtual directory: " + newDir); + addEntry(new VirtDirEntry(newDir, rootDir, VirtFsDir::getFuncs()), + append); + return true; + } + + bool addDirToSearchPath(std::string newDir, const Append append) { -#ifdef UNITTESTS - return VirtFsDir::addToSearchPathSilent(newDir, - append, - SkipError_false); -#else // UNITTESTS - return VirtFsDir::addToSearchPath(newDir, append); -#endif // UNITTESTS + prepareFsPath(newDir); + if (Files::existsLocal(newDir) == false) + { + reportNonTests("VirtFs::addToSearchPath directory not exists: %s", + newDir.c_str()); + return false; + } + return addDirToSearchPathInternal(newDir, append); } - bool addDirToSearchPathSilent(const std::string &restrict newDir, + bool addDirToSearchPathSilent(std::string newDir, const Append append) { - return VirtFsDir::addToSearchPathSilent(newDir, - append, - SkipError_false); + prepareFsPath(newDir); + if (Files::existsLocal(newDir) == false) + { + logger->log("VirtFs::addToSearchPath directory not exists: %s", + newDir.c_str()); + return false; + } + return addDirToSearchPathInternal(newDir, append); } - bool removeDirFromSearchPath(const std::string &restrict oldDir) - { #ifdef UNITTESTS - return VirtFsDir::removeFromSearchPathSilent(oldDir); -#else // UNITTESTS - return VirtFsDir::removeFromSearchPath(oldDir); + bool addDirToSearchPathSilent2(std::string newDir, + const Append append) + { + prepareFsPath(newDir); + if (Files::existsLocal(newDir) == false) + { + logger->log("VirtFs::addToSearchPath directory not exists: %s", + newDir.c_str()); + } + return addDirToSearchPathInternal(newDir, append); + } #endif // UNITTESTS + + bool removeDirFromSearchPathInternal(std::string oldDir) + { + if (findLast(oldDir, std::string(dirSeparator)) == false) + oldDir += dirSeparator; + FOR_EACH (std::vector<VirtFsEntry*>::iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + if (entry->root == oldDir && + entry->type == FsEntryType::Dir) + { + VirtDirEntry *const dirEntry = static_cast<VirtDirEntry*>( + entry); + logger->log("Remove virtual directory: " + oldDir); + mEntries.erase(it); + delete dirEntry; + return true; + } + } + return false; + } + + bool removeDirFromSearchPath(std::string oldDir) + { + prepareFsPath(oldDir); + if (oldDir.find(".zip") != std::string::npos) + { + reportAlways("Called removeFromSearchPath with zip archive"); + return false; + } + if (removeDirFromSearchPathInternal(oldDir) == false) + { + reportAlways("VirtFs::removeDirFromSearchPath not exists: %s", + oldDir.c_str()); + return false; + } + return true; } - bool removeDirFromSearchPathSilent(const std::string &restrict oldDir) + bool removeDirFromSearchPathSilent(std::string oldDir) { - return VirtFsDir::removeFromSearchPathSilent(oldDir); + prepareFsPath(oldDir); + if (oldDir.find(".zip") != std::string::npos) + { + reportAlways("Called removeFromSearchPath with zip archive"); + return false; + } + if (removeDirFromSearchPathInternal(oldDir) == false) + { + logger->log("VirtFs::removeDirFromSearchPath not exists: %s", + oldDir.c_str()); + return false; + } + return true; } - bool addZipToSearchPath(const std::string &restrict newDir, + bool addZipToSearchPath(std::string newDir, const Append append) { -#ifdef UNITTESTS - return VirtFsZip::addToSearchPathSilent(newDir, append); -#else // UNITTESTS - return VirtFsZip::addToSearchPath(newDir, append); -#endif // UNITTESTS + prepareFsPath(newDir); + if (Files::existsLocal(newDir) == false) + { + reportNonTests("VirtFsZip::addToSearchPath file not exists: %s", + newDir.c_str()); + return false; + } + if (findLast(newDir, ".zip") == false) + { + reportAlways("Called VirtFs::addToSearchPath without " + "zip archive"); + return false; + } + if (searchEntryByRootInternal(newDir) != nullptr) + { + reportAlways("VirtFsZip::addToSearchPath already exists: %s", + newDir.c_str()); + return false; + } + VirtZipEntry *const entry = new VirtZipEntry(newDir, + VirtFsZip::getFuncs()); + if (Zip::readArchiveInfo(entry) == false) + { + delete entry; + return false; + } + + logger->log("Add virtual zip: " + newDir); + addEntry(entry, append); + return true; } - bool removeZipFromSearchPath(const std::string &restrict oldDir) + bool removeZipFromSearchPath(std::string oldDir) { -#ifdef UNITTESTS - return VirtFsZip::removeFromSearchPathSilent(oldDir); -#else // UNITTESTS - return VirtFsZip::removeFromSearchPath(oldDir); -#endif // UNITTESTS + prepareFsPath(oldDir); + if (findLast(oldDir, ".zip") == false) + { + reportAlways("Called removeFromSearchPath without zip archive"); + return false; + } + FOR_EACH (std::vector<VirtFsEntry*>::iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + if (entry->root == oldDir && + entry->type == FsEntryType::Zip) + { + VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>( + entry); + logger->log("Remove virtual zip: " + oldDir); + mEntries.erase(it); + delete zipEntry; + return true; + } + } + + reportAlways("VirtFs::removeZipFromSearchPath not exists: %s", + oldDir.c_str()); + return false; } - std::string getRealDir(std::string filename) + std::string getRealDir(std::string fileName) { - prepareFsPath(filename); - if (checkPath(filename) == false) + prepareFsPath(fileName); + if (checkPath(fileName) == false) { - reportAlways("VirtFs::getRealDir invalid path: %s", - filename.c_str()); + reportAlways("VirtFsDir::getRealDir invalid path: %s", + fileName.c_str()); return std::string(); } - VirtDirEntry *const entry = VirtFsDir::searchEntryByPath(filename); - if (entry == nullptr) - return VirtFsZip::getRealDirInternal(filename); - return entry->mUserDir; + + std::string rootDir = fileName; + if (findLast(rootDir, std::string(dirSeparator)) == false) + rootDir += dirSeparator; + + FOR_EACH (std::vector<VirtFsEntry*>::const_iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + std::string realDir; + if (entry->funcs->getRealDir(entry, + fileName, + rootDir, + realDir) == true) + { + return realDir; + } + } + return std::string(); } bool mkdir(const std::string &restrict dirname) @@ -232,6 +496,18 @@ namespace VirtFs { VirtFsDir::deinit(); VirtFsZip::deinit(); + FOR_EACH (std::vector<VirtFsEntry*>::iterator, it, mEntries) + { + VirtFsEntry *const entry = *it; + if (entry->type == FsEntryType::Dir) + delete static_cast<VirtDirEntry*>(entry); + else if (entry->type == FsEntryType::Zip) + delete static_cast<VirtZipEntry*>(entry); + else + delete entry; + } +// delete_all(mEntries); + mEntries.clear(); return true; } diff --git a/src/fs/virtfs/virtfs.h b/src/fs/virtfs/virtfs.h new file mode 100644 index 000000000..bf05b7f90 --- /dev/null +++ b/src/fs/virtfs/virtfs.h @@ -0,0 +1,51 @@ +/* + * The ManaPlus Client + * Copyright (C) 2013-2017 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program 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 2 of the License, or + * any later version. + * + * This program 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 this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef UTILS_FS_VIRTFS_VIRTFS_H +#define UTILS_FS_VIRTFS_VIRTFS_H + +#include "enums/simpletypes/append.h" + +#include "localconsts.h" + +#include <string> +#include <vector> + +struct VirtFsEntry; + +namespace VirtFs +{ + bool addDirToSearchPathInternal(const std::string &restrict newDir, + const Append append); + bool removeDirFromSearchPathInternal(std::string oldDir); + std::vector<VirtFsEntry*> &getEntries(); + VirtFsEntry *searchEntryByRootInternal(const std::string &restrict + root); + VirtFsEntry *searchEntryInternal(const std::string &restrict root, + const FsEntryType type); + void addEntry(VirtFsEntry *const entry, + const Append append); +#ifdef UNITTESTS + bool addDirToSearchPathSilent2(std::string newDir, + const Append append); +#endif // UNITTESTS +} // namespace VirtFs + +#endif // UTILS_FS_VIRTFS_VIRTFS_H diff --git a/src/fs/virtfs/virtfs_unittest.cc b/src/fs/virtfs/virtfs_unittest.cc new file mode 100644 index 000000000..7e23227b9 --- /dev/null +++ b/src/fs/virtfs/virtfs_unittest.cc @@ -0,0 +1,1421 @@ +/* + * The ManaPlus Client + * Copyright (C) 2016-2017 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program 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 2 of the License, or + * any later version. + * + * This program 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 this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef USE_PHYSFS + +#include "catch.hpp" + +#include "fs/files.h" +#include "fs/virtfs.h" +#include "fs/virtfstools.h" +#include "fs/virtlist.h" + +#include "fs/virtfs/virtdirentry.h" +#include "fs/virtfs/virtfs.h" +#include "fs/virtfs/ziplocalheader.h" + +#include "utils/checkutils.h" +#include "utils/delete2.h" + +#include "debug.h" + +TEST_CASE("VirtFs1 getEntries") +{ + VirtFs::init("."); + REQUIRE(VirtFs::getEntries().empty()); + REQUIRE(VirtFs::searchEntryByRootInternal("test") == nullptr); + VirtFs::deinit(); +} + +TEST_CASE("VirtFs1 getBaseDir") +{ + VirtFs::init("."); + REQUIRE(VirtFs::getBaseDir() != nullptr); + VirtFs::deinit(); +} + +TEST_CASE("VirtFs1 addDirToSearchPath") +{ + VirtFs::init("."); + logger = new Logger(); + SECTION("simple 1") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_false)); + REQUIRE(VirtFs::searchEntryByRootInternal("dir1/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("test/") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir1"); + } + + SECTION("simple 2") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1/", + Append_true)); + REQUIRE(VirtFs::searchEntryByRootInternal("dir1/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("test/") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir1/"); + } + + SECTION("simple 3") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_false)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir2", + Append_false)); + REQUIRE(VirtFs::searchEntryByRootInternal("dir1/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("dir2/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("test/") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == "dir2/"); + REQUIRE(VirtFs::getEntries()[1]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir2"); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[1])->userDir == "dir1"); + } + + SECTION("simple 4") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1\\", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir2", + Append_true)); + REQUIRE(VirtFs::searchEntryByRootInternal("dir1/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("dir2/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("test/") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[1]->root == "dir2/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir1/"); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[1])->userDir == "dir2"); + } + + SECTION("simple 5") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir2", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir3/test", + Append_true)); + REQUIRE(VirtFs::searchEntryByRootInternal("dir1/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("dir2/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("dir3/test/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("test/") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 3); + REQUIRE(VirtFs::getEntries()[0]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[1]->root == "dir2/"); + REQUIRE(VirtFs::getEntries()[2]->root == "dir3/test/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[2]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir1"); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[1])->userDir == "dir2"); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[2])->userDir == "dir3/test"); + } + + SECTION("simple 6") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir2", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir3/test", + Append_false)); + REQUIRE(VirtFs::searchEntryByRootInternal("dir1/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("dir2/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("dir3/test/") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal("test/") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 3); + REQUIRE(VirtFs::getEntries()[0]->root == "dir3/test/"); + REQUIRE(VirtFs::getEntries()[1]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[2]->root == "dir2/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[2]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir3/test"); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[1])->userDir == "dir1"); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[2])->userDir == "dir2"); + } + + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 addZipToSearchPath") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + std::vector<ZipLocalHeader*> headers; + if (Files::existsLocal(name) == false) + prefix = "../"; + + SECTION("simple 1") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_false)); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") == nullptr); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + } + + SECTION("simple 2") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_false)); + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_false)); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Zip); + } + + SECTION("simple 3") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_true)); + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_true)); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Zip); + } + + SECTION("simple 4") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_false)); + REQUIRE(VirtFs::addDirToSearchPath(prefix + "data/test", + Append_false)); + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_false)); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 3); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[2]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[2]->type == FsEntryType::Zip); + } + + SECTION("simple 5") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_false)); + REQUIRE(VirtFs::addDirToSearchPath(prefix + "data/test", + Append_false)); + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_true)); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 3); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[2]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[2]->type == FsEntryType::Zip); + } + + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 removeFromSearchPath") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + std::vector<ZipLocalHeader*> headers; + if (Files::existsLocal(name) == false) + prefix = "../"; + + SECTION("simple 1") + { + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir1")); + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir1/")); + } + + SECTION("simple 2") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_true)); + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir2")); + REQUIRE(VirtFs::removeDirFromSearchPath("dir1")); + } + + SECTION("simple 3") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir2//dir3", + Append_true)); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir3", + Append_false)); + REQUIRE(VirtFs::getEntries().size() == 3); + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir2")); + REQUIRE(VirtFs::removeDirFromSearchPath("dir1")); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == "dir3/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir3"); + REQUIRE(VirtFs::getEntries()[1]->root == "dir2/dir3/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[1])->userDir == "dir2/dir3"); + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir1")); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == "dir3/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir3"); + REQUIRE(VirtFs::getEntries()[1]->root == "dir2/dir3/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[1])->userDir == "dir2/dir3"); + REQUIRE(VirtFs::removeDirFromSearchPath("dir2/dir3")); + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir2/dir3/")); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == "dir3/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir3"); + } + + SECTION("simple 4") + { + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_true)); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir1"); + REQUIRE_THROWS(VirtFs::removeDirFromSearchPath("dir2")); + REQUIRE(VirtFs::removeDirFromSearchPath("dir1")); + REQUIRE(VirtFs::getEntries().size() == 0); + REQUIRE(VirtFs::addDirToSearchPathSilent2("dir1", + Append_true)); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == "dir1/"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Dir); + REQUIRE(static_cast<VirtDirEntry*>( + VirtFs::getEntries()[0])->userDir == "dir1"); + } + + SECTION("simple 5") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_true)); + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_true)); + + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Zip); + + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") == nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 1); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + } + + SECTION("simple 6") + { + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_false)); + REQUIRE(VirtFs::addDirToSearchPath(prefix + "data/test", + Append_false)); + REQUIRE(VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_false)); + + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 3); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + REQUIRE(VirtFs::getEntries()[2]->root == + prefix + "data/test/test.zip"); + REQUIRE(VirtFs::getEntries()[2]->type == FsEntryType::Zip); + + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test.zip") == nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/test2.zip") != nullptr); + REQUIRE(VirtFs::searchEntryByRootInternal( + prefix + "data/test/") != nullptr); + REQUIRE(VirtFs::getEntries().size() == 2); + REQUIRE(VirtFs::getEntries()[0]->root == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getEntries()[0]->type == FsEntryType::Zip); + REQUIRE(VirtFs::getEntries()[1]->root == + prefix + "data/test/"); + REQUIRE(VirtFs::getEntries()[1]->type == FsEntryType::Dir); + } + + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 exists") +{ + VirtFs::init("."); + logger = new Logger(); + const bool dir1 = VirtFs::addDirToSearchPathSilent("data/", + Append_false); + VirtFs::addDirToSearchPathSilent("..\\data", + Append_false); + + REQUIRE(VirtFs::exists("test")); + REQUIRE(VirtFs::exists("test/")); + REQUIRE(VirtFs::exists("test/dir1")); + REQUIRE(VirtFs::exists("test/dir1/")); + REQUIRE(VirtFs::exists("test/dir") == false); + REQUIRE(VirtFs::exists("test//units.xml") == true); + REQUIRE(VirtFs::exists("test/\\units123.xml") == false); + REQUIRE(VirtFs::exists("tesQ/units.xml") == false); + REQUIRE(VirtFs::exists("units.xml") == false); + + if (dir1 == true) + { + VirtFs::addDirToSearchPath("data//test", + Append_false); + } + else + { + VirtFs::addDirToSearchPathSilent("..//data\\test", + Append_false); + } + + REQUIRE(VirtFs::exists("test") == true); + REQUIRE(VirtFs::exists("test/dir1")); + REQUIRE(VirtFs::exists("test/dir1\\")); + REQUIRE(VirtFs::exists("test/dir") == false); + REQUIRE(VirtFs::exists("test\\units.xml") == true); + REQUIRE(VirtFs::exists("test/units123.xml") == false); + REQUIRE(VirtFs::exists("tesQ/units.xml") == false); + REQUIRE(VirtFs::exists("units.xml") == true); + REQUIRE(VirtFs::exists("units.xml/") == false); + + if (dir1 == true) + VirtFs::removeDirFromSearchPathSilent("data/test"); + else + VirtFs::removeDirFromSearchPathSilent("../data/test"); + + REQUIRE(VirtFs::exists("test") == true); + REQUIRE(VirtFs::exists("test/dir1")); + REQUIRE(VirtFs::exists("test/dir") == false); + REQUIRE(VirtFs::exists("test\\units.xml") == true); + REQUIRE(VirtFs::exists("test/units123.xml") == false); + REQUIRE(VirtFs::exists("tesQ/units.xml") == false); + REQUIRE(VirtFs::exists("units.xml") == false); + REQUIRE(VirtFs::exists("units.xml/") == false); + + REQUIRE_THROWS(VirtFs::exists("test/../units.xml")); + + VirtFs::deinit(); + delete2(logger); +} + +static void removeTemp(StringVect &restrict list) +{ + int cnt = 0; + std::sort(list.begin(), list.end()); + + FOR_EACH (StringVectIter, it, list) + { + if (*it != "serverlistplus.xml.part") + { + logger->log("file: %d %s", + cnt, + (*it).c_str()); + cnt ++; + } + } + + FOR_EACH (StringVectIter, it, list) + { + if (*it == "serverlistplus.xml.part") + { + list.erase(it); + return; + } + } +} + +TEST_CASE("VirtFs1 getRealDir1") +{ + VirtFs::init("."); + logger = new Logger(); + REQUIRE(VirtFs::getRealDir(".") == ""); + REQUIRE(VirtFs::getRealDir("..") == ""); + const bool dir1 = VirtFs::addDirToSearchPathSilent("data", + Append_false); + REQUIRE((dir1 || VirtFs::addDirToSearchPathSilent("../data", + Append_false)) == true); + if (dir1 == true) + { + REQUIRE(VirtFs::getRealDir("test") == "data"); + REQUIRE(VirtFs::getRealDir("test/test.txt") == + "data"); + REQUIRE(VirtFs::getRealDir("test\\test.txt") == + "data"); + REQUIRE(VirtFs::getRealDir("test//test.txt") == + "data"); + } + else + { + REQUIRE(VirtFs::getRealDir("test") == "../data"); + REQUIRE(VirtFs::getRealDir("test/test.txt") == + "../data"); + REQUIRE(VirtFs::getRealDir("test\\test.txt") == + "../data"); + REQUIRE(VirtFs::getRealDir("test//test.txt") == + "../data"); + } + REQUIRE(VirtFs::getRealDir("zzz") == ""); + + VirtFs::addDirToSearchPathSilent("data/test", + Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", + Append_false); + if (dir1 == true) + { + REQUIRE(VirtFs::getRealDir("test") == "data"); + REQUIRE(VirtFs::getRealDir("test/test.txt") == + "data"); + REQUIRE(VirtFs::getRealDir("test\\test.txt") == + "data"); + REQUIRE(VirtFs::getRealDir("test.txt") == + "data/test"); + } + else + { + REQUIRE(VirtFs::getRealDir("test") == "../data"); + REQUIRE(VirtFs::getRealDir("test/test.txt") == + "../data"); + REQUIRE(VirtFs::getRealDir("test\\test.txt") == + "../data"); + REQUIRE(VirtFs::getRealDir("test.txt") == + "../data/test"); + } + REQUIRE(VirtFs::getRealDir("zzz") == ""); + + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); + + if (dir1 == true) + { + REQUIRE(VirtFs::getRealDir("test") == "data"); + REQUIRE(VirtFs::getRealDir("test/test.txt") == + "data"); + } + else + { + REQUIRE(VirtFs::getRealDir("test") == "../data"); + REQUIRE(VirtFs::getRealDir("test/test.txt") == + "../data"); + } + REQUIRE(VirtFs::getRealDir("zzz") == ""); + + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 getRealDir2") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix("data/test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + VirtFs::addZipToSearchPath(prefix + "test2.zip", + Append_false); + + REQUIRE(VirtFs::getRealDir(".") == ""); + REQUIRE(VirtFs::getRealDir("..") == ""); + REQUIRE(VirtFs::getRealDir("test.txt") == prefix + "test2.zip"); + REQUIRE(VirtFs::getRealDir("dir/1") == prefix + "test2.zip"); + REQUIRE(VirtFs::getRealDir("dir\\dye.png") == + prefix + "test2.zip"); + REQUIRE(VirtFs::getRealDir("zzz") == ""); + + VirtFs::addZipToSearchPath(prefix + "test.zip", + Append_false); + REQUIRE(VirtFs::getRealDir("dir//dye.png") == + prefix + "test2.zip"); + REQUIRE(VirtFs::getRealDir("dir///hide.png") == + prefix + "test.zip"); + REQUIRE(VirtFs::getRealDir("dir\\\\brimmedhat.png") == + prefix + "test.zip"); + REQUIRE(VirtFs::getRealDir("zzz") == ""); + + VirtFs::removeZipFromSearchPath(prefix + "test.zip"); + + REQUIRE(VirtFs::getRealDir("dir/brimmedhat.png") == ""); + REQUIRE(VirtFs::getRealDir("test.txt") == prefix + "test2.zip"); + REQUIRE(VirtFs::getRealDir("dir//dye.png") == + prefix + "test2.zip"); + REQUIRE(VirtFs::getRealDir("zzz") == ""); + + VirtFs::removeZipFromSearchPath(prefix + "test2.zip"); + VirtFs::deinit(); + delete2(logger); +} + +static bool inList(VirtList *list, + const std::string &name) +{ + FOR_EACH (StringVectCIter, it, list->names) + { + if (*it == name) + return true; + } + return false; +} + +TEST_CASE("VirtFs1 enumerateFiles1") +{ + VirtFs::init("."); + logger = new Logger; + + VirtFs::addDirToSearchPathSilent("data", + Append_false); + VirtFs::addDirToSearchPathSilent("../data", + Append_false); + + VirtList *list = nullptr; + + const int cnt1 = VirtFs::exists("test/test2.txt") ? 28 : 27; + const int cnt2 = 28; + + VirtFs::permitLinks(false); + list = VirtFs::enumerateFiles("test"); + removeTemp(list->names); + const size_t sz = list->names.size(); + REQUIRE(sz == cnt1); + VirtFs::freeList(list); + + VirtFs::permitLinks(true); + list = VirtFs::enumerateFiles("test/"); + removeTemp(list->names); + REQUIRE(list->names.size() == cnt2); + VirtFs::freeList(list); + + VirtFs::permitLinks(true); + list = VirtFs::enumerateFiles("test/units.xml"); + REQUIRE(list->names.size() == 0); + VirtFs::freeList(list); + + VirtFs::permitLinks(false); + list = VirtFs::enumerateFiles("test\\"); + removeTemp(list->names); + REQUIRE(list->names.size() == cnt1); + VirtFs::freeList(list); + + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 enumerateFiles2") +{ + VirtFs::init("."); + logger = new Logger; + + VirtFs::addDirToSearchPathSilent("data/test/dir1", + Append_false); + VirtFs::addDirToSearchPathSilent("../data/test/dir1", + Append_false); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("/"); + const size_t sz = list->names.size(); + REQUIRE(list->names.size() == 5); + REQUIRE(inList(list, "file1.txt")); + REQUIRE_FALSE(inList(list, "file2.txt")); + VirtFs::freeList(list); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 enumerateFiles3") +{ + VirtFs::init("."); + logger = new Logger; + + VirtFs::addDirToSearchPathSilent("data/test/dir1", + Append_false); + VirtFs::addDirToSearchPathSilent("../data/test/dir1", + Append_false); + VirtFs::addDirToSearchPathSilent("data/test/dir2", + Append_false); + VirtFs::addDirToSearchPathSilent("../data/test/dir2", + Append_false); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("/"); + const size_t sz = list->names.size(); + REQUIRE(list->names.size() == 6); + REQUIRE(inList(list, "file1.txt")); + REQUIRE(inList(list, "file2.txt")); + VirtFs::freeList(list); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFsZip enumerateFiles4") +{ + VirtFs::init("."); + logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix("data\\test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "test.zip", + Append_false); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("dir"); + REQUIRE(list->names.size() == 2); + REQUIRE(inList(list, "brimmedhat.png")); + REQUIRE(inList(list, "hide.png")); + VirtFs::freeList(list); + + VirtFs::removeZipFromSearchPath(prefix + "test.zip"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFsZip enumerateFiles5") +{ + VirtFs::init("."); + logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix("data//test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "test.zip", + Append_true); + VirtFs::addZipToSearchPath(prefix + "test2.zip", + Append_true); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("dir"); + FOR_EACH (StringVectCIter, it, list->names) + { + logger->log("filename: " + *it); + } + + REQUIRE(list->names.size() == 5); + REQUIRE(inList(list, "brimmedhat.png")); + REQUIRE(inList(list, "hide.png")); + REQUIRE(inList(list, "1")); + REQUIRE(inList(list, "gpl")); + REQUIRE(inList(list, "dye.png")); + VirtFs::freeList(list); + + VirtFs::removeZipFromSearchPath(prefix + "test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "test2.zip"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFsZip enumerateFiles6") +{ + VirtFs::init("."); + logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix("data\\test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "test.zip", + Append_false); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("/"); + REQUIRE(list->names.size() == 1); + REQUIRE(inList(list, "dir")); + VirtFs::freeList(list); + + VirtFs::removeZipFromSearchPath(prefix + "test.zip"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFsZip enumerateFiles7") +{ + VirtFs::init("."); + logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix("data\\test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "test2.zip", + Append_false); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("/"); + REQUIRE(list->names.size() == 4); + REQUIRE(inList(list, "dir")); + REQUIRE(inList(list, "dir2")); + REQUIRE(inList(list, "test.txt")); + REQUIRE(inList(list, "units.xml")); + VirtFs::freeList(list); + + VirtFs::removeZipFromSearchPath(prefix + "test2.zip"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFsZip enumerateFiles8") +{ + VirtFs::init("."); + logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_false); + VirtFs::addDirToSearchPathSilent(prefix + "data/test", + Append_false); + + VirtList *list = nullptr; + + list = VirtFs::enumerateFiles("dir2"); + REQUIRE(list->names.size() >= 6); + REQUIRE(inList(list, "file1.txt")); + REQUIRE(inList(list, "file2.txt")); + REQUIRE(inList(list, "hide.png")); + REQUIRE(inList(list, "paths.xml")); + REQUIRE(inList(list, "test.txt")); + REQUIRE(inList(list, "units.xml")); + VirtFs::freeList(list); + + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data/test"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 isDirectory1") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPath(prefix + "data", + Append_false); + + REQUIRE(VirtFs::isDirectory("test/units.xml") == false); + REQUIRE(VirtFs::isDirectory("test/units.xml/") == false); + REQUIRE(VirtFs::isDirectory("test//units.xml") == false); + REQUIRE(VirtFs::isDirectory("test/units123.xml") == false); + REQUIRE(VirtFs::isDirectory("test//units123.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ/units.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ//units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml") == false); + REQUIRE(VirtFs::isDirectory("test") == true); + REQUIRE(VirtFs::isDirectory("test/") == true); + REQUIRE(VirtFs::isDirectory("test//") == true); + REQUIRE(VirtFs::isDirectory("test/dir1") == true); + REQUIRE(VirtFs::isDirectory("test//dir1") == true); + REQUIRE(VirtFs::isDirectory("test//dir1/") == true); + REQUIRE(VirtFs::isDirectory("test//dir1//") == true); + REQUIRE(VirtFs::isDirectory("test\\dir1/") == true); + REQUIRE(VirtFs::isDirectory("test/dir1//") == true); + REQUIRE(VirtFs::isDirectory("testQ") == false); + REQUIRE(VirtFs::isDirectory("testQ/") == false); + REQUIRE(VirtFs::isDirectory("testQ//") == false); + + VirtFs::addDirToSearchPath(prefix + "data/test", + Append_false); + + REQUIRE(VirtFs::isDirectory("test/units.xml") == false); + REQUIRE(VirtFs::isDirectory("test/units.xml/") == false); + REQUIRE(VirtFs::isDirectory("test//units.xml") == false); + REQUIRE(VirtFs::isDirectory("test/units123.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ/units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml") == false); + REQUIRE(VirtFs::isDirectory("test") == true); + REQUIRE(VirtFs::isDirectory("testQ") == false); + REQUIRE(VirtFs::isDirectory("test/dir1") == true); + REQUIRE(VirtFs::isDirectory("test\\dir1") == true); + + VirtFs::removeDirFromSearchPath(prefix + "data/test"); + + REQUIRE(VirtFs::isDirectory("test/units.xml") == false); + REQUIRE(VirtFs::isDirectory("test/units123.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ/units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml/") == false); + REQUIRE(VirtFs::isDirectory("test") == true); + REQUIRE(VirtFs::isDirectory("test/") == true); + REQUIRE(VirtFs::isDirectory("testQ") == false); + REQUIRE(VirtFs::isDirectory("test/dir1") == true); + + VirtFs::removeDirFromSearchPathSilent(prefix + "data"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 isDirectory2") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", + Append_false); + + REQUIRE(VirtFs::isDirectory("dir2/units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2/units.xml/") == false); + REQUIRE(VirtFs::isDirectory("dir2//units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2/units123.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2//units123.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ/units.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ//units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir") == true); + REQUIRE(VirtFs::isDirectory("dir2/") == true); + REQUIRE(VirtFs::isDirectory("dir2//") == true); + REQUIRE(VirtFs::isDirectory("dir/1") == true); + REQUIRE(VirtFs::isDirectory("dir//1") == true); + REQUIRE(VirtFs::isDirectory("dir\\1/") == true); + REQUIRE(VirtFs::isDirectory("dir/1") == true); + REQUIRE(VirtFs::isDirectory("dir/1/zzz") == false); + REQUIRE(VirtFs::isDirectory("test/dir1\\") == false); + REQUIRE(VirtFs::isDirectory("testQ") == false); + REQUIRE(VirtFs::isDirectory("testQ/") == false); + REQUIRE(VirtFs::isDirectory("testQ//") == false); + + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", + Append_false); + + REQUIRE(VirtFs::isDirectory("dir2/units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2/units.xml/") == false); + REQUIRE(VirtFs::isDirectory("dir2\\units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2/units123.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2//units123.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ/units.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ//units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir") == true); + REQUIRE(VirtFs::isDirectory("dir2/") == true); + REQUIRE(VirtFs::isDirectory("dir2\\") == true); + REQUIRE(VirtFs::isDirectory("dir/1") == true); + REQUIRE(VirtFs::isDirectory("dir//1") == true); + REQUIRE(VirtFs::isDirectory("dir//1/") == true); + REQUIRE(VirtFs::isDirectory("dir/1") == true); + REQUIRE(VirtFs::isDirectory("dir/1/zzz") == false); + REQUIRE(VirtFs::isDirectory("test/dir1//") == false); + REQUIRE(VirtFs::isDirectory("testQ") == false); + REQUIRE(VirtFs::isDirectory("testQ/") == false); + REQUIRE(VirtFs::isDirectory("testQ//") == false); + + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + + REQUIRE(VirtFs::isDirectory("dir2/units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2/units.xml/") == false); + REQUIRE(VirtFs::isDirectory("dir2//units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2/units123.xml") == false); + REQUIRE(VirtFs::isDirectory("dir2//units123.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ/units.xml") == false); + REQUIRE(VirtFs::isDirectory("tesQ//units.xml") == false); + REQUIRE(VirtFs::isDirectory("units.xml") == false); + REQUIRE(VirtFs::isDirectory("dir") == true); + REQUIRE(VirtFs::isDirectory("dir2/") == false); + REQUIRE(VirtFs::isDirectory("dir2//") == false); + REQUIRE(VirtFs::isDirectory("dir/1") == false); + REQUIRE(VirtFs::isDirectory("dir\\1") == false); + REQUIRE(VirtFs::isDirectory("dir//1/") == false); + REQUIRE(VirtFs::isDirectory("dir/1") == false); + REQUIRE(VirtFs::isDirectory("dir/1/zzz") == false); + REQUIRE(VirtFs::isDirectory("test/dir1//") == false); + REQUIRE(VirtFs::isDirectory("testQ") == false); + REQUIRE(VirtFs::isDirectory("testQ/") == false); + REQUIRE(VirtFs::isDirectory("testQ//") == false); + + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 openRead1") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPath(prefix + "data", + Append_false); + + VirtFile *file = nullptr; + + file = VirtFs::openRead("test/units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("test\\units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("test/units123.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("tesQ/units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("testQ"); + REQUIRE(file == nullptr); + + VirtFs::addDirToSearchPath(prefix + "data/test", + Append_false); + + file = VirtFs::openRead("test/units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("test/units123.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("tesQ/units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("testQ"); + REQUIRE(file == nullptr); + + VirtFs::removeDirFromSearchPath(prefix + "data/test"); + + file = VirtFs::openRead("test/units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("test/units123.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("tesQ/units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("testQ"); + REQUIRE(file == nullptr); + + VirtFs::removeDirFromSearchPath(prefix + "data"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 openRead2") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix("data/test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "test2.zip", + Append_false); + + VirtFile *file = nullptr; + + file = VirtFs::openRead("dir2/units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("dir2\\units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("dir2/units123.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("tesQ/units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("units.xml1"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("testQ"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("dir/brimmedhat.png"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("dir//brimmedhat.png"); + REQUIRE(file == nullptr); + + VirtFs::addZipToSearchPath(prefix + "test.zip", + Append_false); + + file = VirtFs::openRead("dir2/units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("dir2//units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("dir2/units123.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("tesQ/units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("units.xml1"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("testQ"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("dir/brimmedhat.png"); + REQUIRE(file != nullptr); + VirtFs::close(file); + + VirtFs::removeZipFromSearchPath(prefix + "test.zip"); + + file = VirtFs::openRead("dir2/units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("dir2\\/\\units.xml"); + REQUIRE(file != nullptr); + VirtFs::close(file); + file = VirtFs::openRead("dir2/units123.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("tesQ/units.xml"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("units.xml1"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("testQ"); + REQUIRE(file == nullptr); + file = VirtFs::openRead("dir/brimmedhat.png"); + REQUIRE(file == nullptr); + + VirtFs::removeZipFromSearchPath(prefix + "test2.zip"); + + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 permitLinks") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPath(prefix + "data", + Append_false); + + const int cnt1 = VirtFs::exists("test/test2.txt") ? 26 : 25; + const int cnt2 = 26; + + StringVect list; + VirtFs::permitLinks(false); + VirtFs::getFiles("test", list); + removeTemp(list); + const size_t sz = list.size(); + REQUIRE(sz == cnt1); + + list.clear(); + VirtFs::permitLinks(true); + VirtFs::getFiles("test", list); + removeTemp(list); + REQUIRE(list.size() == cnt2); + + list.clear(); + VirtFs::permitLinks(false); + VirtFs::getFiles("test", list); + removeTemp(list); + REQUIRE(list.size() == cnt1); + + VirtFs::removeDirFromSearchPathSilent(prefix + "data"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 read1") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPath(prefix + "data", + Append_false); + + VirtFile *file = VirtFs::openRead("test/test.txt"); + REQUIRE(file != nullptr); + REQUIRE(VirtFs::fileLength(file) == 23); + const int fileSize = VirtFs::fileLength(file); + + void *restrict buffer = calloc(fileSize + 1, 1); + REQUIRE(VirtFs::read(file, buffer, 1, fileSize) == fileSize); + REQUIRE(strcmp(static_cast<char*>(buffer), + "test line 1\ntest line 2") == 0); + REQUIRE(VirtFs::tell(file) == fileSize); + REQUIRE(VirtFs::eof(file) == true); + + free(buffer); + buffer = calloc(fileSize + 1, 1); + REQUIRE(VirtFs::seek(file, 12) != 0); + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == 12); + REQUIRE(VirtFs::read(file, buffer, 1, 11) == 11); + REQUIRE(strcmp(static_cast<char*>(buffer), + "test line 2") == 0); + REQUIRE(VirtFs::eof(file) == true); + + VirtFs::close(file); + free(buffer); + + VirtFs::removeDirFromSearchPath(prefix + "data"); + VirtFs::deinit(); + delete2(logger); +} + +TEST_CASE("VirtFs1 read2") +{ + VirtFs::init("."); + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix("data/test/"); + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "test2.zip", + Append_false); + VirtFile *file = nullptr; + void *restrict buffer = nullptr; + + SECTION("test 1") + { + file = VirtFs::openRead("dir2//test.txt"); + REQUIRE(file != nullptr); + REQUIRE(VirtFs::fileLength(file) == 23); + const int fileSize = VirtFs::fileLength(file); + + buffer = calloc(fileSize + 1, 1); + REQUIRE(VirtFs::read(file, buffer, 1, fileSize) == fileSize); + REQUIRE(strcmp(static_cast<char*>(buffer), + "test line 1\ntest line 2") == 0); + REQUIRE(VirtFs::tell(file) == fileSize); + REQUIRE(VirtFs::eof(file) == true); + } + + SECTION("test 2") + { + file = VirtFs::openRead("dir2\\/test.txt"); + REQUIRE(file != nullptr); + REQUIRE(VirtFs::fileLength(file) == 23); + const int fileSize = VirtFs::fileLength(file); + + buffer = calloc(fileSize + 1, 1); + REQUIRE(VirtFs::seek(file, 12) != 0); + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == 12); + REQUIRE(VirtFs::read(file, buffer, 1, 11) == 11); + REQUIRE(strcmp(static_cast<char*>(buffer), + "test line 2") == 0); + REQUIRE(VirtFs::eof(file) == true); + } + + SECTION("test 3") + { + file = VirtFs::openRead("dir2//test.txt"); + REQUIRE(file != nullptr); + const int fileSize = VirtFs::fileLength(file); + + buffer = calloc(fileSize + 1, 1); + for (int f = 0; f < fileSize; f ++) + { + REQUIRE(VirtFs::seek(file, f) != 0); + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == f); + } + } + + SECTION("test 4") + { + file = VirtFs::openRead("dir2/test.txt"); + REQUIRE(file != nullptr); + const int fileSize = VirtFs::fileLength(file); + const char *restrict const str = "test line 1\ntest line 2"; + buffer = calloc(fileSize + 1, 1); + for (int f = 0; f < fileSize - 1; f ++) + { + REQUIRE(VirtFs::read(file, buffer, 1, 1) == 1); + REQUIRE(static_cast<char*>(buffer)[0] == str[f]); + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == f + 1); + } + REQUIRE(VirtFs::read(file, buffer, 1, 1) == 1); + REQUIRE(static_cast<char*>(buffer)[0] == str[22]); + REQUIRE(VirtFs::eof(file) == true); + REQUIRE(VirtFs::tell(file) == fileSize); + } + + SECTION("test 5") + { + file = VirtFs::openRead("dir2\\\\test.txt"); + REQUIRE(file != nullptr); + const int fileSize = VirtFs::fileLength(file); + const char *restrict const str = "test line 1\ntest line 2"; + buffer = calloc(fileSize + 1, 1); + for (int f = 0; f < fileSize - 1; f += 2) + { + REQUIRE(VirtFs::read(file, buffer, 2, 1) == 1); + REQUIRE(static_cast<char*>(buffer)[0] == str[f]); + REQUIRE(static_cast<char*>(buffer)[1] == str[f + 1]); + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == f + 2); + } + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == 22); + REQUIRE(VirtFs::read(file, buffer, 2, 1) == 0); + REQUIRE(VirtFs::eof(file) == false); + } + + SECTION("test 6") + { + file = VirtFs::openRead("dir2//test.txt"); + REQUIRE(file != nullptr); + const int fileSize = VirtFs::fileLength(file); + const char *restrict const str = "test line 1\ntest line 2"; + buffer = calloc(fileSize + 1, 1); + for (int f = 0; f < fileSize - 1; f += 2) + { + REQUIRE(VirtFs::read(file, buffer, 1, 2) == 2); + REQUIRE(static_cast<char*>(buffer)[0] == str[f]); + REQUIRE(static_cast<char*>(buffer)[1] == str[f + 1]); + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == f + 2); + } + REQUIRE(VirtFs::eof(file) == false); + REQUIRE(VirtFs::tell(file) == 22); + REQUIRE(VirtFs::read(file, buffer, 1, 2) == 1); + REQUIRE(static_cast<char*>(buffer)[0] == str[22]); + REQUIRE(VirtFs::eof(file) == true); + } + + VirtFs::close(file); + free(buffer); + VirtFs::removeZipFromSearchPath(prefix + "test2.zip"); + VirtFs::deinit(); + delete2(logger); +} + +#endif // USE_PHYSFS diff --git a/src/fs/virtfs/virtfsdir.cpp b/src/fs/virtfs/virtfsdir.cpp index a269d7bec..38c0c1559 100644 --- a/src/fs/virtfs/virtfsdir.cpp +++ b/src/fs/virtfs/virtfsdir.cpp @@ -94,6 +94,46 @@ namespace VirtFsDir } } // namespace + VirtFile *openInternal(VirtFsEntry *restrict const entry, + const std::string &filename, + const int mode) + { + const std::string path = entry->root + filename; + if (Files::existsLocal(path) == false) + return nullptr; + const int fd = open(path.c_str(), + mode, + S_IRUSR | S_IWUSR); + if (fd == -1) + { + reportAlways("VirtFs::open file open error: %s", + filename.c_str()); + return nullptr; + } + VirtFile *restrict const file = new VirtFile(&funcs); + file->mPrivate = new VirtFilePrivate(fd); + + return file; + } + + VirtFile *openRead(VirtFsEntry *restrict const entry, + const std::string &filename) + { + return openInternal(entry, filename, O_RDONLY); + } + + VirtFile *openWrite(VirtFsEntry *restrict const entry, + const std::string &filename) + { + return openInternal(entry, filename, O_WRONLY | O_CREAT | O_TRUNC); + } + + VirtFile *openAppend(VirtFsEntry *restrict const entry, + const std::string &filename) + { + return openInternal(entry, filename, O_WRONLY | O_CREAT | O_APPEND); + } + VirtFile *openReadDirEntry(VirtDirEntry *const entry, const std::string &filename) { @@ -165,13 +205,15 @@ namespace VirtFsDir if (append == Append_true) { mEntries.push_back(new VirtDirEntry(newDir, - rootDir)); + rootDir, + &funcs)); } else { mEntries.insert(mEntries.begin(), new VirtDirEntry(newDir, - rootDir)); + rootDir, + &funcs)); } return true; } @@ -205,13 +247,15 @@ namespace VirtFsDir if (append == Append_true) { mEntries.push_back(new VirtDirEntry(newDir, - rootDir)); + rootDir, + &funcs)); } else { mEntries.insert(mEntries.begin(), new VirtDirEntry(newDir, - rootDir)); + rootDir, + &funcs)); } return true; } @@ -311,6 +355,18 @@ namespace VirtFsDir ptr->tell = &VirtFsDir::tell; ptr->seek = &VirtFsDir::seek; ptr->eof = &VirtFsDir::eof; + ptr->exists = &VirtFsDir::exists; + ptr->getRealDir = &VirtFsDir::getRealDir; + ptr->enumerate = &VirtFsDir::enumerate; + ptr->isDirectory = &VirtFsDir::isDirectory; + ptr->openRead = &VirtFsDir::openRead; + ptr->openWrite = &VirtFsDir::openWrite; + ptr->openAppend = &VirtFsDir::openAppend; + } + + VirtFsFuncs *getFuncs() + { + return &funcs; } const char *getBaseDir() @@ -337,11 +393,26 @@ namespace VirtFsDir VirtDirEntry *const entry = *it; const std::string path = entry->root + filename; if (Files::existsLocal(path)) - return entry->mUserDir; + return entry->userDir; } return std::string(); } + bool getRealDir(VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName A_UNUSED, + std::string &realDir) + { + VirtDirEntry *const dirEntry = static_cast<VirtDirEntry*>(entry); + const std::string path = dirEntry->root + filename; + if (Files::existsLocal(dirEntry->root + filename)) + { + realDir = dirEntry->userDir; + return true; + } + return false; + } + bool exists(std::string name) { prepareFsPath(name); @@ -360,6 +431,13 @@ namespace VirtFsDir return false; } + bool exists(VirtFsEntry *restrict const entry, + const std::string &fileName, + const std::string &dirName A_UNUSED) + { + return Files::existsLocal(entry->root + fileName); + } + VirtList *enumerateFiles(std::string dirName) { VirtList *const list = new VirtList; @@ -373,6 +451,45 @@ namespace VirtFsDir return enumerateFiles(dirName, list); } + void enumerate(VirtFsEntry *restrict const entry, + const std::string &dirName, + StringVect &names) + { + const std::string path = entry->root + dirName; + const struct dirent *next_file = nullptr; + DIR *const dir = opendir(path.c_str()); + if (dir) + { + while ((next_file = readdir(dir))) + { + const std::string file = next_file->d_name; + if (file == "." || file == "..") + continue; + if (mPermitLinks == false) + { + struct stat statbuf; + if (lstat(path.c_str(), &statbuf) == 0 && + S_ISLNK(statbuf.st_mode) != 0) + { + continue; + } + } + bool found(false); + FOR_EACH (StringVectCIter, itn, names) + { + if (*itn == file) + { + found = true; + break; + } + } + if (found == false) + names.push_back(file); + } + closedir(dir); + } + } + VirtList *enumerateFiles(const std::string &restrict dirName, VirtList *restrict const list) { @@ -420,16 +537,19 @@ namespace VirtFsDir return list; } - bool isDirectory(std::string dirName) + bool isDirectory(VirtFsEntry *restrict const entry, + const std::string &dirName, + bool &isDirFlag) { - prepareFsPath(dirName); - if (checkPath(dirName) == false) + std::string path = entry->root + dirName; + + struct stat statbuf; + if (stat(path.c_str(), &statbuf) == 0) { - reportAlways("VirtFsDir::isDirectory invalid path: %s", - dirName.c_str()); - return false; + isDirFlag = (S_ISDIR(statbuf.st_mode) != 0); + return true; } - return isDirectoryInternal(dirName); + return false; } bool isDirectoryInternal(const std::string &restrict dirName) diff --git a/src/fs/virtfs/virtfsdir.h b/src/fs/virtfs/virtfsdir.h index 6ae3ec9f1..069c20c8d 100644 --- a/src/fs/virtfs/virtfsdir.h +++ b/src/fs/virtfs/virtfsdir.h @@ -25,13 +25,13 @@ #include "enums/simpletypes/append.h" #include "enums/simpletypes/skiperror.h" -#include "localconsts.h" +#include "utils/stringvector.h" -#include <vector> -#include <string> +#include "localconsts.h" struct VirtDirEntry; struct VirtFile; +struct VirtFsEntry; struct VirtFsFuncs; struct VirtList; @@ -39,10 +39,17 @@ namespace VirtFsDir { VirtDirEntry *searchEntryByRoot(const std::string &restrict root); VirtDirEntry *searchEntryByPath(const std::string &restrict path); + VirtFile *openRead(VirtFsEntry *restrict const entry, + const std::string &filename); + VirtFile *openWrite(VirtFsEntry *restrict const entry, + const std::string &filename); + VirtFile *openAppend(VirtFsEntry *restrict const entry, + const std::string &filename); VirtFile *openReadDirEntry(VirtDirEntry *const entry, const std::string &filename); const char *getBaseDir(); const char *getUserDir(); + VirtFsFuncs *getFuncs(); bool addToSearchPath(std::string newDir, const Append append); bool addToSearchPathSilent(std::string newDir, @@ -55,10 +62,18 @@ namespace VirtFsDir void deinit(); std::vector<VirtDirEntry*> &getEntries(); bool exists(std::string name); + bool exists(VirtFsEntry *restrict const entry, + const std::string &fileName, + const std::string &dirName); + void enumerate(VirtFsEntry *restrict const entry, + const std::string &dirName, + StringVect &names); VirtList *enumerateFiles(std::string dirName) RETURNS_NONNULL; VirtList *enumerateFiles(const std::string &restrict dirName, VirtList *restrict const list) RETURNS_NONNULL; - bool isDirectory(std::string dirName); + bool isDirectory(VirtFsEntry *restrict const entry, + const std::string &dirName, + bool &isDirFlag); bool isDirectoryInternal(const std::string &restrict dirName); bool isSymbolicLink(std::string name); void freeList(VirtList *restrict const handle); @@ -67,6 +82,10 @@ namespace VirtFsDir VirtFile *openAppend(const std::string &restrict filename); bool setWriteDir(std::string newDir); std::string getRealDir(std::string filename); + bool getRealDir(VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName, + std::string &realDir); bool mkdir(std::string dirName); bool remove(std::string filename); void permitLinks(const bool val); diff --git a/src/fs/virtfs/virtfsdir_unittest.cc b/src/fs/virtfs/virtfsdir_unittest.cc index f195b10bd..8986ccdc5 100644 --- a/src/fs/virtfs/virtfsdir_unittest.cc +++ b/src/fs/virtfs/virtfsdir_unittest.cc @@ -31,7 +31,7 @@ #include "utils/delete2.h" #include "debug.h" - +/* TEST_CASE("VirtFsDir getEntries") { VirtFsDir::init("."); @@ -60,7 +60,7 @@ TEST_CASE("VirtFsDir addToSearchPath") REQUIRE(VirtFsDir::searchEntryByRoot("test/") == nullptr); REQUIRE(VirtFsDir::getEntries().size() == 1); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir1"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir1"); } SECTION("simple 2") @@ -72,7 +72,7 @@ TEST_CASE("VirtFsDir addToSearchPath") REQUIRE(VirtFsDir::searchEntryByRoot("test/") == nullptr); REQUIRE(VirtFsDir::getEntries().size() == 1); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir1/"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir1/"); } SECTION("simple 3") @@ -89,8 +89,8 @@ TEST_CASE("VirtFsDir addToSearchPath") REQUIRE(VirtFsDir::getEntries().size() == 2); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir2/"); REQUIRE(VirtFsDir::getEntries()[1]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir2"); - REQUIRE(VirtFsDir::getEntries()[1]->mUserDir == "dir1"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir2"); + REQUIRE(VirtFsDir::getEntries()[1]->userDir == "dir1"); } SECTION("simple 4") @@ -107,8 +107,8 @@ TEST_CASE("VirtFsDir addToSearchPath") REQUIRE(VirtFsDir::getEntries().size() == 2); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir1/"); REQUIRE(VirtFsDir::getEntries()[1]->root == "dir2/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[1]->mUserDir == "dir2"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir1/"); + REQUIRE(VirtFsDir::getEntries()[1]->userDir == "dir2"); } SECTION("simple 5") @@ -128,11 +128,11 @@ TEST_CASE("VirtFsDir addToSearchPath") REQUIRE(VirtFsDir::searchEntryByRoot("test/") == nullptr); REQUIRE(VirtFsDir::getEntries().size() == 3); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir1"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir1"); REQUIRE(VirtFsDir::getEntries()[1]->root == "dir2/"); - REQUIRE(VirtFsDir::getEntries()[1]->mUserDir == "dir2"); + REQUIRE(VirtFsDir::getEntries()[1]->userDir == "dir2"); REQUIRE(VirtFsDir::getEntries()[2]->root == "dir3/test/"); - REQUIRE(VirtFsDir::getEntries()[2]->mUserDir == "dir3/test"); + REQUIRE(VirtFsDir::getEntries()[2]->userDir == "dir3/test"); } SECTION("simple 6") @@ -152,11 +152,11 @@ TEST_CASE("VirtFsDir addToSearchPath") REQUIRE(VirtFsDir::searchEntryByRoot("test/") == nullptr); REQUIRE(VirtFsDir::getEntries().size() == 3); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir3/test/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir3/test"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir3/test"); REQUIRE(VirtFsDir::getEntries()[1]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[1]->mUserDir == "dir1"); + REQUIRE(VirtFsDir::getEntries()[1]->userDir == "dir1"); REQUIRE(VirtFsDir::getEntries()[2]->root == "dir2/"); - REQUIRE(VirtFsDir::getEntries()[2]->mUserDir == "dir2"); + REQUIRE(VirtFsDir::getEntries()[2]->userDir == "dir2"); } VirtFsDir::deinit(); @@ -199,20 +199,20 @@ TEST_CASE("VirtFsDir removeFromSearchPath") REQUIRE(VirtFsDir::removeFromSearchPath("dir1")); REQUIRE(VirtFsDir::getEntries().size() == 2); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir3/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir3"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir3"); REQUIRE(VirtFsDir::getEntries()[1]->root == "dir2/dir3/"); - REQUIRE(VirtFsDir::getEntries()[1]->mUserDir == "dir2/dir3"); + REQUIRE(VirtFsDir::getEntries()[1]->userDir == "dir2/dir3"); REQUIRE_THROWS(VirtFsDir::removeFromSearchPath("dir1")); REQUIRE(VirtFsDir::getEntries().size() == 2); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir3/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir3"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir3"); REQUIRE(VirtFsDir::getEntries()[1]->root == "dir2/dir3/"); - REQUIRE(VirtFsDir::getEntries()[1]->mUserDir == "dir2/dir3"); + REQUIRE(VirtFsDir::getEntries()[1]->userDir == "dir2/dir3"); REQUIRE(VirtFsDir::removeFromSearchPath("dir2/dir3")); REQUIRE_THROWS(VirtFsDir::removeFromSearchPath("dir2/dir3/")); REQUIRE(VirtFsDir::getEntries().size() == 1); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir3/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir3"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir3"); } SECTION("simple 4") @@ -222,7 +222,7 @@ TEST_CASE("VirtFsDir removeFromSearchPath") SkipError_true)); REQUIRE(VirtFsDir::getEntries().size() == 1); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir1"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir1"); REQUIRE_THROWS(VirtFsDir::removeFromSearchPath("dir2")); REQUIRE(VirtFsDir::removeFromSearchPath("dir1")); REQUIRE(VirtFsDir::getEntries().size() == 0); @@ -231,7 +231,7 @@ TEST_CASE("VirtFsDir removeFromSearchPath") SkipError_true)); REQUIRE(VirtFsDir::getEntries().size() == 1); REQUIRE(VirtFsDir::getEntries()[0]->root == "dir1/"); - REQUIRE(VirtFsDir::getEntries()[0]->mUserDir == "dir1"); + REQUIRE(VirtFsDir::getEntries()[0]->userDir == "dir1"); } VirtFsDir::deinit(); @@ -731,4 +731,5 @@ TEST_CASE("VirtFsDir read") VirtFsDir::deinit(); delete2(logger); } +*/ #endif // USE_PHYSFS diff --git a/src/fs/virtfs/virtfsentry.cpp b/src/fs/virtfs/virtfsentry.cpp index 61ccedccc..2a5cead24 100644 --- a/src/fs/virtfs/virtfsentry.cpp +++ b/src/fs/virtfs/virtfsentry.cpp @@ -22,11 +22,15 @@ #include "fs/virtfs/virtfsentry.h" +#include "fs/virtfsfuncs.h" + #include "debug.h" -VirtFsEntry::VirtFsEntry(const FsEntryType &type0) : +VirtFsEntry::VirtFsEntry(const FsEntryType &type0, + VirtFsFuncs *restrict const funcs0) : root(), - type(type0) + type(type0), + funcs(funcs0) { } diff --git a/src/fs/virtfs/virtfsentry.h b/src/fs/virtfs/virtfsentry.h index 0a73c7edb..367b90b2c 100644 --- a/src/fs/virtfs/virtfsentry.h +++ b/src/fs/virtfs/virtfsentry.h @@ -28,9 +28,12 @@ #include "localconsts.h" +struct VirtFsFuncs; + struct VirtFsEntry notfinal { - explicit VirtFsEntry(const FsEntryType &type0); + VirtFsEntry(const FsEntryType &type0, + VirtFsFuncs *restrict const funcs); A_DELETE_COPY(VirtFsEntry) @@ -39,6 +42,8 @@ struct VirtFsEntry notfinal std::string root; FsEntryType type; + + VirtFsFuncs *funcs; }; #endif // USE_PHYSFS diff --git a/src/fs/virtfs/virtfszip.cpp b/src/fs/virtfs/virtfszip.cpp index 8ee39a8d9..881e028cc 100644 --- a/src/fs/virtfs/virtfszip.cpp +++ b/src/fs/virtfs/virtfszip.cpp @@ -102,6 +102,11 @@ namespace VirtFsZip return nullptr; } + VirtFsFuncs *getFuncs() + { + return &funcs; + } + bool addToSearchPathSilent(std::string newDir, const Append append) { @@ -125,7 +130,7 @@ namespace VirtFsZip newDir.c_str()); return false; } - entry = new VirtZipEntry(newDir); + entry = new VirtZipEntry(newDir, &funcs); if (Zip::readArchiveInfo(entry) == false) { delete entry; @@ -166,7 +171,7 @@ namespace VirtFsZip newDir.c_str()); return false; } - entry = new VirtZipEntry(newDir); + entry = new VirtZipEntry(newDir, &funcs); if (Zip::readArchiveInfo(entry) == false) { delete entry; @@ -259,6 +264,13 @@ namespace VirtFsZip ptr->tell = &VirtFsZip::tell; ptr->seek = &VirtFsZip::seek; ptr->eof = &VirtFsZip::eof; + ptr->exists = &VirtFsZip::exists; + ptr->getRealDir = &VirtFsZip::getRealDir; + ptr->enumerate = &VirtFsZip::enumerate; + ptr->isDirectory = &VirtFsZip::isDirectory; + ptr->openRead = &VirtFsZip::openRead; + ptr->openWrite = &VirtFsZip::openWrite; + ptr->openAppend = &VirtFsZip::openAppend; } std::string getRealDir(std::string filename) @@ -282,6 +294,35 @@ namespace VirtFsZip return std::string(); } + bool getRealDir(VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName, + std::string &realDir) + { + VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>(entry); + FOR_EACH (std::vector<ZipLocalHeader*>::const_iterator, + it2, + zipEntry->mHeaders) + { + if ((*it2)->fileName == filename) + { + realDir = entry->root; + return true; + } + } + FOR_EACH (std::vector<std::string>::const_iterator, + it2, + zipEntry->mDirs) + { + if (*it2 == dirName) + { + realDir = entry->root; + return true; + } + } + return false; + } + bool exists(std::string name) { prepareFsPath(name); @@ -296,6 +337,28 @@ namespace VirtFsZip return entry != nullptr; } + bool exists(VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName) + { + VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>(entry); + FOR_EACH (std::vector<ZipLocalHeader*>::const_iterator, + it2, + zipEntry->mHeaders) + { + if ((*it2)->fileName == filename) + return true; + } + FOR_EACH (std::vector<std::string>::const_iterator, + it2, + zipEntry->mDirs) + { + if (*it2 == dirName) + return true; + } + return false; + } + VirtList *enumerateFiles(std::string dirName) { VirtList *const list = new VirtList; @@ -309,6 +372,66 @@ namespace VirtFsZip return enumerateFiles(dirName, list); } + void enumerate(VirtFsEntry *restrict const entry, + const std::string &dirName, + StringVect &names) + { + VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>(entry); + if (dirName == "/") + { + FOR_EACH (std::vector<ZipLocalHeader*>::const_iterator, + it2, + zipEntry->mHeaders) + { + ZipLocalHeader *const header = *it2; + std::string fileName = header->fileName; + // skip subdirs from enumeration + const size_t idx = fileName.find(dirSeparator); + if (idx != std::string::npos) + fileName.erase(idx); + bool found(false); + FOR_EACH (StringVectCIter, itn, names) + { + if (*itn == fileName) + { + found = true; + break; + } + } + if (found == false) + names.push_back(fileName); + } + } + else + { + FOR_EACH (std::vector<ZipLocalHeader*>::const_iterator, + it2, + zipEntry->mHeaders) + { + ZipLocalHeader *const header = *it2; + std::string fileName = header->fileName; + if (findCutFirst(fileName, dirName) == true) + { + // skip subdirs from enumeration + const size_t idx = fileName.find(dirSeparator); + if (idx != std::string::npos) + fileName.erase(idx); + bool found(false); + FOR_EACH (StringVectCIter, itn, names) + { + if (*itn == fileName) + { + found = true; + break; + } + } + if (found == false) + names.push_back(fileName); + } + } + } + } + VirtList *enumerateFiles(std::string dirName, VirtList *restrict const list) { @@ -380,16 +503,22 @@ namespace VirtFsZip return list; } - bool isDirectory(std::string dirName) + bool isDirectory(VirtFsEntry *restrict const entry, + const std::string &dirName, + bool &isDirFlag) { - prepareFsPath(dirName); - if (checkPath(dirName) == false) + VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>(entry); + FOR_EACH (std::vector<std::string>::const_iterator, + it2, + zipEntry->mDirs) { - reportAlways("VirtFsZip::isDirectory invalid path: %s", - dirName.c_str()); - return false; + if (*it2 == dirName) + { + isDirFlag = true; + return true; + } } - return isDirectoryInternal(dirName); + return false; } bool isDirectoryInternal(std::string dirName) @@ -440,6 +569,43 @@ namespace VirtFsZip return openReadInternal(filename); } + VirtFile *openRead(VirtFsEntry *restrict const entry, + const std::string &filename) + { + VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>(entry); + FOR_EACH (std::vector<ZipLocalHeader*>::const_iterator, + it2, + zipEntry->mHeaders) + { + ZipLocalHeader *restrict const header = *it2; + if (header->fileName == filename) + { + uint8_t *restrict const buf = Zip::readFile(header); + if (buf == nullptr) + return nullptr; + VirtFile *restrict const file = new VirtFile(&funcs); + file->mPrivate = new VirtFilePrivate(buf, + header->uncompressSize); + return file; + } + } + return nullptr; + } + + VirtFile *openWrite(VirtFsEntry *restrict const entry, + const std::string &filename) + { + reportAlways("VirtFs::openWrite for zip not implemented."); + return nullptr; + } + + VirtFile *openAppend(VirtFsEntry *restrict const entry, + const std::string &filename) + { + reportAlways("VirtFs::openAppend for zip not implemented."); + return nullptr; + } + VirtFile *openReadInternal(const std::string &filename) { ZipLocalHeader *restrict const header = searchHeaderByName(filename); diff --git a/src/fs/virtfs/virtfszip.h b/src/fs/virtfs/virtfszip.h index a8af1a449..e88c74b69 100644 --- a/src/fs/virtfs/virtfszip.h +++ b/src/fs/virtfs/virtfszip.h @@ -25,19 +25,20 @@ #include "enums/simpletypes/append.h" #include "enums/simpletypes/skiperror.h" -#include "localconsts.h" +#include "utils/stringvector.h" -#include <vector> -#include <string> +#include "localconsts.h" struct VirtFile; struct VirtList; struct VirtFsFuncs; +struct VirtFsEntry; struct VirtZipEntry; struct ZipLocalHeader; namespace VirtFsZip { + VirtFsFuncs *getFuncs(); VirtZipEntry *searchEntryByArchive(const std::string &restrict archiveName); ZipLocalHeader *searchHeaderByName(const std::string &restrict filename); @@ -54,20 +55,38 @@ namespace VirtFsZip void deinit(); std::vector<VirtZipEntry*> &getEntries(); bool exists(std::string name); + bool exists(VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName); + void enumerate(VirtFsEntry *restrict const entry, + const std::string &dirName, + StringVect &names); VirtList *enumerateFiles(std::string dirName) RETURNS_NONNULL; VirtList *enumerateFiles(std::string dirName, VirtList *restrict const list) RETURNS_NONNULL; - bool isDirectory(std::string dirName); + bool isDirectory(VirtFsEntry *restrict const entry, + const std::string &dirName, + bool &isDirFlag); bool isDirectoryInternal(std::string dirName); bool isSymbolicLink(std::string name); void freeList(VirtList *restrict const handle); VirtFile *openRead(std::string filename); + VirtFile *openRead(VirtFsEntry *restrict const entry, + const std::string &filename); + VirtFile *openWrite(VirtFsEntry *restrict const entry, + const std::string &filename); + VirtFile *openAppend(VirtFsEntry *restrict const entry, + const std::string &filename); VirtFile *openReadInternal(const std::string &filename); VirtFile *openWrite(const std::string &restrict filename); VirtFile *openAppend(const std::string &restrict filename); bool setWriteDir(const std::string &restrict newDir); std::string getRealDir(std::string filename); std::string getRealDirInternal(const std::string &filename); + bool getRealDir(VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName, + std::string &realDir); bool mkdir(const std::string &restrict dirName); bool remove(const std::string &restrict filename); void permitLinks(const bool val); diff --git a/src/fs/virtfs/virtfszip_unittest.cc b/src/fs/virtfs/virtfszip_unittest.cc index 9a3f9a491..72dc16f64 100644 --- a/src/fs/virtfs/virtfszip_unittest.cc +++ b/src/fs/virtfs/virtfszip_unittest.cc @@ -32,7 +32,7 @@ #include "utils/delete2.h" #include "debug.h" - +/* TEST_CASE("VirtFsZip getEntries") { VirtFsZip::init(); @@ -749,4 +749,5 @@ TEST_CASE("VirtFsZip read") VirtFsZip::deinit(); delete2(logger); } +*/ #endif // USE_PHYSFS diff --git a/src/fs/virtfs/virtzipentry.cpp b/src/fs/virtfs/virtzipentry.cpp index 68b44ef4d..324e54fb4 100644 --- a/src/fs/virtfs/virtzipentry.cpp +++ b/src/fs/virtfs/virtzipentry.cpp @@ -28,8 +28,9 @@ #include "debug.h" -VirtZipEntry::VirtZipEntry(const std::string &restrict archiveName) : - VirtFsEntry(FsEntryType::Zip), +VirtZipEntry::VirtZipEntry(const std::string &restrict archiveName, + VirtFsFuncs *restrict const funcs0) : + VirtFsEntry(FsEntryType::Zip, funcs0), mHeaders() { root = archiveName; diff --git a/src/fs/virtfs/virtzipentry.h b/src/fs/virtfs/virtzipentry.h index 5114d99bf..d48e4ccc6 100644 --- a/src/fs/virtfs/virtzipentry.h +++ b/src/fs/virtfs/virtzipentry.h @@ -33,7 +33,8 @@ struct ZipLocalHeader; struct VirtZipEntry final : public VirtFsEntry { - explicit VirtZipEntry(const std::string &restrict archiveName); + VirtZipEntry(const std::string &restrict archiveName, + VirtFsFuncs *restrict const funcs); A_DELETE_COPY(VirtZipEntry) diff --git a/src/fs/virtfs/zip_unittest.cc b/src/fs/virtfs/zip_unittest.cc index 35d4b1f8e..4b9258ec5 100644 --- a/src/fs/virtfs/zip_unittest.cc +++ b/src/fs/virtfs/zip_unittest.cc @@ -26,6 +26,7 @@ #include "fs/files.h" +#include "fs/virtfs/virtfszip.h" #include "fs/virtfs/virtzipentry.h" #include "fs/virtfs/zip.h" #include "fs/virtfs/ziplocalheader.h" @@ -46,7 +47,8 @@ TEST_CASE("Zip readArchiveInfo") { name = prefix + "data/test/test.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -66,7 +68,8 @@ TEST_CASE("Zip readArchiveInfo") { name = prefix + "data/test/test2.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -123,7 +126,8 @@ TEST_CASE("Zip readArchiveInfo") { name = prefix + "data/test/test3.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -143,7 +147,8 @@ TEST_CASE("Zip readArchiveInfo") { name = prefix + "data/test/test4.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -173,7 +178,8 @@ TEST_CASE("Zip readCompressedFile") { name = prefix + "data/test/test2.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -206,7 +212,8 @@ TEST_CASE("Zip readFile") { name = prefix + "data/test/test.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -229,7 +236,8 @@ TEST_CASE("Zip readFile") { name = prefix + "data/test/test2.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); @@ -259,7 +267,8 @@ TEST_CASE("Zip readFile") { name = prefix + "data/test/test3.zip"; - VirtZipEntry *const entry = new VirtZipEntry(name); + VirtZipEntry *const entry = new VirtZipEntry(name, + VirtFsZip::getFuncs()); std::vector<ZipLocalHeader*> &headers = entry->mHeaders; REQUIRE(Zip::readArchiveInfo(entry)); diff --git a/src/fs/virtfs_unittest.cc b/src/fs/virtfs_unittest.cc index 228d0576a..c1dcc4fd0 100644 --- a/src/fs/virtfs_unittest.cc +++ b/src/fs/virtfs_unittest.cc @@ -20,6 +20,8 @@ #include "catch.hpp" +#include "fs/files.h" +#include "fs/paths.h" #include "fs/virtfs.h" #include "fs/virtfstools.h" #include "fs/virtlist.h" @@ -51,8 +53,8 @@ TEST_CASE("VirtFs getUserDir") TEST_CASE("VirtFs exists1") { logger = new Logger(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); REQUIRE(VirtFs::exists("test") == true); REQUIRE(VirtFs::exists("test/dir1") == true); @@ -62,8 +64,8 @@ TEST_CASE("VirtFs exists1") REQUIRE(VirtFs::exists("tesQ/units.xml") == false); REQUIRE(VirtFs::exists("units.xml") == false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); REQUIRE(VirtFs::exists("test") == true); REQUIRE(VirtFs::exists("test/dir1") == true); @@ -73,8 +75,8 @@ TEST_CASE("VirtFs exists1") REQUIRE(VirtFs::exists("tesQ/units.xml") == false); REQUIRE(VirtFs::exists("units.xml") == true); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); REQUIRE(VirtFs::exists("test") == true); REQUIRE(VirtFs::exists("test/dir1") == true); @@ -84,16 +86,20 @@ TEST_CASE("VirtFs exists1") REQUIRE(VirtFs::exists("tesQ/units.xml") == false); REQUIRE(VirtFs::exists("units.xml") == false); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } TEST_CASE("VirtFs exists2") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); REQUIRE(VirtFs::exists("test") == false); REQUIRE(VirtFs::exists("test/units.xml") == false); @@ -105,18 +111,20 @@ TEST_CASE("VirtFs exists2") REQUIRE(VirtFs::exists("units.xml.") == false); REQUIRE(VirtFs::exists("units.xml2") == false); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); delete2(logger); } TEST_CASE("VirtFs exists3") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); REQUIRE(VirtFs::exists("test") == false); REQUIRE(VirtFs::exists("test/units.xml") == false); @@ -130,20 +138,21 @@ TEST_CASE("VirtFs exists3") REQUIRE(VirtFs::exists("dir2/2") == false); REQUIRE(VirtFs::exists("dir2/paths.xml")); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); delete2(logger); } TEST_CASE("VirtFs exists4") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); + VirtFs::addDirToSearchPathSilent(prefix + "data/test", Append_false); REQUIRE(VirtFs::exists("test") == false); REQUIRE(VirtFs::exists("test/units.xml") == false); @@ -161,10 +170,23 @@ TEST_CASE("VirtFs exists4") REQUIRE(VirtFs::exists("dir2/file2.txt")); REQUIRE(VirtFs::exists("dir2/file3.txt") == false); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + VirtFs::removeDirFromSearchPathSilent(prefix + "data/test"); + delete2(logger); +} + +TEST_CASE("VirtFs exists5") +{ + logger = new Logger(); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + const std::string realDir = getRealPath(prefix + "data"); + logger->log("real dir: " + realDir); + REQUIRE_FALSE(VirtFs::exists(realDir)); + delete2(logger); } @@ -209,8 +231,8 @@ TEST_CASE("VirtFs enumerateFiles1") { logger = new Logger; - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); VirtList *list = nullptr; @@ -241,8 +263,8 @@ TEST_CASE("VirtFs enumerateFiles1") REQUIRE(list->names.size() == 0); VirtFs::freeList(list); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } @@ -250,9 +272,9 @@ TEST_CASE("VirtFs enumerateFiles2") { logger = new Logger; - VirtFs::addDirToSearchPath("data/test/dir1", + VirtFs::addDirToSearchPathSilent("data/test/dir1", Append_false); - VirtFs::addDirToSearchPath("../data/test/dir1", + VirtFs::addDirToSearchPathSilent("../data/test/dir1", Append_false); VirtList *list = nullptr; @@ -262,18 +284,20 @@ TEST_CASE("VirtFs enumerateFiles2") REQUIRE(list->names.size() == 5); VirtFs::freeList(list); - VirtFs::removeDirFromSearchPath("data/test/dir1"); - VirtFs::removeDirFromSearchPath("../data/test/dir1"); + VirtFs::removeDirFromSearchPathSilent("data/test/dir1"); + VirtFs::removeDirFromSearchPathSilent("../data/test/dir1"); delete2(logger); } TEST_CASE("VirtFs enumerateFiles3") { logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; - VirtFs::addZipToSearchPath("data/test/test.zip", - Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); VirtList *list = nullptr; @@ -283,18 +307,19 @@ TEST_CASE("VirtFs enumerateFiles3") REQUIRE(inList(list, "dir")); VirtFs::freeList(list); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); delete2(logger); } TEST_CASE("VirtFs enumerateFiles4") { logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; - VirtFs::addZipToSearchPath("data/test/test2.zip", - Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); VirtList *list = nullptr; @@ -307,21 +332,21 @@ TEST_CASE("VirtFs enumerateFiles4") REQUIRE(inList(list, "units.xml")); VirtFs::freeList(list); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); delete2(logger); } TEST_CASE("VirtFs enumerateFiles5") { logger = new Logger; + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; - VirtFs::addZipToSearchPath("data/test/test2.zip", - Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent(prefix + "data/test", Append_false); VirtList *list = nullptr; @@ -334,18 +359,16 @@ TEST_CASE("VirtFs enumerateFiles5") REQUIRE(inList(list, "units.xml")); VirtFs::freeList(list); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + VirtFs::removeDirFromSearchPathSilent(prefix + "data/test"); delete2(logger); } TEST_CASE("VirtFs isDirectory1") { logger = new Logger(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); REQUIRE(VirtFs::isDirectory("test/units.xml") == false); REQUIRE(VirtFs::isDirectory("test/units.xml/") == false); @@ -368,8 +391,8 @@ TEST_CASE("VirtFs isDirectory1") REQUIRE(VirtFs::isDirectory("testQ/") == false); REQUIRE(VirtFs::isDirectory("testQ//") == false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); REQUIRE(VirtFs::isDirectory("test/units.xml") == false); REQUIRE(VirtFs::isDirectory("test/units.xml/") == false); @@ -381,8 +404,8 @@ TEST_CASE("VirtFs isDirectory1") REQUIRE(VirtFs::isDirectory("testQ") == false); REQUIRE(VirtFs::isDirectory("test/dir1") == true); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); REQUIRE(VirtFs::isDirectory("test/units.xml") == false); REQUIRE(VirtFs::isDirectory("test/units123.xml") == false); @@ -394,16 +417,20 @@ TEST_CASE("VirtFs isDirectory1") REQUIRE(VirtFs::isDirectory("testQ") == false); REQUIRE(VirtFs::isDirectory("test/dir1") == true); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } TEST_CASE("VirtFs isDirectory2") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); REQUIRE(VirtFs::isDirectory("test/units.xml") == false); REQUIRE(VirtFs::isDirectory("dir") == true); @@ -413,18 +440,20 @@ TEST_CASE("VirtFs isDirectory2") REQUIRE(VirtFs::isDirectory("dir3") == false); REQUIRE(VirtFs::isDirectory("test.txt") == false); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); delete2(logger); } TEST_CASE("VirtFs isDirectory3") { logger = new Logger(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPath(prefix + "data", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); REQUIRE(VirtFs::isDirectory("test/units.xml") == false); REQUIRE(VirtFs::isDirectory("test")); @@ -437,18 +466,16 @@ TEST_CASE("VirtFs isDirectory3") REQUIRE(VirtFs::isDirectory("test.txt") == false); REQUIRE(VirtFs::isDirectory("dir/hide.png") == false); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data"); delete2(logger); } TEST_CASE("VirtFs openRead1") { logger = new Logger(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); VirtFile *file = nullptr; @@ -466,8 +493,8 @@ TEST_CASE("VirtFs openRead1") file = VirtFs::openRead("testQ"); REQUIRE(file == nullptr); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); file = VirtFs::openRead("test/units.xml"); REQUIRE(file != nullptr); @@ -484,8 +511,8 @@ TEST_CASE("VirtFs openRead1") file = VirtFs::openRead("testQ"); REQUIRE(file == nullptr); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); file = VirtFs::openRead("test/units.xml"); REQUIRE(file != nullptr); @@ -501,16 +528,20 @@ TEST_CASE("VirtFs openRead1") file = VirtFs::openRead("testQ"); REQUIRE(file == nullptr); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } TEST_CASE("VirtFs openRead2") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); VirtFile *file = nullptr; @@ -526,18 +557,20 @@ TEST_CASE("VirtFs openRead2") REQUIRE(file != nullptr); VirtFs::close(file); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); delete2(logger); } TEST_CASE("VirtFs openRead3") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); + VirtFs::addDirToSearchPath(prefix + "data/test", Append_false); VirtFile *file = nullptr; @@ -558,31 +591,19 @@ TEST_CASE("VirtFs openRead3") file = VirtFs::openRead("dir/dye.pn_"); REQUIRE(file == nullptr); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data/test"); delete2(logger); } -TEST_CASE("VirtFs addZipToSearchPath") -{ - // +++ need implement -} - -TEST_CASE("VirtFs removeZipFromSearchPath") -{ - // +++ need implement -} - TEST_CASE("VirtFs getRealDir1") { logger = new Logger(); REQUIRE(VirtFs::getRealDir(".") == ""); REQUIRE(VirtFs::getRealDir("..") == ""); - const bool dir1 = VirtFs::addDirToSearchPath("data", Append_false); - REQUIRE((dir1 || VirtFs::addDirToSearchPath("../data", Append_false)) == - true); + const bool dir1 = VirtFs::addDirToSearchPathSilent("data", Append_false); + REQUIRE((dir1 || VirtFs::addDirToSearchPathSilent("../data", Append_false)) + == true); if (dir1 == true) { REQUIRE(VirtFs::getRealDir("test") == "data"); @@ -597,8 +618,8 @@ TEST_CASE("VirtFs getRealDir1") } REQUIRE(VirtFs::getRealDir("zzz") == ""); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); if (dir1 == true) { REQUIRE(VirtFs::getRealDir("test") == "data"); @@ -632,8 +653,8 @@ TEST_CASE("VirtFs getRealDir1") REQUIRE(VirtFs::getRealDir("hide.png") == "../data/test"); } - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); if (dir1 == true) { @@ -652,61 +673,48 @@ TEST_CASE("VirtFs getRealDir1") REQUIRE(VirtFs::exists("dir/hide.png")); REQUIRE(VirtFs::getRealDir("zzz") == ""); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + if (dir1 == true) + VirtFs::removeZipFromSearchPath("data/test/test.zip"); + else + VirtFs::removeZipFromSearchPath("../data/test/test.zip"); delete2(logger); } TEST_CASE("VirtFs getrealDir2") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); - const bool dir1 = VirtFs::addDirToSearchPath("data", Append_false); - REQUIRE((dir1 || VirtFs::addDirToSearchPath("../data", Append_false)) == - true); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; - REQUIRE(VirtFs::getRealDir("zzz") == ""); + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); + VirtFs::addDirToSearchPath(prefix + "data/test", Append_false); + VirtFs::addDirToSearchPath(prefix + "data", Append_false); - if (dir1 == true) - { - REQUIRE(VirtFs::getRealDir("dir1/file1.txt") == - "data/test"); - REQUIRE(VirtFs::getRealDir("hide.png") == "data/test"); - REQUIRE(VirtFs::getRealDir("dir//hide.png") == - "data/test/test2.zip"); - REQUIRE(VirtFs::getRealDir("dir/1//test.txt") == - "data/test/test2.zip"); - } - else - { - REQUIRE(VirtFs::getRealDir("dir1/file1.txt") == - "../data/test"); - REQUIRE(VirtFs::getRealDir("hide.png") == "../data/test"); - REQUIRE(VirtFs::getRealDir("dir//hide.png") == - "../data/test/test2.zip"); - REQUIRE(VirtFs::getRealDir("dir/1//test.txt") == - "../data/test/test2.zip"); - } + REQUIRE(VirtFs::getRealDir("zzz") == ""); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + REQUIRE(VirtFs::getRealDir("dir1/file1.txt") == + prefix + "data/test"); + REQUIRE(VirtFs::getRealDir("hide.png") == prefix + "data/test"); + REQUIRE(VirtFs::getRealDir("dir//hide.png") == + prefix + "data/test/test2.zip"); + REQUIRE(VirtFs::getRealDir("dir/1//test.txt") == + prefix + "data/test/test2.zip"); + + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data/test"); + VirtFs::removeDirFromSearchPath(prefix + "data"); delete2(logger); } TEST_CASE("VirtFs permitLinks") { logger = new Logger(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); const int cnt1 = VirtFs::exists("test/test2.txt") ? 26 : 25; const int cnt2 = 26; @@ -730,16 +738,16 @@ TEST_CASE("VirtFs permitLinks") removeTemp(list); REQUIRE(list.size() == cnt1); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } TEST_CASE("VirtFs read1") { logger = new Logger(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); VirtFile *file = VirtFs::openRead("test/test.txt"); REQUIRE(file != nullptr); @@ -766,16 +774,20 @@ TEST_CASE("VirtFs read1") VirtFs::close(file); free(buffer); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } TEST_CASE("VirtFs read2") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); VirtFile *file = VirtFs::openRead("dir2/test.txt"); REQUIRE(file != nullptr); @@ -802,18 +814,20 @@ TEST_CASE("VirtFs read2") VirtFs::close(file); free(buffer); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); delete2(logger); } TEST_CASE("VirtFs read3") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test2.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test2.zip", Append_false); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test2.zip", Append_false); + VirtFs::addDirToSearchPath(prefix + "data", Append_false); VirtFile *file = VirtFs::openRead("dir2/test.txt"); REQUIRE(file != nullptr); @@ -840,20 +854,21 @@ TEST_CASE("VirtFs read3") VirtFs::close(file); free(buffer); - VirtFs::removeZipFromSearchPath("data/test/test2.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test2.zip"); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test2.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data"); delete2(logger); } TEST_CASE("VirtFs read4") { logger = new Logger(); - VirtFs::addDirToSearchPath("data/test", Append_true); - VirtFs::addDirToSearchPath("../data/test", Append_true); - VirtFs::addZipToSearchPath("data/test/test5.zip", Append_true); - VirtFs::addZipToSearchPath("../data/test/test5.zip", Append_true); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPath(prefix + "data/test", Append_true); + VirtFs::addZipToSearchPath(prefix + "data/test/test5.zip", Append_true); VirtFile *file = VirtFs::openRead("dir1/file1.txt"); REQUIRE(file != nullptr); @@ -880,20 +895,21 @@ TEST_CASE("VirtFs read4") VirtFs::close(file); free(buffer); - VirtFs::removeZipFromSearchPath("data/test/test5.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test5.zip"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test5.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data/test"); delete2(logger); } TEST_CASE("VirtFs read5") { logger = new Logger(); - VirtFs::addZipToSearchPath("data/test/test5.zip", Append_true); - VirtFs::addZipToSearchPath("../data/test/test5.zip", Append_true); - VirtFs::addDirToSearchPath("data/test", Append_true); - VirtFs::addDirToSearchPath("../data/test", Append_true); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addZipToSearchPath(prefix + "data/test/test5.zip", Append_true); + VirtFs::addDirToSearchPath(prefix + "data/test", Append_true); VirtFile *file = VirtFs::openRead("dir1/file1.txt"); REQUIRE(file != nullptr); @@ -920,9 +936,7 @@ TEST_CASE("VirtFs read5") VirtFs::close(file); free(buffer); - VirtFs::removeZipFromSearchPath("data/test/test5.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test5.zip"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test5.zip"); + VirtFs::removeDirFromSearchPath(prefix + "data/test"); delete2(logger); } diff --git a/src/fs/virtfsfuncs.h b/src/fs/virtfsfuncs.h index fee057944..b78643f7f 100644 --- a/src/fs/virtfsfuncs.h +++ b/src/fs/virtfsfuncs.h @@ -23,11 +23,14 @@ #include "enums/simpletypes/append.h" -#include "localconsts.h" +#include "utils/stringvector.h" -#include <string> +#include "localconsts.h" struct VirtFile; +#ifndef USE_PHYSFS +struct VirtFsEntry; +#endif // USE_PHYSFS struct VirtFsFuncs final { @@ -58,6 +61,27 @@ struct VirtFsFuncs final int (*seek) (VirtFile *restrict const file, const uint64_t pos); int (*eof) (VirtFile *restrict const file); +#ifndef USE_PHYSFS + bool (*exists) (VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName); + bool (*getRealDir) (VirtFsEntry *restrict const entry, + const std::string &filename, + const std::string &dirName, + std::string &realDir); + void (*enumerate) (VirtFsEntry *restrict const entry, + const std::string &dirName, + StringVect &names); + bool (*isDirectory) (VirtFsEntry *restrict const entry, + const std::string &dirName, + bool &isDirFlag); + VirtFile *(*openRead) (VirtFsEntry *restrict const entry, + const std::string &filename); + VirtFile *(*openWrite) (VirtFsEntry *restrict const entry, + const std::string &filename); + VirtFile *(*openAppend) (VirtFsEntry *restrict const entry, + const std::string &filename); +#endif // USE_PHYSFS }; #endif // UTILS_VIRTFSFUNCS_H diff --git a/src/fs/virtfstools.cpp b/src/fs/virtfstools.cpp index cf3da4b7a..0b434a340 100644 --- a/src/fs/virtfstools.cpp +++ b/src/fs/virtfstools.cpp @@ -227,37 +227,3 @@ namespace VirtFs return true; } } // namespace VirtFs - -#ifdef USE_PHYSFS -// +++ temporary add it here -namespace VirtFsPhys -{ - void getFiles(const std::string &path, - StringVect &list) - { - VirtList *const fonts = VirtFsPhys::enumerateFiles(path); - FOR_EACH (StringVectCIter, i, fonts->names) - { - if (!VirtFsPhys::isDirectory(path + dirSeparator + *i)) - list.push_back(*i); - } - VirtFsPhys::freeList(fonts); - } -} // namespace VirtFs -#else // USE_PHYSFS -// +++ temporary add it here -namespace VirtFsDir -{ - void getFiles(const std::string &path, - StringVect &list) - { - VirtList *const fonts = VirtFsDir::enumerateFiles(path); - FOR_EACH (StringVectCIter, i, fonts->names) - { - if (!VirtFsDir::isDirectory(path + dirSeparator + *i)) - list.push_back(*i); - } - VirtFsDir::freeList(fonts); - } -} // namespace VirtFs -#endif // USE_PHYSFS diff --git a/src/fs/virtfstools.h b/src/fs/virtfstools.h index b2cfb3373..4f2a77f4c 100644 --- a/src/fs/virtfstools.h +++ b/src/fs/virtfstools.h @@ -51,20 +51,4 @@ namespace VirtFs std::string loadTextFileString(const std::string &fileName); } // namespace VirtFs -#ifdef USE_PHYSFS -// +++ temporary add it here -namespace VirtFsPhys -{ - void getFiles(const std::string &path, - StringVect &list); -} // namespace VirtFs -#else // USE_PHYSFS -// +++ temporary add it here -namespace VirtFsDir -{ - void getFiles(const std::string &path, - StringVect &list); -} // namespace VirtFs -#endif // USE_PHYSFS - #endif // UTILS_VIRTFSTOOLS_H diff --git a/src/gui/widgets/browserbox_unittest.cc b/src/gui/widgets/browserbox_unittest.cc index 0dd8af585..485c67ca4 100644 --- a/src/gui/widgets/browserbox_unittest.cc +++ b/src/gui/widgets/browserbox_unittest.cc @@ -50,8 +50,8 @@ TEST_CASE("BrowserBox tests", "browserbox") client = new Client; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper; @@ -175,8 +175,8 @@ TEST_CASE("BrowserBox tests", "browserbox") Widget::setGlobalFont(nullptr); delete box; delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/gui/windowmanager_unittest.cc b/src/gui/windowmanager_unittest.cc index 38471370d..58f85ec2a 100644 --- a/src/gui/windowmanager_unittest.cc +++ b/src/gui/windowmanager_unittest.cc @@ -139,10 +139,10 @@ TEST_CASE("Windows tests", "windowmanager") resourceManager = nullptr; ResourceManager::init(); resourceManager->cleanOrphans(true); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); paths.setDefaultValues(getPathsDefaults()); branding.setValue("onlineServerFile", "test/serverlistplus.xml"); mainGraphics = new SDLGraphics; @@ -690,10 +690,10 @@ TEST_CASE("Windows tests", "windowmanager") delete2(inventoryHandler); delete2(charServerHandler); delete2(playerHandler); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); delete2(logger); // VirtFs::deinit(); diff --git a/src/integrity_unittest.cc b/src/integrity_unittest.cc index 0095f22ca..a0789d09c 100644 --- a/src/integrity_unittest.cc +++ b/src/integrity_unittest.cc @@ -25,6 +25,7 @@ #include "being/actorsprite.h" +#include "fs/files.h" #include "fs/virtfs.h" #include "fs/virtfsrwops.h" #include "fs/virtfstools.h" @@ -116,8 +117,13 @@ TEST_CASE("integrity tests", "integrity") SDL_Init(SDL_INIT_VIDEO); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + std::string name("data/test/test.zip"); + std::string prefix; + if (Files::existsLocal(name) == false) + prefix = "../" + prefix; + + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); #ifdef USE_SDL2 imageHelper = new SurfaceImageHelper; @@ -221,12 +227,10 @@ TEST_CASE("integrity tests", "integrity") SECTION("integrity Loader::getImage test 2") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); Image *const image = Loader::getImage( "dir/hide.png"); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); REQUIRE(image != nullptr); REQUIRE(image->getSDLSurface() != nullptr); image->decRef(); @@ -234,12 +238,10 @@ TEST_CASE("integrity tests", "integrity") SECTION("integrity Loader::getImage test 3") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); Image *const image = Loader::getImage( "dir/brimmedhat.png"); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); REQUIRE(image != nullptr); REQUIRE(image->getSDLSurface() != nullptr); image->decRef(); @@ -247,8 +249,7 @@ TEST_CASE("integrity tests", "integrity") SECTION("integrity Loader::getImage test 4") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); SDL_RWops *const rw = VirtFs::RWopsOpenRead(name1); if (!rw) @@ -260,13 +261,10 @@ TEST_CASE("integrity tests", "integrity") SDL_RWclose(rw); REQUIRE(sz == size1); SDL_RWclose(rw); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); - VirtFs::addDirToSearchPath("data/test", Append_true); - VirtFs::addDirToSearchPath("../data/test", Append_true); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + VirtFs::addDirToSearchPathSilent(prefix + "data/test", Append_true); REQUIRE(compareBuffers(buf) == true); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent(prefix + "data/test"); } #ifdef USE_PHYSFS @@ -410,18 +408,17 @@ TEST_CASE("integrity tests", "integrity") VirtFs::removeZipFromSearchPath("data/test/test.zip"); VirtFs::removeZipFromSearchPath("../data/test/test.zip"); - VirtFs::addDirToSearchPath("data/test", Append_true); - VirtFs::addDirToSearchPath("../data/test", Append_true); + VirtFs::addDirToSearchPathSilent("data/test", Append_true); + VirtFs::addDirToSearchPathSilent("../data/test", Append_true); REQUIRE(compareBuffers(buf) == true); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); } #endif // USE_PHYSFS SECTION("integrity Loader::getImage test 7") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); SDL_RWops *const rw = VirtFs::RWopsOpenRead(name1); if (!rw) @@ -448,19 +445,17 @@ TEST_CASE("integrity tests", "integrity") REQUIRE(sz == size1); SDL_RWclose(rw); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); - VirtFs::addDirToSearchPath("data/test", Append_true); - VirtFs::addDirToSearchPath("../data/test", Append_true); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); + VirtFs::addDirToSearchPathSilent("data/test", Append_true); + VirtFs::addDirToSearchPathSilent("../data/test", Append_true); REQUIRE(compareBuffers(buf) == true); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); } SECTION("integrity Loader::getImage test 8") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); SDL_RWops *const rw = VirtFs::RWopsOpenRead(name1); if (!rw) @@ -473,36 +468,31 @@ TEST_CASE("integrity tests", "integrity") } SDL_Surface *const tmpImage = IMG_LoadPNG_RW(rw); SDL_RWclose(rw); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); REQUIRE(tmpImage != nullptr); SDL_FreeSurface(tmpImage); } SECTION("integrity Loader::getImage test 9") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); SDL_RWops *const rw = VirtFs::RWopsOpenRead(name1); if (!rw) logger->log("Physfs error: %s", VirtFs::getLastError()); REQUIRE(rw != nullptr); Resource *const res = imageHelper->load(rw); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); REQUIRE(res != nullptr); delete res; } SECTION("integrity Loader::getImage test 10") { - VirtFs::addZipToSearchPath("data/test/test.zip", Append_false); - VirtFs::addZipToSearchPath("../data/test/test.zip", Append_false); + VirtFs::addZipToSearchPath(prefix + "data/test/test.zip", Append_false); Image *const image = Loader::getImage( name1); - VirtFs::removeZipFromSearchPath("data/test/test.zip"); - VirtFs::removeZipFromSearchPath("../data/test/test.zip"); + VirtFs::removeZipFromSearchPath(prefix + "data/test/test.zip"); REQUIRE(image != nullptr); REQUIRE(image->getSDLSurface() != nullptr); image->decRef(); @@ -513,8 +503,8 @@ TEST_CASE("integrity tests", "integrity") delete client; client = nullptr; - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/resources/dye/dye_unittest.cc b/src/resources/dye/dye_unittest.cc index cc368d865..ff1aa8995 100644 --- a/src/resources/dye/dye_unittest.cc +++ b/src/resources/dye/dye_unittest.cc @@ -2359,10 +2359,10 @@ TEST_CASE("Dye real dye") SDL_Init(SDL_INIT_VIDEO); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); #ifdef USE_SDL2 imageHelper = new SurfaceImageHelper; @@ -2394,10 +2394,10 @@ TEST_CASE("Dye real dye") dyeCheck("|A:#0000FFFF,FF000050", "arrow_up_A.png"); } delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/resources/dye/dyepalette_unittest.cc b/src/resources/dye/dyepalette_unittest.cc index 7df69e952..4f9d26bb6 100644 --- a/src/resources/dye/dyepalette_unittest.cc +++ b/src/resources/dye/dyepalette_unittest.cc @@ -60,10 +60,10 @@ TEST_CASE("DyePalette tests") SDL_Init(SDL_INIT_VIDEO); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); @@ -384,10 +384,10 @@ TEST_CASE("DyePalette tests") REQUIRE(palette.mColors[0].value[3] == 0x77); } delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/resources/map/maplayer_unittest.cc b/src/resources/map/maplayer_unittest.cc index a3978b1e2..58821682c 100644 --- a/src/resources/map/maplayer_unittest.cc +++ b/src/resources/map/maplayer_unittest.cc @@ -1650,8 +1650,8 @@ TEST_CASE("MapLayer drawSpecialLayer (specialLayer)") { logger = new Logger; ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); imageHelper = new SDLImageHelper; #ifdef USE_SDL2 @@ -1994,8 +1994,8 @@ TEST_CASE("MapLayer drawSpecialLayer (specialLayer)") delete map; delete mock; GraphicsManager::deleteRenderers(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } @@ -2003,8 +2003,8 @@ TEST_CASE("MapLayer drawSpecialLayer (tempLayer)") { logger = new Logger; ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); imageHelper = new SDLImageHelper; #ifdef USE_SDL2 @@ -2353,8 +2353,8 @@ TEST_CASE("MapLayer drawSpecialLayer (tempLayer)") delete map; delete mock; GraphicsManager::deleteRenderers(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } @@ -2362,8 +2362,8 @@ TEST_CASE("MapLayer drawFringe") { logger = new Logger; ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); imageHelper = new SDLImageHelper; #ifdef USE_SDL2 @@ -3240,7 +3240,7 @@ TEST_CASE("MapLayer drawFringe") delete mock; delete2(theme); GraphicsManager::deleteRenderers(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } diff --git a/src/resources/map/speciallayer_unittest.cc b/src/resources/map/speciallayer_unittest.cc index 223d05b4e..cda761896 100644 --- a/src/resources/map/speciallayer_unittest.cc +++ b/src/resources/map/speciallayer_unittest.cc @@ -45,8 +45,8 @@ TEST_CASE("SpecialLayer updateCache") logger = new Logger; client = new Client; ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); imageHelper = new SDLImageHelper; #ifdef USE_SDL2 @@ -262,7 +262,7 @@ TEST_CASE("SpecialLayer updateCache") delete layer; resourceManager->cleanOrphans(); delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); } diff --git a/src/resources/resourcemanager/resourcemanager_unittest.cc b/src/resources/resourcemanager/resourcemanager_unittest.cc index fa0a07b76..52da99571 100644 --- a/src/resources/resourcemanager/resourcemanager_unittest.cc +++ b/src/resources/resourcemanager/resourcemanager_unittest.cc @@ -96,8 +96,8 @@ TEST_CASE("resourcemanager", "resourcemanager") logger = new Logger(); ResourceManager::init(); ResourceManager *safeResman = resourceManager; - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); imageHelper = new SDLImageHelper(); #ifdef USE_SDL2 @@ -660,8 +660,8 @@ TEST_CASE("resourcemanager", "resourcemanager") delete resourceManager; resourceManager = safeResman; delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/resources/sprite/animatedsprite_unittest.cc b/src/resources/sprite/animatedsprite_unittest.cc index 85a1c3e87..b0e1fe78a 100644 --- a/src/resources/sprite/animatedsprite_unittest.cc +++ b/src/resources/sprite/animatedsprite_unittest.cc @@ -62,8 +62,8 @@ TEST_CASE("AnimatedSprite tests", "animatedsprite") SDL_Init(SDL_INIT_VIDEO); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); #ifdef USE_SDL2 @@ -182,8 +182,8 @@ TEST_CASE("AnimatedSprite tests", "animatedsprite") } delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/utils/chatutils_unittest.cc b/src/utils/chatutils_unittest.cc index 421798227..8c237b70a 100644 --- a/src/utils/chatutils_unittest.cc +++ b/src/utils/chatutils_unittest.cc @@ -55,8 +55,8 @@ TEST_CASE("chatutils replaceVars") SDL_Init(SDL_INIT_VIDEO); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); theme = new Theme; Theme::selectSkin(); imageHelper = new SDLImageHelper(); @@ -238,8 +238,8 @@ TEST_CASE("chatutils replaceVars") delete2(actorManager); delete2(localPlayer); delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/utils/stringutils_unittest.cc b/src/utils/stringutils_unittest.cc index b0fdbf0de..31e09e4ae 100644 --- a/src/utils/stringutils_unittest.cc +++ b/src/utils/stringutils_unittest.cc @@ -1394,10 +1394,10 @@ TEST_CASE("stringuntils replaceItemLinks") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); ItemDB::NamedItemInfos &namedInfos = ItemDB::getNamedItemInfosTest(); ItemDB::ItemInfos &infos = ItemDB::getItemInfosTest(); @@ -1618,10 +1618,10 @@ TEST_CASE("stringuntils replaceItemLinks") delete_all(infos); infos.clear(); namedInfos.clear(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/utils/translation/poparser_unittest.cc b/src/utils/translation/poparser_unittest.cc index 9182bebbc..c7fc2e560 100644 --- a/src/utils/translation/poparser_unittest.cc +++ b/src/utils/translation/poparser_unittest.cc @@ -51,8 +51,8 @@ TEST_CASE("PoParser tests", "PoParser") dirSeparator = "/"; logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); @@ -123,8 +123,8 @@ TEST_CASE("PoParser tests", "PoParser") delete dict; } delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } diff --git a/src/utils/xml_unittest.cc b/src/utils/xml_unittest.cc index f5211bcb5..ee5451fc6 100644 --- a/src/utils/xml_unittest.cc +++ b/src/utils/xml_unittest.cc @@ -52,8 +52,8 @@ TEST_CASE("xml doc") XML::initXML(); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); #ifdef USE_SDL2 @@ -359,8 +359,8 @@ TEST_CASE("xml doc") } delete2(theme); delete2(client); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); diff --git a/src/utils/xmlutils_unittest.cc b/src/utils/xmlutils_unittest.cc index dff0b130c..6653952cc 100644 --- a/src/utils/xmlutils_unittest.cc +++ b/src/utils/xmlutils_unittest.cc @@ -45,8 +45,8 @@ TEST_CASE("xmlutils readXmlIntVector 1") XML::initXML(); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); @@ -79,8 +79,8 @@ TEST_CASE("xmlutils readXmlIntVector 1") REQUIRE(1 == arr[4]); delete2(client); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -92,8 +92,8 @@ TEST_CASE("xmlutils readXmlStringMap 1") XML::initXML(); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); @@ -125,8 +125,8 @@ TEST_CASE("xmlutils readXmlStringMap 1") REQUIRE(arr["Metal"] == "26"); delete2(client); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } @@ -138,10 +138,10 @@ TEST_CASE("xmlutils readXmlIntMap 1") XML::initXML(); logger = new Logger(); ResourceManager::init(); - VirtFs::addDirToSearchPath("data", Append_false); - VirtFs::addDirToSearchPath("../data", Append_false); - VirtFs::addDirToSearchPath("data/test", Append_false); - VirtFs::addDirToSearchPath("../data/test", Append_false); + VirtFs::addDirToSearchPathSilent("data", Append_false); + VirtFs::addDirToSearchPathSilent("../data", Append_false); + VirtFs::addDirToSearchPathSilent("data/test", Append_false); + VirtFs::addDirToSearchPathSilent("../data/test", Append_false); mainGraphics = new SDLGraphics; imageHelper = new SDLImageHelper(); @@ -173,10 +173,10 @@ TEST_CASE("xmlutils readXmlIntMap 1") REQUIRE(arr[3] == 0); delete2(client); ResourceManager::deleteInstance(); - VirtFs::removeDirFromSearchPath("data/test"); - VirtFs::removeDirFromSearchPath("../data/test"); - VirtFs::removeDirFromSearchPath("data"); - VirtFs::removeDirFromSearchPath("../data"); + VirtFs::removeDirFromSearchPathSilent("data/test"); + VirtFs::removeDirFromSearchPathSilent("../data/test"); + VirtFs::removeDirFromSearchPathSilent("data"); + VirtFs::removeDirFromSearchPathSilent("../data"); delete2(logger); // VirtFs::deinit(); } |