Move test cases to test dir

src/session/test/CMakeLists.txt

@@ -0,0 +1,35 @@
+###############################################################################
+# gtest
+###############################################################################
+
+add_executable(gtest_session gtest_session.cpp)
+target_include_directories(gtest_session PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_link_libraries(gtest_session session_manager gtest)
+
+add_executable(gtest_session_pool gtest_session_pool.cpp)
+target_include_directories(gtest_session_pool PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_link_libraries(gtest_session_pool session_manager gtest)
+
+add_executable(gtest_session_table gtest_session_table.cpp)
+target_include_directories(gtest_session_table PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_link_libraries(gtest_session_table session_manager gtest)
+
+add_executable(gtest_session_timer gtest_session_timer.cpp)
+target_include_directories(gtest_session_timer PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_link_libraries(gtest_session_timer session_manager gtest)
+
+add_executable(gtest_session_queue gtest_session_queue.cpp)
+target_include_directories(gtest_session_queue PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_link_libraries(gtest_session_queue session_manager gtest)
+
+add_executable(gtest_session_manager gtest_session_manager.cpp)
+target_include_directories(gtest_session_manager PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_link_libraries(gtest_session_manager session_manager gtest)
+
+include(GoogleTest)
+gtest_discover_tests(gtest_session)
+gtest_discover_tests(gtest_session_pool)
+gtest_discover_tests(gtest_session_table)
+gtest_discover_tests(gtest_session_timer)
+gtest_discover_tests(gtest_session_queue)
+gtest_discover_tests(gtest_session_manager)

src/session/test/gtest_session.cpp

@@ -0,0 +1,118 @@
+#include <gtest/gtest.h>
+
+#include "session_private.h"
+
+#define SESSION_KEY_IPV4_TCP(name)                        \
+    struct tuple6 name;                                   \
+    memset(&name, 0, sizeof(struct tuple6));              \
+    (name).ip_type = IP_TYPE_V4;                          \
+    (name).src_addr.v4.s_addr = inet_addr("192.168.1.2"); \
+    (name).dst_addr.v4.s_addr = inet_addr("192.168.1.3"); \
+    (name).src_port = htons(1234);                        \
+    (name).dst_port = htons(5678);                        \
+    (name).ip_proto = IPPROTO_TCP;                        \
+    (name).security_zone = 0;
+
+#define SESSION_KEY_IPV6_UDP(name)                                           \
+    struct tuple6 name;                                                      \
+    memset(&name, 0, sizeof(struct tuple6));                                 \
+    (name).ip_type = IP_TYPE_V6;                                             \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:8329", &(name).src_addr.v6); \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:832a", &(name).dst_addr.v6); \
+    (name).src_port = htons(1234);                                           \
+    (name).dst_port = htons(5678);                                           \
+    (name).ip_proto = IPPROTO_UDP;                                           \
+    (name).security_zone = 0;
+
+#define SESSION_KEY_IPV6_TCP(name)                                           \
+    struct tuple6 name;                                                      \
+    memset(&name, 0, sizeof(struct tuple6));                                 \
+    (name).ip_type = IP_TYPE_V6;                                             \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:8329", &(name).src_addr.v6); \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:832a", &(name).dst_addr.v6); \
+    (name).src_port = htons(1234);                                           \
+    (name).dst_port = htons(5678);                                           \
+    (name).ip_proto = IPPROTO_TCP;                                           \
+    (name).security_zone = 0;
+
+void free_ex_data(struct session *sess, uint8_t idx, void *ex_ptr, void *arg)
+{
+    if (ex_ptr)
+    {
+        printf("free_ex_data: %s\n", (char *)ex_ptr);
+        free(ex_ptr);
+        ex_ptr = NULL;
+    }
+}
+
+TEST(SESSION, EX_NEW_INDEX)
+{
+    uint8_t idx1 = session_get_ex_new_index("key1", NULL, NULL);
+    uint8_t idx2 = session_get_ex_new_index("key2", NULL, NULL);
+    uint8_t idx3 = session_get_ex_new_index("key1", NULL, NULL);
+    EXPECT_TRUE(idx1 != idx2);
+    EXPECT_TRUE(idx1 == idx3);
+}
+
+TEST(SESSION, EX_SET_GET)
+{
+    struct session sess;
+    memset(&sess, 0, sizeof(sess));
+    uint8_t idx = session_get_ex_new_index("ex_set_get", NULL, NULL);
+    session_set_ex_data(&sess, idx, (void *)0x1234);
+    EXPECT_TRUE(session_get0_ex_data(&sess, idx) == (void *)0x1234);
+}
+
+TEST(SESSION, EX_FREE_BY_RESET_NULL)
+{
+    struct session sess;
+    memset(&sess, 0, sizeof(sess));
+    uint8_t idx = session_get_ex_new_index("ex_free_by_reset_null", free_ex_data, NULL);
+    char *ptr = strdup("hello");
+    session_set_ex_data(&sess, idx, ptr);
+    session_set_ex_data(&sess, idx, NULL);
+}
+
+TEST(SESSION, EX_FREE_BY_CALL_API)
+{
+    struct session sess;
+    memset(&sess, 0, sizeof(sess));
+    uint8_t idx = session_get_ex_new_index("ex_free_by_call_api", free_ex_data, NULL);
+    char *ptr = strdup("hello");
+    session_set_ex_data(&sess, idx, ptr);
+    session_free_ex_data(&sess, idx);
+}
+
+TEST(SESSION, EV_QUEUE)
+{
+    uint32_t event = 0;
+    struct session sess;
+    session_init(&sess);
+    EXPECT_TRUE(session_pop_event(&sess, &event) == false);
+    EXPECT_TRUE(session_push_event(&sess, 0x1234) == true);
+    EXPECT_TRUE(session_pop_event(&sess, &event) == true);
+    EXPECT_TRUE(event == 0x1234);
+    EXPECT_TRUE(session_pop_event(&sess, &event) == false);
+
+    for (int j = 0; j < 10; j++)
+    {
+        for (uint32_t i = 0; i < SESSION_EVENT_QUEUE_SIZE - 1; i++)
+        {
+            EXPECT_TRUE(session_push_event(&sess, i) == true);
+        }
+        EXPECT_TRUE(session_push_event(&sess, 0) == false);
+
+        for (uint32_t i = 0; i < SESSION_EVENT_QUEUE_SIZE - 1; i++)
+        {
+            EXPECT_TRUE(session_pop_event(&sess, &event) == true);
+            EXPECT_TRUE(event == i);
+        }
+        EXPECT_TRUE(session_pop_event(&sess, &event) == false);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/session/test/gtest_session_pool.cpp

@@ -0,0 +1,62 @@
+#include <gtest/gtest.h>
+
+#include "session_pool.h"
+
+TEST(SESSION_POOL, POP_PUSH)
+{
+    struct session *sess1 = NULL;
+    struct session *sess2 = NULL;
+    struct session *sess3 = NULL;
+    struct session *sess4 = NULL;
+    struct session_pool *sess_pool = NULL;
+
+    sess_pool = session_pool_create(3);
+    EXPECT_TRUE(sess_pool != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 3);
+
+    sess1 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess1 != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 2);
+    sess2 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess2 != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 1);
+    sess3 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess3 != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 0);
+    sess4 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess4 == NULL);
+
+    session_pool_free(sess_pool, sess1);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 1);
+    session_pool_free(sess_pool, sess2);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 2);
+    session_pool_free(sess_pool, sess3);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 3);
+
+    sess1 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess1 != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 2);
+    sess2 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess2 != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 1);
+    sess3 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess3 != NULL);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 0);
+    sess4 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess4 == NULL);
+
+    session_pool_free(sess_pool, sess1);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 1);
+    session_pool_free(sess_pool, sess2);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 2);
+    session_pool_free(sess_pool, sess3);
+    EXPECT_TRUE(session_pool_get_count(sess_pool) == 3);
+
+    session_pool_destroy(sess_pool);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/session/test/gtest_session_queue.cpp

