Add core tests r85 (#5776)

Author: matyhtf

core-tests/include/test_core.h

@@ -37,6 +37,7 @@
 
 #define TEST_HTTP_DOMAIN "www.gov.cn"
 #define TEST_HTTP_EXPECT "Location: https://www.gov.cn/"
+#define TEST_HTTPS_EXPECT "中国政府网"
 
 #define TEST_STR "hello world, hello swoole\n"
 #define TEST_STR2 "I am Rango\n"
@@ -59,7 +60,7 @@
 #define ASSERT_ERREQ(x) ASSERT_EQ(swoole_get_last_error(), x)
 #define EXPECT_ERREQ(x) EXPECT_EQ(swoole_get_last_error(), x)
 
-#define TIMER_PARAMS Timer *timer, TimerNode *tnode
+#define TIMER_PARAMS swoole::Timer *timer, swoole::TimerNode *tnode
 
 #ifdef SW_VERBOSE
 #define DEBUG() std::cout

core-tests/src/_lib/server.cpp

@@ -40,12 +40,12 @@ Server::Server(std::string _host, int _port, swoole::Server::Mode _mode, int _ty
     serv.private_data_2 = this;
 
     if (!listen(host, port, (swSocketType) type)) {
-        swoole_warning("listen(%s:%d) fail[error=%d].", host.c_str(), port, errno);
+        swoole_sys_warning("listen(%s:%d) failed", host.c_str(), port);
         exit(0);
     }
 
     if (serv.create() < 0) {
-        swoole_warning("create server fail[error=%d].", errno);
+        swoole_sys_warning("create server failed");
         exit(0);
     }
 }

core-tests/src/core/base.cpp

@@ -342,3 +342,28 @@ TEST(base, fatal_error) {
     ASSERT_TRUE(rs->contains("(ERROR 9999)"));
     File::remove(TEST_LOG_FILE);
 }
+
+TEST(base, spinlock) {
+    test::counter_init();
+    auto counter = test::counter_ptr();
+    int n = 4096;
+
+    auto test_fn = [counter, n]() {
+        SW_LOOP_N(n) {
+            sw_spinlock((sw_atomic_t *) &counter[0]);
+            counter[1]++;
+            if (i % 100 == 0) {
+                usleep(5);
+            }
+            sw_spinlock_release((sw_atomic_t *) &counter[0]);
+        }
+    };
+
+    std::thread t1(test_fn);
+    std::thread t2(test_fn);
+
+    t1.join();
+    t2.join();
+
+    ASSERT_EQ(counter[1], n * 2);
+}

core-tests/src/core/hash.cpp

@@ -20,29 +20,44 @@
 #include "test_core.h"
 #include "swoole_hash.h"
 
+static const int hash_count = 8192;
+static const int str_max_len = 1024;
 static const char *data = "hello world, PHP  the best.";
 
 TEST(hash, crc32) {
     ASSERT_EQ(swoole_crc32(data, strlen(data)), 2962796788);
 }
 
 static void test_hash_func(uint64_t (*hash_fn)(const char *key, size_t len), int n) {
+    std::vector<uint64_t> hashes;
+    std::vector<std::string> data;
+    hashes.resize(n);
+    data.resize(n);
+
     SW_LOOP_N(n) {
-        size_t len = 1 + swoole_random_int() % 256;
-        char buf[256];
+        size_t len = 1 + swoole_random_int() % str_max_len;
+        char buf[str_max_len];
         ASSERT_EQ(swoole_random_bytes(buf, len), len);
-        ASSERT_GT(hash_fn(buf, len), 0);
+        hashes[i] = hash_fn(buf, len);
+        data[i] = std::string(buf, len);
+    }
+
+    usleep(100);
+
+    SW_LOOP_N(n) {
+        auto &s = data.at(i);
+        ASSERT_EQ(hashes[i], hash_fn(s.c_str(), s.length()));
     }
 }
 
 TEST(hash, php) {
-    test_hash_func(swoole_hash_jenkins, 100);
+    test_hash_func(swoole_hash_php, hash_count);
 }
 
 TEST(hash, jenkins) {
-    test_hash_func(swoole_hash_jenkins, 100);
+    test_hash_func(swoole_hash_jenkins, hash_count);
 }
 
 TEST(hash, austin) {
-    test_hash_func(swoole_hash_austin, 100);
+    test_hash_func(swoole_hash_austin, hash_count);
 }

core-tests/src/coroutine/async.cpp

@@ -59,3 +59,40 @@ TEST(coroutine_async, error) {
         ASSERT_EQ(errno, ENOENT);
     });
 }
