first

1 files changed, 1526 insertions, 0 deletions

diff --git a/test/base/FileTest.c b/test/base/FileTest.c
new file mode 100644
index 0000000..45977c1
--- /dev/null
+++ b/test/base/FileTest.c
@@ -0,0 +1,1526 @@
+#include "unit/TestRunner.h"
+#include "base/File.h"
+
+#define TEST_DIRNAME "test_dir"
+#define TEST_DIRNAME_WITH_DOT "test.dir"
+#define TEST_DIRNAME_COPY_DEST "test_dir_dest"
+#define TEST_FILENAME "test_file.txt"
+
+static void _fileTestTeardown(void)
+{
+    CharString testFilePath = newCharStringWithCString(TEST_FILENAME);
+    File testFile = newFileWithPath(testFilePath);
+    CharString testDirPath = newCharStringWithCString(TEST_DIRNAME);
+    File testDir = newFileWithPath(testDirPath);
+    CharString testDirWithDotPath = newCharStringWithCString(TEST_DIRNAME_WITH_DOT);
+    File testDirWithDot = newFileWithPath(testDirWithDotPath);
+    CharString testDirCopyPath = newCharStringWithCString(TEST_DIRNAME_COPY_DEST);
+    File testDirCopy = newFileWithPath(testDirCopyPath);
+
+    if (fileExists(testFile)) {
+        fileRemove(testFile);
+    }
+
+    if (fileExists(testDir)) {
+        fileRemove(testDir);
+    }
+
+    if (fileExists(testDirWithDot)) {
+        fileRemove(testDirWithDot);
+    }
+
+    if (fileExists(testDirCopy)) {
+        fileRemove(testDirCopy);
+    }
+
+    freeFile(testFile);
+    freeFile(testDir);
+    freeFile(testDirWithDot);
+    freeFile(testDirCopy);
+    freeCharString(testFilePath);
+    freeCharString(testDirPath);
+    freeCharString(testDirWithDotPath);
+    freeCharString(testDirCopyPath);
+}
+
+static int _testNewFileDefault(void)
+{
+    File f = newFile();
+
+    assertNotNull(f);
+    assertCharStringEquals(EMPTY_STRING, f->absolutePath);
+    assertIntEquals(kFileTypeInvalid, f->fileType);
+    assertIntEquals(kFileOpenModeClosed, f->_openMode);
+    assertIsNull(f->_fileHandle);
+    assertFalse(fileExists(f));
+
+    freeFile(f);
+    return 0;
+}
+
+static int _testNewFileAlreadyExists(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    File ftest = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+
+    ftest = newFileWithPath(p);
+    assertIntEquals(kFileTypeFile, ftest->fileType);
+    assertIntEquals(kFileOpenModeClosed, ftest->_openMode);
+    assertIsNull(ftest->_fileHandle);
+
+    freeCharString(p);
+    freeFile(f);
+    freeFile(ftest);
+    return 0;
+}
+
+static int _testNewFileWithRelativePath(void)
+{
+    CharString p = newCharString();
+    CharString pAbs = newCharString();
+    CharString pwd = fileGetCurrentDirectory();
+    File f = NULL;
+
+    sprintf(p->data, "%s%c%s", TEST_DIRNAME, PATH_DELIMITER, TEST_FILENAME);
+    f = newFileWithPath(p);
+    assertNotNull(f);
+    sprintf(pAbs->data, "%s%c%s", pwd->data, PATH_DELIMITER, p->data);
+    assertCharStringEquals(pAbs->data, f->absolutePath);
+    assertFalse(fileExists(f));
+    assertIntEquals(kFileTypeInvalid, f->fileType);
+    assertIntEquals(kFileOpenModeClosed, f->_openMode);
+    assertIsNull(f->_fileHandle);
+
+    freeFile(f);
+    freeCharString(p);
+    freeCharString(pAbs);
+    freeCharString(pwd);
+    return 0;
+}
+
+static int _testNewFileWithAbsolutePath(void)
+{
+    CharString p = newCharString();
+    CharString pAbs = newCharString();
+    File f = NULL;
+
+    sprintf(p->data, "%s%c%s%c%s", ROOT_DIRECTORY, PATH_DELIMITER, TEST_DIRNAME, PATH_DELIMITER, TEST_FILENAME);
+    f = newFileWithPath(p);
+    assertNotNull(f);
+    // Mostly just testing to make sure that absolute paths are not incorrectly
+    // translated from relative ones
+    sprintf(pAbs->data, "%s%c%s%c%s", ROOT_DIRECTORY, PATH_DELIMITER, TEST_DIRNAME, PATH_DELIMITER, TEST_FILENAME);
+    assert(charStringIsEqualTo(pAbs, f->absolutePath, false));
+    assertFalse(fileExists(f));
+    assertIntEquals(kFileTypeInvalid, f->fileType);
+    assertIntEquals(kFileOpenModeClosed, f->_openMode);
+    assertIsNull(f->_fileHandle);
+
+    freeFile(f);
+    freeCharString(p);
+    freeCharString(pAbs);
+    return 0;
+}
+
+static int _testNewFileWithNetworkPath(void)
+{
+#if WINDOWS
+    CharString p = newCharString();
+    CharString pAbs = newCharString();
+    CharString pwd = fileGetCurrentDirectory();
+    File f;
+
+    sprintf(p->data, "\\\\%s%c%s", TEST_DIRNAME, PATH_DELIMITER, TEST_FILENAME);
+    f = newFileWithPath(p);
+    assertNotNull(f);
+    pAbs = newCharString();
+    // Mostly just testing to make sure that network paths are not incorrectly
+    // translated from relative ones
+    sprintf(pAbs->data, "\\\\%s%c%s", TEST_DIRNAME, PATH_DELIMITER, TEST_FILENAME);
+    assert(charStringIsEqualTo(pAbs, f->absolutePath, false));
+    assertFalse(fileExists(f));
+    assertIntEquals(kFileTypeInvalid, f->fileType);
+    assertIntEquals(kFileOpenModeClosed, f->_openMode);
+    assertIsNull(f->_fileHandle);
+
+    freeFile(f);
+    freeCharString(p);
+    freeCharString(pAbs);
+    freeCharString(pwd);
+#elif UNIX
+    // Unix systems mount network drives as regular filesystem paths, this test
+    // isn't necessary on that platform
+#else
+    assert(false);
+#endif
+    return 0;
+}
+
+static int _testNewFileWithInvalidPath(void)
+{
+    CharString p;
+    File f;
+
+    // These characters are not permitted in filenames on Windows or Unix. The
+    // file interface should refuse to create an object with such a path,
+    // regardless of type.
+
+    p = newCharStringWithCString("*");
+    f = newFileWithPath(p);
+    assertIsNull(f);
+    freeCharString(p);
+
+    p = newCharStringWithCString(":");
+    f = newFileWithPath(p);
+    assertIsNull(f);
+    freeCharString(p);
+
+    p = newCharStringWithCString("?");
+    f = newFileWithPath(p);
+    assertIsNull(f);
+    freeCharString(p);
+
+    p = newCharStringWithCString("<");
+    f = newFileWithPath(p);
+    assertIsNull(f);
+    freeCharString(p);
+
+    p = newCharStringWithCString(">");
+    f = newFileWithPath(p);
+    assertIsNull(f);
+    freeCharString(p);
+
+    p = newCharStringWithCString("|");
+    f = newFileWithPath(p);
+    assertIsNull(f);
+    freeCharString(p);
+
+    freeFile(f);
+    return 0;
+}
+
+static int _testNewFileWithNullPath(void)
+{
+    File f;
+
+    // Should yield the same result as newFile()
+    f = newFileWithPath(NULL);
+    assertNotNull(f);
+    assertCharStringEquals(EMPTY_STRING, f->absolutePath);
+    assertIntEquals(kFileTypeInvalid, f->fileType);
+    assertFalse(fileExists(f));
+
+    freeFile(f);
+    return 0;
+}
+
+static int _testNewFileWithCStringPath(void)
+{
+    File f = newFileWithPathCString(TEST_FILENAME);
+    assertNotNull(f);
+    assertFalse(fileExists(f));
+    freeFile(f);
+    return 0;
+}
+
+static int _testNewFileWithCStringPathNull(void)
+{
+    File f = newFileWithPathCString(NULL);
+    assertIsNull(f);
+    return 0;
+}
+
+static int _testNewFileWithParent(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File dir = newFileWithPath(pdir);
+    File f = NULL;
+    CharString pwd = fileGetCurrentDirectory();
+    CharString pAbs = newCharString();
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    f = newFileWithParent(dir, pfile);
+    assertNotNull(f);
+    assertFalse(fileExists(f));
+    sprintf(pAbs->data, "%s%c%s%c%s", pwd->data, PATH_DELIMITER, pdir->data, PATH_DELIMITER, pfile->data);
+    assertCharStringEquals(pAbs->data, f->absolutePath);
+    assertIntEquals(kFileOpenModeClosed, f->_openMode);
+    assertIsNull(f->_fileHandle);
+
+    freeCharString(pAbs);
+    freeCharString(pdir);
+    freeCharString(pfile);
+    freeCharString(pwd);
+    freeFile(f);
+    freeFile(dir);
+    return 0;
+}
+
+static int _testNewFileWithParentNullParent(void)
+{
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithParent(NULL, pfile);
+    assertIsNull(f);
+    freeCharString(pfile);
+    return 0;
+}
+
+static int _testNewFileWithParentNullPath(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(pdir);
+    File f = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    newFileWithParent(d, NULL);
+    assertIsNull(f);
+
+    freeCharString(pdir);
+    freeFile(d);
+    return 0;
+}
+
+static int _testNewFileWithParentEmptyPath(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    CharString empty = newCharString();
+    File d = newFileWithPath(pdir);
+    File f = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    newFileWithParent(d, empty);
+    assertIsNull(f);
+
+    freeCharString(pdir);
+    freeCharString(empty);
+    freeFile(d);
+    return 0;
+}
+
+static int _testNewFileWithParentAlreadyExists(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File dir = newFileWithPath(pdir);
+    File f = NULL;
+    File ftest = NULL;
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    f = newFileWithParent(dir, pfile);
+    assertNotNull(f);
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    ftest = newFileWithParent(dir, pfile);
+    assert(fileExists(ftest));
+    assertIntEquals(kFileTypeFile, ftest->fileType);
+
+    freeCharString(pdir);
+    freeCharString(pfile);
+    freeFile(f);
+    freeFile(ftest);
+    freeFile(dir);
+    return 0;
+}
+
+static int _testNewFileWithParentNotDirectory(void)
+{
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(pfile);
+    File ftest = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    ftest = newFileWithParent(f, pfile);
+    assertIsNull(ftest);
+
+    freeCharString(pfile);
+    freeFile(f);
+    freeFile(ftest);
+    return 0;
+}
+
+static int _testNewFileWithParentInvalid(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File dir = newFileWithPath(pdir);
+    File f = NULL;
+
+    assertFalse(fileExists(dir));
+    f = newFileWithParent(dir, pfile);
+    assertIsNull(f);
+
+    freeCharString(pdir);
+    freeCharString(pfile);
+    freeFile(f);
+    freeFile(dir);
+    return 0;
+}
+
+static int _testNewFileWithParentAbsolutePath(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    File dir = newFileWithPath(pdir);
+    File f = NULL;
+    CharString p = newCharString();
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    assert(fileExists(dir));
+    sprintf(p->data, "%s%c%s", ROOT_DIRECTORY, PATH_DELIMITER, TEST_FILENAME);
+    f = newFileWithParent(dir, p);
+    assertIsNull(f);
+
+    freeCharString(p);
+    freeCharString(pdir);
+    freeFile(f);
+    freeFile(dir);
+    return 0;
+}
+
+static int _testFileExists(void)
+{
+    File f;
+    FILE *fp = fopen(TEST_FILENAME, "w");
+    CharString c = newCharStringWithCString(TEST_FILENAME);
+    assert(fp != NULL);
+    fclose(fp);
+
+    f = newFileWithPath(c);
+    assert(fileExists(f));
+
+    freeFile(f);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testFileExistsInvalid(void)
+{
+    CharString c = newCharStringWithCString("invalid");
+    File f = newFileWithPath(c);
+
+    assertFalse(fileExists(f));
+
+    freeFile(f);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testFileCreateFile(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f, f2;
+
+    f = newFileWithPath(p);
+    assertNotNull(f);
+    // Might fail because a previous test didn't clean up properly
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assertIntEquals(kFileOpenModeWrite, f->_openMode);
+    assertNotNull(f->_fileHandle);
+
+    // Just to make sure...
+    f2 = newFileWithPath(p);
+    assert(fileExists(f2));
+    assertIntEquals(kFileTypeFile, f2->fileType);
+    assertIntEquals(kFileOpenModeClosed, f2->_openMode);
+    assertIsNull(f2->_fileHandle);
+
+    freeFile(f);
+    freeFile(f2);
+    freeCharString(p);
+    return 0;
+}
+
+static int _testFileCreateDir(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File f = newFileWithPath(p);
+    File f2;
+
+    assertNotNull(f);
+    // Might fail because a previous test didn't clean up properly
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeDirectory));
+    assert(fileExists(f));
+    // Just to make sure...
+    f2 = newFileWithPath(p);
+    assert(fileExists(f2));
+    assertIntEquals(kFileTypeDirectory, f2->fileType);
+    assertIntEquals(kFileOpenModeClosed, f->_openMode);
+    assertIsNull(f->_fileHandle);
+
+    freeFile(f);
+    freeFile(f2);
+    freeCharString(p);
+    return 0;
+}
+
+static int _testFileCreateInvalidType(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+
+    assertNotNull(f);
+    // Might fail because a previous test didn't clean up properly
+    assertFalse(fileExists(f));
+    assertFalse(fileCreate(f, kFileTypeInvalid));
+    assertFalse(fileExists(f));
+
+    freeFile(f);
+    freeCharString(p);
+    return 0;
+}
+
+static int _testFileCreateAlreadyExists(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+
+    assertNotNull(f);
+    // Might fail because a previous test didn't clean up properly
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assertFalse(fileCreate(f, kFileTypeFile));
+
+    freeFile(f);
+    freeCharString(p);
+    return 0;
+}
+
+static int _testFileCopyToWithFile(void)
+{
+    CharString psrc = newCharStringWithCString(TEST_FILENAME);
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    File src = newFileWithPath(psrc);
+    File dest = newFileWithPath(pdest);
+    File copy = NULL;
+
+    assertNotNull(src);
+    assertNotNull(dest);
+    assertFalse(fileExists(src));
+    assertFalse(fileExists(dest));
+
+    assert(fileCreate(dest, kFileTypeDirectory));
+    assert(fileExists(dest));
+    assert(fileCreate(src, kFileTypeFile));
+    assert(fileExists(src));
+    copy = fileCopyTo(src, dest);
+    assertNotNull(copy);
+    assert(fileExists(copy));
+
+    freeFile(src);
+    freeFile(dest);
+    freeFile(copy);
+    freeCharString(psrc);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileCopyToWithDirectory(void)
+{
+    CharString psrc = newCharStringWithCString(TEST_DIRNAME);
+    CharString psrcFile = newCharStringWithCString(TEST_FILENAME);
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME_COPY_DEST);
+    File src = newFileWithPath(psrc);
+    File srcFile = NULL;
+    File dest = newFileWithPath(pdest);
+    File copy = NULL;
+
+    assertNotNull(src);
+    assertNotNull(dest);
+    assertFalse(fileExists(src));
+    assertFalse(fileExists(dest));
+
+    assert(fileCreate(dest, kFileTypeDirectory));
+    assert(fileExists(dest));
+
+    assert(fileCreate(src, kFileTypeDirectory));
+    assert(fileExists(src));
+    srcFile = newFileWithParent(src, psrcFile);
+    assertNotNull(srcFile);
+    assertFalse(fileExists(srcFile));
+    assert(fileCreate(srcFile, kFileTypeFile));
+    assert(fileExists(srcFile));
+
+    copy = fileCopyTo(src, dest);
+    assertNotNull(copy);
+    assert(fileExists(copy));
+
+    freeFile(src);
+    freeFile(srcFile);
+    freeFile(dest);
+    freeFile(copy);
+    freeCharString(psrc);
+    freeCharString(psrcFile);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileCopyToInvalidDestination(void)
+{
+    CharString psrc = newCharStringWithCString(TEST_FILENAME);
+    CharString pdest = newCharStringWithCString("invalid");
+    File src = newFileWithPath(psrc);
+    File dest = newFileWithPath(pdest);
+    File copy = NULL;
+
+    assertNotNull(src);
+    assertNotNull(dest);
+    assertFalse(fileExists(src));
+    assertFalse(fileExists(dest));
+
+    assert(fileCreate(src, kFileTypeFile));
+    assert(fileExists(src));
+    copy = fileCopyTo(src, dest);
+    assertIsNull(copy);
+
+    freeFile(src);
+    freeFile(dest);
+    freeFile(copy);
+    freeCharString(psrc);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileCopyInvalidTo(void)
+{
+    CharString psrc = newCharStringWithCString("invalid");
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    File src = newFileWithPath(psrc);
+    File dest = newFileWithPath(pdest);
+    File copy = NULL;
+
+    assertNotNull(src);
+    assertNotNull(dest);
+    assertFalse(fileExists(src));
+    assertFalse(fileExists(dest));
+
+    assert(fileCreate(dest, kFileTypeDirectory));
+    assert(fileExists(dest));
+    copy = fileCopyTo(src, dest);
+    assertIsNull(copy);
+
+    freeFile(src);
+    freeFile(dest);
+    freeFile(copy);
+    freeCharString(psrc);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileCopyToNull(void)
+{
+    CharString psrc = newCharStringWithCString(TEST_FILENAME);
+    File src = newFileWithPath(psrc);
+    File copy = NULL;
+
+    assertNotNull(src);
+    assertFalse(fileExists(src));
+
+    assert(fileCreate(src, kFileTypeFile));
+    assert(fileExists(src));
+    copy = fileCopyTo(src, NULL);
+    assertIsNull(copy);
+
+    freeFile(src);
+    freeFile(copy);
+    freeCharString(psrc);
+    return 0;
+}
+
+static int _testFileRemoveDir(void)
+{
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    File dir = newFileWithPath(pdest);
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    assert(fileExists(dir));
+    assert(fileRemove(dir));
+    assertFalse(fileExists(dir));
+
+    freeFile(dir);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileRemoveDirWithContents(void)
+{
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    CharString psubdir = newCharStringWithCString(TEST_DIRNAME);
+    CharString psubfile = newCharStringWithCString(TEST_FILENAME);
+    File dir = newFileWithPath(pdest);
+    File subdir = NULL;
+    File subfile = NULL;
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    assert(fileExists(dir));
+
+    // Must be created after parent directory is created
+    subdir = newFileWithParent(dir, psubdir);
+    assertNotNull(subdir);
+    assertFalse(fileExists(subdir));
+    assert(fileCreate(subdir, kFileTypeDirectory));
+    assert(fileExists(subdir));
+
+    // Must be created after parent directory is created
+    subfile = newFileWithParent(dir, psubfile);
+    assertNotNull(subfile);
+    assertFalse(fileExists(subfile));
+    assert(fileCreate(subfile, kFileTypeFile));
+    assert(fileExists(subfile));
+    // Windows will not be able to delete this directory unless all files in it are
+    // closed and unlocked.
+    fileClose(subfile);
+
+    // Remove the parent directory and assert that all children are gone
+    assert(fileRemove(dir));
+    assertFalse(fileExists(dir));
+    assertFalse(fileExists(subdir));
+    assertFalse(fileExists(subfile));
+
+    freeFile(dir);
+    freeFile(subdir);
+    freeFile(subfile);
+    freeCharString(pdest);
+    freeCharString(psubdir);
+    freeCharString(psubfile);
+    return 0;
+}
+
+static int _testFileRemoveFile(void)
+{
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(pfile);
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileRemove(f));
+    assertFalse(fileExists(f));
+
+    freeCharString(pfile);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileRemoveInvalid(void)
+{
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(pfile);
+
+    assertFalse(fileExists(f));
+    assertFalse(fileRemove(f));
+
+    freeCharString(pfile);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileListDirectory(void)
+{
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    CharString psubdir = newCharStringWithCString(TEST_DIRNAME);
+    CharString psubfile = newCharStringWithCString(TEST_FILENAME);
+    File dir = newFileWithPath(pdest);
+    File subdir = NULL;
+    File subfile = NULL;
+    LinkedList list;
+    File item;
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    assert(fileExists(dir));
+
+    subdir = newFileWithParent(dir, psubdir);
+    assertNotNull(subdir);
+    assertFalse(fileExists(subdir));
+    assert(fileCreate(subdir, kFileTypeDirectory));
+    assertNotNull(subdir);
+
+    subfile = newFileWithParent(dir, psubfile);
+    assertNotNull(subfile);
+    assertFalse(fileExists(subfile));
+    assert(fileCreate(subfile, kFileTypeFile));
+    assert(fileExists(subfile));
+
+    list = fileListDirectory(dir);
+    assertNotNull(list);
+    item = (File)list->item;
+    assertNotNull(item);
+
+    if (item->fileType == kFileTypeFile) {
+        assertCharStringContains(TEST_FILENAME, item->absolutePath);
+    } else if (item->fileType == kFileTypeDirectory) {
+        assertCharStringContains(TEST_DIRNAME, item->absolutePath);
+    } else {
+        assert(false);
+    }
+
+    item = (File)(((LinkedList)list->nextItem)->item);
+    assertNotNull(item);
+
+    if (item->fileType == kFileTypeFile) {
+        assertCharStringContains(TEST_FILENAME, item->absolutePath);
+    } else if (item->fileType == kFileTypeDirectory) {
+        assertCharStringContains(TEST_DIRNAME, item->absolutePath);
+    } else {
+        assert(false);
+    }
+
+    freeLinkedListAndItems(list, (LinkedListFreeItemFunc)freeFile);
+    freeFile(dir);
+    freeFile(subfile);
+    freeFile(subdir);
+    freeCharString(pdest);
+    freeCharString(psubdir);
+    freeCharString(psubfile);
+    return 0;
+}
+
+static int _testFileListDirectoryInvalid(void)
+{
+    CharString pdest = newCharStringWithCString(TEST_FILENAME);
+    File file = newFileWithPath(pdest);
+    LinkedList list;
+
+    assertFalse(fileExists(file));
+    assert(fileCreate(file, kFileTypeFile));
+    assert(fileExists(file));
+    list = fileListDirectory(file);
+    assertIsNull(list);
+
+    freeFile(file);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileListDirectoryNotExists(void)
+{
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    File dir = newFileWithPath(pdest);
+    LinkedList list;
+
+    assertFalse(fileExists(dir));
+    list = fileListDirectory(dir);
+    assertIsNull(list);
+
+    freeFile(dir);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileListDirectoryEmpty(void)
+{
+    CharString pdest = newCharStringWithCString(TEST_DIRNAME);
+    File dir = newFileWithPath(pdest);
+    LinkedList list;
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    assert(fileExists(dir));
+    list = fileListDirectory(dir);
+    assertNotNull(list);
+    assertIntEquals(0, linkedListLength(list));
+
+    freeLinkedList(list);
+    freeFile(dir);
+    freeCharString(pdest);
+    return 0;
+}
+
+static int _testFileGetSize(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileWrite(f, p));
+    fileClose(f); // force flush and close to be called
+    assertSizeEquals(strlen(p->data), fileGetSize(f));
+
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetSizeNotExists(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+
+    assertFalse(fileExists(f));
+    assertSizeEquals((size_t)0, fileGetSize(f));
+
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetSizeDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(p);
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    assertSizeEquals((size_t)0, fileGetSize(d));
+
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileReadContents(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    result = fileReadContents(f);
+    assertNotNull(result);
+    assertCharStringEquals(p->data, result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileReadContentsNotExists(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    result = fileReadContents(f);
+    assertIsNull(result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileReadContentsDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(p);
+    CharString result = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    result = fileReadContents(d);
+    assertIsNull(result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileReadLines(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    LinkedList lines = NULL;
+    CharString *items = NULL;
+    int i;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    assert(fileWriteBytes(f, "\n", 1));
+    assert(fileWrite(f, p));
+    lines = fileReadLines(f);
+    assertNotNull(lines);
+    assertIntEquals(2, linkedListLength(lines));
+    items = (CharString *)linkedListToArray(lines);
+    assertNotNull(items);
+
+    for (i = 0; i < linkedListLength(lines); i++) {
+        assertCharStringEquals(p->data, items[i]);
+    }
+
+    freeLinkedListAndItems(lines, (LinkedListFreeItemFunc)freeCharString);
+    freeCharString(p);
+    freeFile(f);
+    free(items);
+    return 0;
+}
+
+static int _testFileReadLinesEmpty(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    LinkedList lines = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    lines = fileReadLines(f);
+    assertNotNull(lines);
+    assertIntEquals(0, linkedListLength(lines));
+
+    freeLinkedList(lines);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileReadLinesNotExists(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    LinkedList result = NULL;
+
+    assertFalse(fileExists(f));
+    result = fileReadLines(f);
+    assertIsNull(result);
+
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileReadLinesDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(p);
+    LinkedList result = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    result = fileReadLines(d);
+    assertIsNull(result);
+
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileReadBytes(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    size_t s = 0;
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    fileClose(f);
+    s = fileGetSize(f);
+    assert(s > 0);
+    char *fileData = fileReadBytes(f, s);
+    result = newCharStringWithCString(fileData);
+    assertNotNull(result);
+    assertCharStringEquals(TEST_FILENAME, result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    free(fileData);
+    return 0;
+}
+
+static int _testFileReadBytesNotExists(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    void *result = NULL;
+
+    assertFalse(fileExists(f));
+    // Note the fake size here
+    result = fileReadBytes(f, (size_t)100);
+    assertIsNull(result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileReadBytesDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File d = newFileWithPath(p);
+    void *result = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    result = fileReadBytes(d, (size_t)100);
+    assertIsNull(result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileReadBytesZeroSize(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    size_t s = 0;
+    char *result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    fileClose(f);
+    s = fileGetSize(f);
+    assert(s > 0);
+    result = (char *)fileReadBytes(f, 0);
+    assertIsNull(result);
+
+    free(result);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileReadBytesGreaterSize(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    size_t s = 0;
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    fileClose(f);
+    s = fileGetSize(f);
+    assert(s > 0);
+    char *fileData = (char*)fileReadBytes(f, s * 2);
+    result = newCharStringWithCString(fileData);
+    assertNotNull(result);
+    assertCharStringEquals(TEST_FILENAME, result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    free(fileData);
+    return 0;
+}
+
+static int _testFileWrite(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    result = fileReadContents(f);
+    assertNotNull(result);
+    assertCharStringEquals(TEST_FILENAME, result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileWriteMultiple(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    CharString p2 = newCharStringWithCString(p->data);
+    File f = newFileWithPath(p);
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWrite(f, p));
+    assert(fileWrite(f, p));
+    result = fileReadContents(f);
+    assertNotNull(result);
+    charStringAppend(p, p2);
+    assertCharStringEquals(p->data, result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeCharString(p2);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileWriteInvalid(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+
+    assertFalse(fileExists(f));
+    assertFalse(fileWrite(f, p));
+
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileWriteDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File d = newFileWithPath(p);
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assertFalse(fileWrite(d, p));
+
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileWriteBytes(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    size_t s = 0;
+    CharString result = NULL;
+
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+    assert(fileWriteBytes(f, p->data, strlen(p->data)));
+    fileClose(f);
+    s = fileGetSize(f);
+    assert(s > 0);
+    char *fileData = (char *)fileReadBytes(f, s);
+    result = newCharStringWithCString(fileData);
+    assertNotNull(result);
+    assertCharStringEquals(TEST_FILENAME, result);
+
+    freeCharString(result);
+    freeCharString(p);
+    freeFile(f);
+    free(fileData);
+    return 0;
+}
+
+static int _testFileWriteBytesInvalid(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+
+    assertFalse(fileExists(f));
+    assertFalse(fileWriteBytes(f, p->data, strlen(p->data)));
+
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileWriteBytesDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File d = newFileWithPath(p);
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assertFalse(fileWriteBytes(d, p->data, strlen(p->data)));
+
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileGetBasename(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    CharString b = fileGetBasename(f);
+
+    assertNotNull(b);
+    assertCharStringEquals(TEST_FILENAME, b);
+
+    freeCharString(b);
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetBasenameInvalid(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFile();
+    CharString b = fileGetBasename(f);
+
+    assertIsNull(b);
+
+    freeCharString(p);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetBasenameDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(p);
+    CharString b = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    b = fileGetBasename(d);
+    assertNotNull(b);
+    assertCharStringEquals(TEST_DIRNAME, b);
+
+    freeCharString(b);
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileGetParent(void)
+{
+    CharString pdir = newCharStringWithCString(TEST_DIRNAME);
+    File dir = newFileWithPath(pdir);
+    CharString pfile = newCharStringWithCString(TEST_FILENAME);
+    File f = NULL;
+    File result = NULL;
+
+    assertFalse(fileExists(dir));
+    assert(fileCreate(dir, kFileTypeDirectory));
+    assert(fileExists(dir));
+
+    f = newFileWithParent(dir, pfile);
+    assertNotNull(f);
+    assertFalse(fileExists(f));
+    assert(fileCreate(f, kFileTypeFile));
+    assert(fileExists(f));
+
+    result = fileGetParent(f);
+    assertNotNull(result);
+    assertCharStringEquals(dir->absolutePath->data, result->absolutePath);
+
+    freeCharString(pdir);
+    freeCharString(pfile);
+    freeFile(f);
+    freeFile(dir);
+    freeFile(result);
+    return 0;
+}
+
+static int _testFileGetParentInvalid(void)
+{
+    File f = newFile();
+    File result = fileGetParent(f);
+    assertIsNull(result);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetExtension(void)
+{
+    CharString p = newCharStringWithCString(TEST_FILENAME);
+    File f = newFileWithPath(p);
+    CharString extension = fileGetExtension(f);
+
+    assertNotNull(extension);
+    assertCharStringEquals("txt", extension);
+
+    freeCharString(p);
+    freeCharString(extension);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetExtensionDirectory(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(p);
+    CharString result = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+    assert(fileExists(d));
+    result = fileGetExtension(d);
+    assertIsNull(result);
+
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileGetExtensionInvalid(void)
+{
+    File f = newFile();
+    CharString result = fileGetExtension(f);
+    assertIsNull(result);
+    freeFile(f);
+    return 0;
+}
+
+static int _testFileGetExtensionNone(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME);
+    File d = newFileWithPath(p);
+    CharString result = NULL;
+
+    result = fileGetExtension(d);
+    assertIsNull(result);
+
+    freeCharString(p);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileGetExtensionWithDotInPath(void)
+{
+    CharString p = newCharStringWithCString(TEST_DIRNAME_WITH_DOT);
+    File d = newFileWithPath(p);
+    CharString pfile = newCharStringWithCString(TEST_DIRNAME_COPY_DEST);
+    File f = NULL;
+    CharString result = NULL;
+
+    assertFalse(fileExists(d));
+    assert(fileCreate(d, kFileTypeDirectory));
+
+    f = newFileWithParent(d, pfile);
+    assertNotNull(f);
+    result = fileGetExtension(f);
+    // The parent directory has a dot, but the file doesn't so this call
+    // should return null.
+    assertIsNull(result);
+
+    freeCharString(p);
+    freeCharString(pfile);
+    freeFile(f);
+    freeFile(d);
+    return 0;
+}
+
+static int _testFileFreeNull(void)
+{
+    freeFile(NULL);
+    return 0;
+}
+
+TestSuite addFileTests(void);
+TestSuite addFileTests(void)
+{
+    TestSuite testSuite = newTestSuite("File", NULL, _fileTestTeardown);
+    addTest(testSuite, "NewFileDefault", _testNewFileDefault);
+
+    addTest(testSuite, "NewFileAlreadyExists", _testNewFileAlreadyExists);
+    addTest(testSuite, "NewFileWithRelativePath", _testNewFileWithRelativePath);
+    addTest(testSuite, "NewFileWithAbsolutePath", _testNewFileWithAbsolutePath);
+    addTest(testSuite, "NewFileWithNetworkPath", _testNewFileWithNetworkPath);
+    addTest(testSuite, "NewFileWithInvalidPath", _testNewFileWithInvalidPath);
+    addTest(testSuite, "NewFileWithNullPath", _testNewFileWithNullPath);
+
+    addTest(testSuite, "NewFileWithCStringPath", _testNewFileWithCStringPath);
+    addTest(testSuite, "NewFileWithCStringPathNull", _testNewFileWithCStringPathNull);
+
+    addTest(testSuite, "NewFileWithParent", _testNewFileWithParent);
+    addTest(testSuite, "NewFileWithParentNullParent", _testNewFileWithParentNullParent);
+    addTest(testSuite, "NewFileWithParentNullPath", _testNewFileWithParentNullPath);
+    addTest(testSuite, "NewFileWithParentEmptyPath", _testNewFileWithParentEmptyPath);
+    addTest(testSuite, "NewFileWithParentAlreadyExists", _testNewFileWithParentAlreadyExists);
+    addTest(testSuite, "NewFileWithParentNotDirectory", _testNewFileWithParentNotDirectory);
+    addTest(testSuite, "NewFileWithParentInvalid", _testNewFileWithParentInvalid);
+    addTest(testSuite, "NewFileWithParentAbsolutePath", _testNewFileWithParentAbsolutePath);
+
+    addTest(testSuite, "FileExists", _testFileExists);
+    addTest(testSuite, "FileExistsInvalid", _testFileExistsInvalid);
+
+    addTest(testSuite, "FileCreateFile", _testFileCreateFile);
+    addTest(testSuite, "FileCreateDir", _testFileCreateDir);
+    addTest(testSuite, "FileCreateInvalidType", _testFileCreateInvalidType);
+    addTest(testSuite, "FileCreateAlreadyExists", _testFileCreateAlreadyExists);
+
+    addTest(testSuite, "FileCopyToWithFile", _testFileCopyToWithFile);
+    addTest(testSuite, "FileCopyToWithDirectory", _testFileCopyToWithDirectory);
+    addTest(testSuite, "FileCopyToInvalidDestination", _testFileCopyToInvalidDestination);
+    addTest(testSuite, "FileCopyNullTo", _testFileCopyInvalidTo);
+    addTest(testSuite, "FileCopyToNull", _testFileCopyToNull);
+
+    addTest(testSuite, "FileRemoveDir", _testFileRemoveDir);
+    addTest(testSuite, "FileRemoveDirWithContents", _testFileRemoveDirWithContents);
+    addTest(testSuite, "FileRemoveFile", _testFileRemoveFile);
+    addTest(testSuite, "FileRemoveInvalid", _testFileRemoveInvalid);
+
+    addTest(testSuite, "FileListDirectory", _testFileListDirectory);
+    addTest(testSuite, "FileListDirectoryInvalid", _testFileListDirectoryInvalid);
+    addTest(testSuite, "FileListDirectoryNotExists", _testFileListDirectoryNotExists);
+    addTest(testSuite, "FileListDirectoryEmpty", _testFileListDirectoryEmpty);
+
+    addTest(testSuite, "FileGetSize", _testFileGetSize);
+    addTest(testSuite, "FileGetSizeNotExists", _testFileGetSizeNotExists);
+    addTest(testSuite, "FileGetSizeDirectory", _testFileGetSizeDirectory);
+
+    addTest(testSuite, "FileReadContents", _testFileReadContents);
+    addTest(testSuite, "FileReadContentsNotExists", _testFileReadContentsNotExists);
+    addTest(testSuite, "FileReadContentsDirectory", _testFileReadContentsDirectory);
+
+    addTest(testSuite, "FileReadLines", _testFileReadLines);
+    addTest(testSuite, "FileReadLinesEmpty", _testFileReadLinesEmpty);
+    addTest(testSuite, "FileReadLinesNotExists", _testFileReadLinesNotExists);
+    addTest(testSuite, "FileReadLinesDirectory", _testFileReadLinesDirectory);
+
+    addTest(testSuite, "FileReadBytes", _testFileReadBytes);
+    addTest(testSuite, "FileReadBytesNotExists", _testFileReadBytesNotExists);
+    addTest(testSuite, "FileReadBytesDirectory", _testFileReadBytesDirectory);
+    addTest(testSuite, "FileReadBytesZeroSize", _testFileReadBytesZeroSize);
+    addTest(testSuite, "FileReadBytesGreaterSize", _testFileReadBytesGreaterSize);
+
+    addTest(testSuite, "FileWrite", _testFileWrite);
+    addTest(testSuite, "FileWriteMulitple", _testFileWriteMultiple);
+    addTest(testSuite, "FileWriteInvalid", _testFileWriteInvalid);
+    addTest(testSuite, "FileWriteDirectory", _testFileWriteDirectory);
+
+    addTest(testSuite, "FileWriteBytes", _testFileWriteBytes);
+    addTest(testSuite, "FileWriteBytesInvalid", _testFileWriteBytesInvalid);
+    addTest(testSuite, "FileWriteBytesDirectory", _testFileWriteBytesDirectory);
+
+    addTest(testSuite, "FileGetBasename", _testFileGetBasename);
+    addTest(testSuite, "FileGetBasenameInvalid", _testFileGetBasenameInvalid);
+    addTest(testSuite, "FileGetBasenameDirectory", _testFileGetBasenameDirectory);
+
+    addTest(testSuite, "FileGetParent", _testFileGetParent);
+    addTest(testSuite, "FileGetParentInvalid", _testFileGetParentInvalid);
+
+    addTest(testSuite, "FileGetExtension", _testFileGetExtension);
+    addTest(testSuite, "FileGetExtensionDirectory", _testFileGetExtensionDirectory);
+    addTest(testSuite, "FileGetExtensionInvalid", _testFileGetExtensionInvalid);
+    addTest(testSuite, "FileGetExtensionNone", _testFileGetExtensionNone);
+    addTest(testSuite, "FileGetExtensionWithDotInPath", _testFileGetExtensionWithDotInPath);
+
+    addTest(testSuite, "FileFreeNull", _testFileFreeNull);
+
+    return testSuite;
+}