Optimzie core tests (#5748)

* Optimize core tests --filter=[core]

* Optimize core tests [2] --filter=[core]

* Optimize core tests [3] --filter=[core]

* Optimize core tests [4] --filter=[core]

* Optimize core tests [5] --filter=[core]

Author: matyhtf

CMakeLists.txt

@@ -42,6 +42,7 @@ if(CODE_COVERAGE)
     target_compile_options(coverage_config INTERFACE
         -O0
         -g
+        -fprofile-update=atomic
         --coverage
     )
     if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.13)

core-tests/include/test_core.h

@@ -56,10 +56,13 @@ std::string get_ssl_dir();
 std::string get_jpg_file();
 bool is_github_ci();
 int exec_js_script(const std::string &file, const std::string &args);
+std::string http_get_request(const std::string &domain, const std::string &path);
 int get_random_port();
 
 Socks5Proxy *create_socks5_proxy();
 HttpProxy *create_http_proxy();
 
+pid_t child_proc(const std::function<void(void)> &fn);
+
 }  // namespace test
 };  // namespace swoole

core-tests/src/main.cpp

@@ -58,6 +58,18 @@ string get_jpg_file() {
     return root_path + TEST_JPG_FILE;
 }
 
+string http_get_request(const string &domain, const string &path) {
+    return "GET " + path +
+           " HTTP/1.1\r\n"
+           "Host: " +
+           domain +
+           "\r\n"
+           "Connection: close\r\n"
+           "User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) "
+           "Chrome/51.0.2704.106 Safari/537.36"
+           "\r\n\r\n";
+}
+
 bool is_github_ci() {
     return getenv("GITHUB_ACTIONS") != nullptr;
 }
@@ -95,5 +107,16 @@ int get_random_port() {
     return TEST_PORT + swoole_system_random(1, 10000);
 }
 
+pid_t child_proc(const std::function<void(void)> &fn) {
+    pid_t child_pid = fork();
+    if (child_pid == -1) {
+        throw std::system_error();
+    } else if (child_pid == 0) {
+        fn();
+        exit(0);
+    }
+    return child_pid;
+}
+
 }  // namespace test
 }  // namespace swoole

core-tests/src/network/client.cpp

@@ -10,8 +10,8 @@ using swoole::Pipe;
 using swoole::Socks5Proxy;
 using swoole::String;
 using swoole::network::AsyncClient;
-using swoole::network::SyncClient;
 using swoole::network::Client;
+using swoole::network::SyncClient;
 using swoole::test::create_http_proxy;
 using swoole::test::create_socks5_proxy;
 using swoole::test::Process;
@@ -159,6 +159,34 @@ TEST(client, async_tcp_dns) {
     test_async_client_tcp("localhost", swoole::test::get_random_port());
 }
 
+TEST(client, sleep) {
+    swoole_event_init(SW_EVENTLOOP_WAIT_EXIT);
+
+    String buf(65536);
+
+    auto domain = "httpbin.org";
+
+    Client client(SW_SOCK_TCP, true);
+    client.onConnect = [&domain](Client *cli) {
+        cli->sleep();
+        swoole_timer_after(200, [cli, &domain](auto _1, auto _2) {
+            auto req = swoole::test::http_get_request(domain, "/");
+            cli->send(cli, req.c_str(), req.length(), 0);
+            cli->wakeup();
+        });
+    };
+
+    client.onError = [](Client *cli) {};
+    client.onClose = [](Client *cli) {};
+    client.onReceive = [&buf](Client *cli, const char *data, size_t length) { buf.append(data, length); };
+
+    ASSERT_EQ(client.connect(&client, domain, 80, -1, 0), 0);
+
+    swoole_event_wait();
+
+    ASSERT_TRUE(buf.contains("HTTP/1.1 200 OK"));
+}
+
 TEST(client, connect_refuse) {
     int ret;
     Client cli(SW_SOCK_TCP, false);

core-tests/src/network/socket.cpp

@@ -341,42 +341,43 @@ TEST(socket, check_liveness) {
 #define CRLF "\r\n"
 
 TEST(socket, sync) {
-	auto sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, 0);
-
-	swoole::network::Address addr;
-	ASSERT_TRUE(addr.assign("tcp://httpbin.org:80"));
-
-	ASSERT_EQ(sock->connect(addr), 0);
-
-	const char *req = "GET / HTTP/1.1" CRLF \
-			"Host: httpbin.org" CRLF \
-			"User-Agent: curl/7.81.0" CRLF \
-			"Accept: */*" CRLF \
-			"Connection: close" CRLF \
-			CRLF CRLF;
-	ssize_t n = strlen(req);
-	ASSERT_EQ(sock->write_sync(req, n), n);
-
-	string resp;
-	SW_LOOP {
-		char buf[1024];
-		n = sock->read_sync(buf, sizeof(buf));
-		if (n == 0) {
-			break;
-		}
-		ASSERT_GT(n, 0);
-		resp.append(buf, n);
-	}
-
-	ASSERT_GT(resp.length(), 4096);
-	sock->free();
+    auto sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, 0);
+
+    swoole::network::Address addr;
+    ASSERT_TRUE(addr.assign("tcp://httpbin.org:80"));
+
+    ASSERT_EQ(sock->connect(addr), 0);
+
+    const char *req = "GET / HTTP/1.1" CRLF "Host: httpbin.org" CRLF "User-Agent: curl/7.81.0" CRLF "Accept: */*" CRLF
+                      "Connection: close" CRLF CRLF CRLF;
+    ssize_t n = strlen(req);
+    ASSERT_EQ(sock->write_sync(req, n), n);
+    ASSERT_TRUE(sock->check_liveness());
+
+    string resp;
+    SW_LOOP {
+        char buf[1024];
+        n = sock->read_sync(buf, sizeof(buf));
+        if (n == 0) {
+            break;
+        }
+        ASSERT_GT(n, 0);
+        resp.append(buf, n);
+    }
+
+    ASSERT_GT(resp.length(), 4096);
+
+    usleep(50000);
+    ASSERT_FALSE(sock->check_liveness());
+
+    sock->free();
 }
 
 TEST(socket, ipv6_addr) {
-	auto sock = make_socket(SW_SOCK_TCP6, SW_FD_STREAM, 0);
-	swoole::network::Address addr;
-	ASSERT_TRUE(addr.assign("tcp://[::1]:12345"));
-	ASSERT_EQ(sock->connect(addr), SW_ERR);
-	ASSERT_EQ(errno, ECONNREFUSED);
-	sock->free();
+    auto sock = make_socket(SW_SOCK_TCP6, SW_FD_STREAM, 0);
+    swoole::network::Address addr;
+    ASSERT_TRUE(addr.assign("tcp://[::1]:12345"));
+    ASSERT_EQ(sock->connect(addr), SW_ERR);
+    ASSERT_EQ(errno, ECONNREFUSED);
+    sock->free();
 }

