Add unit tests for MacOS, refactor, and optimize code (#5803)

Author: matyhtf

.github/workflows/unit.yml

@@ -93,4 +93,5 @@ jobs:
           export PHP_VERSION=${{ matrix.php-version }}
           export SWOOLE_CI_IN_MACOS=1
           cd ${{runner.workspace}}/swoole-src
+          ulimit -n 100000
           ./scripts/run-tests.sh

CMakeLists.txt

@@ -4,7 +4,7 @@ project(libswoole)
 enable_language(ASM)
 set(SWOOLE_VERSION 6.1.0-dev)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -g")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -g")

config.m4

@@ -1309,9 +1309,9 @@ EOF
     CXXFLAGS="$CXXFLAGS -Wall -Wno-unused-function -Wno-deprecated -Wno-deprecated-declarations"
 
     if test "$SW_OS" = "CYGWIN" || test "$SW_OS" = "MINGW"; then
-        CXXFLAGS="$CXXFLAGS -std=gnu++11"
+        CXXFLAGS="$CXXFLAGS -std=gnu++14"
     else
-        CXXFLAGS="$CXXFLAGS -std=c++11"
+        CXXFLAGS="$CXXFLAGS -std=c++14"
     fi
 
     if test "$SW_CPU" = "arm"; then

core-tests/src/network/socket.cpp

@@ -32,34 +32,39 @@ TEST(socket, connect_sync) {
     sock = make_socket(SW_SOCK_UNIX_STREAM, SW_FD_STREAM, 0);
     ASSERT_NE(sock, nullptr);
     sa.assign(SW_SOCK_UNIX_STREAM, "/tmp/swole-not-exists.sock");
-    ASSERT_EQ(sock->connect_sync(sa, 0.3), SW_ERR);
+    sock->set_timeout(0.3, SW_TIMEOUT_CONNECT);
+    ASSERT_EQ(sock->connect_sync(sa), SW_ERR);
     ASSERT_EQ(swoole_get_last_error(), ENOENT);
     sock->free();
 
     sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, 0);
     ASSERT_NE(sock, nullptr);
     sa.assign(SW_SOCK_TCP, "192.168.199.199", 80);
-    ASSERT_EQ(sock->connect_sync(sa, 0.3), SW_ERR);
+    sock->set_timeout(0.3, SW_TIMEOUT_CONNECT);
+    ASSERT_EQ(sock->connect_sync(sa), SW_ERR);
     ASSERT_EQ(swoole_get_last_error(), ETIMEDOUT);
     sock->free();
 
     sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, 0);
     ASSERT_NE(sock, nullptr);
     sa.assign(SW_SOCK_TCP, "127.0.0.1", 59999);
-    ASSERT_EQ(sock->connect_sync(sa, 0.3), SW_ERR);
+    sock->set_timeout(0.3, SW_TIMEOUT_CONNECT);
+    ASSERT_EQ(sock->connect_sync(sa), SW_ERR);
     ASSERT_EQ(swoole_get_last_error(), ECONNREFUSED);
     sock->free();
 
     sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, 0);
     ASSERT_NE(sock, nullptr);
     sa.assign(SW_SOCK_TCP, TEST_HTTP_DOMAIN, 80);
-    ASSERT_EQ(sock->connect_sync(sa, 0.3), SW_OK);
+    sock->set_timeout(0.3, SW_TIMEOUT_CONNECT);
+    ASSERT_EQ(sock->connect_sync(sa), SW_OK);
     sock->free();
 
     sock = make_socket(SW_SOCK_UDP, SW_FD_STREAM, 0);
     ASSERT_NE(sock, nullptr);
     sa.assign(SW_SOCK_UDP, "127.0.0.1", 9900);
-    ASSERT_EQ(sock->connect_sync(sa, 0.3), SW_OK);
+    sock->set_timeout(0.3, SW_TIMEOUT_CONNECT);
+    ASSERT_EQ(sock->connect_sync(sa), SW_OK);
     sock->free();
 }
 