@@ -0,0 +1,29 @@
+#include <gtest/gtest.h>
+
+#include "session_private.h"
+#include "session_queue.h"
+
+TEST(SESSION_QUEUE, POP_PUSH)
+{
+    struct session sess1;
+    struct session sess2;
+    struct session_queue *queue = NULL;
+
+    queue = session_queue_create();
+    EXPECT_TRUE(queue != NULL);
+
+    EXPECT_TRUE(session_queue_pop(queue) == NULL);
+    session_queue_push(queue, &sess1);
+    session_queue_push(queue, &sess2);
+    EXPECT_TRUE(session_queue_pop(queue) == &sess1);
+    EXPECT_TRUE(session_queue_pop(queue) == &sess2);
+    EXPECT_TRUE(session_queue_pop(queue) == NULL);
+
+    session_queue_destroy(queue);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/session/test/gtest_session_table.cpp

@@ -0,0 +1,200 @@
+#include <gtest/gtest.h>
+
+#include "session_pool.h"
+#include "session_table.h"
+
+#define SESSION_KEY_IPV4_TCP(name)                        \
+    struct tuple6 name;                                   \
+    memset(&name, 0, sizeof(struct tuple6));              \
+    (name).ip_type = IP_TYPE_V4;                          \
+    (name).src_addr.v4.s_addr = inet_addr("192.168.1.2"); \
+    (name).dst_addr.v4.s_addr = inet_addr("192.168.1.3"); \
+    (name).src_port = htons(1234);                        \
+    (name).dst_port = htons(5678);                        \
+    (name).ip_proto = IPPROTO_TCP;                        \
+    (name).security_zone = 0;
+
+#define SESSION_KEY_IPV6_UDP(name)                                           \
+    struct tuple6 name;                                                      \
+    memset(&name, 0, sizeof(struct tuple6));                                 \
+    (name).ip_type = IP_TYPE_V6;                                             \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:8329", &(name).src_addr.v6); \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:832a", &(name).dst_addr.v6); \
+    (name).src_port = htons(1234);                                           \
+    (name).dst_port = htons(5678);                                           \
+    (name).ip_proto = IPPROTO_UDP;                                           \
+    (name).security_zone = 0;
+
+#define SESSION_KEY_IPV6_TCP(name)                                           \
+    struct tuple6 name;                                                      \
+    memset(&name, 0, sizeof(struct tuple6));                                 \
+    (name).ip_type = IP_TYPE_V6;                                             \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:8329", &(name).src_addr.v6); \
+    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:832a", &(name).dst_addr.v6); \
+    (name).src_port = htons(1234);                                           \
+    (name).dst_port = htons(5678);                                           \
+    (name).ip_proto = IPPROTO_TCP;                                           \
+    (name).security_zone = 0;
+
+static void session_free_callback(struct session *sess, void *arg)
+{
+    if (sess)
+    {
+        struct session_pool *sess_pool = (struct session_pool *)arg;
+        session_pool_free(sess_pool, sess);
+        sess = NULL;
+    }
+}
+
+TEST(SESSION_TABLE, OP_SESSION)
+{
+    struct session *sess1 = NULL;
+    struct session *sess2 = NULL;
+    struct session *sess3 = NULL;
+    struct session_pool *sess_pool = NULL;
+    struct session_table *sess_table = NULL;
+
+    SESSION_KEY_IPV4_TCP(tuple_1);
+    SESSION_KEY_IPV6_UDP(tuple_2);
+    SESSION_KEY_IPV6_TCP(tuple_3);
+
+    struct tuple6 reversed_tuple_1;
+    struct tuple6 reversed_tuple_2;
+    struct tuple6 reversed_tuple_3;
+
+    tuple6_reverse(&tuple_1, &reversed_tuple_1);
+    tuple6_reverse(&tuple_2, &reversed_tuple_2);
+    tuple6_reverse(&tuple_3, &reversed_tuple_3);
+
+    // Create
+    sess_pool = session_pool_create(3);
+    EXPECT_TRUE(sess_pool != NULL);
+    sess_table = session_table_create();
+    EXPECT_TRUE(sess_table != NULL);
+    session_table_set_freecb(sess_table, session_free_callback, sess_pool);
+
+    // Add
+    sess1 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess1 != NULL);
+    session_set_id(sess1, 1);
+    session_set_tuple6(sess1, &tuple_1);
+
+    sess2 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess2 != NULL);
+    session_set_id(sess2, 2);
+    session_set_tuple6(sess2, &tuple_2);
+
+    sess3 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess3 != NULL);
+    session_set_id(sess3, 3);
+    session_set_tuple6(sess3, &tuple_3);
+
+    EXPECT_TRUE(session_table_add_session(sess_table, &tuple_1, sess1) == 0);
+    EXPECT_TRUE(session_table_get_count(sess_table) == 1);
+    EXPECT_TRUE(session_table_add_session(sess_table, &tuple_2, sess2) == 0);
+    EXPECT_TRUE(session_table_get_count(sess_table) == 2);
+    EXPECT_TRUE(session_table_add_session(sess_table, &tuple_3, sess3) == 0);
+    EXPECT_TRUE(session_table_get_count(sess_table) == 3);
+
+    // Search
+    EXPECT_TRUE(session_table_find_session(sess_table, &tuple_1) == sess1);
+    EXPECT_TRUE(session_table_find_session(sess_table, &tuple_2) == sess2);
+    EXPECT_TRUE(session_table_find_session(sess_table, &tuple_3) == sess3);
+
+    EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_1) == sess1);
+    EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_2) == sess2);
+    EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_3) == sess3);
+
+    // Delete
+    session_table_delete_session(sess_table, &tuple_1);
+    EXPECT_TRUE(session_table_get_count(sess_table) == 2);
+    EXPECT_TRUE(session_table_find_session(sess_table, &tuple_1) == NULL);
+    EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_1) == NULL);
+
+    session_table_delete_session(sess_table, &reversed_tuple_2);
+    EXPECT_TRUE(session_table_get_count(sess_table) == 1);
+    EXPECT_TRUE(session_table_find_session(sess_table, &tuple_2) == NULL);
+    EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_2) == NULL);
+
+    session_table_delete_session(sess_table, &tuple_3);
+    EXPECT_TRUE(session_table_get_count(sess_table) == 0);
+    EXPECT_TRUE(session_table_find_session(sess_table, &tuple_3) == NULL);
+    EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_3) == NULL);
+
+    // Destroy
+    session_table_destroy(sess_table);
+    session_pool_destroy(sess_pool);
+}
+
+TEST(SESSION_TABLE, FIND_OLDEST_NEWEST)
+{
+    struct session *sess1 = NULL;
+    struct session *sess2 = NULL;
+    struct session *sess3 = NULL;
+    struct session_pool *sess_pool = NULL;
+    struct session_table *sess_table = NULL;
+
+    SESSION_KEY_IPV4_TCP(tuple_1);
+    SESSION_KEY_IPV6_UDP(tuple_2);
+    SESSION_KEY_IPV6_TCP(tuple_3);
+
+    // Create
+    sess_pool = session_pool_create(3);
+    EXPECT_TRUE(sess_pool != NULL);
+    sess_table = session_table_create();
+    EXPECT_TRUE(sess_table != NULL);
+    session_table_set_freecb(sess_table, session_free_callback, sess_pool);
+
+    // Add Session
+
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == NULL);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == NULL);
+
+    sess1 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess1 != NULL);
+    session_set_id(sess1, 1);
+    session_set_tuple6(sess1, &tuple_1);
+    EXPECT_TRUE(session_table_add_session(sess_table, &tuple_1, sess1) == 0);
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess1);
+
+    sess2 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess2 != NULL);
+    session_set_id(sess2, 2);
+    session_set_tuple6(sess2, &tuple_2);
+    EXPECT_TRUE(session_table_add_session(sess_table, &tuple_2, sess2) == 0);
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess2);
+
+    sess3 = session_pool_alloc(sess_pool);
+    EXPECT_TRUE(sess3 != NULL);
+    session_set_id(sess3, 3);
+    session_set_tuple6(sess3, &tuple_3);
+    EXPECT_TRUE(session_table_add_session(sess_table, &tuple_3, sess3) == 0);
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);
+
+    // Delete Session
+
+    session_table_delete_session(sess_table, &tuple_1);
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess2);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);
+
+    session_table_delete_session(sess_table, &tuple_2);
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess3);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);
+
+    session_table_delete_session(sess_table, &tuple_3);
+    EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == NULL);
+    EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == NULL);
+
+    // Destroy
+    session_table_destroy(sess_table);
+    session_pool_destroy(sess_pool);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/session/test/gtest_session_timer.cpp

