organized unit tests

test/webfuse/tests/core/test_base64.cc

@@ -0,0 +1,122 @@
+#include <gtest/gtest.h>
+#include "webfuse/core/base64.h"
+
+TEST(Base64, EncodedSize)
+{
+    ASSERT_EQ(4, wf_base64_encoded_size(1));
+    ASSERT_EQ(4, wf_base64_encoded_size(2));
+    ASSERT_EQ(4, wf_base64_encoded_size(3));
+
+    ASSERT_EQ(8, wf_base64_encoded_size(4));
+    ASSERT_EQ(8, wf_base64_encoded_size(5));
+    ASSERT_EQ(8, wf_base64_encoded_size(6));
+
+    ASSERT_EQ(120, wf_base64_encoded_size(90));
+}
+
+TEST(Base64, Encode)
+{
+    char buffer[42];
+
+    std::string in = "Hello";
+    size_t length = wf_base64_encode((uint8_t const*) in.c_str(), in.size(), buffer, 42);
+    ASSERT_EQ(8, length);
+    ASSERT_STREQ("SGVsbG8=", buffer);
+
+    in = "Hello\n";
+    length = wf_base64_encode((uint8_t const*) in.c_str(), in.size(), buffer, 42);
+    ASSERT_EQ(8, length);
+    ASSERT_STREQ("SGVsbG8K", buffer);
+
+    in = "Blue";
+    length = wf_base64_encode((uint8_t const*) in.c_str(), in.size(), buffer, 42);
+    ASSERT_EQ(8, length);
+    ASSERT_STREQ("Qmx1ZQ==", buffer);
+}
+
+TEST(Base64, FailedToEncodeBufferTooSmall)
+{
+    char buffer[1];
+
+    std::string in = "Hello";
+    size_t length = wf_base64_encode((uint8_t const*) in.c_str(), in.size(), buffer, 1);
+    ASSERT_EQ(0, length);
+}
+
+TEST(Base64, DecodedSize)
+{
+    std::string in = "SGVsbG8=";    // Hello
+    size_t length = wf_base64_decoded_size(in.c_str(), in.size());
+    ASSERT_EQ(5, length);
+
+    in = "SGVsbG8K";    // Hello\n
+    length = wf_base64_decoded_size(in.c_str(), in.size());
+    ASSERT_EQ(6, length);
+
+    in = "Qmx1ZQ==";    // Blue
+    length = wf_base64_decoded_size(in.c_str(), in.size());
+    ASSERT_EQ(4, length);
+}
+
+TEST(Base64, IsValid)
+{
+    std::string in = "SGVsbG8=";    // Hello
+    ASSERT_TRUE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "SGVsbG8K";    // Hello\n
+    ASSERT_TRUE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qmx1ZQ==";    // Blue
+    ASSERT_TRUE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qmx1ZQ=a";
+    ASSERT_FALSE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qmx1ZQ";
+    ASSERT_FALSE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qmx1ZQ=";
+    ASSERT_FALSE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qmx1Z===";
+    ASSERT_FALSE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qmx1ZQ?=";
+    ASSERT_FALSE(wf_base64_isvalid(in.c_str(), in.size()));
+
+    in = "Qm?1ZQ==";
+    ASSERT_FALSE(wf_base64_isvalid(in.c_str(), in.size()));
+}
+
+TEST(Base64, Decode)
+{
+    char buffer[42];
+
+    std::string in = "SGVsbG8=";    // Hello
+    size_t length = wf_base64_decode(in.c_str(), in.size(), (uint8_t*) buffer, 42);
+    ASSERT_EQ(5, length);
+    buffer[length] = '\0';
+    ASSERT_STREQ("Hello", buffer);
+
+    in = "SGVsbG8K";    // Hello\n
+    length = wf_base64_decode(in.c_str(), in.size(), (uint8_t*) buffer, 42);
+    ASSERT_EQ(6, length);
+    buffer[length] = '\0';
+    ASSERT_STREQ("Hello\n", buffer);
+
+    in = "Qmx1ZQ==";    // Blue
+    length = wf_base64_decode(in.c_str(), in.size(), (uint8_t*) buffer, 42);
+    ASSERT_EQ(4, length);
+    buffer[length] = '\0';
+    ASSERT_STREQ("Blue", buffer);
+}
+
+TEST(Base64, FailToDecodeBufferTooSmall)
+{
+    char buffer[1];
+
+    std::string in = "SGVsbG8=";    // Hello
+    size_t length = wf_base64_decode(in.c_str(), in.size(), (uint8_t*) buffer, 1);
+    ASSERT_EQ(0, length);
+}
+

