sepated unit and integration tests

test-src/unit/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/unit/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/unit/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/unit/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/unit/webfuse/test_app.cpp

@@ -0,0 +1,7 @@
+#include "webfuse/webfuse.hpp"
+#include <gtest/gtest.h>
+
+TEST(app, init)
+{
+    webfuse::app app;
+}

test-src/unit/webfuse/test_request_type.cpp

@@ -0,0 +1,37 @@
+#include "webfuse/request_type.hpp"
+#include <gtest/gtest.h>
+
+using webfuse::request_type;
+
+class request_type_test: public testing::TestWithParam<request_type> { };
+
+TEST_P(request_type_test, conversion)
+{
+    auto const expected = GetParam();
+    auto const actual = webfuse::get_request_type(static_cast<uint8_t>(expected));
+    
+    ASSERT_EQ(expected, actual);
+}
+
+INSTANTIATE_TEST_CASE_P(request_type_values, request_type_test,
+    testing::Values(
+        request_type::access, request_type::getattr, request_type::readlink,
+        request_type::symlink, request_type::link, request_type::link,
+        request_type::rename, request_type::chmod, request_type::chown,
+        request_type::truncate, request_type::fsync, request_type::open,
+        request_type::mknod, request_type::create, request_type::release,
+        request_type::unlink, request_type::read, request_type::write,
+        request_type::mkdir, request_type::readdir, request_type::rmdir,
+        request_type::statfs, request_type::utimens, request_type::unknown)
+);
+
+TEST(request_type, unknown_values)
+{
+    auto const expected = request_type::unknown;
+
+    ASSERT_EQ(expected, webfuse::get_request_type(0x20));
+    ASSERT_EQ(expected, webfuse::get_request_type(0x30));
+    ASSERT_EQ(expected, webfuse::get_request_type(0x80));
+    ASSERT_EQ(expected, webfuse::get_request_type(0x42));
+    ASSERT_EQ(expected, webfuse::get_request_type(0xff));
+}

test-src/unit/webfuse/test_response_type.cpp

@@ -0,0 +1,38 @@
+#include "webfuse/response_type.hpp"
+#include <gtest/gtest.h>
+
+using webfuse::request_type;
+
+class response_type_test: public testing::TestWithParam<request_type> { };
+
+TEST_P(response_type_test, conversion)
+{
+    auto const value = GetParam();
+    auto const actual = webfuse::get_response_type(value);
+    auto const expected = static_cast<webfuse::response_type>(static_cast<uint8_t>(value) | 0x80);
+    
+    ASSERT_EQ(expected, actual);
+}
+
+INSTANTIATE_TEST_CASE_P(response_type_values, response_type_test,
+    testing::Values(
+        request_type::access, request_type::getattr, request_type::readlink,
+        request_type::symlink, request_type::link, request_type::link,
+        request_type::rename, request_type::chmod, request_type::chown,
+        request_type::truncate, request_type::fsync, request_type::open,
+        request_type::mknod, request_type::create, request_type::release,
+        request_type::unlink, request_type::read, request_type::write,
+        request_type::mkdir, request_type::readdir, request_type::rmdir,
+        request_type::statfs, request_type::utimens, request_type::unknown)
+);
+
+TEST(respones_type, unknown_values)
+{
+    auto const expected = webfuse::response_type::unknown;
+
+    ASSERT_EQ(expected, webfuse::get_response_type(static_cast<request_type>(0x20)));
+    ASSERT_EQ(expected, webfuse::get_response_type(static_cast<request_type>(0x30)));
+    ASSERT_EQ(expected, webfuse::get_response_type(static_cast<request_type>(80)));
+    ASSERT_EQ(expected, webfuse::get_response_type(static_cast<request_type>(0x42)));
+    ASSERT_EQ(expected, webfuse::get_response_type(static_cast<request_type>(0xff)));
+}