@@ -0,0 +1,160 @@
+#include <gtest/gtest.h>
+
+#include "session_timer.h"
+#include "session_private.h"
+
+static void session_expire(struct session *sess, void *arg)
+{
+    printf("=== session %lu expired ===\n", session_get_id(sess));
+}
+
+TEST(SESSION_TIMER, ADD_DEL)
+{
+    struct session sess;
+    struct session_timer *timer = session_timer_create();
+    EXPECT_TRUE(timer != NULL);
+
+    session_init(&sess);
+    session_set_id(&sess, 1);
+    session_set_expirecb(&sess, session_expire, NULL, 1000);
+
+    session_timer_add_session(timer, &sess);
+    session_timer_del_session(timer, &sess);
+
+    session_timer_destroy(timer);
+}
+
+TEST(SESSION_TIMER, EXPIRE)
+{
+    struct session *sess = NULL;
+    struct session sess1;
+    struct session sess2;
+    struct session sess3;
+    struct session_timer *timer = session_timer_create();
+    EXPECT_TRUE(timer != NULL);
+
+    session_init(&sess1);
+    session_init(&sess2);
+    session_init(&sess3);
+    session_set_id(&sess1, 1);
+    session_set_id(&sess2, 2);
+    session_set_id(&sess3, 3);
+    session_set_expirecb(&sess1, session_expire, NULL, 5);
+    session_set_expirecb(&sess2, session_expire, NULL, 5);
+    session_set_expirecb(&sess3, session_expire, NULL, 10);
+
+    session_timer_add_session(timer, &sess1);
+    session_timer_add_session(timer, &sess2);
+    session_timer_add_session(timer, &sess3);
+
+    for (uint64_t abs_current_ts = 0; abs_current_ts < 15; abs_current_ts++)
+    {
+        printf("current timestamp %lu\n", abs_current_ts);
+        do
+        {
+            sess = session_timer_expire_session(timer, abs_current_ts);
+            if (sess != NULL)
+            {
+                session_run_expirecb(sess);
+            }
+        } while (sess);
+    }
+
+    session_timer_destroy(timer);
+}
+
+TEST(SESSION_TIMER, BEFORE_EXPIRE_DEL)
+{
+    struct session *sess = NULL;
+    struct session sess1;
+    struct session sess2;
+    struct session sess3;
+    struct session_timer *timer = session_timer_create();
+    EXPECT_TRUE(timer != NULL);
+
+    session_init(&sess1);
+    session_init(&sess2);
+    session_init(&sess3);
+    session_set_id(&sess1, 1);
+    session_set_id(&sess2, 2);
+    session_set_id(&sess3, 3);
+    session_set_expirecb(&sess1, session_expire, NULL, 5);
+    session_set_expirecb(&sess2, session_expire, NULL, 5);
+    session_set_expirecb(&sess3, session_expire, NULL, 10);
+
+    session_timer_add_session(timer, &sess1);
+    session_timer_add_session(timer, &sess2);
+    session_timer_add_session(timer, &sess3);
+
+    for (uint64_t abs_current_ts = 0; abs_current_ts < 15; abs_current_ts++)
+    {
+        printf("current timestamp %lu\n", abs_current_ts);
+        if (abs_current_ts == 2)
+        {
+            printf("delete timer 2\n");
+            session_timer_del_session(timer, &sess2);
+        }
+        do
+        {
+            sess = session_timer_expire_session(timer, abs_current_ts);
+            if (sess != NULL)
+            {
+                session_run_expirecb(sess);
+            }
+        } while (sess);
+    }
+
+    session_timer_destroy(timer);
+}
+
+TEST(SESSION_TIMER, BEFORE_EXPIRE_UPDATE)
+{
+    struct session *sess = NULL;
+    struct session sess1;
+    struct session sess2;
+    struct session sess3;
+    struct session_timer *timer = session_timer_create();
+    EXPECT_TRUE(timer != NULL);
+
+    session_init(&sess1);
+    session_init(&sess2);
+    session_init(&sess3);
+    session_set_id(&sess1, 1);
+    session_set_id(&sess2, 2);
+    session_set_id(&sess3, 3);
+    session_set_expirecb(&sess1, session_expire, NULL, 5);
+    session_set_expirecb(&sess2, session_expire, NULL, 5);
+    session_set_expirecb(&sess3, session_expire, NULL, 10);
+
+    session_timer_add_session(timer, &sess1);
+    session_timer_add_session(timer, &sess2);
+    session_timer_add_session(timer, &sess3);
+
+    for (uint64_t abs_current_ts = 0; abs_current_ts < 15; abs_current_ts++)
+    {
+        printf("current timestamp %lu\n", abs_current_ts);
+        if (abs_current_ts == 2)
+        {
+            printf("update timer 2\n");
+            session_timer_del_session(timer, &sess2);
+            session_set_expirecb(&sess2, session_expire, NULL, 8);
+            session_timer_add_session(timer, &sess2);
+        }
+        do
+        {
+            sess = session_timer_expire_session(timer, abs_current_ts);
+            if (sess != NULL)
+            {
+                session_run_expirecb(sess);
+            }
+        } while (sess);
+    }
+
+    session_timer_destroy(timer);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}