FilesystemTest.cpp File Reference

#include "Std.hpp"
#include "Filesystem.hpp"
#include "unit.hpp"

Go to the source code of this file.

Classes
struct	TestPathmask

Macros
#define	SYSTEMCATEGORY   system_category
#define	ABS   "./"
#define	REL   "./relative"
#define	A   "/"
#define	D   ":"

Functions
string	setSystemDrive (const string &path)
void	create_file (const bfs::path &ph, const string &contents)
void	createTestPath ()
void	deleteTestPath ()
set< bfs::path >	parsePathArray (const string &pathArray)
void	testExpandPathmask ()
void	testAbbreviateByteSize ()
int	main (int argc, const char *argv[])

Variables
string	systemDrive
const char *	testPathContentPairArray []
const int	testPathContentPairArraySize = sizeof(testPathContentPairArray) / sizeof(const char*)
const TestPathmask	testPathmaskArray []
const int	testPathmaskArraySize = sizeof(testPathmaskArray) / sizeof(TestPathmask)

---

Macro Definition Documentation

#define SYSTEMCATEGORY   system_category

Definition at line 37 of file FilesystemTest.cpp.

Referenced by create_file().

#define ABS   "./"

Definition at line 48 of file FilesystemTest.cpp.

Referenced by testExpandPathmask().

#define REL   "./relative"

Definition at line 49 of file FilesystemTest.cpp.

#define A   "/"

Definition at line 50 of file FilesystemTest.cpp.

Referenced by gjinverse(), InvertMatrix(), isUpperTriangular(), main(), pwiz::math::qr(), pwiz::math::LinearSolver< LinearSolverType_LU >::solve(), testBanded(), testBandedComplex(), testComplex(), testDouble(), testDoubleQR(), testQR(), testRectangularQR(), and testSparse().

#define D   ":"

Definition at line 51 of file FilesystemTest.cpp.

Referenced by parsePathArray().

---

Function Documentation

string setSystemDrive

(

const string &

path

)

Definition at line 55 of file FilesystemTest.cpp.

References systemDrive.

Referenced by createTestPath(), deleteTestPath(), parsePathArray(), and testExpandPathmask().

{
    return bal::replace_all_copy(path, "%SD%", systemDrive);
}

void create_file	(	const bfs::path &	ph,
		const string &	contents
	)

Definition at line 116 of file FilesystemTest.cpp.

References SYSTEMCATEGORY.

Referenced by createTestPath().

{
    ofstream f(ph.string().c_str());
    if (!f)
        throw bfs::filesystem_error("create_file", ph, error_code(errno, SYSTEMCATEGORY));
    if (!contents.empty()) f << contents;
}

void createTestPath

(

)

Definition at line 125 of file FilesystemTest.cpp.

References create_file(), setSystemDrive(), testPathContentPairArray, testPathContentPairArraySize, and unit_assert.

Referenced by testExpandPathmask().

{
    for (int i=0; i < testPathContentPairArraySize; i += 2)
    {
        // if content is empty, create a directory
        if (strlen(testPathContentPairArray[i+1]) == 0)
            bfs::create_directory(setSystemDrive(testPathContentPairArray[i]));
        else
            create_file(setSystemDrive(testPathContentPairArray[i]), testPathContentPairArray[i+1]);

        // test that the directory/file was really created
        unit_assert(bfs::exists(setSystemDrive(testPathContentPairArray[i])));
    }
}

void deleteTestPath

(

)

Definition at line 141 of file FilesystemTest.cpp.

References setSystemDrive(), testPathContentPairArray, and testPathContentPairArraySize.

Referenced by main(), and testExpandPathmask().

{
    for (int i=0; i < testPathContentPairArraySize; i += 2)
        if (bfs::exists(setSystemDrive(testPathContentPairArray[i])))
            bfs::remove_all(setSystemDrive(testPathContentPairArray[i]));
}

set<bfs::path> parsePathArray

(

const string &

pathArray

)

Definition at line 149 of file FilesystemTest.cpp.

References D, and setSystemDrive().

Referenced by testExpandPathmask().

{
    set<bfs::path> pathSet;
    vector<string> tokens;
    bal::split(tokens, pathArray, bal::is_any_of(D));
    if (!tokens.empty() && !tokens[0].empty())
        for (size_t i=0; i < tokens.size(); ++i)
            pathSet.insert(setSystemDrive(tokens[i]));
    return pathSet;
}

void testExpandPathmask

