Increase the unit test coverage, optimize the code in the reactor/string module, and remove the select reactor. (#5757)

* Added more core tests for Reactor, optimize code, add comments. --filter=[core]

* optimize core tests --filter=[core]

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

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

* Added sw_printf/swoole_set_stdout_stream/swoole_get_stdout_stream API. Added more core tests for coroutine.

* code format

* Remove select reactor. Optimize reactor/coroutine core tests. --filter=[core]

* Remove useless code in Reactor module. Optimiz tests

* Move the functions with a larger number of lines from the header file to the .cc source file.

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

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

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

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

Author: matyhtf

core-tests/include/test_core.h

@@ -35,6 +35,14 @@
 
 #define TEST_DOMAIN_BAIDU "www.baidu.com"
 
+#define TEST_HTTP_DOMAIN "www.gov.cn"
+#define TEST_HTTP_EXPECT "Location: https://www.gov.cn/"
+
+#define TEST_STR "hello world, hello swoole\n"
+#define TEST_STR2 "I am Rango\n"
+
+#define TEST_LOG_FILE "/tmp/swoole.log"
+
 #define TEST_REQUEST_BAIDU                                                                                             \
     "GET / HTTP/1.1\r\n"                                                                                               \
     "Host: www.baidu.com\r\n"                                                                                          \

core-tests/src/core/base.cpp

@@ -307,7 +307,7 @@ TEST(base, only_dump) {
 }
 
 TEST(base, redirect_stdout) {
-    auto file = "/tmp/swoole.log";
+    auto file = TEST_LOG_FILE;
     auto out_1 = "hello world, hello swoole!\n";
     auto out_2 = "write to /dev/null\n";
     auto status = test::spawn_exec_and_wait([&]() {

core-tests/src/core/log.cpp

@@ -143,7 +143,7 @@ TEST(log, redirect_1) {
 
 TEST(log, redirect_2) {
     auto status = test::spawn_exec_and_wait([]() {
-        auto file = "/tmp/swoole.log";
+        auto file = TEST_LOG_FILE;
         auto str = "hello world, hello swoole\n";
 
         sw_logger()->reset();

core-tests/src/core/string.cpp

@@ -45,6 +45,98 @@ TEST(string, rtrim) {
     ASSERT_EQ(strcmp("", buf), 0);
 }
 
+TEST(string, move_and_copy) {
+    String s1(TEST_STR);
+    ASSERT_MEMEQ(s1.str, TEST_STR, s1.length);
+
+    String s2(s1);
+    ASSERT_MEMEQ(s2.str, TEST_STR, s2.length);
+    ASSERT_NE(s1.str, nullptr);
+
+    String s3(std::move(s1));
+    ASSERT_MEMEQ(s3.str, TEST_STR, s3.length);
+    ASSERT_EQ(s1.str, nullptr);
+
+    String s4;
+    s4 = s3;
+    ASSERT_MEMEQ(s4.str, TEST_STR, s4.length);
+    ASSERT_NE(s3.str, nullptr);
+
+    String s5;
+    s5 = std::move(s3);
+    ASSERT_MEMEQ(s5.str, TEST_STR, s5.length);
+    ASSERT_EQ(s3.str, nullptr);
+
+    String s6(SW_STRL(TEST_STR));
+    ASSERT_MEMEQ(s6.str, TEST_STR, s6.length);
+}
+
+TEST(string, append) {
+    String s1(TEST_STR);
+    s1.append(12345678);
+
+    String s2(TEST_STR2);
+    s1.append(s2);
+
+    ASSERT_MEMEQ(s1.str, TEST_STR "12345678" TEST_STR2, s1.length);
+}
+
+TEST(string, write) {
+    String s1;
+    s1.reserve(32);
+
+    String s2(TEST_STR);
+    s1.repeat(" ", 1, 30);
+    s1.write(30, s2);
+
+    auto s3 = s1.substr(30, s2.length);
+    ASSERT_MEMEQ(s3.str, TEST_STR, s3.length);
+}
+
+TEST(string, repeat) {
+    auto end_str = "[end]";
+    String s1;
+    s1.repeat(SW_STRL("hello\r\n"), 5);
+    s1.append(end_str);
+
+    int count = 0;
+    auto offset = s1.split(SW_STRL("\r\n"), [&](const char *data, size_t length) -> bool {
+        count++;
+        EXPECT_MEMEQ(data, "hello\r\n", 7);
+        return true;
+    });
+
+    ASSERT_EQ(offset, s1.length - strlen(end_str));
+    ASSERT_MEMEQ(s1.str + offset, end_str, strlen(end_str));
+
+    ASSERT_EQ(count, 5);
+}
+
+TEST(string, release) {
+    String s1(TEST_STR);
+    ASSERT_MEMEQ(s1.str, TEST_STR, s1.length);
+
+    auto s2 = s1.release();
+    ASSERT_EQ(s1.str, nullptr);
+    ASSERT_EQ(s1.length, 0);
+
+    ASSERT_MEMEQ(s2, TEST_STR, strlen(TEST_STR));
+    sw_free(s2);
+}
+
+TEST(string, ub) {
+    String s1(TEST_STR);
+    String s2(TEST_STR2);
+
+    s1 = s2;
+    s1 = s1;
+
+    auto rs = s1.substr(s1.length, 10);
+    ASSERT_EQ(rs.str, nullptr);
+
+    ASSERT_FALSE(s1.repeat("\r\n", 2, 0));
+}
+
 TEST(string, strnpos) {
     {
         string haystack = "hello world";

core-tests/src/coroutine/base.cpp

@@ -210,6 +210,44 @@ TEST(coroutine_base, cancel) {
     });
 }
 
+TEST(coroutine_base, noncancelable) {
+    std::unordered_map<std::string, bool> flags;
+    coroutine::run([&flags](void *arg) {
+        auto cid = Coroutine::create([&flags](void *_arg) {
+            Coroutine *current = Coroutine::get_current();
+            flags["yield_1"] = true;
+            current->yield();
+            ASSERT_FALSE(current->is_canceled());
+
+            flags["yield_2"] = true;
+            current->yield_ex(-1);
+            ASSERT_TRUE(current->is_canceled());
+        });
+
+        auto co = Coroutine::get_by_cid(cid);
+
+        flags["cancel_1"] = true;
+        ASSERT_FALSE(co->cancel());
+        ASSERT_EQ(swoole_get_last_error(), SW_ERROR_CO_CANNOT_CANCEL);
+        flags["resume_1"] = true;
+        co->resume();
+
+        flags["cancel_2"] = true;
+        ASSERT_TRUE(co->cancel());
+        flags["resume_2"] = true;
+
+        flags["done"] = true;
+    });
+
+    ASSERT_TRUE(flags["yield_1"]);
+    ASSERT_TRUE(flags["yield_2"]);
+    ASSERT_TRUE(flags["cancel_1"]);
+    ASSERT_TRUE(flags["resume_1"]);
+    ASSERT_TRUE(flags["cancel_2"]);
+    ASSERT_TRUE(flags["resume_2"]);
+    ASSERT_TRUE(flags["done"]);
+}
+
 TEST(coroutine_base, timeout) {
     coroutine::run([](void *arg) {
         auto co = Coroutine::get_current_safe();
@@ -224,6 +262,7 @@ TEST(coroutine_base, gdb) {
         long cid = current->get_cid();
         ASSERT_EQ(swoole_coroutine_count(), 1);
         ASSERT_EQ(swoole_coroutine_get(cid), current);
+        ASSERT_EQ(swoole_coroutine_get(999999), nullptr);
 
         swoole_coroutine_iterator_reset();
         ASSERT_EQ(swoole_coroutine_iterator_each(), current);
@@ -234,3 +273,54 @@ TEST(coroutine_base, gdb) {
         Coroutine::print_list();
     });
 }
+
+TEST(coroutine_base, bailout) {
+    int status;
+
+    status = test::spawn_exec_and_wait([]() {
+        std::unordered_map<std::string, bool> flags;
+        coroutine::run([&flags](void *arg) {
+            Coroutine::create([&flags](void *_arg) {
+                Coroutine *current = Coroutine::get_current();
+                current->bailout([&flags]() { flags["exit"] = true; });
+                flags["end"] = true;
+            });
+        });
+
+        ASSERT_TRUE(flags["exit"]);
+        ASSERT_FALSE(flags["end"]);
+    });
+    ASSERT_EQ(status, 0);
+
+    status = test::spawn_exec_and_wait([]() {
+        std::unordered_map<std::string, bool> flags;
+        coroutine::run([&flags](void *arg) {
+            Coroutine *current = Coroutine::get_current();
+            current->bailout(nullptr);
+            flags["end"] = true;
+        });
+
+        ASSERT_TRUE(flags["exit"]);
+        ASSERT_FALSE(flags["end"]);
+    });
+    ASSERT_EQ(WEXITSTATUS(status), 1);
+
+    status = test::spawn_exec_and_wait([]() {
+        std::unordered_map<std::string, bool> flags;
+        coroutine::run([&flags](void *arg) {
+            Coroutine *current = Coroutine::get_current();
+            swoole_event_defer(
+                [current, &flags](void *args) {
+                    flags["bailout"] = true;
+                    current->bailout(nullptr);
+                    flags["end"] = true;
+                },
+                nullptr);
+            flags["exit"] = true;
+        });
+
+        ASSERT_TRUE(flags["exit"]);
+        ASSERT_TRUE(flags["end"]);
+    });
+    ASSERT_EQ(WEXITSTATUS(status), 0);
+}

core-tests/src/network/client.cpp

@@ -184,7 +184,7 @@ TEST(client, sleep) {
 
     String buf(65536);
 
-    auto domain = "httpbin.org";
+    auto domain = TEST_HTTP_DOMAIN;
 
     Client client(SW_SOCK_TCP, true);
     client.onConnect = [&domain](Client *cli) {
@@ -204,7 +204,7 @@ TEST(client, sleep) {
 
     swoole_event_wait();
 
-    ASSERT_TRUE(buf.contains("HTTP/1.1 200 OK"));
+    ASSERT_TRUE(buf.contains(TEST_HTTP_EXPECT));
 }
 
 TEST(client, connect_refuse) {

core-tests/src/network/socket.cpp

@@ -343,11 +343,11 @@ TEST(socket, check_liveness) {
 static void test_socket_sync(network::Socket *sock, bool connect = true) {
     if (connect) {
         network::Address addr;
-        ASSERT_TRUE(addr.assign("tcp://httpbin.org:80"));
+        ASSERT_TRUE(addr.assign("tcp://" TEST_HTTP_DOMAIN ":80"));
         ASSERT_EQ(sock->connect(addr), 0);
     }
 
-    auto req = test::http_get_request("httpbin.org", "/get");
+    auto req = test::http_get_request(TEST_HTTP_DOMAIN, "/get");
     ASSERT_EQ(sock->write_sync(req.c_str(), req.length()), req.length());
     ASSERT_TRUE(sock->check_liveness());
 
@@ -362,7 +362,7 @@ static void test_socket_sync(network::Socket *sock, bool connect = true) {
         resp.append(buf, n);
     }
 
-    ASSERT_TRUE(resp.find("HTTP/1.1 200 OK") != resp.npos);
+    ASSERT_TRUE(resp.find(TEST_HTTP_EXPECT) != resp.npos);
 
     usleep(50000);
     ASSERT_FALSE(sock->check_liveness());
@@ -378,7 +378,7 @@ TEST(socket, sync) {
 TEST(socket, dup) {
     auto sock = make_socket(SW_SOCK_TCP, SW_FD_STREAM, 0);
     network::Address addr;
-    ASSERT_TRUE(addr.assign("tcp://httpbin.org:80"));
+    ASSERT_TRUE(addr.assign("tcp://" TEST_HTTP_DOMAIN ":80"));
     ASSERT_EQ(sock->connect(addr), 0);
 
     auto sock_2 = sock->dup();
@@ -389,9 +389,27 @@ TEST(socket, dup) {
 
 TEST(socket, ipv6_addr) {
     auto sock = make_socket(SW_SOCK_TCP6, SW_FD_STREAM, 0);
-    swoole::network::Address addr;
+    network::Address addr;
     ASSERT_TRUE(addr.assign("tcp://[::1]:12345"));
     ASSERT_EQ(sock->connect(addr), SW_ERR);
     ASSERT_EQ(errno, ECONNREFUSED);
     sock->free();
 }
+
+TEST(socket, loopback_addr) {
+    network::Address addr1;
+    addr1.assign(SW_SOCK_TCP, "127.0.0.1", 0);
+    ASSERT_TRUE(addr1.is_loopback_addr());
+
+    network::Address addr2;
+    addr2.assign(SW_SOCK_TCP6, "::1", 0);
+    ASSERT_TRUE(addr1.is_loopback_addr());
+
+    network::Address addr3;
+    addr3.assign(SW_SOCK_TCP, "192.168.1.2", 0);
+    ASSERT_FALSE(addr3.is_loopback_addr());
+
+    network::Address addr4;
+    addr4.assign(SW_SOCK_TCP6, "192::66::88", 0);
+    ASSERT_FALSE(addr4.is_loopback_addr());
+}