Fix tests [14] --filter=[core] --verbose

Author: matyhtf

core-tests/src/core/wheel_timer.cpp

@@ -109,3 +109,36 @@ TEST(async, schedule) {
     ASSERT_EQ(handle_count, N);
     ASSERT_EQ(callback_count, N);
 }
+
+
+TEST(async, misc) {
+    int count = 1000;
+    callback_count = 0;
+    std::atomic<int> handle_count(0);
+    AsyncEvent event = {};
+    AsyncEvent *rv;
+    event.object = &handle_count;
+    event.callback = [](AsyncEvent *event) { callback_count++; };
+    event.handler = [](AsyncEvent *event) { ++(*static_cast<std::atomic<int> *>(event->object)); };
+
+    swoole_event_init(SW_EVENTLOOP_WAIT_EXIT);
+
+    auto ret = swoole::async::dispatch(&event);
+    EXPECT_EQ(ret->object, event.object);
+
+    sw_async_threads()->notify_one();
+
+    AsyncEvent event2 = { };
+    event2.callback = [](AsyncEvent *event) {
+        ASSERT_EQ(event->retval, -1);
+        ASSERT_EQ(event->error, SW_ERROR_AIO_BAD_REQUEST);
+        callback_count++;
+    };
+    rv = swoole::async::dispatch(&event2);
+    EXPECT_NE(rv, nullptr);
+
+    swoole_event_wait();
+
+    ASSERT_EQ(handle_count, 1);
+    ASSERT_EQ(callback_count, 2);
+}

core-tests/src/os/async.cpp

@@ -77,3 +77,9 @@ TEST(os, thread_name) {
     });
     t.join();
 }
+
+TEST(os, thread_id) {
+    auto tid = swoole_thread_id_to_str(std::this_thread::get_id());
+    DEBUG() << "current thread id: " << tid << "\n";
+    ASSERT_FALSE(tid.empty());
+}

core-tests/src/os/os.cpp

@@ -20,10 +20,12 @@
 #include "swoole_lock.h"
 
 #include <thread>
+#include <string>
 
 long swoole_thread_get_native_id(void);
 bool swoole_thread_set_name(const char *name);
 bool swoole_thread_get_name(char *buf, size_t len);
+std::string swoole_thread_id_to_str(std::thread::id id);
 
 namespace swoole {
 class Thread {

include/swoole_thread.h

@@ -26,6 +26,7 @@
 #include <set>
 #include <vector>
 #include <stack>
+#include <thread>
 #include <type_traits>
 
 #define __SCOPEGUARD_CONCATENATE_IMPL(s1, s2) s1##s2
@@ -243,5 +244,4 @@ static inline bool ends_with(const char *haystack, size_t l_haystack, const char
     }
     return memcmp(haystack + l_haystack - l_needle, needle, l_needle) == 0;
 }
-
 }  // namespace swoole

include/swoole_util.h

@@ -223,3 +223,4 @@ uint64_t swoole_hash_austin(const char *key, size_t keylen) {
 
     return h;
 }
+

include/swoole_wheel_timer.h

@@ -22,6 +22,7 @@
 #include "swoole_pipe.h"
 #include "swoole_async.h"
 #include "swoole_util.h"
+#include "swoole_thread.h"
 
 #include <thread>
 #include <atomic>
@@ -30,7 +31,6 @@
 #include <condition_variable>
 #include <mutex>
 #include <queue>
-#include <sstream>
 #include <system_error>
 
 static std::mutex async_thread_lock;
@@ -173,22 +173,16 @@ class ThreadPool {
         return _queue.count();
     }
 
-    static std::string get_thread_id(std::thread::id id) {
-        std::stringstream ss;
-        ss << id;
-        return ss.str();
-    }
-
     void release_thread(std::thread::id tid) {
         auto i = threads.find(tid);
         if (i == threads.end()) {
-            swoole_warning("AIO thread#%s is missing", get_thread_id(tid).c_str());
+            swoole_warning("AIO thread#%s is missing", swoole_thread_id_to_str(tid).c_str());
             return;
         } else {
             std::thread *_thread = i->second;
             swoole_trace_log(SW_TRACE_AIO,
                              "release idle thread#%s, we have %zu now",
-                             get_thread_id(tid).c_str(),
+                             swoole_thread_id_to_str(tid).c_str(),
                              threads.size() - 1);
             if (_thread->joinable()) {
                 _thread->join();

src/core/misc.cc

@@ -20,6 +20,9 @@
 #include "swoole_socket.h"
 #include "swoole_async.h"
 
+#include <thread>
+#include <sstream>
+
 #include <arpa/inet.h>
 
 #if __APPLE__
@@ -143,6 +146,12 @@ bool swoole_thread_get_name(char *buf, size_t len) {
     return check_pthread_return_value(pthread_getname_np(pthread_self(), buf, len));
 }
 
+std::string swoole_thread_id_to_str(std::thread::id id) {
+    std::stringstream ss;
+    ss << id;
+    return ss.str();
+}
+
 namespace swoole {
 GetaddrinfoRequest::GetaddrinfoRequest(
     std::string _hostname, int _family, int _socktype, int _protocol, std::string _service)

src/os/async_thread.cc

@@ -810,7 +810,7 @@ int Server::create() {
         minimum_connection += ports.back()->get_fd();
     }
     if (max_connection < minimum_connection) {
-        auto real_max_connection = SW_MAX(minimum_connection + 1, (int) SwooleG.max_sockets);
+        auto real_max_connection = SW_MAX(minimum_connection + 1, SwooleG.max_sockets);
         swoole_warning(
             "max_connection must be bigger than %u, it's reset to %u", minimum_connection, real_max_connection);
         max_connection = real_max_connection;