Added more core tests, reacfor, remove useless code. (#5774)

Author: matyhtf

core-tests/include/test_core.h

@@ -42,6 +42,7 @@
 #define TEST_STR2 "I am Rango\n"
 
 #define TEST_LOG_FILE "/tmp/swoole.log"
+#define TEST_SOCK_FILE "/tmp/swoole-core-tests.sock"
 
 #define TEST_REQUEST_BAIDU                                                                                             \
     "GET / HTTP/1.1\r\n"                                                                                               \

core-tests/src/core/wheel_timer.cpp

@@ -140,31 +140,37 @@ TEST(coroutine_hook, getaddrinfo) {
     });
 }
 
-TEST(coroutine_hook, fstat) {
-    coroutine::run([](void *arg) {
-        int fd = swoole_coroutine_open(TEST_TMP_FILE, O_RDONLY, 0);
-        struct stat statbuf_1;
-        swoole_coroutine_fstat(fd, &statbuf_1);
+static void test_fstat() {
+    int fd = swoole_coroutine_open(TEST_TMP_FILE, O_RDONLY, 0);
+    struct stat statbuf_1;
+    swoole_coroutine_fstat(fd, &statbuf_1);
 
-        struct stat statbuf_2;
-        fstat(fd, &statbuf_2);
+    struct stat statbuf_2;
+    fstat(fd, &statbuf_2);
 
-        ASSERT_EQ(memcmp(&statbuf_1, &statbuf_2, sizeof(statbuf_2)), 0);
+    ASSERT_EQ(memcmp(&statbuf_1, &statbuf_2, sizeof(statbuf_2)), 0);
 
-        swoole_coroutine_close(fd);
-    });
+    swoole_coroutine_close(fd);
 }
 
-TEST(coroutine_hook, statvfs) {
-    coroutine::run([](void *arg) {
-        struct statvfs statbuf_1;
-        swoole_coroutine_statvfs("/tmp", &statbuf_1);
+TEST(coroutine_hook, fstat) {
+    coroutine::run([](void *arg) { test_fstat(); });
+    test_fstat();
+}
 
-        struct statvfs statbuf_2;
-        statvfs("/tmp", &statbuf_2);
+static void test_statvfs() {
+    struct statvfs statbuf_1;
+    swoole_coroutine_statvfs("/tmp", &statbuf_1);
 
-        ASSERT_EQ(memcmp(&statbuf_1, &statbuf_2, sizeof(statbuf_2)), 0);
-    });
+    struct statvfs statbuf_2;
+    statvfs("/tmp", &statbuf_2);
+
+    ASSERT_EQ(memcmp(&statbuf_1, &statbuf_2, sizeof(statbuf_2)), 0);
+}
+
+TEST(coroutine_hook, statvfs) {
+    coroutine::run([](void *arg) { test_statvfs(); });
+    test_statvfs();
 }
 
 static void test_hook_dir() {
@@ -403,7 +409,13 @@ TEST(coroutine_hook, timeout) {
         size_t length = text.length();
 
         // unregister fd
+        errno = 0;
         ASSERT_EQ(swoole_coroutine_socket_set_timeout(pairs[0], SO_SNDTIMEO, 0.05), -1);
+        ASSERT_EQ(errno, EINVAL);
+
+        errno = 0;
+        ASSERT_EQ(swoole_coroutine_socket_set_connect_timeout(pairs[0], 0.05), -1);
+        ASSERT_EQ(errno, EINVAL);
 
         swoole::Coroutine::create([&](void *) {
             ASSERT_EQ(swoole_coroutine_socket_create(pairs[0]), 0);
@@ -665,3 +677,60 @@ TEST(coroutine_hook, poll_fake) {
         ASSERT_TRUE(fds[0].revents & POLLOUT);
     });
 }
+
+TEST(coroutine_hook, unwrap) {
+    auto pair = create_socket_pair();
+    auto _sock0 = pair.first;
+    auto _sock1 = pair.second;
+
+    ASSERT_EQ(swoole_coroutine_socket_unwrap(_sock0->get_fd()), -1);
+
+    coroutine::run([&](void *arg) {
+        ASSERT_EQ(swoole_coroutine_socket_unwrap(999999), -1);
+        ASSERT_EQ(swoole_coroutine_socket_create(_sock0->get_fd()), 0);
+        ASSERT_GT(swoole_coroutine_write(_sock0->get_fd(), SW_STRL(TEST_STR)), 0);
+
+        // blocking, wrap-socket not exists
+        char buf[128];
+        ASSERT_EQ(swoole_coroutine_read(_sock1->get_fd(), buf, sizeof(buf)), strlen(TEST_STR));
+        ASSERT_EQ(swoole_coroutine_socket_unwrap(_sock1->get_fd()), -1);
+        // unwrap
+        ASSERT_EQ(swoole_coroutine_socket_unwrap(_sock0->get_fd()), 0);
+        // fail to unwrap
+        ASSERT_EQ(swoole_coroutine_socket_unwrap(_sock0->get_fd()), -1);
+    });
+}
+
+static void test_freopen() {
+    auto output_file = "/tmp/output.txt";
+    unlink(output_file);
+    unlink(TEST_LOG_FILE);
+
+    auto fp = swoole_coroutine_fopen(TEST_LOG_FILE, "w");
+    if (fp == NULL) {
+        fprintf(stderr, "Failed to open '%s': %s (errno=%d)\n", TEST_LOG_FILE, strerror(errno), errno);
+    }
+    ASSERT_NE(fp, nullptr);
+    swoole_coroutine_fputs("hello\n", fp);
+
+    ASSERT_NE(swoole_coroutine_freopen(output_file, "w", fp), nullptr);
+    swoole_coroutine_fputs("world\n", fp);
+
+    swoole_coroutine_fclose(fp);
+
+    auto rs1 = swoole::file_get_contents(output_file);
+    ASSERT_FALSE(rs1->contains("hello\n"));
+    ASSERT_TRUE(rs1->contains("world\n"));
+
+    auto rs2 = swoole::file_get_contents(TEST_LOG_FILE);
+    ASSERT_TRUE(rs2->contains("hello\n"));
+    ASSERT_FALSE(rs2->contains("world\n"));
+
+    unlink(TEST_LOG_FILE);
+    unlink(output_file);
+}
+
+TEST(coroutine_hook, freopen) {
+    coroutine::run([&](void *arg) { test_freopen(); });
+    test_freopen();
+}

core-tests/src/coroutine/hook.cpp

@@ -773,10 +773,4 @@ TEST(client, ssl) {
 
     ASSERT_TRUE(sw_tg_buffer()->contains("中华人民共和国"));
 }
-
-TEST(client, ssl_reinit) {
-    swoole_ssl_destroy();
-    swoole_ssl_init();
-    test_ssl_get_baidu();
-}
 #endif

core-tests/src/network/client.cpp

@@ -609,18 +609,21 @@ TEST(socket, get_domain_and_type) {
     test_sock_type(SW_SOCK_UDP6, AF_INET6, SOCK_DGRAM);
     test_sock_type(SW_SOCK_UNIX_STREAM, AF_LOCAL, SOCK_STREAM);
     test_sock_type(SW_SOCK_UNIX_DGRAM, AF_LOCAL, SOCK_DGRAM);
+    test_sock_type(SW_SOCK_RAW, AF_INET, SOCK_RAW);
+    test_sock_type(SW_SOCK_RAW6, AF_INET6, SOCK_RAW);
 
     int sock_domain, sock_type;
-    ASSERT_EQ(network::Socket::get_domain_and_type(SW_SOCK_RAW, &sock_domain, &sock_type), SW_ERR);
+    ASSERT_EQ(network::Socket::get_domain_and_type((swSocketType) (SW_SOCK_RAW6 + 1), &sock_domain, &sock_type),
+              SW_ERR);
 }
 
 TEST(socket, make_socket) {
     network::Socket *sock;
 
     sock = make_socket(SW_SOCK_RAW, SW_FD_STREAM, 0);
     ASSERT_EQ(sock, nullptr);
-    ASSERT_EQ(errno, ESOCKTNOSUPPORT);
-    ASSERT_EQ(swoole_get_last_error(), ESOCKTNOSUPPORT);
+    ASSERT_EQ(errno, EPROTONOSUPPORT);
+    ASSERT_EQ(swoole_get_last_error(), EPROTONOSUPPORT);
 
     sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, AF_INET6, SOCK_RDM, 999, 0);
     ASSERT_EQ(sock, nullptr);
@@ -635,8 +638,13 @@ TEST(socket, make_server_socket) {
 
     sock = make_server_socket(SW_SOCK_RAW, bad_addr);
     ASSERT_EQ(sock, nullptr);
-    ASSERT_EQ(errno, ESOCKTNOSUPPORT);
-    ASSERT_EQ(swoole_get_last_error(), ESOCKTNOSUPPORT);
+    if (geteuid() == 0) {  // root
+        ASSERT_EQ(errno, EPROTONOSUPPORT);
+        ASSERT_EQ(swoole_get_last_error(), EPROTONOSUPPORT);
+    } else {
+        ASSERT_EQ(errno, ESOCKTNOSUPPORT);
+        ASSERT_EQ(swoole_get_last_error(), ESOCKTNOSUPPORT);
+    }
 
     sock = make_server_socket(SW_SOCK_TCP, bad_addr);
     ASSERT_EQ(sock, nullptr);

core-tests/src/network/socket.cpp

@@ -109,3 +109,34 @@ TEST(async, schedule) {
     ASSERT_EQ(handle_count, N);
     ASSERT_EQ(callback_count, N);
 }
+
+TEST(async, misc) {
+    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

@@ -21,6 +21,8 @@ static void test_func(ProcessPool &pool) {
     data.info.len = size;
     memcpy(data.data, rmem.value(), size);
 
+    DEBUG() << "dispatch: " << size << " bytes\n";
+
     int worker_id = -1;
     ASSERT_EQ(pool.dispatch_sync(&data, &worker_id), SW_OK);
 
@@ -48,6 +50,8 @@ static void test_func_message_protocol(ProcessPool &pool) {
         pool->running = false;
         String *_data = (String *) pool->ptr;
         usleep(10000);
+
+        DEBUG() << "received: " << rdata->info.len << " bytes\n";
         EXPECT_MEMEQ(_data->str, rdata->data, rdata->info.len);
     };
     test_func(pool);
@@ -60,6 +64,8 @@ static void test_func_stream_protocol(ProcessPool &pool) {
         String *_data = (String *) pool->ptr;
         EventData *msg = (EventData *) rdata->data;
         usleep(10000);
+
+        DEBUG() << "received: " << rdata->info.len << " bytes\n";
         EXPECT_MEMEQ(_data->str, msg->data, msg->len());
     };
     test_func(pool);
@@ -93,6 +99,10 @@ TEST(process_pool, unix_sock) {
     ProcessPool pool{};
     signal(SIGPIPE, SIG_IGN);
     ASSERT_EQ(pool.create(1, 0, SW_IPC_UNIXSOCK), SW_OK);
+    ASSERT_EQ(pool.listen(TEST_HOST, TEST_PORT, 128), SW_ERR);
+    ASSERT_ERREQ(SW_ERROR_OPERATION_NOT_SUPPORT);
+    ASSERT_EQ(pool.listen(TEST_SOCK_FILE, 128), SW_ERR);
+    ASSERT_ERREQ(SW_ERROR_OPERATION_NOT_SUPPORT);
 
     test_func_task_protocol(pool);
 }
@@ -144,6 +154,13 @@ TEST(process_pool, stream_protocol) {
     test_func_stream_protocol(pool);
 }
 
+TEST(process_pool, stream_protocol_with_msgq) {
+    ProcessPool pool{};
+    ASSERT_EQ(pool.create(1, 0x9501, SW_IPC_MSGQUEUE), SW_OK);
+
+    test_func_stream_protocol(pool);
+}
+
 constexpr int magic_number = 99900011;
 static ProcessPool *current_pool = nullptr;
 static Worker *current_worker = nullptr;
@@ -542,10 +559,57 @@ TEST(process_pool, listen_unixsock) {
     t1.join();
 }
 
-TEST(process_pool, max_request_grace) {
+TEST(process_pool, worker) {
     Worker worker{};
+    worker.init();
+
+    ASSERT_TRUE(worker.is_running());
+    ASSERT_GT(worker.start_time, 0);
     worker.set_max_request(1000, 200);
 
     ASSERT_GT(SwooleWG.max_request, 1000);
     ASSERT_LE(SwooleWG.max_request, 1200);
+
+    worker.shutdown();
+    ASSERT_TRUE(worker.is_shutdown());
+
+    swoole_set_worker_type(SW_USER_WORKER);
+    ASSERT_EQ(swoole_get_worker_symbol(), '@');
+
+    swoole_set_worker_type(SW_TASK_WORKER);
+    ASSERT_EQ(swoole_get_worker_symbol(), '^');
+
+    swoole_set_worker_type(SW_WORKER);
+    ASSERT_EQ(swoole_get_worker_symbol(), '*');
+
+    swoole_set_worker_type(SW_MASTER);
+    ASSERT_EQ(swoole_get_worker_symbol(), '#');
+
+    swoole_set_worker_type(SW_MANAGER);
+    ASSERT_EQ(swoole_get_worker_symbol(), '$');
+
+    worker.set_status_to_idle();
+    ASSERT_TRUE(worker.is_idle());
+    ASSERT_FALSE(worker.is_busy());
+
+    worker.set_status_to_busy();
+    ASSERT_FALSE(worker.is_idle());
+    ASSERT_TRUE(worker.is_busy());
+
+    worker.set_status(SW_WORKER_EXIT);
+    ASSERT_FALSE(worker.is_idle());
+    ASSERT_FALSE(worker.is_busy());
+}
+
+TEST(process_pool, add_worker) {
+    Worker worker{};
+    worker.pid = getpid();
+
+    ProcessPool pool{};
+    ASSERT_EQ(pool.create(1, 0, SW_IPC_UNIXSOCK), SW_OK);
+
+    pool.add_worker(&worker);
+
+    auto *worker2 = pool.get_worker_by_pid(getpid());
+    ASSERT_EQ(&worker, worker2);
 }

core-tests/src/os/process_pool.cpp

@@ -322,11 +322,6 @@ TEST(protocol, unpack) {
     {
         char buffer[8];
 
-        // Create a test value that will be different when byte-swapped
-        uint16_t test16 = 0x1234;
-        uint32_t test32 = 0x12345678;
-        uint64_t test64 = 0x123456789ABCDEF0ULL;
-
         // Test that 'n' and 'v' formats handle endianness correctly
         buffer[0] = 0x12;
         buffer[1] = 0x34;