added filesystem interface

test-src/webfuse/filesystem/test_accessmode.cpp

@@ -0,0 +1,26 @@
+#include "webfuse/filesystem/accessmode.hpp"
+#include <gtest/gtest.h>
+
+using webfuse::access_mode;
+
+TEST(accessmode, f_ok)
+{
+    ASSERT_EQ(0, access_mode::f_ok);
+    ASSERT_EQ(F_OK, access_mode::f_ok);
+}
+
+class accessmode_test: public testing::TestWithParam<int> { };
+
+TEST_P(accessmode_test, conversion)
+{
+    int const expected = GetParam();
+    auto mode = access_mode::from_int(expected);
+    ASSERT_EQ(expected, mode.to_int());
+}
+
+INSTANTIATE_TEST_CASE_P(accesmode_values, accessmode_test, 
+    testing::Values(
+        F_OK, R_OK, W_OK, X_OK, 
+        R_OK | W_OK, R_OK | X_OK, W_OK | X_OK, 
+        R_OK | W_OK | X_OK)
+);

test-src/webfuse/filesystem/test_fileattributes.cpp

@@ -0,0 +1,101 @@
+#include "webfuse/filesystem/fileattributes.hpp"
+
+#include <gtest/gtest.h>
+
+using webfuse::file_attributes;
+using webfuse::user_id;
+using webfuse::group_id;
+using webfuse::filemode;
+
+TEST(file_attibutes, create_empty)
+{
+    file_attributes attributes;
+
+    ASSERT_EQ(0, attributes.inode);
+    ASSERT_EQ(0, attributes.nlink);
+    ASSERT_EQ(0, attributes.mode);
+    ASSERT_EQ(user_id::invalid, attributes.uid);
+    ASSERT_EQ(group_id::invalid, attributes.gid);
+    ASSERT_EQ(0, attributes.rdev);
+    ASSERT_EQ(0, attributes.size);
+    ASSERT_EQ(0, attributes.blocks);
+    ASSERT_EQ(0, attributes.atime.seconds);
+    ASSERT_EQ(0, attributes.atime.nsec);
+    ASSERT_EQ(0, attributes.mtime.seconds);
+    ASSERT_EQ(0, attributes.mtime.nsec);
+    ASSERT_EQ(0, attributes.ctime.seconds);
+    ASSERT_EQ(0, attributes.ctime.nsec);
+}
+
+TEST(file_attibutes, from_stat)
+{
+    struct stat info;
+    info.st_ino = 1;
+    info.st_nlink = 2;
+    info.st_mode = S_IFREG | 0644;
+    info.st_uid = 1000;
+    info.st_gid = 1234;
+    info.st_rdev = 0;
+    info.st_size = 21 * 1024;
+    info.st_blocks = 42;
+    info.st_atim.tv_sec = 1;
+    info.st_atim.tv_nsec = 2;
+    info.st_mtim.tv_sec = 3;
+    info.st_mtim.tv_nsec = 4;
+    info.st_ctim.tv_sec = 5;
+    info.st_ctim.tv_nsec = 6;
+
+    file_attributes attributes(info);
+
+    ASSERT_EQ(info.st_ino, attributes.inode);
+    ASSERT_EQ(info.st_nlink, attributes.nlink);
+    ASSERT_EQ(info.st_mode, attributes.mode.to_mode());
+    ASSERT_EQ(info.st_uid, attributes.uid.to_uid());
+    ASSERT_EQ(info.st_gid, attributes.gid.to_gid());
+    ASSERT_EQ(info.st_rdev, attributes.rdev);
+    ASSERT_EQ(info.st_size, attributes.size);
+    ASSERT_EQ(info.st_blocks, attributes.blocks);
+    ASSERT_EQ(info.st_atim.tv_sec, attributes.atime.seconds);
+    ASSERT_EQ(info.st_atim.tv_nsec, attributes.atime.nsec);
+    ASSERT_EQ(info.st_mtim.tv_sec, attributes.mtime.seconds);
+    ASSERT_EQ(info.st_mtim.tv_nsec, attributes.mtime.nsec);
+    ASSERT_EQ(info.st_ctim.tv_sec, attributes.ctime.seconds);
+    ASSERT_EQ(info.st_ctim.tv_nsec, attributes.ctime.nsec);
+}
+
+TEST(file_attibutes, to_stat)
+{
+    file_attributes attributes;
+    attributes.inode = 1;
+    attributes.nlink = 2;
+    attributes.mode = filemode(S_IFREG | 0644);
+    attributes.uid = user_id(1000);
+    attributes.gid = group_id(1234);
+    attributes.rdev = 0;
+    attributes.size = 21 * 1024;
+    attributes.blocks = 42;
+    attributes.atime.seconds = 1;
+    attributes.atime.nsec = 2;
+    attributes.mtime.seconds = 3;
+    attributes.mtime.nsec = 4;
+    attributes.ctime.seconds = 5;
+    attributes.ctime.nsec = 6;
+
+    struct stat info;
+    attributes.to_stat(info);
+
+    ASSERT_EQ(attributes.inode, info.st_ino);
+    ASSERT_EQ(attributes.nlink, info.st_nlink);
+    ASSERT_EQ(attributes.mode.to_mode(), info.st_mode);
+    ASSERT_EQ(attributes.uid.to_uid(), info.st_uid);
+    ASSERT_EQ(attributes.gid.to_gid(), info.st_gid);
+    ASSERT_EQ(attributes.rdev, info.st_rdev);
+    ASSERT_EQ(attributes.size, info.st_size);
+    ASSERT_EQ(attributes.blocks, info.st_blocks);
+    ASSERT_EQ(attributes.atime.seconds, info.st_atim.tv_sec);
+    ASSERT_EQ(attributes.atime.nsec, info.st_atim.tv_nsec);
+    ASSERT_EQ(attributes.mtime.seconds, info.st_mtim.tv_sec);
+    ASSERT_EQ(attributes.mtime.nsec, info.st_mtim.tv_nsec);
+    ASSERT_EQ(attributes.ctime.seconds, info.st_ctim.tv_sec);
+    ASSERT_EQ(attributes.ctime.nsec, info.st_ctim.tv_nsec);
+}

