add cmocka for trace service

6 files changed, 204 insertions, 35 deletions

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 4a6f967..d8b1225 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -29,7 +29,7 @@ stages:
         - make VERBOSE=1
         - if [[ "${TEST_OPTIONS}" == *"ENABLE_CTEST"* ]]; then
                 cd ${BUILD_ROOT_DIR};
-                ctest --output-on-failure;
+                ctest --output-on-failure -V;
           fi
         - if [[ "${TEST_OPTIONS}" == *"ENABLE_PACKAGE_TEST"* ]]; then
                 cd ${BUILD_ROOT_DIR};
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e4c2fd8..aa49fd5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -111,9 +111,8 @@ endif()
 message(STATUS "CMAKE_C_FLAGS: ${CMAKE_C_FLAGS}")
 message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
 
-if(ENABLE_PTF_TEST OR ENABLE_FUZZING_TEST)
-	enable_testing()
-endif()
+# The CTest module invokes enable_testing automatically unless BUILD_TESTING is set to OFF.
+include(CTest)
 
 if(ENABLE_VNODE_CHECK_THREAD_SAFE)
 	add_definitions(-DVNODE_CHECK_THREAD_SAFE)
diff --git a/infra/src/dp_trace.c b/infra/src/dp_trace.c
index d09214f..7fe8227 100644
--- a/infra/src/dp_trace.c
+++ b/infra/src/dp_trace.c
@@ -4,6 +4,7 @@
 #include <libgen.h>
 #include <linux/if_ether.h>
 #include <rte_common.h>
+#include <rte_errno.h>
 #include <rte_ether.h>
 #include <rte_ip.h>
 #include <rte_tcp.h>
@@ -30,7 +31,7 @@ static struct dp_trace_instance * dp_trace_instance_create()
 
     instance->pool = rte_mempool_create(DP_TRACE_POOL_NAME, DP_TRACE_POOL_SIZE, DP_TRACE_RECORD_SIZE, 0, 0, NULL, NULL,
                                         NULL, NULL, rte_socket_id(), 0);
