more and more tests

test/CMakeLists.txt

@@ -21,7 +21,9 @@ set(
 # List of available targets
 
 set(TARGET_MAIN main)
+set(TARGET_ASYNC async)
 set(TARGET_LOOP loop)
+set(TARGET_WORK work)
 
 # Test TARGET_MAIN
 
@@ -31,6 +33,14 @@ target_include_directories(${TARGET_MAIN} PRIVATE ${COMMON_INCLUDE_DIRS})
 target_link_libraries(${TARGET_MAIN} PRIVATE ${COMMON_LINK_LIBS})
 add_test(NAME ${TARGET_MAIN} COMMAND ${TARGET_MAIN})
 
+# Test TARGET_ASYNC
+
+set(TARGET_ASYNC_SOURCES uvw/async.cpp)
+add_executable(${TARGET_ASYNC} ${TARGET_ASYNC_SOURCES})
+target_include_directories(${TARGET_ASYNC} PRIVATE ${COMMON_INCLUDE_DIRS})
+target_link_libraries(${TARGET_ASYNC} PRIVATE ${COMMON_LINK_LIBS})
+add_test(NAME ${TARGET_ASYNC} COMMAND ${TARGET_ASYNC})
+
 # Test TARGET_LOOP
 
 set(TARGET_LOOP_SOURCES uvw/loop.cpp)
@@ -38,3 +48,11 @@ add_executable(${TARGET_LOOP} ${TARGET_LOOP_SOURCES})
 target_include_directories(${TARGET_LOOP} PRIVATE ${COMMON_INCLUDE_DIRS})
 target_link_libraries(${TARGET_LOOP} PRIVATE ${COMMON_LINK_LIBS})
 add_test(NAME ${TARGET_LOOP} COMMAND ${TARGET_LOOP})
+
+# Test TARGET_WORK
+
+set(TARGET_WORK_SOURCES uvw/work.cpp)
+add_executable(${TARGET_WORK} ${TARGET_WORK_SOURCES})
+target_include_directories(${TARGET_WORK} PRIVATE ${COMMON_INCLUDE_DIRS})
+target_link_libraries(${TARGET_WORK} PRIVATE ${COMMON_LINK_LIBS})
+add_test(NAME ${TARGET_WORK} COMMAND ${TARGET_WORK})

test/uvw/async.cpp

@@ -0,0 +1,32 @@
+#include <gtest/gtest.h>
+#include <uvw.hpp>
+
+TEST(Async, Send) {
+    auto loop = uvw::Loop::getDefault();
+    auto handle = loop->resource<uvw::AsyncHandle>();
+
+    bool checkErrorEvent = false;
+    bool checkAsyncEvent = false;
+
+    handle->on<uvw::ErrorEvent>([&checkErrorEvent](const uvw::ErrorEvent &, uvw::AsyncHandle &){
+        ASSERT_FALSE(checkErrorEvent);
+        checkErrorEvent = true;
+    });
+
+    handle->on<uvw::AsyncEvent>([&checkAsyncEvent](const uvw::AsyncEvent &, uvw::AsyncHandle &handle){
+        ASSERT_FALSE(checkAsyncEvent);
+        checkAsyncEvent = true;
+        handle.close();
+        ASSERT_TRUE(handle.closing());
+    });
+
+    handle->send();
+
+    ASSERT_TRUE(handle->active());
+    ASSERT_FALSE(handle->closing());
+
+    loop->run();
+
+    ASSERT_FALSE(checkErrorEvent);
+    ASSERT_TRUE(checkAsyncEvent);
+}

test/uvw/loop.cpp

@@ -2,9 +2,7 @@
 #include <uvw.hpp>
 
 
-TEST(Loop, Basics) {
+TEST(Loop, PartiallyDone) {
-    // TODO partially done
-
     auto def = uvw::Loop::getDefault();
 
     ASSERT_TRUE(static_cast<bool>(def));

test/uvw/work.cpp

@@ -0,0 +1,64 @@
+#include <gtest/gtest.h>
+#include <uvw.hpp>
+
+
+TEST(Work, RunTask) {
+    auto loop = uvw::Loop::getDefault();
+
+    bool checkErrorEvent = false;
+    bool checkWorkEvent = false;
+    bool checkTask = false;
+
+    auto req = loop->resource<uvw::WorkReq>([&checkTask](){
+        ASSERT_FALSE(checkTask);
+        checkTask = true;
+    });
+
+    req->on<uvw::WorkEvent>([&checkWorkEvent](const uvw::WorkEvent &, uvw::WorkReq &){
+        ASSERT_FALSE(checkWorkEvent);
+        checkWorkEvent = true;
+    });
+
+    req->on<uvw::ErrorEvent>([&checkErrorEvent](const uvw::ErrorEvent &, uvw::WorkReq &){
+        ASSERT_FALSE(checkErrorEvent);
+        checkErrorEvent = true;
+    });
+
+    req->queue();
+    loop->run();
+
+    ASSERT_FALSE(checkErrorEvent);
+    ASSERT_TRUE(checkWorkEvent);
+    ASSERT_TRUE(checkTask);
+}
+
+TEST(Work, Cancellation) {
+    auto loop = uvw::Loop::getDefault();
+
+    bool checkErrorEvent = false;
+    bool checkWorkEvent = false;
+    bool checkTask = false;
+
+    auto req = loop->resource<uvw::WorkReq>([&checkTask](){
+        ASSERT_FALSE(checkTask);
+        checkTask = true;
+    });
+
+    req->on<uvw::WorkEvent>([&checkWorkEvent](const uvw::WorkEvent &, uvw::WorkReq &){
+        ASSERT_FALSE(checkWorkEvent);
+        checkWorkEvent = true;
+    });
+
+    req->on<uvw::ErrorEvent>([&checkErrorEvent](const uvw::ErrorEvent &, uvw::WorkReq &){
+        ASSERT_FALSE(checkErrorEvent);
+        checkErrorEvent = true;
+    });
+
+    req->queue();
+    req->cancel();
+    loop->run();
+
+    ASSERT_TRUE(checkErrorEvent);
+    ASSERT_FALSE(checkWorkEvent);
+    ASSERT_FALSE(checkTask);
+}