(

)

Definition at line 161 of file FilesystemTest.cpp.

References ABS, createTestPath(), deleteTestPath(), e(), pwiz::util::expand_pathmask(), parsePathArray(), setSystemDrive(), systemDrive, testPathmaskArray, testPathmaskArraySize, and unit_assert.

Referenced by main().

{
    char* systemDriveEnv = ::getenv("SystemDrive"); // usually "C:" on Windows
    if (systemDriveEnv)
        systemDrive = systemDriveEnv;

    // create a filesystem tree for testing
    createTestPath();

    for (int i=0; i < testPathmaskArraySize; ++i)
    {
        try
        {
            vector<bfs::path> matchingPaths;
            expand_pathmask(setSystemDrive(testPathmaskArray[i].pathmask), matchingPaths);

            set<bfs::path> targetPathSet = parsePathArray(testPathmaskArray[i].pathnameArray);
            unit_assert(matchingPaths.size() == targetPathSet.size());

            set<bfs::path> matchingPathSet(matchingPaths.begin(), matchingPaths.end());
            vector<bfs::path> xorSet;
            std::set_symmetric_difference(targetPathSet.begin(), targetPathSet.end(),
                                          matchingPathSet.begin(), matchingPathSet.end(),
                                          xorSet.end());
            unit_assert(xorSet.empty());
        }
        catch (exception& e)
        {
            cout << "Unit test on pathmask \"" << setSystemDrive(testPathmaskArray[i].pathmask) << "\" failed:\n"
                 << e.what() << endl;
        }
    }

    // special test of wildcard in the root (on Windows)
    vector<bfs::path> matchingPaths;
    expand_pathmask(setSystemDrive(ABS"*"), matchingPaths);
    unit_assert(find(matchingPaths.begin(), matchingPaths.end(), setSystemDrive(ABS"pwiz_foofoo_test")) != matchingPaths.end());
    unit_assert(find(matchingPaths.begin(), matchingPaths.end(), setSystemDrive(ABS"pwiz_foo_test")) != matchingPaths.end());
    unit_assert(find(matchingPaths.begin(), matchingPaths.end(), setSystemDrive(ABS"pwiz_bar_test")) != matchingPaths.end());

    // cleanup test tree
    deleteTestPath();
}

void testAbbreviateByteSize

(

)

Definition at line 206 of file FilesystemTest.cpp.

References pwiz::util::abbreviate_byte_size(), pwiz::util::ByteSizeAbbreviation_IEC, pwiz::util::ByteSizeAbbreviation_JEDEC, and unit_assert.

Referenced by main().

{
    unit_assert(abbreviate_byte_size(1) == "1 B");
    unit_assert(abbreviate_byte_size(999) == "999 B");
    unit_assert(abbreviate_byte_size(1000) == "1 KB");
    unit_assert(abbreviate_byte_size(999999) == "999 KB");
    unit_assert(abbreviate_byte_size(1000000) == "1 MB");
    unit_assert(abbreviate_byte_size(999999999) == "999 MB");
    unit_assert(abbreviate_byte_size(1000000000) == "1 GB");

    unit_assert(abbreviate_byte_size(1, ByteSizeAbbreviation_IEC) == "1 B");
    unit_assert(abbreviate_byte_size(1023, ByteSizeAbbreviation_IEC) == "1023 B");
    unit_assert(abbreviate_byte_size(1024, ByteSizeAbbreviation_IEC) == "1 KiB");
    unit_assert(abbreviate_byte_size((1024 << 10)-1, ByteSizeAbbreviation_IEC) == "1023 KiB");
    unit_assert(abbreviate_byte_size((1024 << 10), ByteSizeAbbreviation_IEC) == "1 MiB");
    unit_assert(abbreviate_byte_size((1024 << 20)-1, ByteSizeAbbreviation_IEC) == "1023 MiB");
    unit_assert(abbreviate_byte_size((1024 << 20), ByteSizeAbbreviation_IEC) == "1 GiB");

    unit_assert(abbreviate_byte_size(1, ByteSizeAbbreviation_JEDEC) == "1 B");
    unit_assert(abbreviate_byte_size(1023, ByteSizeAbbreviation_JEDEC) == "1023 B");
    unit_assert(abbreviate_byte_size(1024, ByteSizeAbbreviation_JEDEC) == "1 KB");
    unit_assert(abbreviate_byte_size((1024 << 10)-1, ByteSizeAbbreviation_JEDEC) == "1023 KB");
    unit_assert(abbreviate_byte_size((1024 << 10), ByteSizeAbbreviation_JEDEC) == "1 MB");
    unit_assert(abbreviate_byte_size((1024 << 20)-1, ByteSizeAbbreviation_JEDEC) == "1023 MB");
    unit_assert(abbreviate_byte_size((1024 << 20), ByteSizeAbbreviation_JEDEC) == "1 GB");
}

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 234 of file FilesystemTest.cpp.