+
+TEST(coroutine_async, cancel) {
+    coroutine::run([](void *arg) {
+        AsyncEvent ev = {};
+        auto co = swoole::Coroutine::get_current();
+        swoole_timer_after(50, [co](TIMER_PARAMS) { co->cancel(); });
+
+        bool retval = swoole::coroutine::async(
+            [](AsyncEvent *event) {
+                usleep(200000);
+                event->retval = magic_code;
+            },
+            ev);
+
+        ASSERT_EQ(retval, false);
+        ASSERT_EQ(ev.error, SW_ERROR_CO_CANCELED);
+        DEBUG() << "done\n";
+    });
+}
+
+TEST(coroutine_async, timeout) {
+    coroutine::run([](void *arg) {
+        AsyncEvent ev = {};
+
+        bool retval = swoole::coroutine::async(
+            [](AsyncEvent *event) {
+                usleep(200000);
+                event->retval = magic_code;
+            },
+            ev,
+            0.1);
+
+        ASSERT_EQ(retval, false);
+        ASSERT_EQ(ev.error, SW_ERROR_CO_TIMEDOUT);
+        DEBUG() << "done\n";
+    });
+}

core-tests/src/coroutine/socket.cpp

@@ -1371,7 +1371,7 @@ TEST(coroutine_socket, sendmsg_and_recvmsg) {
     });
 }
 