core-tests/src/os/os.cpp

@@ -0,0 +1,77 @@
+/*
+  +----------------------------------------------------------------------+
+  | Swoole                                                               |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 2.0 of the Apache license,    |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.apache.org/licenses/LICENSE-2.0.html                      |
+  | If you did not receive a copy of the Apache2.0 license and are unable|
+  | to obtain it through the world-wide-web, please send a note to       |
+  | [email protected] so we can mail you a copy immediately.            |
+  +----------------------------------------------------------------------+
+  | @link     https://www.swoole.com/                                    |
+  | @contact  [email protected]                                            |
+  | @license  https://github.com/swoole/swoole-src/blob/master/LICENSE   |
+  | @Author   Tianfeng Han  <[email protected]>                           |
+  +----------------------------------------------------------------------+
+*/
+
+#include "test_core.h"
+
+#include "swoole_file.h"
+#include "swoole_thread.h"
+
+using namespace swoole;
+
+TEST(os, daemon) {
+    auto sid = getsid(getpid());
+    int status;
+    swoole_waitpid(test::child_proc([sid](){
+        ASSERT_EQ(sid, getsid(getpid()));
+        ASSERT_TRUE(isatty(STDIN_FILENO));
+
+        ASSERT_EQ(swoole_daemon(0, 0), 0);
+        ASSERT_NE(sid, getsid(getpid()));
+
+        ASSERT_FALSE(isatty(STDIN_FILENO));
+    }), &status, 0);
+}
+
+TEST(os, cpu_affinity) {
+    cpu_set_t ori_affinity, affinity;
+    ASSERT_EQ(swoole_get_cpu_affinity(&affinity), 0);
+    ori_affinity = affinity;
+
+    CPU_ZERO(&affinity);
+    CPU_SET(1, &affinity);
+
+    ASSERT_EQ(swoole_set_cpu_affinity(&affinity), 0);
+    ASSERT_EQ(swoole_get_cpu_affinity(&affinity), 0);
+
+    auto cpu_n = SW_CPU_NUM;
+    SW_LOOP_N(cpu_n) {
+        if (i == 1) {
+            ASSERT_TRUE(CPU_ISSET(i, &affinity));
+        } else {
+            ASSERT_FALSE(CPU_ISSET(i, &affinity));
+        }
+    }
+
+    ASSERT_EQ(swoole_set_cpu_affinity(&ori_affinity), 0);
+}
+
+TEST(os, thread_name) {
+    std::thread t([](){
+        char new_name[512];
+        auto thread_name = "sw-core-tests";
+        ASSERT_TRUE(swoole_thread_set_name(thread_name));
+        ASSERT_TRUE(swoole_thread_get_name(new_name, sizeof(new_name)));
+
+        ASSERT_STREQ(thread_name, new_name);
+
+        ASSERT_FALSE(swoole_thread_set_name("swoole-core-tests-max-size-is-16"));
+        ASSERT_EQ(swoole_get_last_error(), ERANGE);
+    });
+    t.join();
+}

