Add unit tests and fix issues uncovered by tests

Resolves #1

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "C_Cpp.default.compileCommands": "/home/jkent/esp/ramfs/builddir/compile_commands.json",
+    "C_Cpp.default.configurationProvider": "mesonbuild.mesonbuild"
+}

include/ramfs/ramfs.h

@@ -180,6 +180,7 @@ ssize_t ramfs_write(ramfs_fh_t *fh, const char *buf, size_t len);
  * \param[in]   fh      \a ramfs_fh_t handle
  * \param[in]   offset  file position (relative or absolute)
  * \param[in]   mode    \a SEEK_SET, SEEK_CUR, or \a SEEK_END
+ * \return              position in file, or -1 on error
  */
 ssize_t ramfs_seek(ramfs_fh_t *fh, off_t offset, int mode);
 

meson.build

@@ -25,3 +25,5 @@ ramfs_dep = declare_dependency(
 )
 
 meson.override_dependency('ramfs', ramfs_dep)
+
+subdir('tests')

src/ramfs_rbtree.c

@@ -612,13 +612,14 @@ int ramfs_rmdir(ramfs_entry_t *entry)
     }
 
     ramfs_dir_t *dir = (ramfs_dir_t *) entry;
+    ramfs_dir_t *parent = entry->parent;
 
     if (dir->rbtree.count > 0) {
         errno = ENOTEMPTY;
         return -1;
     }
 
-    ramfs_rbtree_delete_node(&dir->rbtree, &dir->entry.rbnode);
+    ramfs_rbtree_delete_node(&parent->rbtree, &dir->entry.rbnode);
     free((void *) dir->entry.rbnode.key);
     free(dir);
     return 0;
@@ -633,14 +634,21 @@ void ramfs_rmtree(ramfs_entry_t *entry)
         return;
     }
 
-    ramfs_rbtree_t *rbtree = &entry->parent->rbtree;
-    while ((entry = (ramfs_entry_t *) ramfs_rbtree_last(rbtree)) != NULL) {
-        if (ramfs_is_dir(entry)) {
-            ramfs_rmtree(entry);
+    ramfs_entry_t *child;
+    ramfs_dir_t *dir = (ramfs_dir_t *) entry;
+    ramfs_rbtree_t *rbtree = (ramfs_rbtree_t *) dir->rbtree.root;
+
+    while ((child = (ramfs_entry_t *) ramfs_rbtree_last(rbtree)) != NULL) {
+        if (ramfs_is_dir(child)) {
+            ramfs_rmtree(child);
         } else {
-            free(((ramfs_file_t *) entry)->data);
+            free(((ramfs_file_t *) child)->data);
         }
-        ramfs_rbtree_delete_node(rbtree, &entry->rbnode);
+        ramfs_rbtree_delete_node(rbtree, &child->rbnode);
+        free((void *) child->rbnode.key);
+        free(child);
+    }
+    if (entry->parent != NULL) {
         free((void *) entry->rbnode.key);
         free(entry);
     }

src/ramfs_vector.c

@@ -135,7 +135,7 @@ static ramfs_entry_t *remove(ramfs_entry_t *entry)
         return NULL;
     }
 
-    return remove_index(entry, i);
+    return remove_index(&entry->parent->entry, i);
 }
 
 ramfs_fs_t *ramfs_init(void)
@@ -741,6 +741,8 @@ void ramfs_rmtree(ramfs_entry_t *entry)
             free(dir->children[i]);
         }
     }
-    free((void *) entry->name);
-    free(entry);
+    if (entry->parent != NULL) {
+        free((void *) entry->name);
+        free(entry);
+    }
 }

tests/create.c

@@ -0,0 +1,24 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+    ramfs_entry_t *file;
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    file = ramfs_create(fs, "test", 0);
+    assert(file != NULL);
+
+    ramfs_deinit(fs);
+    fs = NULL;
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}

tests/deinit.c

@@ -0,0 +1,20 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    ramfs_deinit(fs);
+    fs = NULL;
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}

tests/init.c

@@ -0,0 +1,17 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}

tests/issue_1.c