-std::pair<std::shared_ptr<Socket>, std::shared_ptr<Socket>> create_socket_pair() {
+std::pair<std::shared_ptr<Socket>, std::shared_ptr<Socket> > create_socket_pair() {
     int pairs[2];
     socketpair(AF_UNIX, SOCK_STREAM, 0, pairs);
 
@@ -1381,7 +1381,7 @@ std::pair<std::shared_ptr<Socket>, std::shared_ptr<Socket>> create_socket_pair()
     sock0->get_socket()->set_buffer_size(65536);
     sock1->get_socket()->set_buffer_size(65536);
 
-    std::pair<std::shared_ptr<Socket>, std::shared_ptr<Socket>> result(sock0, sock1);
+    std::pair<std::shared_ptr<Socket>, std::shared_ptr<Socket> > result(sock0, sock1);
     return result;
 }
 
@@ -1478,3 +1478,73 @@ TEST(coroutine_socket, option) {
     optval *= 2;
     ASSERT_TRUE(sock.set_option(SOL_SOCKET, SO_RCVBUF, optval));
 }
+
+static void test_ssl_verify() {
+    Socket sock(SW_SOCK_TCP);
+    sock.enable_ssl_encrypt();
+    sock.set_tls_host_name(TEST_HTTP_DOMAIN);
+    sock.set_ssl_verify_peer(true);
+    ASSERT_TRUE(sock.connect(TEST_HTTP_DOMAIN, 443));
+    ASSERT_TRUE(sock.ssl_verify(false));
+
+    auto req = swoole::test::http_get_request(TEST_HTTP_DOMAIN, "/");
+    ASSERT_EQ(sock.send(req.c_str(), req.length()), req.length());
+    ASSERT_TRUE(sock.check_liveness());
+
+    String buf(65536);
+    SW_LOOP {
+        auto n = sock.recv(buf.str + buf.length, buf.size - buf.length);
+        if (n <= 0) {
+            break;
+        }
+        buf.grow(n);
+    }
+
+    ASSERT_TRUE(buf.contains(TEST_HTTPS_EXPECT));
+
+    usleep(50000);
+    ASSERT_FALSE(sock.check_liveness());
+}
+
+TEST(coroutine_socket, ssl_verify) {
+    coroutine::run([](void *arg) { test_ssl_verify(); });
+}
+
+TEST(coroutine_socket, shutdown) {
+    coroutine::run([](void *arg) {
+        Socket sock(SW_SOCK_TCP);
+        ASSERT_TRUE(sock.connect(TEST_HTTP_DOMAIN, 80));
+        ASSERT_TRUE(sock.shutdown(SHUT_RD));
+        ASSERT_FALSE(sock.shutdown(SHUT_RD));
+        ASSERT_ERREQ(ENOTCONN);
+
+        ASSERT_TRUE(sock.shutdown(SHUT_WR));
+        ASSERT_FALSE(sock.shutdown(SHUT_WR));
+        ASSERT_ERREQ(ENOTCONN);
+
+        ASSERT_FALSE(sock.shutdown());
+        ASSERT_ERREQ(ENOTCONN);
+    });
+}
+
+TEST(coroutine_socket, recv_packet) {
+    coroutine::run([](void *arg) {
+        Socket sock(SW_SOCK_TCP);
+        ASSERT_TRUE(sock.connect(TEST_HTTP_DOMAIN, 80));
+        auto req = swoole::test::http_get_request(TEST_HTTP_DOMAIN, "/");
+        ASSERT_EQ(sock.send(req.c_str(), req.length()), req.length());
+        ASSERT_TRUE(sock.check_liveness());
+        auto n = sock.recv_packet();
+        ASSERT_GT(n, 0);
+        auto buf = sock.get_read_buffer();
+        ASSERT_TRUE(buf->contains(TEST_HTTP_EXPECT));
+    });
+}
+
+TEST(coroutine_socket, set_error) {
+    Socket sock(SW_SOCK_TCP);
+    sock.set_err(1000, std::string(TEST_STR));
+
+    ASSERT_EQ(sock.errCode, 1000);
+    ASSERT_STREQ(sock.errMsg, TEST_STR);
+}

core-tests/src/coroutine/system.cpp

@@ -138,13 +138,30 @@ TEST(coroutine_system, wait_event_readable) {
             ASSERT_GT(p.write(GREETING, strlen(GREETING)), 0);
         });
 
+        // bad fd
+        EXPECT_EQ(System::wait_event(9999, SW_EVENT_READ, 1), -1);
+        EXPECT_EQ(errno, EBADF);
+        EXPECT_ERREQ(EBADF);
+
+        // trigger event
         char buffer[128];
         auto pipe_sock = p.get_socket(false);
-        System::wait_event(pipe_sock->get_fd(), SW_EVENT_READ, 1);
+        // readable
+        EXPECT_EQ(System::wait_event(pipe_sock->get_fd(), SW_EVENT_READ, 1), SW_EVENT_READ);
+        // readable + writable
+        EXPECT_EQ(System::wait_event(pipe_sock->get_fd(), SW_EVENT_READ | SW_EVENT_WRITE, 1),
+                  SW_EVENT_READ | SW_EVENT_WRITE);
+
         ssize_t n = pipe_sock->read(buffer, sizeof(buffer));
         buffer[n] = 0;
         EXPECT_EQ(strlen(GREETING), n);
         EXPECT_STREQ(GREETING, buffer);
+
+        // timeout
+        auto pipe_sock_2 = p.get_socket(true);
+        EXPECT_EQ(System::wait_event(pipe_sock_2->get_fd(), SW_EVENT_READ, 0.1), -1);
+        EXPECT_EQ(errno, SW_ERROR_CO_TIMEDOUT);
+        EXPECT_ERREQ(SW_ERROR_CO_TIMEDOUT);
     });
 }
 