test/webfuse/tests/core/test_container_of.cc

@@ -0,0 +1,29 @@
+#include <gtest/gtest.h>
+#include "webfuse/core/container_of.h"
+
+namespace
+{
+
+struct MyStruct
+{
+    int first;
+    int second;
+};
+
+}
+
+TEST(ContainerOf, FirstMember)
+{
+    MyStruct my_struct = {23, 42};
+
+    int * first = &my_struct.first;
+    ASSERT_EQ(&my_struct, wf_container_of(first, MyStruct, first));
+}
+
+TEST(ContainerOf, SecondMember)
+{
+    MyStruct my_struct = {23, 42};
+
+    int * second = &my_struct.second;
+    ASSERT_EQ(&my_struct, wf_container_of(second, MyStruct, second));
+}

test/webfuse/tests/core/test_message.cc

@@ -0,0 +1,22 @@
+#include <gtest/gtest.h>
+#include <cstring>
+#include "webfuse/core/message.h"
+
+TEST(wf_message, create)
+{
+    json_t * value = json_object();
+    
+    struct wf_message * message = wf_message_create(value);
+    ASSERT_NE(nullptr, message);
+    ASSERT_EQ(2, message->length);
+    ASSERT_TRUE(0 == strncmp("{}", message->data, 2));
+
+    wf_message_dispose(message);
+    json_decref(value);
+}
+
+TEST(wf_message, fail_to_create)
+{
+    struct wf_message * message = wf_message_create(nullptr);
+    ASSERT_EQ(nullptr, message);
+}

test/webfuse/tests/core/test_message_queue.cc

@@ -0,0 +1,52 @@
+#include <gtest/gtest.h>
+#include "webfuse/core/message_queue.h"
+#include "webfuse/core/message.h"
+#include "webfuse/core/slist.h"
+
+namespace
+{
+
+    struct wf_slist_item * create_message(char const * content)
+    {
+        json_t * value = json_object();
+        json_object_set_new(value, "content", json_string(content));
+        struct wf_message * message = wf_message_create(value);
+
+        json_decref(value);
+        return &message->item;
+    }
+
+}
+
+TEST(wf_message_queue, cleanup_empty_list)
+{
+    struct wf_slist queue;
+    wf_slist_init(&queue);
+
+    wf_message_queue_cleanup(&queue);
+    ASSERT_TRUE(wf_slist_empty(&queue));
+}
+
+TEST(wf_message_queue, cleanup_one_element)
+{
+    struct wf_slist queue;
+    wf_slist_init(&queue);
+
+    wf_slist_append(&queue, create_message("Hello"));
+
+    wf_message_queue_cleanup(&queue);
+    ASSERT_TRUE(wf_slist_empty(&queue));
+}
+
+TEST(wf_message_queue, cleanup_multiple_element)
+{
+    struct wf_slist queue;
+    wf_slist_init(&queue);
+
+    wf_slist_append(&queue, create_message("Hello"));
+    wf_slist_append(&queue, create_message("World"));
+    wf_slist_append(&queue, create_message("!"));
+
+    wf_message_queue_cleanup(&queue);
+    ASSERT_TRUE(wf_slist_empty(&queue));
+}

test/webfuse/tests/core/test_path.cc