test-src/webfuse/filesystem/test_filemode.cpp

@@ -0,0 +1,25 @@
+#include "webfuse/filesystem/filemode.hpp"
+#include <gtest/gtest.h>
+
+using webfuse::filemode;
+
+class filemode_test: public testing::TestWithParam<mode_t> { };
+
+TEST_P(filemode_test, conversion)
+{
+    mode_t const expected = GetParam();
+    auto value = filemode::from_mode(expected);
+    ASSERT_EQ(expected, value.to_mode());
+}
+
+INSTANTIATE_TEST_CASE_P(filemode_value, filemode_test,
+    testing::Values(
+        S_IROTH, S_IWOTH, S_IXOTH,
+        S_IRGRP, S_IWGRP, S_IXGRP,        
+        S_IRUSR, S_IWUSR, S_IXUSR,
+        S_ISUID, S_ISGID, S_ISVTX,     
+        S_IFREG, S_IFCHR, S_IFBLK, S_IFDIR, S_IFIFO, S_IFLNK, S_IFSOCK,
+        S_IFREG | 0644,
+        S_IFDIR | 0755
+    )
+);

test-src/webfuse/filesystem/test_groupid.cpp

@@ -0,0 +1,27 @@
+#include "webfuse/filesystem/groupid.hpp"
+#include <gtest/gtest.h>
+
+using webfuse::group_id;
+
+TEST(group_id, invalid)
+{
+    group_id invalid_group;
+
+    ASSERT_EQ(group_id::invalid, invalid_group);
+}
+
+TEST(group_id, to_gid)
+{
+    group_id group(69);
+    gid_t id = group.to_gid();
+
+    ASSERT_EQ(69, id);
+}
+
+TEST(group_id, from_gid)
+{
+    gid_t id = 99;
+    auto group = group_id::from_gid(id);
+
+    ASSERT_EQ(99, group);
+}

