Added more core tests, Increase test coverage to 83% (#5779)

Author: matyhtf

.github/workflows/ext.yml

@@ -7,7 +7,7 @@ env:
 
 jobs:
   build-ubuntu-latest:
-    if: "!contains(github.event.head_commit.message, '--filter=') || contains(github.event.head_commit.message, '[ext]')"
+    if: "!contains(github.event.head_commit.message, '--filter=') || contains(github.event.head_commit.message, '[ubuntu]')"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

core-tests/src/core/base.cpp

@@ -367,3 +367,36 @@ TEST(base, spinlock) {
 
     ASSERT_EQ(counter[1], n * 2);
 }
+
+TEST(base, futex) {
+    sw_atomic_t value = 1;
+
+    std::thread t1([&value] {
+        DEBUG() << "wait 1\n";
+        ASSERT_EQ(sw_atomic_futex_wait(&value, -1), SW_OK);  // no wait
+        value = 0;
+
+        DEBUG() << "wait 2\n";
+
+        ASSERT_EQ(sw_atomic_futex_wait(&value, 0.05), SW_ERR);  // timed out
+        ASSERT_EQ(sw_atomic_futex_wait(&value, 0.5), SW_OK);    // success
+
+        DEBUG() << "wait 3\n";
+
+        value = 0;
+        ASSERT_EQ(sw_atomic_futex_wait(&value, -1), SW_OK);  // no timeout
+    });
+
+    std::thread t2([&value] {
+        usleep(100000);
+        DEBUG() << "wakeup 1\n";
+        ASSERT_EQ(sw_atomic_futex_wakeup(&value, 1), 1);
+
+        DEBUG() << "wakeup 2\n";
+        usleep(100000);
+        ASSERT_EQ(sw_atomic_futex_wakeup(&value, 1), 1);
+    });
+
+    t1.join();
+    t2.join();
+}

core-tests/src/core/log.cpp

@@ -15,18 +15,39 @@ TEST(log, level) {
     for (auto iter = processTypes.begin(); iter != processTypes.end(); iter++) {
         swoole_set_worker_type(*iter);
         sw_logger()->reset();
+
+        ASSERT_FALSE(sw_logger()->is_opened());
+
+        sw_logger()->set_level(999);
+        ASSERT_EQ(sw_logger()->get_level(), SW_LOG_NONE);
+
+        sw_logger()->set_level(SW_LOG_DEBUG - 10);
+        ASSERT_EQ(sw_logger()->get_level(), SW_LOG_DEBUG);
+
         sw_logger()->set_level(SW_LOG_NOTICE);
         sw_logger()->open(file);
 
+        ASSERT_TRUE(sw_logger()->is_opened());
+
+        sw_logger()->put(SW_LOG_DEBUG, SW_STRL("hello no debug"));
+        sw_logger()->put(SW_LOG_TRACE, SW_STRL("hello no trace"));
         sw_logger()->put(SW_LOG_INFO, SW_STRL("hello info"));
         sw_logger()->put(SW_LOG_NOTICE, SW_STRL("hello notice"));
         sw_logger()->put(SW_LOG_WARNING, SW_STRL("hello warning"));
 
+        sw_logger()->set_level(SW_LOG_DEBUG);
+        sw_logger()->put(SW_LOG_DEBUG, SW_STRL("hello debug"));
+        sw_logger()->put(SW_LOG_TRACE, SW_STRL("hello trace"));
+
         auto content = file_get_contents(file);
 
         sw_logger()->close();
         unlink(file);
 
+        ASSERT_FALSE(content->contains(SW_STRL("hello no debug")));
+        ASSERT_FALSE(content->contains(SW_STRL("hello no trace")));
+        ASSERT_TRUE(content->contains(SW_STRL("hello debug")));
+        ASSERT_TRUE(content->contains(SW_STRL("hello trace")));
         ASSERT_FALSE(content->contains(SW_STRL("hello info")));
         ASSERT_TRUE(content->contains(SW_STRL("hello notice")));
         ASSERT_TRUE(content->contains(SW_STRL("hello warning")));

core-tests/src/memory/table.cpp

@@ -58,9 +58,11 @@ class table_t {
             throw exception_t("alloc failed", swoole_get_last_error());
         }
 
-        table->add_column("id", TableColumn::TYPE_INT, 0);
-        table->add_column("name", TableColumn::TYPE_STRING, 32);
-        table->add_column("score", TableColumn::TYPE_FLOAT, 0);
+        EXPECT_TRUE(table->add_column("id", TableColumn::TYPE_INT, 0));
+        EXPECT_TRUE(table->add_column("name", TableColumn::TYPE_STRING, 32));
+        EXPECT_TRUE(table->add_column("score", TableColumn::TYPE_FLOAT, 0));
+
+        EXPECT_FALSE(table->add_column("bad_field", (TableColumn::Type) 8, 0));
 
         if (!table->create()) {
             throw exception_t("create failed", swoole_get_last_error());
@@ -134,6 +136,8 @@ class table_t {
 TEST(table, create) {
     table_t table(1024);
 
+    ASSERT_GT(table.ptr()->get_memory_size(), table.ptr()->get_size() * table.ptr()->get_column_size());
+
     table.set("php", {"php", 1, 1.245});
     table.set("java", {"java", 2, 3.1415926});
     table.set("c++", {"c++", 3, 4.888});

core-tests/src/network/dns.cpp

@@ -64,7 +64,7 @@ TEST(dns, cancel) {
     test::coroutine::run([](void *arg) {
         auto co = Coroutine::get_current_safe();
         Coroutine::create([co](void *) {
-            System::sleep(0.002);
+            System::sleep(0.001);
             co->cancel();
         });
         auto list1 = swoole::coroutine::dns_lookup("www.baidu-not-found-for-cancel.com", AF_INET, 2);

core-tests/src/os/timer.cpp

@@ -151,4 +151,42 @@ TEST(timer, error) {
     swoole_timer_delay(nullptr, 100);
     ASSERT_FALSE(swoole_timer_del(nullptr));
     SwooleTG.timer = tmp;
+
+    swoole_timer_free();
+}
+
+TEST(timer, reinit) {
+    int timer1_count = 0;
+    int timer2_count = 0;
+
+    swoole_timer_after(
+        20,
+        [&](Timer *, TimerNode *) {
+            timer1_count++;
+            DEBUG() << "timer2_count" << timer2_count << "\n";
+        },
+        nullptr);
+
+    swoole_event_init(SW_EVENTLOOP_WAIT_EXIT);
+
+    sw_timer()->reinit(sw_reactor());
+
+    uint64_t ms1 = swoole::time<std::chrono::milliseconds>();
+
+    swoole_timer_tick(
+        100,
+        [&](Timer *, TimerNode *tnode) {
+            timer2_count++;
+            DEBUG() << "timer2_count" << timer2_count << "\n";
+            if (timer2_count == 5) {
+                swoole_timer_del(tnode);
+            }
+        },
+        nullptr);
+
+    swoole_event_wait();
+    uint64_t ms2 = swoole::time<std::chrono::milliseconds>();
+    ASSERT_LE(ms2 - ms1, 510);
+    ASSERT_EQ(timer1_count, 1);
+    ASSERT_EQ(timer2_count, 5);
 }

core-tests/src/server/server.cpp

@@ -2895,3 +2895,181 @@ TEST(server, no_idle_task_worker) {
 
     remove(TEST_LOG_FILE);
 }
+
+static void test_conn_overflow(Server::Mode mode, bool send_yield) {
+    Server serv(mode);
+    serv.worker_num = 1;
+    serv.send_yield = send_yield;
+    swoole_set_log_level(SW_LOG_WARNING);
+
+    test::counter_init();
+    auto counter = test::counter_ptr();
+
+    Mutex *lock = new Mutex(Mutex::PROCESS_SHARED);
+    lock->lock();
+
+    ListenPort *port = serv.add_port(SW_SOCK_TCP, TEST_HOST, 0);
+    if (!port) {
+        swoole_warning("listen failed, [error=%d]", swoole_get_last_error());
+        exit(2);
+    }
+
+    ASSERT_EQ(serv.create(), SW_OK);
+
+    thread t1;
+    serv.onStart = [&lock, &t1](Server *serv) {
+        t1 = thread([=]() {
+            swoole_signal_block_all();
+
+            lock->lock();
+
+            ListenPort *port = serv->get_primary_port();
+
+            network::SyncClient c(SW_SOCK_TCP);
+            c.connect(TEST_HOST, port->port);
+            c.send(packet, strlen(packet));
+            char buf[1024];
+            c.recv(buf, sizeof(buf));
+            c.close();
+
+            kill(serv->gs->master_pid, SIGTERM);
+        });
+    };
+
+    serv.onWorkerStart = [&lock](Server *serv, Worker *worker) {
+        if (worker->id == 0) {
+            lock->unlock();
+        }
+        test::counter_incr(3);
+        DEBUG() << "onWorkerStart: id=" << worker->id << "\n";
+    };
+
+    serv.onReceive = [counter, send_yield](Server *serv, RecvData *req) -> int {
+        auto sid = req->session_id();
+        auto conn = serv->get_connection_by_session_id(sid);
+        conn->overflow = 1;
+
+        EXPECT_FALSE(serv->send(sid, SW_STRL(TEST_STR)));
+        EXPECT_ERREQ(send_yield ? SW_ERROR_OUTPUT_SEND_YIELD : SW_ERROR_OUTPUT_BUFFER_OVERFLOW);
+
+        counter[0] = 1;
+
+        swoole_timer_after(100, [serv, sid](TIMER_PARAMS) { serv->close(sid); });
+
+        return SW_OK;
+    };
+
+    ASSERT_EQ(serv.start(), 0);
+
+    t1.join();
+    delete lock;
+    ASSERT_EQ(counter[0], 1);
+    ASSERT_EQ(counter[3], 1);
+}
+
+TEST(server, overflow_1) {
+    test_conn_overflow(Server::MODE_BASE, false);
+}
+
+TEST(server, overflow_2) {
+    test_conn_overflow(Server::MODE_PROCESS, false);
+}
+
+TEST(server, overflow_3) {
+    test_conn_overflow(Server::MODE_BASE, true);
+}
+
+TEST(server, overflow_4) {
+    test_conn_overflow(Server::MODE_PROCESS, true);
+}
+
+TEST(server, send_timeout) {
+    Server serv(Server::MODE_BASE);
+    serv.worker_num = 1;
+    swoole_set_log_level(SW_LOG_WARNING);
+
+    test::counter_init();
+    auto counter = test::counter_ptr();
+
+    Mutex *lock = new Mutex(Mutex::PROCESS_SHARED);
+    lock->lock();
+
+    ListenPort *port = serv.add_port(SW_SOCK_TCP, TEST_HOST, 0);
+    if (!port) {
+        swoole_warning("listen failed, [error=%d]", swoole_get_last_error());
+        exit(2);
+    }
+
+    port->max_idle_time = 1;
+
+    String wbuf(2 * 1024 * 1024);
+    wbuf.append_random_bytes(2 * 1024 * 1024, false);
+
+    ASSERT_EQ(serv.create(), SW_OK);
+
+    thread t1;
+    serv.onStart = [&lock, &t1, &wbuf](Server *serv) {
+        t1 = thread([=]() {
+            swoole_signal_block_all();
+
+            lock->lock();
+
+            ListenPort *port = serv->get_primary_port();
+
+            network::SyncClient c(SW_SOCK_TCP);
+            c.connect(TEST_HOST, port->port);
+            c.send(packet, strlen(packet));
+
+            String rbuf(3 * 1024 * 1024);
+
+            auto rn = c.recv(rbuf.str, 1024);
+            EXPECT_EQ(rn, 1024);
+            rbuf.length += 1024;
+
+            sleep(2);
+
+            while (true) {
+                rn = c.recv(rbuf.str + rbuf.length, rbuf.size - rbuf.length);
+                if (rn <= 0) {
+                    break;
+                }
+                rbuf.length += rn;
+            }
+
+            EXPECT_MEMEQ(rbuf.str, wbuf.str, rbuf.length);
+            c.close();
+
+            kill(serv->gs->master_pid, SIGTERM);
+        });
+    };
+
+    serv.onWorkerStart = [&lock](Server *serv, Worker *worker) {
+        if (worker->id == 0) {
+            lock->unlock();
+        }
+        test::counter_incr(3);
+        DEBUG() << "onWorkerStart: id=" << worker->id << "\n";
+    };
+
+    serv.onReceive = [&wbuf](Server *serv, RecvData *req) -> int {
+        auto sid = req->session_id();
+        auto conn = serv->get_connection_by_session_id(sid);
+
+        swoole_timer_del(conn->socket->recv_timer);
+        conn->socket->recv_timer = nullptr;
+        conn->socket->set_buffer_size(65536);
+
+        EXPECT_TRUE(serv->send(sid, wbuf.str, wbuf.length));
+
+        test::counter_incr(0);
+
+        return SW_OK;
+    };
+
+    ASSERT_EQ(serv.start(), 0);
+
+    t1.join();
+    delete lock;
+    ASSERT_EQ(counter[0], 1);
+    ASSERT_EQ(counter[3], 1);
+}

include/swoole_reactor.h

@@ -363,7 +363,7 @@ class Reactor {
     static int _writable_callback(Reactor *reactor, Event *ev);
     static ssize_t write_func(Reactor *reactor,
                               network::Socket *socket,
-                              size_t _len,
+                              const size_t _len,
                               const std::function<ssize_t()> &send_fn,
                               const std::function<void(Buffer *buffer)> &append_fn);
 

include/swoole_ssl.h

@@ -27,6 +27,10 @@
 #include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/crypto.h>
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/rand.h>
+#include <openssl/conf.h>
 #include <openssl/opensslv.h>
 
 #if OPENSSL_VERSION_NUMBER >= 0x10100000L

include/swoole_table.h

@@ -180,6 +180,10 @@ class Table {
         return size;
     }
 
+    size_t get_column_size() const {
+        return column_map->size();
+    }
+
     TableRow *get_by_index(uint32_t index) const {
         TableRow *row = rows[index];
         return row->active ? row : nullptr;

src/core/timer.cc

@@ -97,6 +97,7 @@ bool Timer::init_with_reactor(Reactor *reactor) {
 }
 
 void Timer::reinit(Reactor *reactor) {
+    close(this);
     init_with_reactor(reactor);
     reactor->timeout_msec = next_msec_;
 }

src/network/socket.cc

@@ -23,13 +23,6 @@
 #include "swoole_string.h"
 #include "swoole_timer.h"
 
-#ifdef SW_USE_OPENSSL
-#include <openssl/x509.h>
-#include <openssl/x509v3.h>
-#include <openssl/rand.h>
-#include <openssl/conf.h>
-#endif
-
 namespace swoole {
 namespace network {