@@ -0,0 +1,58 @@
+#include <gtest/gtest.h>
+#include "webfuse/core/path.h"
+
+TEST(wf_path, empty)
+{
+    struct wf_path * path = wf_path_create("");
+    ASSERT_EQ(0, wf_path_element_count(path));
+    ASSERT_EQ(nullptr, wf_path_get_element(path, 0));
+
+    wf_path_dispose(path);
+}
+
+TEST(wf_path, relative_file)
+{
+    struct wf_path * path = wf_path_create("some.file");
+    ASSERT_EQ(1, wf_path_element_count(path));
+    ASSERT_STREQ("some.file", wf_path_get_element(path, 0));
+
+    wf_path_dispose(path);
+}
+
+TEST(wf_path, absolute_file)
+{
+    struct wf_path * path = wf_path_create("/absolute.file");
+    ASSERT_EQ(1, wf_path_element_count(path));
+    ASSERT_STREQ("absolute.file", wf_path_get_element(path, 0));
+
+    wf_path_dispose(path);
+}
+
+TEST(wf_path, nested_path)
+{
+    struct wf_path * path = wf_path_create("/a/nested/path");
+    ASSERT_EQ(3, wf_path_element_count(path));
+    ASSERT_STREQ("a", wf_path_get_element(path, 0));
+    ASSERT_STREQ("nested", wf_path_get_element(path, 1));
+    ASSERT_STREQ("path", wf_path_get_element(path, 2));
+
+    wf_path_dispose(path);
+}
+
+TEST(wf_path, deep_nested_path)
+{
+    struct wf_path * path = wf_path_create("/this/is/a/very/deep/nested/path/to/some/file");
+    ASSERT_EQ(10, wf_path_element_count(path));
+    ASSERT_STREQ("this", wf_path_get_element(path, 0));
+    ASSERT_STREQ("is", wf_path_get_element(path, 1));
+    ASSERT_STREQ("a", wf_path_get_element(path, 2));
+    ASSERT_STREQ("very", wf_path_get_element(path, 3));
+    ASSERT_STREQ("deep", wf_path_get_element(path, 4));
+    ASSERT_STREQ("nested", wf_path_get_element(path, 5));
+    ASSERT_STREQ("path", wf_path_get_element(path, 6));
+    ASSERT_STREQ("to", wf_path_get_element(path, 7));
+    ASSERT_STREQ("some", wf_path_get_element(path, 8));
+    ASSERT_STREQ("file", wf_path_get_element(path, 9));
+
+    wf_path_dispose(path);
+}

test/webfuse/tests/core/test_slist.cc

@@ -0,0 +1,139 @@
+#include <gtest/gtest.h>
+#include "webfuse/core/slist.h"
+
+TEST(wf_slist, init)
+{
+    struct wf_slist list;
+    wf_slist_init(&list);
+
+    ASSERT_EQ(nullptr, list.head.next);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(&list.head, list.last);
+    ASSERT_TRUE(wf_slist_empty(&list));
+    ASSERT_EQ(nullptr, wf_slist_first(&list));    
+}
+
+TEST(wf_slist, append)
+{
+    struct wf_slist list;
+    struct wf_slist_item item[3];
+
+    wf_slist_init(&list);
+    ASSERT_TRUE(wf_slist_empty(&list));
+
+    wf_slist_append(&list, &item[0]);
+    ASSERT_NE(&list.head, list.last);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[0], wf_slist_first(&list));    
+    ASSERT_EQ(&item[0], list.head.next);
+    ASSERT_EQ(&item[0], list.last);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(nullptr, item[0].next);
+
+    wf_slist_append(&list, &item[1]);
+    ASSERT_NE(&list.head, list.last);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[0], wf_slist_first(&list));    
+    ASSERT_EQ(&item[0], list.head.next);
+    ASSERT_EQ(&item[1], list.last);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(&item[1], item[0].next);
+    ASSERT_EQ(nullptr, item[1].next);
+
+    wf_slist_append(&list, &item[2]);
+    ASSERT_NE(&list.head, list.last);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[0], wf_slist_first(&list));    
+    ASSERT_EQ(&item[0], list.head.next);
+    ASSERT_EQ(&item[2], list.last);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(&item[1], item[0].next);
+    ASSERT_EQ(&item[2], item[1].next);
+    ASSERT_EQ(nullptr, item[2].next);
+}
+
+TEST(wf_slist_remove_after, remove_first)
+{
+    struct wf_slist list;
+    struct wf_slist_item item[3];
+
+    wf_slist_init(&list);
+    wf_slist_append(&list, &item[0]);
+    wf_slist_append(&list, &item[1]);
+    wf_slist_append(&list, &item[2]);
+
+    wf_slist_item * removed;
+    
+    removed = wf_slist_remove_first(&list);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[0], removed);
+
+    removed = wf_slist_remove_first(&list);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[1], removed);
+
+    removed = wf_slist_remove_first(&list);
+    ASSERT_TRUE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[2], removed);
+
+    ASSERT_EQ(nullptr, list.head.next);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(&list.head, list.last);
+    ASSERT_EQ(nullptr, wf_slist_first(&list));    
+}
+
+TEST(wf_slist_remove_after, remove_last)
+{
+    struct wf_slist list;
+    struct wf_slist_item item[3];
+
+    wf_slist_init(&list);
+    wf_slist_append(&list, &item[0]);
+    wf_slist_append(&list, &item[1]);
+    wf_slist_append(&list, &item[2]);
+
+    wf_slist_item * removed;
+    
+    removed = wf_slist_remove_after(&list, &item[1]);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[2], removed);
+
+    removed = wf_slist_remove_after(&list, &item[0]);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[1], removed);
+
+    removed = wf_slist_remove_after(&list, &list.head);
+    ASSERT_TRUE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[0], removed);
+
+    ASSERT_EQ(nullptr, list.head.next);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(&list.head, list.last);
+    ASSERT_EQ(nullptr, wf_slist_first(&list));    
+}
+
+TEST(wf_slist_remove_after, remove_after)
+{
+    struct wf_slist list;
+    struct wf_slist_item item[3];
+
+    wf_slist_init(&list);
+    wf_slist_append(&list, &item[0]);
+    wf_slist_append(&list, &item[1]);
+    wf_slist_append(&list, &item[2]);
+
+    wf_slist_item * removed;
+    
+    removed = wf_slist_remove_after(&list, &item[0]);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[1], removed);
+
+    ASSERT_NE(&list.head, list.last);
+    ASSERT_FALSE(wf_slist_empty(&list));
+    ASSERT_EQ(&item[0], wf_slist_first(&list));    
+    ASSERT_EQ(&item[0], list.head.next);
+    ASSERT_EQ(&item[2], list.last);
+    ASSERT_EQ(nullptr, list.last->next);
+    ASSERT_EQ(&item[2], item[0].next);
+    ASSERT_EQ(nullptr, item[2].next);
+}