test-src/webfuse/filesystem/test_openflags.cpp

@@ -0,0 +1,24 @@
+#include "webfuse/filesystem/openflags.hpp"
+#include <gtest/gtest.h>
+#include <fcntl.h>
+
+using webfuse::openflags;
+
+class openflags_test: public testing::TestWithParam<int> { };
+
+TEST_P(openflags_test, conversion)
+{
+    int const expected = GetParam();
+    auto flags = openflags::from_int(expected);
+    ASSERT_EQ(expected, flags.to_int());
+}
+
+INSTANTIATE_TEST_CASE_P(openflags_values, openflags_test,
+    testing::Values<>(
+        O_RDONLY, O_WRONLY, O_RDWR, O_CLOEXEC, O_CREAT,
+        O_DIRECT, O_DIRECTORY, O_EXCL, O_NOCTTY, O_NOFOLLOW,
+        O_TRUNC, O_ASYNC, O_LARGEFILE, O_NOATIME, O_NONBLOCK,
+        O_NDELAY, O_SYNC,
+        O_WRONLY | O_CREAT | O_TRUNC
+    )
+);

test-src/webfuse/filesystem/test_status.cpp

@@ -0,0 +1,28 @@
+#include "webfuse/filesystem/status.hpp"
+#include <gtest/gtest.h>
+#include <errno.h>
+
+using webfuse::status;
+
+class status_test: public testing::TestWithParam<int> { };
+
+TEST_P(status_test, conversion)
+{
+    int const expected = GetParam();
+    auto status = status::from_fusestatus(expected);
+    ASSERT_EQ(expected, status.to_fusestatus());
+}
+
+INSTANTIATE_TEST_CASE_P(status_values, status_test,
+    testing::Values(
+        0, 1, 2, 3, 42,
+        -E2BIG, -EACCES, -EBADF, -EBUSY, -EDESTADDRREQ,
+        -EDQUOT, -EEXIST, -EFAULT, -EFBIG, -EINTR,
+        -EINVAL, -EIO, -EISDIR, -ELOOP, -EMFILE,
+        -ENAMETOOLONG, -ENFILE, -ENODATA, -ENODEV,
+        -ENOENT, -ENOMEM, -ENOSPC, -ENOSYS, -ENOTDIR,
+        -ENOTEMPTY, -ENOTSUP, -ENXIO, -EOVERFLOW, -EPERM,
+        -EPIPE, -ERANGE, -EROFS, -EXDEV, -EWOULDBLOCK,
+        -EAGAIN, -12345
+    )
+);

test-src/webfuse/filesystem/test_userid.cpp

@@ -0,0 +1,27 @@
+#include "webfuse/filesystem/userid.hpp"
+#include <gtest/gtest.h>
+
+using webfuse::user_id;
+
+TEST(user_id, invalid)
+{
+    user_id invalid_user;
+
+    ASSERT_EQ(user_id::invalid, invalid_user);
+}
+
+TEST(user_id, to_uid)
+{
+    user_id user(42);
+    uid_t id = user.to_uid();
+
+    ASSERT_EQ(42, id);
+}
+
+TEST(user_id, from_uid)
+{
+    uid_t id = 23;
+    auto user = user_id::from_uid(id);
+
+    ASSERT_EQ(23, user);
+}

test-src/webfuse/test_app.cpp

@@ -0,0 +1,9 @@
+#include "webfuse/webfuse.hpp"
+#include <gtest/gtest.h>
+
+TEST(app, init)
+{
+    char args0[] = "webfuse";
+    char * args[] = { args0, nullptr };
+    webfuse::app(1, args);
+}