core-tests/src/lock/lock.cpp

@@ -29,11 +29,11 @@ using swoole::RWLock;
 #ifdef HAVE_SPINLOCK
 using swoole::SpinLock;
 #endif
-using swoole::Mutex;
-using swoole::CoroutineLock;
 using swoole::Coroutine;
-using swoole::test::coroutine;
+using swoole::CoroutineLock;
+using swoole::Mutex;
 using swoole::coroutine::System;
+using swoole::test::coroutine;
 
 static void test_func(swLock &lock) {
     int count = 0;
@@ -166,6 +166,33 @@ TEST(lock, coroutine_lock) {
     delete lock;
 }
 
+TEST(lock, coroutine_lock_rd) {
+    CoroutineLock *lock = new CoroutineLock(false);
+    ASSERT_EQ(lock->lock_rd(), SW_ERROR_CO_OUT_OF_COROUTINE);
+    auto callback = [lock]() {
+        coroutine::run([lock](void *arg) {
+            Coroutine::create([lock](void *) {
+                ASSERT_EQ(lock->lock_rd(), 0);
+                ASSERT_EQ(lock->lock_rd(), 0);
+                System::sleep(1);
+                ASSERT_EQ(lock->unlock(), 0);
+            });
+
+            Coroutine::create([lock](void *) {
+                ASSERT_EQ(lock->lock_rd(), 0);
+                System::sleep(1);
+                ASSERT_EQ(lock->unlock(), 0);
+            });
+
+            Coroutine::create([lock](void *) { ASSERT_EQ(lock->trylock_rd(), EBUSY); });
+        });
+    };
+
+    std::thread t1(callback);
+    t1.join();
+    delete lock;
+}
+
 #ifdef HAVE_RWLOCK
 TEST(lock, rwlock_shared) {
     RWLock lock(Mutex::PROCESS_SHARED);

core-tests/src/memory/lru_cache.cpp

@@ -4,8 +4,6 @@
 using namespace swoole;
 using namespace std;
 
-LRUCache cache(2);
-
 int dtor_num = 0;
 class lru_cache_test_class {
   public:
@@ -17,6 +15,7 @@ class lru_cache_test_class {
 };
 
 TEST(lru_cache, basic) {
+    LRUCache<string> cache(2);
     shared_ptr<string> val = make_shared<string>("hello");
     shared_ptr<string> val1 = make_shared<string>("hello1");
 
@@ -37,6 +36,7 @@ TEST(lru_cache, basic) {
 }
 
 TEST(lru_cache, memory_free) {
+    LRUCache<lru_cache_test_class> cache(2);
     shared_ptr<lru_cache_test_class> val = make_shared<lru_cache_test_class>();
     cache.set("test", val);
     ASSERT_EQ(cache.get("test").get(), val.get());
@@ -47,6 +47,7 @@ TEST(lru_cache, memory_free) {
 }
 
 TEST(lru_cache, lru_kick) {
+    LRUCache<lru_cache_test_class> cache(2);
     dtor_num = 0;
     shared_ptr<lru_cache_test_class> val = make_shared<lru_cache_test_class>();
     shared_ptr<lru_cache_test_class> val1 = make_shared<lru_cache_test_class>();
@@ -69,9 +70,9 @@ TEST(lru_cache, lru_kick) {
     ASSERT_EQ(dtor_num, 1);
     ASSERT_EQ(cache.get("test"), nullptr);
 
-    shared_ptr<string> val_str = make_shared<string>("hello");
-    cache.set("test1", val_str);  // update test1 and will del test2
-    ASSERT_EQ(cache.get("test1").get(), val_str.get());
+    shared_ptr<lru_cache_test_class> val4 = make_shared<lru_cache_test_class>();
+    cache.set("test1", val4);  // update test1 and will del test2
+    ASSERT_EQ(cache.get("test1").get(), val4.get());
     ASSERT_EQ(dtor_num, 2);
 
     cache.set("test3", val3);