summaryrefslogtreecommitdiff
path: root/src/fs
diff options
context:
space:
mode:
Diffstat (limited to 'src/fs')
-rw-r--r--src/fs/files_unittest.cc48
-rw-r--r--src/fs/physfs/virtfs.cpp18
-rw-r--r--src/fs/physfs/virtfsphys_unittest.cc34
-rw-r--r--src/fs/virtfs.h24
-rw-r--r--src/fs/virtfs/virtdirentry.cpp9
-rw-r--r--src/fs/virtfs/virtdirentry.h5
-rw-r--r--src/fs/virtfs/virtfs.cpp386
-rw-r--r--src/fs/virtfs/virtfs.h51
-rw-r--r--src/fs/virtfs/virtfs_unittest.cc1421
-rw-r--r--src/fs/virtfs/virtfsdir.cpp144
-rw-r--r--src/fs/virtfs/virtfsdir.h27
-rw-r--r--src/fs/virtfs/virtfsdir_unittest.cc41
-rw-r--r--src/fs/virtfs/virtfsentry.cpp8
-rw-r--r--src/fs/virtfs/virtfsentry.h7
-rw-r--r--src/fs/virtfs/virtfszip.cpp184
-rw-r--r--src/fs/virtfs/virtfszip.h27
-rw-r--r--src/fs/virtfs/virtfszip_unittest.cc3
-rw-r--r--src/fs/virtfs/virtzipentry.cpp5
-rw-r--r--src/fs/virtfs/virtzipentry.h3
-rw-r--r--src/fs/virtfs/zip_unittest.cc25
-rw-r--r--src/fs/virtfs_unittest.cc386
-rw-r--r--src/fs/virtfsfuncs.h28
-rw-r--r--src/fs/virtfstools.cpp34
-rw-r--r--src/fs/virtfstools.h16
24 files changed, 2492 insertions, 442 deletions
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
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-11-01 15:25:11 +0000