core-tests/src/protocol/http2.cpp

@@ -61,3 +61,43 @@ TEST(http2, default_settings) {
     ASSERT_EQ(http2::get_default_setting(SW_HTTP2_SETTINGS_MAX_FRAME_SIZE), _settings.max_frame_size);
     ASSERT_EQ(http2::get_default_setting(SW_HTTP2_SETTINGS_MAX_HEADER_LIST_SIZE), _settings.max_header_list_size);
 }
+
+TEST(http2, pack_setting_frame) {
+    char frame[SW_HTTP2_SETTING_FRAME_SIZE];
+    http2::Settings settings_1{};
+    http2::init_settings(&settings_1);
+    size_t n = http2::pack_setting_frame(frame, settings_1, false);
+
+    ASSERT_GT(n, 16);
+
+    http2::Settings settings_2{};
+    http2::unpack_setting_data(
+        frame + SW_HTTP2_FRAME_HEADER_SIZE, n, [&settings_2](uint16_t id, uint32_t value) -> ReturnCode {
+            swoole_http2_frame_trace_log("id=%d, value=%d", id, value);
+            switch (id) {
+            case SW_HTTP2_SETTING_HEADER_TABLE_SIZE:
+                settings_2.header_table_size = value;
+                break;
+            case SW_HTTP2_SETTINGS_ENABLE_PUSH:
+                settings_2.enable_push = value;
+                break;
+            case SW_HTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
+                settings_2.max_concurrent_streams = value;
+                break;
+            case SW_HTTP2_SETTINGS_INIT_WINDOW_SIZE:
+                settings_2.init_window_size = value;
+                break;
+            case SW_HTTP2_SETTINGS_MAX_FRAME_SIZE:
+                settings_2.max_frame_size = value;
+                break;
+            case SW_HTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
+                settings_2.max_header_list_size = value;
+                break;
+            default:
+                return SW_ERROR;
+            }
+            return SW_SUCCESS;
+        });
+
+    ASSERT_MEMEQ(&settings_1, &settings_2, sizeof(settings_2));
+}

core-tests/src/server/message_bus.cpp

@@ -188,6 +188,8 @@ TEST(message_bus, read_with_buffer) {
     MB_ASSERT(2);
     MB_ASSERT(3);
 
+    ASSERT_GT(tmb.mb.get_memory_size(), 1024 * 1024 * 2);
+
     auto r4 = tmb.q.at(3);
     ASSERT_EQ(r4.fd, 4);
     ASSERT_STREQ(r4.data.c_str(), "");
@@ -196,3 +198,6 @@ TEST(message_bus, read_with_buffer) {
     ASSERT_EQ(r5.fd, 5);
     ASSERT_STREQ(r5.data.c_str(), "");
 }
+
+
+

ext-src/swoole_http2_client_coro.cc

@@ -512,7 +512,6 @@ ReturnCode Client::parse_frame(zval *return_value, bool pipeline_read) {
         last_stream_id = stream_id;
     }
 
-    uint16_t id = 0;
     uint32_t value = 0;
 
     switch (type) {
@@ -522,9 +521,7 @@ ReturnCode Client::parse_frame(zval *return_value, bool pipeline_read) {
             return SW_CONTINUE;
         }
 
-        while (length > 0) {
-            id = ntohs(*(uint16_t *) (buf));
-            value = ntohl(*(uint32_t *) (buf + sizeof(uint16_t)));
+        auto rc = Http2::unpack_setting_data(buf, length, [this](uint16_t id, uint32_t value) -> ReturnCode {
             swoole_http2_frame_trace_log("id=%d, value=%d", id, value);
             switch (id) {
             case SW_HTTP2_SETTING_HEADER_TABLE_SIZE:
@@ -568,8 +565,11 @@ ReturnCode Client::parse_frame(zval *return_value, bool pipeline_read) {
                 // swoole_warning("unknown option[%d]: %d", id, value);
                 break;
             }
-            buf += sizeof(id) + sizeof(value);
-            length -= sizeof(id) + sizeof(value);
+            return SW_SUCCESS;
+        });
+
+        if (rc != SW_SUCCESS) {
+            return rc;
         }
 
         Http2::set_frame_header(frame, SW_HTTP2_TYPE_SETTINGS, 0, SW_HTTP2_FLAG_ACK, stream_id);

include/swoole.h

@@ -148,6 +148,14 @@ typedef unsigned long ulong_t;
 #define SW_LOOP_N(n) for (decltype(n) i = 0; i < n; i++)
 #define SW_LOOP for (;;)
 
+#ifndef MAYBE_UNUSED
+#ifdef __GNUC__
+#define MAYBE_UNUSED __attribute__((used))
+#else
+#define MAYBE_UNUSED
+#endif
+#endif
+
 #ifndef MAX
 #define MAX(A, B) SW_MAX(A, B)
 #endif