summaryrefslogtreecommitdiff
path: root/test/base
diff options
context:
space:
mode:
Diffstat (limited to 'test/base')
-rw-r--r--test/base/CharStringTest.c422
-rw-r--r--test/base/EndianTest.c155
-rw-r--r--test/base/FileTest.c1526
-rw-r--r--test/base/LinkedListTest.c245
-rw-r--r--test/base/PlatformInfoTest.c86
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;
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-12-11 04:07:01 +0000