@@ -0,0 +1,63 @@
+#include <assert.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+    ramfs_entry_t *dir, *file;
+    ramfs_fh_t *fh;
+    char buf[25];
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    dir = ramfs_mkdir(fs, "dir");
+    assert(dir != NULL);
+
+    file = ramfs_create(fs, "dir/test_file.txt", 0);
+    assert(file != NULL);
+
+    fh = ramfs_open(fs, file, O_WRONLY);
+    assert(fh != NULL);
+
+    assert(ramfs_write(fh, "This is dir/test_file.txt", 25) == 25);
+
+    ramfs_close(fh);
+
+    assert(ramfs_rename(fs, "dir/test_file.txt", "dir/test_file_new.txt") == 0);
+
+    file = ramfs_get_entry(fs, "dir/test_file_new.txt");
+    assert(file != NULL);
+
+    fh = ramfs_open(fs, file, O_RDONLY);
+    assert(fh != NULL);
+
+    assert(ramfs_read(fh, buf, 25) == 25);
+
+    assert(memcmp(buf, "This is dir/test_file.txt", 25) == 0);
+
+    ramfs_close(fh);
+
+    file = ramfs_get_entry(fs, "dir/test_file.txt");
+    assert(file == NULL);
+
+    file = ramfs_get_entry(fs, "dir/test_file_new.txt");
+    assert(file != NULL);
+    assert(ramfs_unlink(file) == 0);
+
+    file = ramfs_get_entry(fs, "dir/test_file_new.txt");
+    assert(file == NULL);
+
+    ramfs_deinit(fs);
+    fs = NULL;
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}

tests/meson.build

@@ -0,0 +1,54 @@
+e = executable('init', 'init.c',
+    dependencies: [ramfs_dep],
+)
+test('init', e)
+
+e = executable('deinit', 'deinit.c',
+    dependencies: [ramfs_dep],
+)
+test('deinit', e)
+
+e = executable('mkdir', 'mkdir.c',
+    dependencies: [ramfs_dep],
+)
+test('mkdir', e)
+
+e = executable('rmdir', 'rmdir.c',
+    dependencies: [ramfs_dep],
+)
+test('rmdir', e)
+
+e = executable('create', 'create.c',
+    dependencies: [ramfs_dep],
+)
+test('create', e)
+
+e = executable('unlink', 'unlink.c',
+    dependencies: [ramfs_dep],
+)
+test('unlink', e)
+
+e = executable('open', 'open.c',
+    dependencies: [ramfs_dep],
+)
+test('open', e)
+
+e = executable('write', 'write.c',
+    dependencies: [ramfs_dep],
+)
+test('write', e)
+
+e = executable('read', 'read.c',
+    dependencies: [ramfs_dep],
+)
+test('read', e)
+
+e = executable('seek', 'seek.c',
+    dependencies: [ramfs_dep],
+)
+test('seek', e)
+
+e = executable('issue_1', 'issue_1.c',
+    dependencies: [ramfs_dep],
+)
+test('issue_1', e)

tests/mkdir.c

@@ -0,0 +1,24 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+    ramfs_entry_t *dir;
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    dir = ramfs_mkdir(fs, "test");
+    assert(dir != NULL);
+
+    ramfs_deinit(fs);
+    fs = NULL;
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}

tests/open.c

@@ -0,0 +1,31 @@
+#include <assert.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+    ramfs_entry_t *file;
+    ramfs_fh_t *fh;
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    file = ramfs_create(fs, "test", 0);
+    assert(file != NULL);
+
+    fh = ramfs_open(fs, file, 0);
+    assert(fh != NULL);
+
+    ramfs_close(fh);
+
+    ramfs_deinit(fs);
+    fs = NULL;
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}

tests/read.c

@@ -0,0 +1,45 @@
+#include <assert.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ramfs/ramfs.h"
+
+
+int main(int argc, char *argv[])
+{
+    ramfs_fs_t *fs;
+    ramfs_entry_t *file;
+    ramfs_fh_t *fh;
+    char buf[12];
+
+    fs = ramfs_init();
+    assert(fs != NULL);
+
+    file = ramfs_create(fs, "test", 0);
+    assert(file != NULL);
+
+    fh = ramfs_open(fs, file, O_WRONLY);
+    assert(fh != NULL);
+
+    assert(ramfs_write(fh, "Hello World!", 12) == 12);
+
+    ramfs_close(fh);
+
+    fh = ramfs_open(fs, file, O_RDONLY);
+    assert(fh != NULL);
+
+    assert(ramfs_read(fh, buf, 12) == 12);
+
+    assert(memcmp(buf, "Hello World!", 12) == 0);
+
+    ramfs_close(fh);
+
+    ramfs_deinit(fs);
+    fs = NULL;
+
+    exit(EXIT_SUCCESS);
+    return 0;
+}