@@ -69,7 +74,8 @@ TEST(socket, fail) {
 
     network::Address sa;
     sa.assign(SW_SOCK_TCP, TEST_HTTP_DOMAIN, 80);
-    ASSERT_EQ(sock->connect_sync(sa, 0.3), SW_OK);
+    sock->set_timeout(0.3, SW_TIMEOUT_CONNECT);
+    ASSERT_EQ(sock->connect_sync(sa), SW_OK);
 
     close(sock->get_fd());
 

ext-src/php_swoole_client.h

@@ -43,23 +43,23 @@ struct ClientObject {
     zend_object std;
 };
 
-static sw_inline ClientObject *php_swoole_client_fetch_object(zend_object *obj) {
-    return (ClientObject *) ((char *) obj - swoole_client_handlers.offset);
+static inline ClientObject *php_swoole_client_fetch_object(zend_object *obj) {
+    return reinterpret_cast<ClientObject *>(reinterpret_cast<char *>(obj) - swoole_client_handlers.offset);
 }
 
-static sw_inline ClientObject *php_swoole_client_fetch_object(zval *zobj) {
+static inline ClientObject *php_swoole_client_fetch_object(const zval *zobj) {
     return php_swoole_client_fetch_object(Z_OBJ_P(zobj));
 }
 
-static sw_inline swoole::network::Client *php_swoole_client_get_cli(zval *zobject) {
+static inline swoole::network::Client *php_swoole_client_get_cli(const zval *zobject) {
     return php_swoole_client_fetch_object(Z_OBJ_P(zobject))->cli;
 }
 
-swoole::network::Client *php_swoole_client_get_cli_safe(zval *zobject);
-void php_swoole_client_free(zval *zobject, swoole::network::Client *cli);
-void php_swoole_client_async_free_object(ClientObject *client_obj);
-bool php_swoole_client_check_setting(swoole::network::Client *cli, zval *zset);
+swoole::network::Client *php_swoole_client_get_cli_safe(const zval *zobject);
+void php_swoole_client_free(const zval *zobject, swoole::network::Client *cli);
+void php_swoole_client_async_free_object(const ClientObject *client_obj);
+bool php_swoole_client_check_setting(swoole::network::Client *cli, const zval *zset);
 #ifdef SW_USE_OPENSSL
-void php_swoole_client_check_ssl_setting(swoole::network::Client *cli, zval *zset);
+void php_swoole_client_check_ssl_setting(const swoole::network::Client *cli, const zval *zset);
 bool php_swoole_client_enable_ssl_encryption(swoole::network::Client *cli, zval *zobject);
 #endif

ext-src/php_swoole_cxx.h

@@ -450,28 +450,6 @@ class Array {
     }
 };
 
-enum PipeType {
-    PIPE_TYPE_NONE = 0,
-    PIPE_TYPE_STREAM = 1,
-    PIPE_TYPE_DGRAM = 2,
-};
-
-class Process {
-  public:
-    zend_object *zsocket = nullptr;
-    enum PipeType pipe_type;
-    bool enable_coroutine;
-
-    Process(enum PipeType pipe_type, bool enable_coroutine)
-        : pipe_type(pipe_type), enable_coroutine(enable_coroutine) {}
-
-    ~Process() {
-        if (zsocket) {
-            OBJ_RELEASE(zsocket);
-        }
-    }
-};
-
 class Variable {
   public:
     zval value;

ext-src/php_swoole_private.h

@@ -388,8 +388,8 @@ php_socket *php_swoole_convert_to_socket(int sock);
 #endif
 
 #ifdef HAVE_CPU_AFFINITY
-bool php_swoole_array_to_cpu_set(zval *array, cpu_set_t *cpu_set);
-void php_swoole_cpu_set_to_array(zval *array, cpu_set_t *cpu_set);
+bool php_swoole_array_to_cpu_set(const zval *array, cpu_set_t *cpu_set);
+void php_swoole_cpu_set_to_array(zval *array, const cpu_set_t *cpu_set);
 #endif
 
 zend_bool php_swoole_signal_isset_handler(int signo);

ext-src/php_swoole_process.h

@@ -20,9 +20,15 @@
 #include "php_swoole_cxx.h"
 #include "swoole_process_pool.h"
 
+enum PipeType {
+    PIPE_TYPE_NONE = 0,
+    PIPE_TYPE_STREAM = 1,
+    PIPE_TYPE_DGRAM = 2,
+};
+
 void php_swoole_process_clean();
 int php_swoole_process_start(swoole::Worker *process, zval *zobject);
-swoole::Worker *php_swoole_process_get_worker(zval *zobject);
-void php_swoole_process_set_worker(zval *zobject, swoole::Worker *worker);
+swoole::Worker *php_swoole_process_get_worker(const zval *zobject);
+void php_swoole_process_set_worker(const zval *zobject, swoole::Worker *worker, bool enable_coroutine, int pipe_type);
 
 swoole::ProcessPool *sw_process_pool();