test/webfuse/tests/core/test_status.cc

@@ -0,0 +1,30 @@
+#include <gtest/gtest.h>
+#include "webfuse/core/status_intern.h"
+
+TEST(wf_status, tostring)
+{
+    ASSERT_STREQ("Good", wf_status_tostring(WF_GOOD));
+    ASSERT_STREQ("Bad", wf_status_tostring(WF_BAD));
+    ASSERT_STREQ("Bad (not implemented)", wf_status_tostring(WF_BAD_NOTIMPLEMENTED));
+    ASSERT_STREQ("Bad (busy)", wf_status_tostring(WF_BAD_BUSY));
+    ASSERT_STREQ("Bad (timeout)", wf_status_tostring(WF_BAD_TIMEOUT));
+    ASSERT_STREQ("Bad (format)", wf_status_tostring(WF_BAD_FORMAT));
+    ASSERT_STREQ("Bad (no entry)", wf_status_tostring(WF_BAD_NOENTRY));
+    ASSERT_STREQ("Bad (access denied)", wf_status_tostring(WF_BAD_ACCESS_DENIED));
+
+    ASSERT_STREQ("Bad (unknown)", wf_status_tostring(-1));
+}
+
+TEST(wf_status, to_rc)
+{
+    ASSERT_EQ(0, wf_status_to_rc(WF_GOOD));
+    ASSERT_EQ(-ENOENT, wf_status_to_rc(WF_BAD));
+    ASSERT_EQ(-ENOSYS, wf_status_to_rc(WF_BAD_NOTIMPLEMENTED));
+    ASSERT_EQ(-ENOENT, wf_status_to_rc(WF_BAD_BUSY));
+    ASSERT_EQ(-ETIMEDOUT, wf_status_to_rc(WF_BAD_TIMEOUT));
+    ASSERT_EQ(-ENOENT, wf_status_to_rc(WF_BAD_FORMAT));
+    ASSERT_EQ(-ENOENT, wf_status_to_rc(WF_BAD_NOENTRY));
+    ASSERT_EQ(-EACCES, wf_status_to_rc(WF_BAD_ACCESS_DENIED));
+
+    ASSERT_EQ(-ENOENT, wf_status_to_rc(-1));
+}

test/webfuse/tests/core/test_string.cc

@@ -0,0 +1,18 @@
+#include <gtest/gtest.h>
+#include <stdlib.h>
+
+#include "webfuse/core/string.h"
+
+TEST(wf_string_create, Default)
+{
+    char * value = wf_create_string("test %s/%d", "hello", 42);
+    ASSERT_STREQ("test hello/42", value);
+    free(value);
+}
+
+TEST(wf_string_create, EmptyString)
+{
+    char * value = wf_create_string("");
+    ASSERT_STREQ("", value);
+    free(value);
+}