-    MR_VERIFY_MALLOC(instance->pool);
+    MR_VERIFY_2(instance->pool != NULL, "trace mempool create failed: %s", rte_strerror(rte_errno));
 
     for (unsigned int i = 0; i < DP_TRACE_JOB_NUM_MAX; i++)
     {
@@ -380,8 +381,8 @@ void dp_trace_filter_exec(struct dp_trace_process * trace, struct rte_mbuf * mbu
         if (pkt_parser_result->layers[i].type_id == LAYER_TYPE_ID_ETHER &&
             pkt_parser_result->layers[i].offset >= offset)
         {
-            match_jobs |=
-                dp_trace_filter_exec_jobs_get(trace, mbuf, pkt_parser_result->layers[i].offset, &snaplen, lcore_id);
+            match_jobs |= dp_trace_filter_exec_jobs_get(trace, mbuf, pkt_parser_result->layers[i].offset, &snaplen,
+                                                        lcore_id);
         }
     }
 
@@ -516,8 +517,8 @@ int dp_trace_record_encode(struct rte_mbuf * mbuf, const struct dp_trace_record_
     }
 
     // record header
-    struct dp_trace_record_header * record_header =
-        (struct dp_trace_record_header *)(dp_trace_buffer->buffer + dp_trace_buffer->buffer_used);
+    struct dp_trace_record_header * record_header = (struct dp_trace_record_header *)(dp_trace_buffer->buffer +
+                                                                                      dp_trace_buffer->buffer_used);
 
     record_header->measurement_type = meta->measurement_type;
     snprintf(record_header->appsym, sizeof(record_header->appsym), "%s", meta->appsym);
@@ -612,8 +613,8 @@ static inline void dp_trace_buffer_initialize(struct dp_trace_process * trace, s
             if (this_layer_type_mask == LAYER_TYPE_IPV4)
             {
                 struct rte_ipv4_hdr ipv4_hdr_copy;
-                const struct rte_ipv4_hdr * ipv4_hdr =
-                    rte_pktmbuf_read(mbuf, this_layer_offset, sizeof(struct rte_ipv4_hdr), &ipv4_hdr_copy);
+                const struct rte_ipv4_hdr * ipv4_hdr = rte_pktmbuf_read(mbuf, this_layer_offset,
+                                                                        sizeof(struct rte_ipv4_hdr), &ipv4_hdr_copy);
                 inet_ntop(AF_INET, &ipv4_hdr->src_addr, dp_trace_buffer->inner_src_addr_str,
                           sizeof(dp_trace_buffer->inner_src_addr_str));
                 inet_ntop(AF_INET, &ipv4_hdr->dst_addr, dp_trace_buffer->inner_dst_addr_str,
@@ -622,8 +623,8 @@ static inline void dp_trace_buffer_initialize(struct dp_trace_process * trace, s
             else if (this_layer_type_mask == LAYER_TYPE_IPV6)
             {
                 struct rte_ipv6_hdr ipv6_hdr_copy;
-                const struct rte_ipv6_hdr * ipv6_hdr =
-                    rte_pktmbuf_read(mbuf, this_layer_offset, sizeof(struct rte_ipv6_hdr), &ipv6_hdr_copy);
+                const struct rte_ipv6_hdr * ipv6_hdr = rte_pktmbuf_read(mbuf, this_layer_offset,
+                                                                        sizeof(struct rte_ipv6_hdr), &ipv6_hdr_copy);
                 inet_ntop(AF_INET6, &ipv6_hdr->src_addr, dp_trace_buffer->inner_src_addr_str,
                           sizeof(dp_trace_buffer->inner_src_addr_str));
                 inet_ntop(AF_INET6, &ipv6_hdr->dst_addr, dp_trace_buffer->inner_dst_addr_str,
@@ -644,16 +645,16 @@ static inline void dp_trace_buffer_initialize(struct dp_trace_process * trace, s
             if (this_layer_type_mask == LAYER_TYPE_TCP)
             {
                 struct rte_tcp_hdr tcp_hdr_copy;
-                const struct rte_tcp_hdr * tcp_hdr =
-                    rte_pktmbuf_read(mbuf, this_layer_offset, sizeof(struct rte_tcp_hdr), &tcp_hdr_copy);
+                const struct rte_tcp_hdr * tcp_hdr = rte_pktmbuf_read(mbuf, this_layer_offset,
+                                                                      sizeof(struct rte_tcp_hdr), &tcp_hdr_copy);
                 dp_trace_buffer->inner_src_port = ntohs(tcp_hdr->src_port);
                 dp_trace_buffer->inner_dst_port = ntohs(tcp_hdr->dst_port);
             }
             else if (this_layer_type_mask == LAYER_TYPE_UDP)
             {
                 struct rte_udp_hdr udp_hdr_copy;
-                const struct rte_udp_hdr * udp_hdr =
-                    rte_pktmbuf_read(mbuf, this_layer_offset, sizeof(struct rte_udp_hdr), &udp_hdr_copy);
+                const struct rte_udp_hdr * udp_hdr = rte_pktmbuf_read(mbuf, this_layer_offset,
+                                                                      sizeof(struct rte_udp_hdr), &udp_hdr_copy);
                 dp_trace_buffer->inner_src_port = ntohs(udp_hdr->src_port);
                 dp_trace_buffer->inner_dst_port = ntohs(udp_hdr->dst_port);
             }
diff --git a/service/CMakeLists.txt b/service/CMakeLists.txt
index e7abd05..937e426 100644
--- a/service/CMakeLists.txt
+++ b/service/CMakeLists.txt
@@ -37,4 +37,11 @@ target_link_libraries(test_node_vwire -Wl,--wrap=pkt_drop_trap_process)
 target_link_libraries(test_node_vwire -Wl,--wrap=rte_eal_init)
 target_link_libraries(test_node_vwire -Wl,--wrap=rte_exit)
 
-add_test(NAME test_node_vwire COMMAND test_node_vwire)
\ No newline at end of file
+add_test(NAME test_node_vwire COMMAND test_node_vwire)
+
+add_executable(test_trace_service test/test_trace_service.c ${MRZCPD_SERVICE_SOURCE_FILES})
+target_include_directories(test_node_vwire PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
+target_link_libraries(test_trace_service MESA_prof_load_static libcmocka rt pthread dl infra z elf ${SYSTEMD_LIBRARIES} libdpdk)
+target_link_options(test_trace_service PRIVATE -Wl,--wrap=rte_mp_reply,--wrap=app_event_handler_register,--wrap=app_lookup_by_symbol)
+target_link_options(test_trace_service PRIVATE -Wl,--wrap=sc_main_get)
+add_test(NAME test_trace_service COMMAND test_trace_service)
diff --git a/service/test/test_node_vwire.c b/service/test/test_node_vwire.c
index 260badc..4dd7f03 100644
--- a/service/test/test_node_vwire.c
+++ b/service/test/test_node_vwire.c
@@ -1,13 +1,16 @@
+#include <setjmp.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
-#include <setjmp.h>
 #include <string.h>
+#include <unistd.h>
+
 #include <cmocka.h>
+
 #include <rte_eal.h>
-#include <rte_mempool.h>
 #include <rte_graph.h>
 #include <rte_graph_worker.h>
+#include <rte_mempool.h>
 
 #include <sc_node.h>
 #include <sc_node_common.h>
@@ -26,7 +29,7 @@ int __wrap_rte_eal_init(int argc, char * argv[])
 }
 
 static int rte_exit_called = 0;
-int __wrap_rte_exit(int status, const char *format, ...)
+int __wrap_rte_exit(int status, const char * format, ...)
 {
     rte_exit_called = 1;
     return 0;
@@ -44,16 +47,15 @@ void __wrap_forwarder_table_insert(uint16_t sid, uint16_t type)
     check_expected(type);
 }
 
-extern int __real_rte_eal_init(int argc, char **argv);
-extern int __real_rte_exit(int status, const char *format, ...);
+extern int __real_rte_eal_init(int argc, char ** argv);
+extern int __real_rte_exit(int status, const char * format, ...);
 
 extern int vwire_init(struct sc_main * sc);
 
-
 /* testcase: 1
  * device: vwire_1 <-> vwire_2
  * port_id: 1 <-> 2
-*/
+ */
 
 static void testcase_vwire_ingress_forward_pkts(void ** state)
 {
@@ -253,7 +255,7 @@ static int testgroup_vwire_egress_teardown(void ** state)
     return rte_graph_destroy(graph);
 }
 
-static int testgroup_vwire_ingress_setup(void **state)
+static int testgroup_vwire_ingress_setup(void ** state)
 {
     /* mock pkt source to generate mock packets */
     const char * node_patterns[] = {
@@ -291,7 +293,7 @@ static int testgroup_vwire_ingress_setup(void **state)
     return 0;
 }
 
-static int testgroup_vwire_ingress_teardown(void **state)
+static int testgroup_vwire_ingress_teardown(void ** state)
 {
     /* destroy the graph */
     rte_graph_t graph = (uintptr_t)*state;
@@ -299,7 +301,7 @@ static int testgroup_vwire_ingress_teardown(void **state)
 }
 
 /* ----------------------------------------------------------------------------------------------------------------- */
-static void testcase_vwire_init_success(void **state)
+static void testcase_vwire_init_success(void ** state)
 {
     struct sc_main * mock_sc = *state;
 
@@ -332,7 +334,7 @@ static void testcase_vwire_init_success(void **state)
     rte_free(mock_dev_desc_2);
 }
 
-static void testcase_vwire_device_not_exist(void **state)
+static void testcase_vwire_device_not_exist(void ** state)
 {
     struct sc_main * mock_sc = *state;
 
@@ -345,7 +347,7 @@ static void testcase_vwire_device_not_exist(void **state)
     assert_int_equal(ret, RT_ERR);
 }
 
-static int testgroup_vwire_init_setup(void **state)
+static int testgroup_vwire_init_setup(void ** state)
 {
     struct sc_main * mock_sc = rte_zmalloc(NULL, sizeof(struct sc_main), 0);
     assert_non_null(mock_sc);
@@ -367,14 +369,15 @@ static int testgroup_vwire_init_setup(void **state)
     return 0;
 }
 
-static int testgroup_vwire_init_teardown(void **state)
+static int testgroup_vwire_init_teardown(void ** state)
 {
     struct sc_main * mock_sc = *state;
     rte_free(mock_sc);
+    unlink(mock_sc->local_cfgfile);
     return 0;
 }
 
-int main(int argc, char *argv[])
+int main(int argc, char * argv[])
 {
     /* generate the eal args */
     static char * eal_args[] = {
@@ -407,8 +410,10 @@ int main(int argc, char *argv[])
         cmocka_unit_test(testcase_vwire_egress_forward_pkts),
     };
 
-    cmocka_run_group_tests(group_vwire_init, testgroup_vwire_init_setup, testgroup_vwire_init_teardown);
-    cmocka_run_group_tests(group_vwire_ingress, testgroup_vwire_ingress_setup, testgroup_vwire_ingress_teardown);
-    cmocka_run_group_tests(group_vwire_egress, testgroup_vwire_egress_setup, testgroup_vwire_egress_teardown);
+    ret = cmocka_run_group_tests(group_vwire_init, testgroup_vwire_init_setup, testgroup_vwire_init_teardown);
+    ret += cmocka_run_group_tests(group_vwire_ingress, testgroup_vwire_ingress_setup, testgroup_vwire_ingress_teardown);
+    ret += cmocka_run_group_tests(group_vwire_egress, testgroup_vwire_egress_setup, testgroup_vwire_egress_teardown);
     rte_eal_cleanup();
+
+    return ret;
 }
\ No newline at end of file
diff --git a/service/test/test_trace_service.c b/service/test/test_trace_service.c
new file mode 100644
index 0000000..a6c3e4c
--- /dev/null
+++ b/service/test/test_trace_service.c
@@ -0,0 +1,157 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cmocka.h>
+
+#include <rte_common.h>
+#include <rte_eal.h>
+#include <rte_errno.h>
+#include <rte_malloc.h>
+
+#include <sc_common.h>
+#include <sc_trace.h>
+
+static struct sc_main * mock_sc;
+
+extern int __dp_trace_path_handler(const struct rte_mp_msg * msg, const void * peer);
+
+struct sc_main * __wrap_sc_main_get()
+{
+    return mock_sc;
+}
+
+struct app * __wrap_app_lookup_by_symbol(struct sc_main * sc, const char * appsym)
+{
+    return rte_malloc("cmocka_trace", sizeof(struct app), 0);
+}
+
+void __wrap_app_event_handler_register(struct app_main * app_main, enum app_event_type event_type,
+                                       app_event_handler_t fn_handler, void * arg)
+{
+    return;
+}
+
+int __wrap_rte_mp_reply(struct rte_mp_msg * msg, const char * peer)
+{
+    struct dp_trace_resp * dp_trace_resp = (struct dp_trace_resp *)msg->param;
+    assert_true(dp_trace_resp->errcode == DP_TRACE_SUCCESS);
+
+    enum dp_trace_req_action action = mock_type(enum dp_trace_req_action);
+
+    if (action == DP_TRACE_JOB_ID_USED_GET)
+    {
+        job_bitmap_t id_uesd = mock_type(job_bitmap_t);
+        assert_true(dp_trace_resp->jobs_id_used_get == id_uesd);
+    }
+
+    return 0;
+}
+
+static int group_trace_init_setup(void ** state)
+{
+    size_t size = 10L * 1024 * 1024 * 1024; // 10GB
+    void * ptr = malloc(size);
+    assert_non_null(ptr);
+    free(ptr);
+
+    mock_sc = rte_zmalloc("cmocka_trace", sizeof(struct sc_main), 0);
+    assert_non_null(mock_sc);
+
+    mr_dp_trace_init(mock_sc);
+    assert_non_null(mock_sc->trace);
+
+    *state = mock_sc;
+    return 0;
+}
+
+static int group_trace_init_teardown(void ** state)
+{
+    struct sc_main * mock_sc = *state;
+    rte_free(mock_sc);
+    return 0;
+}
+
+static void testcase_trace_handle_job_add(void ** state)
+{
+    struct rte_mp_msg msg;
+    snprintf(msg.name, sizeof(msg.name), "%s", DP_TRACE_MP_MSG_NAME);
+    struct dp_trace_req * request = (struct dp_trace_req *)msg.param;
+    msg.len_param = sizeof(struct dp_trace_req);
+
+    struct dp_trace_job_desc desc;
+    desc.enable = true;
+    snprintf(desc.bpf_expr, sizeof(desc.bpf_expr), "%s", "ip host 1.1.1.1");
+    desc.rule_index = 0;
+    desc.measurement_type = DP_TRACE_MEASUREMENT_TYPE_TRACE;
+
+    request->action = DP_TRACE_JOB_ADD;
+    request->desc = &desc;
+
+    will_return(__wrap_rte_mp_reply, DP_TRACE_JOB_ADD);
+    __dp_trace_path_handler(&msg, NULL);
+}
+
+static void testcase_trace_handle_job_used_get(void ** state)
+{
+    struct rte_mp_msg msg;
+    snprintf(msg.name, sizeof(msg.name), "%s", DP_TRACE_MP_MSG_NAME);
+    struct dp_trace_req * request = (struct dp_trace_req *)msg.param;
+    msg.len_param = sizeof(struct dp_trace_req);
+
+    request->action = DP_TRACE_JOB_ID_USED_GET;
+
+    will_return(__wrap_rte_mp_reply, DP_TRACE_JOB_ID_USED_GET);
+    will_return(__wrap_rte_mp_reply, 1 << 0);
+    __dp_trace_path_handler(&msg, NULL);
+}
+
+static void testcase_trace_handle_job_del(void ** state)
+{
+    struct rte_mp_msg msg;
+    snprintf(msg.name, sizeof(msg.name), "%s", DP_TRACE_MP_MSG_NAME);
+    struct dp_trace_req * request = (struct dp_trace_req *)msg.param;
+    msg.len_param = sizeof(struct dp_trace_req);
+
+    request->action = DP_TRACE_JOB_DESTROY;
+    request->jobs_id_destroy = (1 << 0);
+    will_return(__wrap_rte_mp_reply, DP_TRACE_JOB_DESTROY);
+    __dp_trace_path_handler(&msg, NULL);
+
+    // Confirm that the job has been deleted
+    request->action = DP_TRACE_JOB_ID_USED_GET;
+    will_return(__wrap_rte_mp_reply, DP_TRACE_JOB_ID_USED_GET);
+    will_return(__wrap_rte_mp_reply, 0);
+    __dp_trace_path_handler(&msg, NULL);
+}
+
+int main(int argc, char * argv[])
+{
+    char * eal_args[] = {
+        "test_trace_service", "-c", "0x1", "--no-huge", "-m", "100", "--no-pci",
+    };
+
+    int ret = rte_eal_init(RTE_DIM(eal_args), eal_args);
+    if (ret < 0)
+    {
+        rte_exit(EXIT_FAILURE, "Error with EAL initialization: %s\n", rte_strerror(rte_errno));
+    }
+
+    const struct CMUnitTest group_trace_service_handle[] = {
+        cmocka_unit_test(testcase_trace_handle_job_add),
+        cmocka_unit_test(testcase_trace_handle_job_used_get),
+        cmocka_unit_test(testcase_trace_handle_job_del),
+    };
+
+    // 0 on success, or the number of failed tests.
+    ret = cmocka_run_group_tests(group_trace_service_handle, group_trace_init_setup, group_trace_init_teardown);
+
+    rte_eal_cleanup();
+
+    // Pass the return value to ctest. Report an error if it is non-zero
+    return ret;
+}
\ No newline at end of file