first

5 files changed, 2434 insertions, 0 deletions

diff --git a/test/base/CharStringTest.c b/test/base/CharStringTest.c
new file mode 100644
index 0000000..aabf206
--- /dev/null
+++ b/test/base/CharStringTest.c
@@ -0,0 +1,422 @@
+#include "unit/TestRunner.h"
+
+static char *const TEST_STRING = "test string";
+static char *const TEST_STRING_CAPS = "TEST STRING";
+static char *const OTHER_TEST_STRING = "other test string";
+
+static int _testNewCharString(void)
+{
+    CharString c = newCharString();
+    assertSizeEquals(kCharStringLengthDefault, c->capacity);
+    assertCharStringEquals(EMPTY_STRING, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testNewCharStringWithCapacity(void)
+{
+    size_t testSize = 123;
+    CharString c = newCharStringWithCapacity(testSize);
+    assertSizeEquals(testSize, c->capacity);
+    assertCharStringEquals(EMPTY_STRING, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testNewObjectWithNullCString(void)
+{
+    CharString c = newCharStringWithCString(NULL);
+    assertSizeEquals(kCharStringLengthDefault, c->capacity);
+    assertCharStringEquals(EMPTY_STRING, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testNewObjectWithEmptyCString(void)
+{
+    CharString c = newCharStringWithCString(EMPTY_STRING);
+    assertSizeEquals(kCharStringLengthDefault, c->capacity);
+    assertCharStringEquals(EMPTY_STRING, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testClearCharString(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    charStringClear(c);
+    assertSizeEquals(kCharStringLengthDefault, c->capacity);
+    assertCharStringEquals(EMPTY_STRING, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCopyToCharString(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    assertSizeEquals(kCharStringLengthDefault, c->capacity);
+    assertCharStringEquals(TEST_STRING, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCopyCharStrings(void)
+{
+    CharString c, c2;
+    c = newCharString();
+    c2 = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    charStringCopy(c2, c);
+    assertCharStringEquals(c2->data, c);
+    freeCharString(c);
+    freeCharString(c2);
+    return 0;
+}
+
+static int _testIsEmptyStringEmpty(void)
+{
+    CharString c = newCharString();
+    assert(charStringIsEmpty(c));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testIsNullEmptyString(void)
+{
+    assert(charStringIsEmpty(NULL));
+    return 0;
+}
+
+static int _testIsRegularStringNotEmpty(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    assertFalse(charStringIsEmpty(c));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testAppendCharStrings(void)
+{
+    CharString a = newCharStringWithCString("a");
+    CharString b = newCharStringWithCString("b");
+    charStringAppend(a, b);
+    assertCharStringEquals("ab", a);
+    freeCharString(a);
+    freeCharString(b);
+    return 0;
+}
+
+static int _testAppendCharStringsOverCapacity(void)
+{
+    CharString a = newCharStringWithCString("a");
+    CharString b = newCharStringWithCString("1234567890");
+    assertSizeEquals((size_t)2, a->capacity);
+    charStringAppend(a, b);
+    assertCharStringEquals("a1234567890", a);
+    assertSizeEquals((size_t)12, a->capacity);
+    freeCharString(a);
+    freeCharString(b);
+    return 0;
+}
+
+static int _testCharStringEqualsSameString(void)
+{
+    CharString c, c2;
+    c = newCharString();
+    c2 = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    charStringCopyCString(c2, TEST_STRING);
+    assert(charStringIsEqualTo(c, c2, false));
+    freeCharString(c);
+    freeCharString(c2);
+    return 0;
+}
+
+static int _testCharStringDoesEqualDifferentString(void)
+{
+    CharString c, c2;
+    c = newCharString();
+    c2 = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    charStringCopyCString(c2, OTHER_TEST_STRING);
+    assertFalse(charStringIsEqualTo(c, c2, false));
+    freeCharString(c);
+    freeCharString(c2);
+    return 0;
+}
+
+static int _testCharStringEqualsSameStringInsensitive(void)
+{
+    CharString c, c2;
+    c = newCharString();
+    c2 = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    charStringCopyCString(c2, TEST_STRING_CAPS);
+    assert(charStringIsEqualTo(c, c2, true));
+    freeCharString(c);
+    freeCharString(c2);
+    return 0;
+}
+
+static int _testCharStringDoesNotEqualSameStringInsensitive(void)
+{
+    CharString c, c2;
+    c = newCharString();
+    c2 = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    charStringCopyCString(c2, TEST_STRING_CAPS);
+    assertFalse(charStringIsEqualTo(c, c2, false));
+    freeCharString(c);
+    freeCharString(c2);
+    return 0;
+}
+
+static int _testCharStringEqualsNull(void)
+{
+    CharString c = newCharString();
+    assertFalse(charStringIsEqualTo(c, NULL, false));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCharStringEqualsSameCString(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    assert(charStringIsEqualToCString(c, TEST_STRING, false));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCharStringNotEqualToDifferentCString(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    assertFalse(charStringIsEqualToCString(c, OTHER_TEST_STRING, false));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCharStringEqualsSameCStringInsensitive(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    assert(charStringIsEqualToCString(c, TEST_STRING_CAPS, true));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCharStringNotEqualsCStringInsensitive(void)
+{
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_STRING);
+    assertFalse(charStringIsEqualToCString(c, TEST_STRING_CAPS, false));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testCharStringEqualsCStringNull(void)
+{
+    CharString c = newCharString();
+    assertFalse(charStringIsEqualToCString(c, NULL, false));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testIsLetter(void)
+{
+    CharString c = newCharStringWithCString("a");
+    assert(charStringIsLetter(c, 0));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testIsNotLetter(void)
+{
+    CharString c = newCharStringWithCString("0");
+    assertFalse(charStringIsLetter(c, 0));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testIsNumber(void)
+{
+    CharString c = newCharStringWithCString("0");
+    assert(charStringIsNumber(c, 0));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testIsNotNumber(void)
+{
+    CharString c = newCharStringWithCString("a");
+    assertFalse(charStringIsNumber(c, 0));
+    freeCharString(c);
+    return 0;
+}
+
+static int _testSplitString(void)
+{
+    CharString c = newCharStringWithCString("abc,def,ghi,");
+    LinkedList l = charStringSplit(c, ',');
+    CharString *items = NULL;
+
+    assertNotNull(l);
+    assertIntEquals(3, linkedListLength(l));
+    items = (CharString *)linkedListToArray(l);
+    assertNotNull(items);
+    assertCharStringEquals("abc", items[0]);
+    assertCharStringEquals("def", items[1]);
+    assertCharStringEquals("ghi", items[2]);
+
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    freeCharString(c);
+    free(items);
+    return 0;
+}
+
+static int _testSplitStringWithoutDelimiter(void)
+{
+    const char *expected = "abcdefg";
+    CharString c = newCharStringWithCString(expected);
+    CharString c2 = NULL;
+    LinkedList l = charStringSplit(c, ',');
+
+    assertNotNull(l);
+    assertIntEquals(1, linkedListLength(l));
+    c2 = l->item;
+    assertCharStringEquals(expected, c2);
+
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testSplitStringNULLDelimiter(void)
+{
+    CharString c = newCharStringWithCString("abcdefh");
+    LinkedList l = charStringSplit(c, 0);
+    assertIsNull(l);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testSplitStringEmptyString(void)
+{
+    CharString c = newCharString();
+    LinkedList l = charStringSplit(c, ',');
+    assertNotNull(l);
+    assertIntEquals(0, linkedListLength(l));
+    freeCharString(c);
+    freeLinkedList(l);
+    return 0;
+}
+
+// This function is not technically public, but we test against it instead of
+// the public version in order to set a shorter line length. This makes test
+// cases much easier to construct.
+extern boolByte _charStringWrap(const char *srcString, char *destString,
+                                size_t destStringSize, int indentSize, int lineLength);
+
+static int _testWrapNullSourceString(void)
+{
+    assertFalse(charStringWrap(NULL, 0));
+    return 0;
+}
+
+static int _testWrapString(void)
+{
+    CharString src = newCharStringWithCString("1234 6789 bcde 01");
+    // Create dest string the same way as in wrapString(), cheap I know...
+    CharString dest = newCharStringWithCapacity(src->capacity * 2);
+    _charStringWrap(src->data, dest->data, dest->capacity, 0, 0x10);
+    assertCharStringEquals("1234 6789 bcde\n01", dest);
+    freeCharString(src);
+    freeCharString(dest);
+    return 0;
+}
+
+static int _testWrapStringWithIndent(void)
+{
+    CharString src = newCharStringWithCString("1234 6789 bcde 01");
+    // Create dest string the same way as in wrapString(), cheap I know...
+    CharString dest = newCharStringWithCapacity(src->capacity * 2);
+    _charStringWrap(src->data, dest->data, dest->capacity, 1, 0xe);
+    assertCharStringEquals(" 1234 6789\n bcde 01", dest);
+    freeCharString(src);
+    freeCharString(dest);
+    return 0;
+}
+
+static int _testWrapStringLongerThanLine(void)
+{
+    CharString src = newCharStringWithCString("123456789abcdef12");
+    // Create dest string the same way as in wrapString(), cheap I know...
+    CharString dest = newCharStringWithCapacity(src->capacity * 2);
+    _charStringWrap(src->data, dest->data, dest->capacity, 0, 0xf);
+    assertCharStringEquals("123456789abcde-\nf12", dest);
+    freeCharString(src);
+    freeCharString(dest);
+    return 0;
+}
+
+static int _testFreeNullCharString(void)
+{
+    freeCharString(NULL);
+    return 0;
+}
+
+TestSuite addCharStringTests(void);
+TestSuite addCharStringTests(void)
+{
+    TestSuite testSuite = newTestSuite("CharString", NULL, NULL);
+
+    addTest(testSuite, "NewObject", _testNewCharString);
+    addTest(testSuite, "NewObjectWithCapacity", _testNewCharStringWithCapacity);
+    addTest(testSuite, "NewObjectWithNullCString", _testNewObjectWithNullCString);
+    addTest(testSuite, "NewObjectWithEmptyCString", _testNewObjectWithEmptyCString);
+
+    addTest(testSuite, "ClearString", _testClearCharString);
+    addTest(testSuite, "CopyToCharString", _testCopyToCharString);
+    addTest(testSuite, "CopyCharStrings", _testCopyCharStrings);
+    addTest(testSuite, "EmptyStringIsEmpty", _testIsEmptyStringEmpty);
+    addTest(testSuite, "NullIsEmpty", _testIsNullEmptyString);
+    addTest(testSuite, "RegularStringIsNotEmpty", _testIsRegularStringNotEmpty);
+
+    addTest(testSuite, "AppendCharStrings", _testAppendCharStrings);
+    addTest(testSuite, "AppendCharStringsOverCapacity", _testAppendCharStringsOverCapacity);
+
+    addTest(testSuite, "EqualsSameString", _testCharStringEqualsSameString);
+    addTest(testSuite, "DoesNotEqualDifferentString", _testCharStringDoesEqualDifferentString);
+    addTest(testSuite, "EqualsSameStringWithCaseInsensitive", _testCharStringEqualsSameStringInsensitive);
+    addTest(testSuite, "DoesNotEqualSameStringWithDifferentCase", _testCharStringDoesNotEqualSameStringInsensitive);
+    addTest(testSuite, "EqualsNull", _testCharStringEqualsNull);
+
+    addTest(testSuite, "EqualsSameCString", _testCharStringEqualsSameCString);
+    addTest(testSuite, "DoesNotEqualDifferentCString", _testCharStringNotEqualToDifferentCString);
+    addTest(testSuite, "EqualsSameCStringWithCaseInsensitive", _testCharStringEqualsSameCStringInsensitive);
+    addTest(testSuite, "DoesNotEqualSameCStringWithDifferentCase", _testCharStringNotEqualsCStringInsensitive);
+    addTest(testSuite, "EqualsCStringNull", _testCharStringEqualsCStringNull);
+
+    addTest(testSuite, "IsLetter", _testIsLetter);
+    addTest(testSuite, "IsNotLetter", _testIsNotLetter);
+    addTest(testSuite, "IsNumber", _testIsNumber);
+    addTest(testSuite, "IsNotNumber", _testIsNotNumber);
+
+    addTest(testSuite, "SplitString", _testSplitString);
+    addTest(testSuite, "SplitStringWithoutDelimiter", _testSplitStringWithoutDelimiter);
+    addTest(testSuite, "SplitStringNULLDelimiter", _testSplitStringNULLDelimiter);
+    addTest(testSuite, "SplitStringEmptyString", _testSplitStringEmptyString);
+
+    addTest(testSuite, "WrapNullSourceString", _testWrapNullSourceString);
+    addTest(testSuite, "WrapString", _testWrapString);
+    addTest(testSuite, "WrapStringWithIndent", _testWrapStringWithIndent);
+    addTest(testSuite, "WrapStringLongerThanLine", _testWrapStringLongerThanLine);
+
+    addTest(testSuite, "FreeNullCharString", _testFreeNullCharString);
+
+    return testSuite;
+}
diff --git a/test/base/EndianTest.c b/test/base/EndianTest.c
new file mode 100644
index 0000000..5b64fb2
--- /dev/null
+++ b/test/base/EndianTest.c
@@ -0,0 +1,155 @@
+#include "unit/TestRunner.h"
+#include "base/Endian.h"
+
+#include "unit/TestRunner.h"
+
+#if LINUX
+#if defined(__BYTE_ORDER__)
+#define HOST_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define HOST_LITTLE_ENDIAN (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#endif
+#elif MACOSX
+#include <machine/endian.h>
+#define HOST_BIG_ENDIAN (__DARWIN_BYTE_ORDER == __DARWIN_BIG_ENDIAN)
+#define HOST_LITTLE_ENDIAN (__DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN)
+#elif WINDOWS
+// Windows is always little-endian, see: http://support.microsoft.com/kb/102025
+#define HOST_BIG_ENDIAN 0
+#define HOST_LITTLE_ENDIAN 1
+#endif
+
+#if !defined(HOST_BIG_ENDIAN) || !defined(HOST_LITTLE_ENDIAN)
+#error Host platform endian-ness not known
+#error Please define either HOST_BIG_ENDIAN or HOST_LITTLE_ENDIAN
+#elif HOST_BIG_ENDIAN && HOST_LITTLE_ENDIAN
+#error Both HOST_BIG_ENDIAN and HOST_LITTLE_ENDIAN cannot be defined to 1!
+#endif
+
+static int _testFlipShortEndian(void)
+{
+    unsigned short s = 0xabcd;
+    unsigned short r = flipShortEndian(s);
+    assertUnsignedLongEquals(0xcdabul, r);
+    assertIntEquals(s, flipShortEndian(r));
+    return 0;
+}
+
+static int _testConvertBigEndianShortToPlatform(void)
+{
+    unsigned short s = 0xabcd;
+    unsigned short r = convertBigEndianShortToPlatform(s);
+#if HOST_BIG_ENDIAN
+    assertUnsignedLongEquals(s, (unsigned long)r);
+#elif HOST_LITTLE_ENDIAN
+    assertUnsignedLongEquals((unsigned long)s, (unsigned long)flipShortEndian(r));
+#endif
+    return 0;
+}
+
+static int _testConvertBigEndianIntToPlatform(void)
+{
+    unsigned int i = 0xdeadbeef;
+    unsigned int r = convertBigEndianIntToPlatform(i);
+#if HOST_BIG_ENDIAN
+    assertUnsignedLongEquals((unsigned long)i, r);
+#elif HOST_LITTLE_ENDIAN
+    assertUnsignedLongEquals(0xefbeaddeul, r);
+#endif
+    return 0;
+}
+
+static int _testConvertLittleEndianIntToPlatform(void)
+{
+    unsigned int i = 0xdeadbeef;
+    unsigned int r = convertLittleEndianIntToPlatform(i);
+#if HOST_BIG_ENDIAN
+    assertUnsignedLongEquals(0xefbeaddeul, r);
+#elif HOST_LITTLE_ENDIAN
+    assertUnsignedLongEquals((unsigned long)i, r);
+#endif
+    return 0;
+}
+
+static int _testConvertBigEndianFloatToPlatform(void)
+{
+    // Generate an integer with a known value and convert it to a float using pointer trickery
+    int i = 0xdeadbeef;
+    int i2 = 0xefbeadbe;
+    float *f = (float *)&i;
+    float *f2 = (float *)&i2;
+    float r = convertBigEndianFloatToPlatform(*f);
+    // Unfortunately, the above pointer trickery will result in a really huge number, so the
+    // standard comparison tolerance is *way* too low. This number is the lowest possible
+    // result that we should accept for this test.
+    const double bigFloatTolerance = 3.02231e+24;
+
+#if HOST_BIG_ENDIAN
+    assertDoubleEquals(*f, r);
+#elif HOST_LITTLE_ENDIAN
+    // Sanity check to make sure that the actual result is the really huge number which we
+    // are expecting.
+    assert(fabs(r) > bigFloatTolerance);
+    assertDoubleEquals(*f2, r, bigFloatTolerance);
+#endif
+    return 0;
+}
+
+static int _testConvertByteArrayToUnsignedShort(void)
+{
+    byte *b = (byte *)malloc(sizeof(byte) * 2);
+    int i;
+    unsigned short s;
+
+    for (i = 0; i < 2; i++) {
+        b[i] = (byte)(0xaa + i);
+    }
+
+    s = convertByteArrayToUnsignedShort(b);
+
+#if HOST_BIG_ENDIAN
+    assertUnsignedLongEquals(0xaaabul, s);
+#elif HOST_LITTLE_ENDIAN
+    assertUnsignedLongEquals(0xabaaul, s);
+#endif
+
+    free(b);
+    return 0;
+}
+
+static int _testConvertByteArrayToUnsignedInt(void)
+{
+    byte *b = (byte *)malloc(sizeof(byte) * 4);
+    unsigned int s;
+
+    for (size_t i = 0; i < 4; i++) {
+        b[i] = (byte)(0xaa + i);
+    }
+    s = convertByteArrayToUnsignedInt(b);
+
+
+#if HOST_BIG_ENDIAN
+    assertUnsignedLongEquals(0xaaabacadul, s);
+#elif HOST_LITTLE_ENDIAN
+    assertUnsignedLongEquals(0xadacabaaul, s);
+#endif
+
+    free(b);
+    return 0;
+}
+
+TestSuite addEndianTests(void);
+TestSuite addEndianTests(void)
+{
+    TestSuite testSuite = newTestSuite("Endian", NULL, NULL);
+
+    addTest(testSuite, "FlipShortEndian", _testFlipShortEndian);
+    addTest(testSuite, "ConvertBigEndianShortToPlatform", _testConvertBigEndianShortToPlatform);
+    addTest(testSuite, "ConvertBigEndianIntToPlatform", _testConvertBigEndianIntToPlatform);
+    addTest(testSuite, "ConvertLittleEndianIntToPlatform", _testConvertLittleEndianIntToPlatform);
+    addTest(testSuite, "ConvertBigEndianFloatToPlatform", _testConvertBigEndianFloatToPlatform);
+
+    addTest(testSuite, "ConvertByteArrayToUnsignedShort", _testConvertByteArrayToUnsignedShort);
+    addTest(testSuite, "ConvertByteArrayToUnsignedInt", _testConvertByteArrayToUnsignedInt);
+
+    return testSuite;
+}
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;
+}
diff --git a/test/base/LinkedListTest.c b/test/base/LinkedListTest.c
new file mode 100644
index 0000000..15b4290
--- /dev/null
+++ b/test/base/LinkedListTest.c
@@ -0,0 +1,245 @@
+#include <stdlib.h>
+#include "unit/TestRunner.h"
+
+static char *const TEST_ITEM_STRING = "test string";
+static char *const OTHER_TEST_ITEM_STRING = "other test string";
+
+static boolByte _gNumForeachCallbacksMade;
+static boolByte _gForeachCallbackOk;
+
+static void _linkedListTestSetup(void)
+{
+    _gNumForeachCallbacksMade = 0;
+    _gForeachCallbackOk = false;
+}
+
+static int _testNewLinkedList(void)
+{
+    LinkedList l = newLinkedList();
+    assertNotNull(l);
+    assertIsNull(l->nextItem);
+    assertIntEquals(0, linkedListLength(l));
+    assert(l->item == NULL);
+    freeLinkedList(l);
+    return 0;
+}
+
+static int _testAppendItemToList(void)
+{
+    LinkedList l = newLinkedList();
+    CharString c = newCharString();
+    charStringCopyCString(c, TEST_ITEM_STRING);
+    linkedListAppend(l, c);
+    assertNotNull(l->item);
+    assertCharStringEquals(TEST_ITEM_STRING, ((CharString)l->item));
+    assertIsNull(l->nextItem);
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    return 0;
+}
+
+static int _testAppendMultipleItemsToList(void)
+{
+    LinkedListIterator i;
+    LinkedList l = newLinkedList();
+    CharString c = newCharString();
+    CharString c2 = newCharString();
+
+    charStringCopyCString(c, TEST_ITEM_STRING);
+    charStringCopyCString(c2, OTHER_TEST_ITEM_STRING);
+    linkedListAppend(l, c);
+    linkedListAppend(l, c2);
+    assertNotNull(l->item);
+    assertCharStringEquals(TEST_ITEM_STRING, ((CharString)l->item));
+    assertNotNull(l->nextItem);
+    i = (LinkedListIterator)(l->nextItem);
+    assertNotNull(i->item);
+    assertCharStringEquals(OTHER_TEST_ITEM_STRING, ((CharString)i->item));
+    assertIsNull(i->nextItem);
+    assertIntEquals(2, linkedListLength(l));
+
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    return 0;
+}
+
+static int _testAppendNullItemToList(void)
+{
+    LinkedList l = newLinkedList();
+    linkedListAppend(l, NULL);
+    assertIsNull(l->item);
+    assertIsNull(l->nextItem);
+    assertIntEquals(0, linkedListLength(l));
+    freeLinkedList(l);
+    return 0;
+}
+
+static int _testAppendItemToNullList(void)
+{
+    CharString c = newCharString();
+    // The test here is not to crash
+    linkedListAppend(NULL, c);
+    freeCharString(c);
+    return 0;
+}
+
+static int _testNumItemsInList(void)
+{
+    CharString c;
+    int i;
+    LinkedList l = newLinkedList();
+
+    for (i = 0; i < 100; i++) {
+        c = newCharString();
+        charStringCopyCString(c, TEST_ITEM_STRING);
+        linkedListAppend(l, c);
+    }
+
+    assertIntEquals(100, linkedListLength(l));
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    return 0;
+}
+
+static int _testNumItemsInNullList(void)
+{
+    assertIntEquals(0, linkedListLength(NULL));
+    return 0;
+}
+
+static int _testLinkedListToArray(void)
+{
+    LinkedList l = newLinkedList();
+    CharString *arr;
+    CharString c;
+
+    linkedListAppend(l, newCharStringWithCString("one"));
+    linkedListAppend(l, newCharStringWithCString("two"));
+
+    arr = (CharString *)linkedListToArray(l);
+    assertNotNull(arr);
+    c = (CharString)arr[0];
+    assertCharStringEquals("one", c);
+    c = (CharString)arr[1];
+    assertCharStringEquals("two", c);
+    assertIsNull(arr[2]);
+
+    free(arr);
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    return 0;
+}
+
+static int _testLinkedListToArrayWithNull(void)
+{
+    CharString **arr;
+    arr = (CharString **)linkedListToArray(NULL);
+    assertIsNull(arr);
+    return 0;
+}
+
+static int _testLinkedListWithEmptyList(void)
+{
+    CharString **arr;
+    LinkedList l = newLinkedList();
+    arr = (CharString **)linkedListToArray(l);
+    assertIsNull(arr);
+    freeLinkedList(l);
+    return 0;
+}
+
+
+static void _linkedListEmptyCallback(void *item, void *userData)
+{
+    _gNumForeachCallbacksMade++;
+}
+
+static int _testForeachOverNullList(void)
+{
+    linkedListForeach(NULL, _linkedListEmptyCallback, NULL);
+    assertIntEquals(0, _gNumForeachCallbacksMade);
+    return 0;
+}
+
+static int _testForeachOverEmptyList(void)
+{
+    LinkedList l = newLinkedList();
+    linkedListForeach(l, _linkedListEmptyCallback, NULL);
+    assertIntEquals(0, _gNumForeachCallbacksMade);
+    freeLinkedList(l);
+    return 0;
+}
+
+static void _linkedListTestStringCallback(void *item, void *userData)
+{
+    CharString charString = (CharString)item;
+    _gForeachCallbackOk = charStringIsEqualToCString(charString, TEST_ITEM_STRING, false);
+    _gNumForeachCallbacksMade++;
+}
+
+static int _testForeachOverList(void)
+{
+    LinkedList l = newLinkedList();
+    CharString c = newCharString();
+
+    charStringCopyCString(c, TEST_ITEM_STRING);
+    linkedListAppend(l, c);
+    linkedListForeach(l, _linkedListTestStringCallback, NULL);
+    assertIntEquals(1, _gNumForeachCallbacksMade);
+    assert(_gForeachCallbackOk);
+
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    return 0;
+}
+
+static void _linkedListUserDataCallback(void *item, void *userData)
+{
+    CharString charString = (CharString)userData;
+    _gForeachCallbackOk = charStringIsEqualToCString(charString, TEST_ITEM_STRING, false);
+    _gNumForeachCallbacksMade++;
+}
+
+static int _testForeachOverUserData(void)
+{
+    LinkedList l = newLinkedList();
+    CharString c = newCharString();
+
+    charStringCopyCString(c, TEST_ITEM_STRING);
+    linkedListAppend(l, c);
+    linkedListForeach(l, _linkedListUserDataCallback, c);
+    assertIntEquals(1, _gNumForeachCallbacksMade);
+    assert(_gForeachCallbackOk);
+
+    freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
+    return 0;
+}
+
+static int _testFreeNullLinkedList(void)
+{
+    freeLinkedList(NULL);
+    return 0;
+}
+
+TestSuite addLinkedListTests(void);
+TestSuite addLinkedListTests(void)
+{
+    TestSuite testSuite = newTestSuite("LinkedList", _linkedListTestSetup, NULL);
+    addTest(testSuite, "NewObject", _testNewLinkedList);
+
+    addTest(testSuite, "AppendItem", _testAppendItemToList);
+    addTest(testSuite, "AppendMultipleItems", _testAppendMultipleItemsToList);
+    addTest(testSuite, "AppendNullItem", _testAppendNullItemToList);
+    addTest(testSuite, "AppendItemToNullList", _testAppendItemToNullList);
+
+    addTest(testSuite, "NumItemsInList", _testNumItemsInList);
+    addTest(testSuite, "NumItemsInNullList", _testNumItemsInNullList);
+
+    addTest(testSuite, "LinkedListToArray", _testLinkedListToArray);
+    addTest(testSuite, "LinkedListToArrayWithNull", _testLinkedListToArrayWithNull);
+    addTest(testSuite, "LinkedListWithEmptyList", _testLinkedListWithEmptyList);
+
+    addTest(testSuite, "ForeachOverNullList", _testForeachOverNullList);
+    addTest(testSuite, "ForeachOverEmptyList", _testForeachOverEmptyList);
+    addTest(testSuite, "ForeachOverList", _testForeachOverList);
+    addTest(testSuite, "ForeachWithUserData", _testForeachOverUserData);
+
+    addTest(testSuite, "FreeNullLinkedList", _testFreeNullLinkedList);
+
+    return testSuite;
+}
diff --git a/test/base/PlatformInfoTest.c b/test/base/PlatformInfoTest.c
new file mode 100644
index 0000000..4744602
--- /dev/null
+++ b/test/base/PlatformInfoTest.c
@@ -0,0 +1,86 @@
+#include "unit/TestRunner.h"
+#include "base/PlatformInfo.h"
+
+static int _testGetPlatformType(void)
+{
+    PlatformInfo platform = newPlatformInfo();
+#if LINUX
+    assertIntEquals(PLATFORM_LINUX, platform->type);
+#elif MACOSX
+    assertIntEquals(PLATFORM_MACOSX, platform->type);
+#elif WINDOWS
+    assertIntEquals(PLATFORM_WINDOWS, platform->type);
+#else
+    assertIntEquals(PLATFORM_UNSUPPORTED, platform->type);
+#endif
+    freePlatformInfo(platform);
+    return 0;
+}
+
+static int _testGetPlatformName(void)
+{
+    PlatformInfo platform = newPlatformInfo();
+#if LINUX
+    assertCharStringContains("Linux", platform->name);
+#elif MACOSX
+    assertCharStringContains("Mac OS X", platform->name);
+#elif WINDOWS
+    assertCharStringContains("Windows", platform->name);
+#else
+    assertCharStringEquals("Unsupported platform", platform->name);
+#endif
+    freePlatformInfo(platform);
+    return 0;
+}
+
+static int _testGetShortPlatformName(void)
+{
+    PlatformInfo platform = newPlatformInfo();
+#if LINUX
+
+    if (platformInfoIsHost64Bit() && platformInfoIsRuntime64Bit()) {
+        assertCharStringEquals("Linux-x86_64", platform->shortName);
+    } else {
+        assertCharStringEquals("Linux-i686", platform->shortName);
+    }
+
+#elif MACOSX
+    assertCharStringEquals("Mac OS X", platform->shortName);
+#elif WINDOWS
+
+    if (platformInfoIsHost64Bit() && platformInfoIsRuntime64Bit()) {
+        assertCharStringEquals("Windows 64-bit", platform->shortName);
+    } else {
+        assertCharStringEquals("Windows 32-bit", platform->shortName);
+    }
+
+#else
+    assertCharStringEquals("Unsupported", platform->shortName);
+#endif
+    freePlatformInfo(platform);
+    return 0;
+}
+
+static int _testIsHostLittleEndian(void)
+{
+#if HOST_BIG_ENDIAN
+    assertFalse(isHostLittleEndian());
+#elif HOST_LITTLE_ENDIAN
+    assert(isHostLittleEndian());
+#endif
+    return 0;
+}
+
+TestSuite addPlatformInfoTests(void);
+TestSuite addPlatformInfoTests(void)
+{
+    TestSuite testSuite = newTestSuite("PlatformInfo", NULL, NULL);
+
+    addTest(testSuite, "GetPlatformType", _testGetPlatformType);
+    addTest(testSuite, "GetPlatformName", _testGetPlatformName);
+    addTest(testSuite, "GetShortPlatformName", _testGetShortPlatformName);
+
+    addTest(testSuite, "IsHostLittleEndian", _testIsHostLittleEndian);
+
+    return testSuite;
+}