References deleteTestPath(), e(), TEST_EPILOG, TEST_FAILED, TEST_PROLOG, testAbbreviateByteSize(), and testExpandPathmask().

{
    TEST_PROLOG(argc, argv)

    try
    {
        testExpandPathmask();
        testAbbreviateByteSize();
    }
    catch (exception& e)
    {
        TEST_FAILED(e.what())
    }
    catch (...)
    {
        TEST_FAILED("Caught unknown exception.")
    }

    deleteTestPath();
    TEST_EPILOG
}

---

Variable Documentation

string systemDrive

Definition at line 54 of file FilesystemTest.cpp.

Referenced by setSystemDrive(), and testExpandPathmask().

const char* testPathContentPairArray[]

Initial value:

{
    
    ABS"pwiz_foofoo_test",                           "root file",
    ABS"pwiz_foo_test",                              "",
    ABS"pwiz_foo_test"A"this file",                  "has content",
    ABS"pwiz_foo_test"A"this dir has",               "",
    ABS"pwiz_foo_test"A"this dir has"A"a test file", "with content",
    ABS"pwiz_bar_test",                              "",
    ABS"pwiz_bar_test"A"some file",                  "12345",
    ABS"pwiz_bar_test"A"some dir",                   "",

    REL"pwiz_foofoo_test",                           "root file",
    REL"pwiz_foo_test",                              "",
    REL"pwiz_foo_test"A"this file",                  "has content",
    REL"pwiz_foo_test"A"this dir has",               "",
    REL"pwiz_foo_test"A"this dir has"A"a test file", "with content",
    REL"pwiz_bar_test",                              "",
    REL"pwiz_bar_test"A"some file",                  "12345",
    REL"pwiz_bar_test"A"some dir",                   ""
}

Definition at line 60 of file FilesystemTest.cpp.

Referenced by createTestPath(), and deleteTestPath().

const int testPathContentPairArraySize = sizeof(testPathContentPairArray) / sizeof(const char*)

Definition at line 83 of file FilesystemTest.cpp.

Referenced by createTestPath(), and deleteTestPath().

const TestPathmask testPathmaskArray[]

Initial value:

{
    { ABS"pwiz_f??f??_test",       ABS"pwiz_foofoo_test" },
    { ABS"pwiz_???_test",          ABS"pwiz_foo_test"D ABS"pwiz_bar_test" },
    { ABS"pwiz_f*o_test",          ABS"pwiz_foo_test"D ABS"pwiz_foofoo_test" },
    { ABS"pwiz_foobar_test",       "" },
    { ABS"pwiz_foo_test"A"no*hit", "" },
    { ABS"pwiz_foo_test"A"*",      ABS"pwiz_foo_test"A"this file"D ABS"pwiz_foo_test"A"this dir has" },
    { ABS"pwiz_foo_test"A"this *", ABS"pwiz_foo_test"A"this file"D ABS"pwiz_foo_test"A"this dir has" },

    { REL"pwiz_f??f??_test",       REL"pwiz_foofoo_test" },
    { REL"pwiz_???_test",          REL"pwiz_foo_test"D REL"pwiz_bar_test" },
    { REL"pwiz_f*o_test",          REL"pwiz_foo_test"D REL"pwiz_foofoo_test" },
    { REL"pwiz_foobar_test",       "" },
    { REL"pwiz_foo_test"A"no*hit", "" },
    { REL"pwiz_foo_test"A"*",      REL"pwiz_foo_test"A"this file"D REL"pwiz_foo_test"A"this dir has" },
    { REL"pwiz_foo_test"A"this *", REL"pwiz_foo_test"A"this file"D REL"pwiz_foo_test"A"this dir has" }
}

Definition at line 93 of file FilesystemTest.cpp.

Referenced by testExpandPathmask().

const int testPathmaskArraySize = sizeof(testPathmaskArray) / sizeof(TestPathmask)

Definition at line 113 of file FilesystemTest.cpp.

Referenced by testExpandPathmask().