diff --git a/0185-add-unitest.patch b/0185-add-unitest.patch new file mode 100644 index 0000000..f679dff --- /dev/null +++ b/0185-add-unitest.patch @@ -0,0 +1,1962 @@ +From 4154201d36719047c7a74d5b6d495228234ff54a Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 1 Feb 2023 15:58:00 +0800 +Subject: [PATCH] add unitest + +--- + src/lstack/include/lstack_protocol_stack.h | 1 + + test/unitest/CMakeLists.txt | 17 ++ + test/unitest/lstack/CMakeLists.txt | 29 ++ + test/unitest/lstack/config/lstack.conf | 21 ++ + test/unitest/lstack/lstack_param_test.c | 206 +++++++++++++ + test/unitest/lstack/lstack_test_case.h | 24 ++ + test/unitest/lstack/lstack_unit_test.c | 206 +++++++++++++ + test/unitest/lstack/main.c | 75 +++++ + test/unitest/lstack/stub.c | 110 +++++++ + test/unitest/ltran/CMakeLists.txt | 58 ++++ + test/unitest/ltran/config/ltran.conf | 23 ++ + test/unitest/ltran/libnet_tcp_test.c | 133 +++++++++ + test/unitest/ltran/ltran_instance_test.c | 75 +++++ + test/unitest/ltran/ltran_param_test.c | 320 +++++++++++++++++++++ + test/unitest/ltran/ltran_stack_test.c | 75 +++++ + test/unitest/ltran/ltran_test_case.h | 29 ++ + test/unitest/ltran/main.c | 80 ++++++ + test/unitest/stub.c | 34 +++ + test/unitest/test.sh | 279 ++++++++++++++++++ + 19 files changed, 1795 insertions(+) + create mode 100644 test/unitest/CMakeLists.txt + create mode 100644 test/unitest/lstack/CMakeLists.txt + create mode 100644 test/unitest/lstack/config/lstack.conf + create mode 100644 test/unitest/lstack/lstack_param_test.c + create mode 100644 test/unitest/lstack/lstack_test_case.h + create mode 100644 test/unitest/lstack/lstack_unit_test.c + create mode 100644 test/unitest/lstack/main.c + create mode 100644 test/unitest/lstack/stub.c + create mode 100644 test/unitest/ltran/CMakeLists.txt + create mode 100644 test/unitest/ltran/config/ltran.conf + create mode 100644 test/unitest/ltran/libnet_tcp_test.c + create mode 100644 test/unitest/ltran/ltran_instance_test.c + create mode 100644 test/unitest/ltran/ltran_param_test.c + create mode 100644 test/unitest/ltran/ltran_stack_test.c + create mode 100644 test/unitest/ltran/ltran_test_case.h + create mode 100644 test/unitest/ltran/main.c + create mode 100644 test/unitest/stub.c + create mode 100644 test/unitest/test.sh + +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index 4fe06cd..b093362 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -15,6 +15,7 @@ + + #include + #include ++#include + + #include + #include +diff --git a/test/unitest/CMakeLists.txt b/test/unitest/CMakeLists.txt +new file mode 100644 +index 0000000..e4946e8 +--- /dev/null ++++ b/test/unitest/CMakeLists.txt +@@ -0,0 +1,17 @@ ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++# gazelle is licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++ ++cmake_minimum_required(VERSION 3.12.1) ++project(gazelle_unittest) ++ ++set(CMAKE_C_FLAGS "-g -D_FORTIFY_SOURCE=2 -O3 -fPIE -fstack-protector-strong -msse4.1") ++ ++add_subdirectory(lstack) ++add_subdirectory(ltran) +diff --git a/test/unitest/lstack/CMakeLists.txt b/test/unitest/lstack/CMakeLists.txt +new file mode 100644 +index 0000000..66dac0f +--- /dev/null ++++ b/test/unitest/lstack/CMakeLists.txt +@@ -0,0 +1,29 @@ ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++# gazelle is licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++ ++cmake_minimum_required(VERSION 3.12.1) ++project(gazelle_unittest) ++ ++set(SRC_PATH ../../../src/lstack/core) ++set(COMMON_PATH ../../../src/common) ++set(LIB_PATH ../../../src/lstack /usr/include/dpdk /usr/include/lwip ${COMMON_PATH} ../../../src/lstack/include /usr/lib64) ++set(EXECUTABLE_OUTPUT_PATH ../) ++ ++set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage") ++set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g -fprofile-arcs -ftest-coverage -lgcov") ++ ++set(LIBRTE_LIB rte_pci rte_bus_pci rte_cmdline rte_hash rte_mempool rte_mempool_ring rte_timer rte_eal rte_ring rte_mbuf rte_kni rte_net_ixgbe rte_ethdev rte_net rte_kvargs) ++ ++add_executable(lstack_test lstack_param_test.c stub.c main.c ${SRC_PATH}/lstack_cfg.c ${COMMON_PATH}/gazelle_parse_config.c) ++target_include_directories(lstack_test PRIVATE ${LIB_PATH}) ++target_link_libraries(lstack_test PRIVATE config boundscheck cunit lwip pthread ${LIBRTE_LIB}) ++#target_link_libraries(lstack_param_test PRIVATE config cunit) ++ ++target_compile_options(lstack_test PRIVATE -DUSE_LIBOS_MEM) +diff --git a/test/unitest/lstack/config/lstack.conf b/test/unitest/lstack/config/lstack.conf +new file mode 100644 +index 0000000..4be9173 +--- /dev/null ++++ b/test/unitest/lstack/config/lstack.conf +@@ -0,0 +1,21 @@ ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++# gazelle is licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++ ++dpdk_args=["--socket-mem", "2048,0,0,0", "--huge-dir", "/mnt/hugepages-2M", "--proc-type", "primary"] ++use_ltran=0 ++low_power_mode=0 ++num_cpus="0,2,4" ++num_weakup="1,3,5" ++ ++numa_bind=1 ++host_addr="192.168.1.10" ++mask_addr="255.255.255.0" ++gateway_addr="192.168.1.1" ++devices="aa:bb:cc:dd:ee:ff" +diff --git a/test/unitest/lstack/lstack_param_test.c b/test/unitest/lstack/lstack_param_test.c +new file mode 100644 +index 0000000..efd07a2 +--- /dev/null ++++ b/test/unitest/lstack/lstack_param_test.c +@@ -0,0 +1,206 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "lstack_cfg.h" ++ ++#define MAX_CMD_LEN 1024 ++ ++int parse_conf_file(const char *path); ++ ++static int execute_cmd(const char *cmd) ++{ ++ int result; ++ result = system(cmd); ++ if (result < 0) { ++ printf("Executing cmd: %s error!!!\n", cmd); ++ } ++ return result; ++} ++ ++static int lstack_bad_param(const char *conf_file_filed) ++{ ++ int ret; ++ const char *conf_file_path = "../lstack/config/lstack_tmp.conf"; ++ char cmd[MAX_CMD_LEN]; ++ ++ execute_cmd("rm -rf ../lstack/config/lstack_tmp.conf"); ++ execute_cmd("cp -f ../lstack/config/lstack.conf ../lstack/config/lstack_tmp.conf"); ++ ++ ret = sprintf_s(cmd, MAX_CMD_LEN, "sed -i '%s' %s", conf_file_filed, conf_file_path); ++ if (ret < 0) { ++ printf("sprintf_s cmd error %s %s!!!\n", conf_file_filed, conf_file_path); ++ return ret; ++ } ++ ++ execute_cmd(cmd); ++ ++ ret = parse_conf_file(conf_file_path); ++ ++ return ret; ++} ++ ++void test_lstack_bad_params_lowpower(void) ++{ ++ /* lstack start lowpower empty */ ++ CU_ASSERT(lstack_bad_param("/^low_power_mode/clow_power_mode=/") != 0); ++ ++ /* lstack start lowpower none */ ++ CU_ASSERT(lstack_bad_param("/low_power_mode/d") == 0); ++ ++ /* lstack start lowpower exceed str */ ++ CU_ASSERT(lstack_bad_param("/^low_power_mode/clow_power_mode=aaa/") != 0); ++} ++ ++void test_lstack_bad_params_num_cpus(void) ++{ ++ /* lstack start num_cpus empty */ ++ CU_ASSERT(lstack_bad_param("/^num_cpus/cnum_cpus=/") != 0); ++ ++ /* lstack start num_cpus none */ ++ CU_ASSERT(lstack_bad_param("/num_cpus/d") != 0); ++ ++ /* lstack start num_cpus exceed str */ ++ CU_ASSERT(lstack_bad_param("/^num_cpus/cnum_cpus=aaa/") != 0); ++} ++ ++void test_lstack_bad_params_host_addr(void) ++{ ++ /* lstack start host_addr empty */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/chost_addr=/") != 0); ++ ++ /* lstack start host_addr none */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/d") != 0); ++ ++ /* lstack start host_addr invaild str */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/chost_addr=\"aaa\"/") != 0); ++ ++ /* lstack start host_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/chost_addr=\"192.168.1.256\"/") != 0); ++} ++ ++void test_lstack_bad_params_mask_addr(void) ++{ ++ /* lstack start mask_addr empty */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=/") != 0); ++ ++ /* lstack start mask_addr none */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/d") != 0); ++ ++ /* lstack start mask_addr invaild str */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=\"aaa\"/") != 0); ++ ++ /* lstack start mask_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=\"256.255.255.0\"/") != 0); ++ ++ /* lstack start mask_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=\"255.254.255.0\"/") != 0); ++} ++ ++void test_lstack_bad_params_gateway_addr(void) ++{ ++ /* lstack start gateway_addr empty */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/cgateway_addr=/") != 0); ++ ++ /* lstack start gateway_addr none */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/d") != 0); ++ ++ /* lstack start gateway_addr invaild str */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/cgateway_addr=\"aaa\"/") != 0); ++ ++ /* lstack start gateway_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/cgateway_addr=\"192.168.1.256\"/") != 0); ++} ++ ++void test_lstack_bad_params_devices(void) ++{ ++ /* lstack start devices empty */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=/") != 0); ++ ++ /* lstack start devices none */ ++ CU_ASSERT(lstack_bad_param("/^devices/d") != 0); ++ ++ /* lstack start devices invaild str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"aaa\"/") != 0); ++ ++ /* lstack start devices exceed str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"ff:ff:ff:ff:ff:ff:ff\"/") != 0); ++ ++ /* lstack start devices exceed str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"ff:ff:ff:ff:ff-ff\"/") != 0); ++ ++ /* lstack start devices exceed str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"ff:ff:ff:ff:ff:fg\"/") != 0); ++} ++ ++void test_lstack_normal_param(void) ++{ ++ int ret; ++ char ip_str[16] = {0}; /* 16:IP max len */ ++ char str[18] = {0}; ++ const char *config_file_path = "../lstack/config/lstack.conf"; ++ ++ ret = parse_conf_file(config_file_path); ++ CU_ASSERT(ret == 0); ++ struct cfg_params *global_params = get_global_cfg_params(); ++ for (int i =0; i< global_params->dpdk_argc; i++) ++ printf("arcv is %s\n", global_params->dpdk_argv[i]); ++ ++ CU_ASSERT(global_params->dpdk_argc == 9); /* 9:参数个数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[0], "lstack") == 0); ++ CU_ASSERT(strcmp(global_params->dpdk_argv[1], "--socket-mem") == 0); /* 1:lstack 参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[2], "2048,0,0,0") == 0); /* 2:lstack 参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[3], "--huge-dir") == 0); /* 3:lstack socket内存参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[4], "/mnt/hugepages-2M") == 0); /* 4:lstack socket内存值 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[5], "--proc-type") == 0); /* 5:lstack huge路径参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[6], "primary") == 0); /* 6:lstack huge路径值 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[7], "-l") == 0); /* 7:lstack进程类型参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[8], "0,2,4") == 0); /* 8:lstack参数 */ ++ ++ struct in_addr tmp_subnet; ++ tmp_subnet.s_addr = global_params->host_addr.addr; ++ char *subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(strcmp(subnet_str, "192.168.1.10") == 0); ++ free(subnet_str); ++ ++ tmp_subnet.s_addr = global_params->netmask.addr; ++ subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(strcmp(subnet_str, "255.255.255.0") == 0); ++ free(subnet_str); ++ ++ tmp_subnet.s_addr = global_params->gateway_addr.addr; ++ subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(strcmp(subnet_str, "192.168.1.1") == 0); ++ free(subnet_str); ++ ++ /* MAC地址转换为字符串 */ ++ ret = sprintf_s(str, sizeof(str), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", global_params->mac_addr[0], ++ global_params->mac_addr[1], ++ global_params->mac_addr[2], // 2mac地址 ++ global_params->mac_addr[3], // 3mac地址 ++ global_params->mac_addr[4], // 4mac地址 ++ global_params->mac_addr[5]); // 5mac地址 ++ CU_ASSERT(ret > 0); ++ CU_ASSERT(strcmp(str, "aa:bb:cc:dd:ee:ff") == 0); /* 匹配的MAC地址 */ ++} +diff --git a/test/unitest/lstack/lstack_test_case.h b/test/unitest/lstack/lstack_test_case.h +new file mode 100644 +index 0000000..cdb2550 +--- /dev/null ++++ b/test/unitest/lstack/lstack_test_case.h +@@ -0,0 +1,24 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#ifndef __LSTACK_TEST_CASE_H__ ++#define __LSTACK_TEST_CASE_H__ ++ ++void test_lstack_normal_param(void); ++void test_lstack_bad_params_devices(void); ++void test_lstack_bad_params_gateway_addr(void); ++void test_lstack_bad_params_mask_addr(void); ++void test_lstack_bad_params_host_addr(void); ++void test_lstack_bad_params_num_cpus(void); ++void test_lstack_bad_params_lowpower(void); ++ ++#endif +diff --git a/test/unitest/lstack/lstack_unit_test.c b/test/unitest/lstack/lstack_unit_test.c +new file mode 100644 +index 0000000..041a7cc +--- /dev/null ++++ b/test/unitest/lstack/lstack_unit_test.c +@@ -0,0 +1,206 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "lstack_cfg.h" ++ ++#define MAX_CMD_LEN 1024 ++ ++int parse_conf_file(const char *path); ++ ++static int execute_cmd(const char *cmd) ++{ ++ int result; ++ result = system(cmd); ++ if (result < 0) { ++ printf("Executing cmd: %s error!!!\n", cmd); ++ } ++ return result; ++} ++ ++static int lstack_bad_param(const char *conf_file_filed) ++{ ++ int ret; ++ const char *conf_file_path = "../lstack/config/lstack_tmp.conf"; ++ char cmd[MAX_CMD_LEN]; ++ ++ execute_cmd("rm -rf ../lstack/config/lstack_tmp.conf"); ++ execute_cmd("cp -f ../lstack/config/lstack.conf ../lstack/config/lstack_tmp.conf"); ++ ++ ret = sprintf_s(cmd, MAX_CMD_LEN, "sed -i '%s' %s", conf_file_filed, conf_file_path); ++ if (ret < 0) { ++ printf("sprintf_s cmd error %s %s!!!\n", conf_file_filed, conf_file_path); ++ return ret; ++ } ++ ++ execute_cmd(cmd); ++ ++ ret = parse_conf_file(conf_file_path); ++ ++ return ret; ++} ++ ++void test_lstack_bad_params_lowpower(void) ++{ ++ /* lstack start lowpower empty */ ++ CU_ASSERT(lstack_bad_param("/^low_power_mode/clow_power_mode=/") != 0); ++ ++ /* lstack start lowpower none */ ++ CU_ASSERT(lstack_bad_param("/low_power_mode/d") == 0); ++ ++ /* lstack start lowpower exceed str */ ++ CU_ASSERT(lstack_bad_param("/^low_power_mode/clow_power_mode=aaa/") != 0); ++} ++ ++void test_lstack_bad_params_num_cpus(void) ++{ ++ /* lstack start num_cpus empty */ ++ CU_ASSERT(lstack_bad_param("/^num_cpus/cnum_cpus=/") != 0); ++ ++ /* lstack start num_cpus none */ ++ CU_ASSERT(lstack_bad_param("/num_cpus/d") != 0); ++ ++ /* lstack start num_cpus exceed str */ ++ CU_ASSERT(lstack_bad_param("/^num_cpus/cnum_cpus=aaa/") != 0); ++} ++ ++void test_lstack_bad_params_host_addr(void) ++{ ++ /* lstack start host_addr empty */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/chost_addr=/") != 0); ++ ++ /* lstack start host_addr none */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/d") != 0); ++ ++ /* lstack start host_addr invaild str */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/chost_addr=\"aaa\"/") != 0); ++ ++ /* lstack start host_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^host_addr/chost_addr=\"192.168.1.256\"/") != 0); ++} ++ ++void test_lstack_bad_params_mask_addr(void) ++{ ++ /* lstack start mask_addr empty */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=/") != 0); ++ ++ /* lstack start mask_addr none */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/d") != 0); ++ ++ /* lstack start mask_addr invaild str */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=\"aaa\"/") != 0); ++ ++ /* lstack start mask_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=\"256.255.255.0\"/") != 0); ++ ++ /* lstack start mask_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^mask_addr/cmask_addr=\"255.254.255.0\"/") != 0); ++} ++ ++void test_lstack_bad_params_gateway_addr(void) ++{ ++ /* lstack start gateway_addr empty */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/cgateway_addr=/") != 0); ++ ++ /* lstack start gateway_addr none */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/d") != 0); ++ ++ /* lstack start gateway_addr invaild str */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/cgateway_addr=\"aaa\"/") != 0); ++ ++ /* lstack start gateway_addr exceed str */ ++ CU_ASSERT(lstack_bad_param("/^gateway_addr/cgateway_addr=\"192.168.1.256\"/") != 0); ++} ++ ++void test_lstack_bad_params_devices(void) ++{ ++ /* lstack start devices empty */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=/") != 0); ++ ++ /* lstack start devices none */ ++ CU_ASSERT(lstack_bad_param("/^devices/d") != 0); ++ ++ /* lstack start devices invaild str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"aaa\"/") != 0); ++ ++ /* lstack start devices exceed str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"ff:ff:ff:ff:ff:ff:ff\"/") != 0); ++ ++ /* lstack start devices exceed str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"ff:ff:ff:ff:ff-ff\"/") != 0); ++ ++ /* lstack start devices exceed str */ ++ CU_ASSERT(lstack_bad_param("/^devices/cdevices=\"ff:ff:ff:ff:ff:fg\"/") != 0); ++} ++ ++void test_lstack_normal_param(void) ++{ ++ int ret; ++ char ip_str[16] = {0}; /* 16:IP max len */ ++ char str[18] = {0}; ++ const char *config_file_path = "../lstack/config/lstack.conf"; ++ ++ ret = parse_conf_file(config_file_path); ++ CU_ASSERT(ret == 0); ++ struct cfg_params *global_params = get_global_cfg_params(); ++ for (int i =0; i< global_params->dpdk_argc; i++) ++ printf("arcv is %s\n", global_params->dpdk_argv[i]); ++ ++ CU_ASSERT(global_params->dpdk_argc == 9); /* 9:参数个数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[0], "lstack") == 0); ++ CU_ASSERT(strcmp(global_params->dpdk_argv[1], "--socket-mem") == 0); /* 1:lstack 参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[2], "2048,0,0,0") == 0); /* 2:lstack 参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[3], "--huge-dir") == 0); /* 3:lstack socket内存参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[4], "/mnt/hugepages-2M") == 0); /* 4:lstack socket内存值 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[5], "--proc-type") == 0); /* 5:lstack huge路径参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[6], "primary") == 0); /* 6:lstack huge路径值 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[7], "-l") == 0); /* 7:lstack进程类型参数 */ ++ CU_ASSERT(strcmp(global_params->dpdk_argv[8], "0,2,4") == 0); /* 8:lstack参数 */ ++ ++ struct in_addr tmp_subnet; ++ tmp_subnet.s_addr = global_params->host_addr.addr; ++ char *subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(strcmp(subnet_str, "192.168.1.10") == 0); ++ free(subnet_str); ++ ++ tmp_subnet.s_addr = global_params->netmask.addr; ++ subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(strcmp(subnet_str, "255.255.255.0") == 0); ++ free(subnet_str); ++ ++ tmp_subnet.s_addr = global_params->gateway_addr.addr; ++ subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(strcmp(subnet_str, "192.168.1.1") == 0); ++ free(subnet_str); ++ ++ /* MAC地址转换为字符串 */ ++ ret = sprintf_s(str, sizeof(str), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", global_params->ethdev.addr_bytes[0], ++ global_params->ethdev.addr_bytes[1], ++ global_params->ethdev.addr_bytes[2], // 2mac地址 ++ global_params->ethdev.addr_bytes[3], // 3mac地址 ++ global_params->ethdev.addr_bytes[4], // 4mac地址 ++ global_params->ethdev.addr_bytes[5]); // 5mac地址 ++ CU_ASSERT(ret > 0); ++ CU_ASSERT(strcmp(str, "aa:bb:cc:dd:ee:ff") == 0); /* 匹配的MAC地址 */ ++} +diff --git a/test/unitest/lstack/main.c b/test/unitest/lstack/main.c +new file mode 100644 +index 0000000..84285dd +--- /dev/null ++++ b/test/unitest/lstack/main.c +@@ -0,0 +1,75 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include "lstack_test_case.h" ++ ++typedef enum { ++ LSTACK_SCREEN = 0, ++ LSTACK_XMLFILE, ++ LSTACK_CONSOLE ++} CU_RunMode; ++ ++int main(int argc, char **argv) ++{ ++ CU_pSuite suite; ++ int num_failures; ++ CU_RunMode g_cunit_mode = LSTACK_SCREEN; ++ ++ if (argc > 1) { ++ g_cunit_mode = atoi(argv[1]); ++ } ++ ++ if (CU_initialize_registry() != CUE_SUCCESS) { ++ return CU_get_error(); ++ } ++ ++ suite = CU_add_suite("lstack", NULL, NULL); ++ if (suite == NULL) { ++ CU_cleanup_registry(); ++ return CU_get_error(); ++ } ++ ++ (void)CU_ADD_TEST(suite, test_lstack_normal_param); ++ (void)CU_ADD_TEST(suite, test_lstack_bad_params_devices); ++ (void)CU_ADD_TEST(suite, test_lstack_bad_params_gateway_addr); ++ (void)CU_ADD_TEST(suite, test_lstack_bad_params_mask_addr); ++ (void)CU_ADD_TEST(suite, test_lstack_bad_params_host_addr); ++ (void)CU_ADD_TEST(suite, test_lstack_bad_params_num_cpus); ++ (void)CU_ADD_TEST(suite, test_lstack_bad_params_lowpower); ++ ++ switch (g_cunit_mode) { ++ case LSTACK_SCREEN: ++ CU_basic_set_mode(CU_BRM_VERBOSE); ++ CU_basic_run_tests(); ++ break; ++ case LSTACK_XMLFILE: ++ CU_set_output_filename("param"); ++ CU_list_tests_to_file(); ++ CU_automated_run_tests(); ++ break; ++ case LSTACK_CONSOLE: ++ CU_console_run_tests(); ++ break; ++ default: ++ (void)printf("not suport cunit mode, only suport: 0 or 1\n"); ++ CU_cleanup_registry(); ++ return CU_get_error(); ++ } ++ ++ num_failures = (int)CU_get_number_of_failures(); ++ CU_cleanup_registry(); ++ return num_failures; ++} +diff --git a/test/unitest/lstack/stub.c b/test/unitest/lstack/stub.c +new file mode 100644 +index 0000000..f1a3a84 +--- /dev/null ++++ b/test/unitest/lstack/stub.c +@@ -0,0 +1,110 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++int lwip_epoll_create(int size) ++{ ++ return 0; ++} ++int lwip_epoll_ctl(int epfd, int op, int fd, const void *event) ++{ ++ return 0; ++} ++int lwip_epoll_wait(int epfd, const void* events, int maxevents, int timeout) ++{ ++ return 0; ++} ++void libnet_per_thread_init(void) ++{ ++ return; ++} ++int lwip_sigaction(int signum, const void *act, const void *oldact) ++{ ++ return 0; ++} ++int lwip_fork(void) ++{ ++ return 0; ++} ++int del_epoll_event(const void *conn, int event) ++{ ++ return 0; ++} ++int add_epoll_event(const void *conn, int event) ++{ ++ return 0; ++} ++int rearm_accept_fd(int fd) ++{ ++ return 0; ++} ++void clean_host_fd(int fd) ++{ ++ return; ++} ++int rearm_host_fd(int fd) ++{ ++ return 0; ++} ++int lwip_is_epfd(int epfd) ++{ ++ return 0; ++} ++int lwip_epoll_close(int epfd) ++{ ++ return 0; ++} ++int eth_dev_poll(void) ++{ ++ return 0; ++} ++int vdev_reg_xmit(int type, const void *qtuple) ++{ ++ return 0; ++} ++ ++void *__wrap_memp_malloc(int type) ++{ ++ void *memp; ++ ++ memp = malloc(5 * 1024 * 1024); /* 5 * 1024 * 1024 = 5M */ ++ ++ return memp; ++} ++ ++int __wrap_sys_mbox_new(const struct sys_mbox **mb, int size) ++{ ++ return 0; ++} ++ ++int __wrap_netconn_prepare_delete(const struct netconn *conn) ++{ ++ return 0; ++} ++ ++int __wrap_netconn_delete(struct netconn *conn) ++{ ++ if (conn != NULL) { ++ free(conn->pcb.tcp); ++ free(conn->op_completed); ++ free(conn); ++ conn = NULL; ++ } ++ return 0; ++} +diff --git a/test/unitest/ltran/CMakeLists.txt b/test/unitest/ltran/CMakeLists.txt +new file mode 100644 +index 0000000..9496053 +--- /dev/null ++++ b/test/unitest/ltran/CMakeLists.txt +@@ -0,0 +1,58 @@ ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++# gazelle is licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++ ++cmake_minimum_required(VERSION 3.12.1) ++project(gazelle_unittest) ++ ++set(LIB_PATH ../../../src/ltran /usr/include/dpdk ../../../src/common ../../../src/lstack/include) ++set(SRC_PATH_LTRAN ../../../src/ltran) ++set(EXECUTABLE_OUTPUT_PATH ../) ++ ++set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage") ++set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g -fprofile-arcs -ftest-coverage -lgcov") ++ ++add_executable(ltran_test ++ ltran_instance_test.c ++ ltran_param_test.c ++ ltran_stack_test.c ++ libnet_tcp_test.c ++ main.c ++ ../stub.c ++ ${SRC_PATH_LTRAN}/ltran_param.c ++ ${SRC_PATH_LTRAN}/ltran_errno.c ++ ${SRC_PATH_LTRAN}/ltran_instance.c ++ ${SRC_PATH_LTRAN}/ltran_stack.c ++ ${SRC_PATH_LTRAN}/ltran_tcp_sock.c ++ ${SRC_PATH_LTRAN}/ltran_tcp_conn.c ++ ${SRC_PATH_LTRAN}/../common/gazelle_dfx_msg.c ++ ${SRC_PATH_LTRAN}/../common/gazelle_parse_config.c ++) ++ ++set_target_properties(ltran_test PROPERTIES LINK_FLAGS "-L$ENV{DPDK_LIB_PATH} -Wl,--whole-archive -Wl,-lrte_pipeline -Wl,--wrap=rte_free -Wl,--wrap=rte_malloc \ ++ -Wl,--no-whole-archive -Wl,--whole-archive -Wl,-lrte_table -Wl,--no-whole-archive -Wl,--whole-archive -Wl,-lrte_port -Wl,--no-whole-archive \ ++ -Wl,-lrte_distributor -Wl,-lrte_ip_frag -Wl,-lrte_meter -Wl,-lrte_lpm -Wl,--whole-archive -Wl,-lrte_acl -Wl,--no-whole-archive \ ++ -Wl,-lrte_jobstats -Wl,-lrte_bitratestats -Wl,-lrte_metrics -Wl,-lrte_latencystats -Wl,-lrte_power -Wl,-lrte_efd -Wl,-lrte_bpf \ ++ -Wl,--whole-archive -Wl,-lrte_gro -Wl,-lrte_cfgfile -Wl,-lrte_gso -Wl,-lrte_hash -Wl,-lrte_member -Wl,-lrte_vhost -Wl,-lrte_kvargs \ ++ -Wl,-lrte_mbuf -Wl,-lrte_ethdev -Wl,-lrte_net -Wl,-lrte_bbdev -Wl,-lrte_cryptodev -Wl,-lrte_security -Wl,-lrte_compressdev -Wl,-lrte_eventdev \ ++ -Wl,-lrte_rawdev -Wl,-lrte_timer -Wl,-lrte_mempool -Wl,-lrte_mempool_ring -Wl,-lrte_ring -Wl,-lrte_pci \ ++ -Wl,-Bstatic -lrte_eal -Wl,-Bdynamic -Wl,-lrte_cmdline \ ++ -Wl,-lrte_sched -Wl,-lrte_reorder -Wl,-lrte_kni -Wl,-lrte_common_cpt -Wl,-lrte_common_octeontx -Wl,-lrte_common_dpaax -Wl,-lrte_bus_pci \ ++ -Wl,-lrte_bus_dpaa -Wl,-lrte_bus_vdev -Wl,-lrte_bus_fslmc -Wl,-lrte_mempool_bucket -Wl,-lrte_mempool_stack -Wl,-lrte_mempool_dpaa \ ++ -Wl,-lrte_mempool_dpaa2 -Wl,-lrte_net_af_packet -Wl,-lrte_net_ark -Wl,-lrte_net_atlantic -Wl,-lrte_net_axgbe \ ++ -Wl,-lrte_net_bnxt -Wl,-lrte_net_bond -Wl,-lrte_net_cxgbe -Wl,-lrte_net_dpaa -Wl,-lrte_net_dpaa2 -Wl,-lrte_net_e1000 -Wl,-lrte_net_ena \ ++ -Wl,-lrte_net_enetc -Wl,-lrte_net_enic -Wl,-lrte_net_failsafe -Wl,-lrte_net_i40e -Wl,-lrte_net_hinic -Wl,-lrte_net_ixgbe -Wl,-lrte_net_kni \ ++ -Wl,-lrte_net_nfp -Wl,-lrte_net_null -Wl,-lpcap -Wl,-lrte_net_qede -Wl,-lrte_net_ring -Wl,-lrte_net_softnic \ ++ -Wl,-lrte_net_tap -Wl,-lrte_net_vdev_netvsc -Wl,-lrte_net_virtio -Wl,-lrte_net_vhost \ ++ -Wl,-lrte_bus_vmbus -Wl,-lrte_net_netvsc -Wl,-lrte_mempool_octeontx -Wl,-lrte_net_octeontx \ ++ -Wl,-lrte_bus_ifpga -Wl,-lrte_stack -Wl,-lrte_telemetry\ ++ -Wl,--no-whole-archive -Wl,-lm -Wl,-lrt -Wl,-lnuma -Wl,-ldl -Wl,-export-dynamic -Wl,-export-dynamic \ ++ -Wl,--as-needed -Wl,-export-dynamic -Wl,-Map=ltran.map -Wl,--cref") ++target_include_directories(ltran_test PRIVATE ${LIB_PATH}) ++target_link_libraries(ltran_test PRIVATE config boundscheck cunit pthread) +diff --git a/test/unitest/ltran/config/ltran.conf b/test/unitest/ltran/config/ltran.conf +new file mode 100644 +index 0000000..bbab844 +--- /dev/null ++++ b/test/unitest/ltran/config/ltran.conf +@@ -0,0 +1,23 @@ ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++# gazelle is licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++ ++forward_kit = "dpdk" ++forward_kit_args = "-l 0,1 --socket-mem 1024,0,0,0 --huge-dir /mnt/hugepages --proc-type auto -n 4" ++kni_switch = 0 ++ ++dispatch_subnet = "192.168.1.0" ++dispatch_subnet_length = 8 ++dispatch_max_clients = 32 ++ ++bond_mode = 1 ++bond_miimon = 100 ++bond_mtu = 1500 ++bond_ports = "0x3, 0xC" ++bond_macs = "52:54:00:25:ef:e0, aa:bb:cc:dd:ee:ff" +diff --git a/test/unitest/ltran/libnet_tcp_test.c b/test/unitest/ltran/libnet_tcp_test.c +new file mode 100644 +index 0000000..6a6eadc +--- /dev/null ++++ b/test/unitest/ltran/libnet_tcp_test.c +@@ -0,0 +1,133 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "ltran_tcp_sock.h" ++#include "ltran_tcp_conn.h" ++ ++#define MAX_CONN 10 ++#define MAX_SOCK 10 ++void test_tcp_conn(void) ++{ ++ struct gazelle_tcp_conn_htable *tcp_conn_htable = NULL; ++ struct gazelle_tcp_conn *tcp_conn = NULL; ++ struct gazelle_tcp_conn *exist_tcp_conn = NULL; ++ struct gazelle_quintuple quintuple; ++ /* 1: set instance on */ ++ int32_t instance_cur_tick = 1; ++ ++ tcp_conn_htable = gazelle_tcp_conn_htable_create(MAX_CONN); ++ CU_ASSERT(tcp_conn_htable != NULL); ++ gazelle_set_tcp_conn_htable(tcp_conn_htable); ++ ++ quintuple.src_ip = inet_addr("192.168.1.1"); ++ quintuple.dst_ip = inet_addr("192.168.1.2"); ++ quintuple.src_port = 22; /* 22:src port id */ ++ quintuple.dst_port = 23; /* 23:dst port id */ ++ quintuple.protocol = 0; ++ tcp_conn = gazelle_conn_add_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ CU_ASSERT(tcp_conn != NULL); ++ tcp_conn->instance_cur_tick = &instance_cur_tick; ++ /* 1: set instacn_cur_tick = instance_reg_tick indicate instance is on */ ++ tcp_conn->instance_reg_tick = 1; ++ ++ exist_tcp_conn = gazelle_conn_get_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ CU_ASSERT(exist_tcp_conn != NULL); ++ ++ gazelle_conn_del_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ exist_tcp_conn = gazelle_conn_get_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ CU_ASSERT(exist_tcp_conn == NULL); ++ ++ gazelle_conn_del_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ ++ for (int i = 0; i <= MAX_CONN; i++) { ++ quintuple.src_port++; ++ tcp_conn = gazelle_conn_add_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ if (i < MAX_CONN) { ++ CU_ASSERT(tcp_conn != NULL); ++ tcp_conn->instance_cur_tick = &instance_cur_tick; ++ /* 1: set instacn_cur_tick = instance_reg_tick indicate instance is on */ ++ tcp_conn->instance_reg_tick = 1; ++ } else { ++ CU_ASSERT(tcp_conn == NULL); ++ } ++ ++ tcp_conn = gazelle_conn_get_by_quintuple(gazelle_get_tcp_conn_htable(), &quintuple); ++ if (i < MAX_CONN) { ++ CU_ASSERT(tcp_conn != NULL); ++ } else { ++ CU_ASSERT(tcp_conn == NULL); ++ } ++ } ++ ++ gazelle_tcp_conn_htable_destroy(); ++} ++ ++void test_tcp_sock(void) ++{ ++ char ip_str[16] = {0}; ++ struct in_addr tmp_subnet; ++ struct gazelle_tcp_sock *tcp_sock = NULL; ++ struct gazelle_tcp_sock *exist_tcp_sock = NULL; ++ /* 1: set instance on */ ++ int32_t instance_cur_tick = 1; ++ ++ gazelle_set_tcp_sock_htable(gazelle_tcp_sock_htable_create(MAX_SOCK)); ++ gazelle_set_tcp_conn_htable(gazelle_tcp_conn_htable_create(GAZELLE_MAX_CONN_NUM)); ++ ++ /* 22:dst port id 1111:dst tid number */ ++ tcp_sock = gazelle_sock_add_by_ipporttid(gazelle_get_tcp_sock_htable(), inet_addr("192.168.1.1"), 22, 1111); ++ CU_ASSERT(tcp_sock != NULL); ++ CU_ASSERT(tcp_sock->tid == 1111); /* 1111:tid number */ ++ CU_ASSERT(tcp_sock->port == 22); /* 22:port id */ ++ ++ tmp_subnet.s_addr = tcp_sock->ip; ++ CU_ASSERT(strcmp(inet_ntoa(tmp_subnet), "192.168.1.1") == 0); ++ tcp_sock->instance_cur_tick = &instance_cur_tick; ++ /* 1: set instacn_cur_tick = instance_reg_tick indicate instance is on */ ++ tcp_sock->instance_reg_tick = 1; ++ ++ /* 22:port id */ ++ exist_tcp_sock = gazelle_sock_get_by_min_conn(gazelle_get_tcp_sock_htable(), inet_addr("192.168.1.1"), 22); ++ CU_ASSERT(exist_tcp_sock != NULL); ++ CU_ASSERT(exist_tcp_sock->tid == 1111); /* 1111:tid number */ ++ ++ /* 22:dst port id 1111:dst tid number */ ++ gazelle_sock_del_by_ipporttid(gazelle_get_tcp_sock_htable(), inet_addr("192.168.1.1"), 22, 1111); ++ /* 22:dst port id */ ++ exist_tcp_sock = gazelle_sock_get_by_min_conn(gazelle_get_tcp_sock_htable(), inet_addr("192.168.1.1"), 22); ++ CU_ASSERT(exist_tcp_sock == NULL); ++ ++ /* 22:port id 1111:dst tid number */ ++ gazelle_sock_del_by_ipporttid(gazelle_get_tcp_sock_htable(), inet_addr("192.168.1.1"), 22, 1111); ++ ++ for (int i = 0; i <= MAX_CONN; i++) { ++ /* 22:dst port id 1111:dst tid number */ ++ tcp_sock = gazelle_sock_add_by_ipporttid(gazelle_get_tcp_sock_htable(), inet_addr("192.168.1.1"), 22, i); ++ if (i < MAX_CONN) { ++ CU_ASSERT(tcp_sock != NULL); ++ } else { ++ CU_ASSERT(tcp_sock == NULL); ++ } ++ } ++ ++ gazelle_tcp_sock_htable_destroy(); ++} +diff --git a/test/unitest/ltran/ltran_instance_test.c b/test/unitest/ltran/ltran_instance_test.c +new file mode 100644 +index 0000000..53acea1 +--- /dev/null ++++ b/test/unitest/ltran/ltran_instance_test.c +@@ -0,0 +1,75 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "ltran_instance.h" ++#include "ltran_param.h" ++#include "ltran_stack.h" ++ ++void test_ltran_instance(void) ++{ ++ struct gazelle_instance *instance = NULL; ++ uint32_t ret; ++ ++ get_ltran_config()->dispatcher.num_clients = 30; /* 30:clients num */ ++ get_ltran_config()->dispatcher.ipv4_subnet_size = 256; /* 256:ipv4 subnet size */ ++ get_ltran_config()->dispatcher.ipv4_net_mask = get_ltran_config()->dispatcher.ipv4_subnet_size - 1; ++ set_instance_mgr(gazelle_instance_mgr_create()); ++ CU_ASSERT(get_instance_mgr() != NULL); ++ ++ instance = gazelle_instance_add_by_pid(get_instance_mgr(), 1111); /* 1111:test pid */ ++ CU_ASSERT(instance != NULL); ++ CU_ASSERT(instance->pid == 1111); /* 1111:test pid */ ++ ++ instance = gazelle_instance_get_by_pid(get_instance_mgr(), 1111); /* 1111:test pid */ ++ CU_ASSERT(instance != NULL); ++ CU_ASSERT(instance->pid == 1111); /* 1111:test pid */ ++ ++ instance->ip_addr.s_addr = inet_addr("192.168.1.1"); ++ ++ instance = gazelle_instance_get_by_ip(get_instance_mgr(), inet_addr("192.168.1.1")); ++ CU_ASSERT(instance != NULL); ++ CU_ASSERT(instance->pid == 1111); /* 1111:test pid */ ++ CU_ASSERT(instance->ip_addr.s_addr == inet_addr("192.168.1.1")); ++ ++ instance = gazelle_instance_get_by_ip(get_instance_mgr(), inet_addr("192.168.1.2")); ++ CU_ASSERT(instance == NULL); ++ ++ instance = gazelle_instance_get_by_pid(get_instance_mgr(), 1112); /* 1112:test pid */ ++ CU_ASSERT(instance == NULL); ++ ++ for (int i = 1; i <= get_instance_mgr()->max_instance_num; i++) { ++ instance = gazelle_instance_add_by_pid(get_instance_mgr(), i); ++ if (i < get_instance_mgr()->max_instance_num) { ++ CU_ASSERT(instance != NULL); ++ } else { ++ CU_ASSERT(instance == NULL); ++ } ++ instance = gazelle_instance_get_by_pid(get_instance_mgr(), i); ++ if (i < get_instance_mgr()->max_instance_num) { ++ CU_ASSERT(instance != NULL); ++ } else { ++ CU_ASSERT(instance == NULL); ++ } ++ } ++ ++ gazelle_instance_mgr_destroy(); ++} +diff --git a/test/unitest/ltran/ltran_param_test.c b/test/unitest/ltran/ltran_param_test.c +new file mode 100644 +index 0000000..3b2a24d +--- /dev/null ++++ b/test/unitest/ltran/ltran_param_test.c +@@ -0,0 +1,320 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "ltran_param.h" ++ ++#define MAX_CMD_LEN 1024 ++ ++static int execute_cmd(const char *cmd) ++{ ++ int ret; ++ ret = system(cmd); ++ if (ret < 0) { ++ printf("Executing cmd: %s error!!!\n", cmd); ++ abort(); ++ } ++ return ret; ++} ++ ++static void restore_tmp_config(void) ++{ ++ execute_cmd("rm -rf ../ltran/config/ltran_tmp.conf"); ++ execute_cmd("cp -f ../ltran/config/ltran.conf ../ltran/config/ltran_tmp.conf"); ++} ++ ++static int ltran_bad_param(const char *conf_file_filed) ++{ ++ int ret; ++ struct ltran_config ltran_conf; ++ const char *conf_file_path = "../ltran/config/ltran_tmp.conf"; ++ char cmd[MAX_CMD_LEN]; ++ ++ restore_tmp_config(); ++ gazelle_set_errno(GAZELLE_SUCCESS); ++ ++ ret = sprintf_s(cmd, MAX_CMD_LEN, "sed -i '%s' %s", conf_file_filed, conf_file_path); ++ if (ret < 0) { ++ printf("sprintf_s return error!!!\n"); ++ return ret; ++ } ++ ++ execute_cmd(cmd); ++ ++ ret = parse_config_file_args(conf_file_path, <ran_conf); ++ ++ return ret; ++} ++ ++void test_ltran_bad_params_clients(void) ++{ ++ /* ltran start negative client */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_max_clients = 32/dispatch_max_clients = -1/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start 0 client */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_max_clients = 32/dispatch_max_clients = 0/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start 999 clinet */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_max_clients = 32/dispatch_max_clients = 999/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start str client */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_max_clients = 32/dispatch_max_clients = \"aaa\"/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start none client */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_max_clients = 32//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start empty client */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_max_clients = 32/dispatch_max_clients = /") == -GAZELLE_EPATH); ++} ++ ++void test_ltran_bad_params_port(void) ++{ ++ /* ltran start zero port */ ++ CU_ASSERT(ltran_bad_param("s/0x3/0x0/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start max port */ ++ CU_ASSERT(ltran_bad_param("s/0x3/0xff/") == 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_SUCCESS); ++ ++ /* ltran start str port */ ++ CU_ASSERT(ltran_bad_param("s/0x3/aaa/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start none port */ ++ CU_ASSERT(ltran_bad_param("s/bond_ports = \"0x3, 0xC\"//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start empty port */ ++ CU_ASSERT(ltran_bad_param("s/bond_ports = \"0x3, 0xC\"/bond_ports = /") == -GAZELLE_EPATH); ++ ++ /* ltran start exceed max port */ ++ CU_ASSERT(ltran_bad_param("s/bond_ports = \"0x3, 0xC\"/bond_ports = \"0xffffffff\"/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++} ++ ++void test_ltran_bad_params_subnet(void) ++{ ++ /* ltran start bad subnet */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_subnet =/cdispatch_subnet = \"aaa\"/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start empty subnet */ ++ CU_ASSERT(ltran_bad_param("/^dispatch_subnet /cdispatch_subnet=") == -GAZELLE_EPATH); ++ ++ /* ltran start none subnet */ ++ CU_ASSERT(ltran_bad_param("/dispatch_subnet =/d") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start not match subnet */ ++ CU_ASSERT(ltran_bad_param("s/.0\"/.1\"/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EHOSTADDR); ++ ++ /* ltran start error subnet */ ++ CU_ASSERT(ltran_bad_param("s/1.0\"/288.0\"/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EINETATON); ++ ++ /* ltran start exceed subnet length */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_subnet_length = 8/dispatch_subnet_length = 17/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start exceed subnet length */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_subnet_length = 8/dispatch_subnet_length = 0/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start str subnet length */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_subnet_length = 8/dispatch_subnet_length = aaa/") == -GAZELLE_EPATH); ++ ++ /* ltran start empty subnet length */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_subnet_length = 8/dispatch_subnet_length = /") == -GAZELLE_EPATH); ++ ++ /* ltran start none subnet length */ ++ CU_ASSERT(ltran_bad_param("s/dispatch_subnet_length = 8//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++} ++ ++void test_ltran_bad_params_bond_mode(void) ++{ ++ /* ltran start negative bond mode */ ++ CU_ASSERT(ltran_bad_param("s/bond_mode = 1/bond_mode = -1/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start unsupport bond mode0 */ ++ CU_ASSERT(ltran_bad_param("s/bond_mode = 1/bond_mode = 0/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start unsupport bond mode2 */ ++ CU_ASSERT(ltran_bad_param("s/bond_mode = 1/bond_mode = 2/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start empty bond mode */ ++ CU_ASSERT(ltran_bad_param("/^bond_mode /cbond_mode =") == -GAZELLE_EPATH); ++ ++ /* ltran start unsupport none mode2 */ ++ CU_ASSERT(ltran_bad_param("s/bond_mode = 1//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++} ++ ++void test_ltran_bad_params_bond_miimon(void) ++{ ++ /* ltran start negative bond miimon */ ++ CU_ASSERT(ltran_bad_param("s/bond_miimon = 100/bond_miimon = -1/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start zero bond miimon */ ++ CU_ASSERT(ltran_bad_param("s/bond_miimon = 100/bond_miimon = 0/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start max bond miimon */ ++ CU_ASSERT(ltran_bad_param("s/bond_miimon = 100/bond_miimon = 2147483647/") == 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_SUCCESS); ++ ++ /* ltran start exceed str bond miimon */ ++ CU_ASSERT(ltran_bad_param("s/bond_miimon = 100/bond_miimon = aaa/") == -GAZELLE_EPATH); ++ ++ /* ltran start empty bond miimon */ ++ CU_ASSERT(ltran_bad_param("s/bond_miimon = 100/bond_miimon = /") == -GAZELLE_EPATH); ++ ++ /* ltran start none bond miimon */ ++ CU_ASSERT(ltran_bad_param("s/bond_miimon = 100//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++} ++ ++void test_ltran_bad_params_bond_mtu(void) ++{ ++ /* ltran start negative bond mtu */ ++ CU_ASSERT(ltran_bad_param("s/bond_mtu = 1500/bond_mtu = -1/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start exceed min bond mtu */ ++ CU_ASSERT(ltran_bad_param("s/bond_mtu = 1500/bond_mtu = 67/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start exceed max bond mtu */ ++ CU_ASSERT(ltran_bad_param("s/bond_mtu = 1500/bond_mtu = 1501/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ERANGE); ++ ++ /* ltran start str bond mtu */ ++ CU_ASSERT(ltran_bad_param("s/bond_mtu = 1500/bond_mtu = aaa/") == -GAZELLE_EPATH); ++ ++ /* ltran start empty bond mtu */ ++ CU_ASSERT(ltran_bad_param("s/bond_mtu = 1500/bond_mtu = /") == -GAZELLE_EPATH); ++ ++ /* ltran start none bond mtu */ ++ CU_ASSERT(ltran_bad_param("s/bond_mtu = 1500//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++} ++ ++void test_ltran_bad_params_macs(void) ++{ ++ /* ltran start max macs */ ++ CU_ASSERT(ltran_bad_param("s/52:54:00:25:ef:e0/ff:ff:ff:ff:ff:ff/") == 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_SUCCESS); ++ ++ /* ltran start error macs */ ++ CU_ASSERT(ltran_bad_param("s/52:54:00:25:ef:e0/ff:ff:ff:ff:ff:fg/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ECONSIST); ++ ++ /* ltran start error macs */ ++ CU_ASSERT(ltran_bad_param("s/52:54:00:25:ef:e0/ff:ff:ff:ff:ff:ff:ff/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ECONSIST); ++ ++ /* ltran start error macs */ ++ CU_ASSERT(ltran_bad_param("s/52:54:00:25:ef:e0/ff:ff:ff:ff:ff-ff/") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ECONSIST); ++ ++ /* ltran start empty macs */ ++ CU_ASSERT(ltran_bad_param("s/52:54:00:25:ef:e0, aa:bb:cc:dd:ee:ff//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_ECONSIST); ++ ++ /* ltran start none macs */ ++ CU_ASSERT(ltran_bad_param("s/bond_macs = \"52:54:00:25:ef:e0, aa:bb:cc:dd:ee:ff\"//") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EPARAM); ++ ++ /* ltran start duplicated macs */ ++ CU_ASSERT(ltran_bad_param("/bond_macs/cbond_macs = \"52:54:00:25:ef:e0, 52:54:00:25:ef:e0\"") != 0); ++ CU_ASSERT(gazelle_get_errno() == GAZELLE_EMAC); ++} ++ ++void check_bond_param(const struct ltran_config *ltran_conf) ++{ ++ CU_ASSERT(ltran_conf->bond.mode == 1); ++ CU_ASSERT(ltran_conf->bond.miimon == 100); /* 100:bond链路监控时间 */ ++ CU_ASSERT(ltran_conf->bond.mtu == 1500); /* 1500:bond mtu值 */ ++ CU_ASSERT(ltran_conf->bond.port_num == 2); /* 2:bond port数目 */ ++ CU_ASSERT(ltran_conf->bond.portmask[0] == 3); /* 3:bond mac端口掩码 */ ++ CU_ASSERT(ltran_conf->bond.portmask[1] == 12); /* 12:bond mac端口掩码 */ ++ CU_ASSERT(ltran_conf->bond.mac_num == 2); /* 2:bond mac地址数目 */ ++ CU_ASSERT(ltran_conf->bond.mac[0].addr_bytes[0] == 82); /* 82:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[0].addr_bytes[1] == 84); /* 84:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[0].addr_bytes[2] == 0); /* 2:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[0].addr_bytes[3] == 37); /* 3:37:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[0].addr_bytes[4] == 239); /* 4:239:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[0].addr_bytes[5] == 224); /* 5:224:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[1].addr_bytes[0] == 170); /* 170:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[1].addr_bytes[1] == 187); /* 187:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[1].addr_bytes[2] == 204); /* 2:204:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[1].addr_bytes[3] == 221); /* 3:221:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[1].addr_bytes[4] == 238); /* 4:238:bond mac地址 */ ++ CU_ASSERT(ltran_conf->bond.mac[1].addr_bytes[5] == 255); /* 5:255:bond mac地址 */ ++} ++ ++void test_ltran_normal_param(void) ++{ ++ int ret; ++ struct ltran_config ltran_conf; ++ char ip_str[16] = {0}; /* 16:IP max len */ ++ const char *config_file_path = "../ltran/config/ltran.conf"; ++ ++ (void)memset_s(<ran_conf, sizeof(struct ltran_config), 0, sizeof(struct ltran_config)); ++ ret = parse_config_file_args(config_file_path, <ran_conf); ++ CU_ASSERT(ret == GAZELLE_OK); ++ ++ struct in_addr tmp_subnet; ++ tmp_subnet.s_addr = ntohl(ltran_conf.dispatcher.ipv4_subnet_addr.s_addr); ++ char *subnet_str = strdup(inet_ntop(AF_INET, &tmp_subnet, ip_str, sizeof(ip_str))); ++ CU_ASSERT(subnet_str != NULL); ++ CU_ASSERT(ltran_conf.dpdk.dpdk_argc == 11); /* 11:参数个数 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[0], "ltran") == 0); ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[1], "-l") == 0); ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[2], "0,1") == 0); /* 2:ltran绑在0,1核 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[3], "--socket-mem") == 0); /* 3:ltran socket内存参数 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[4], "1024,0,0,0") == 0); /* 4:ltran socket内存值 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[5], "--huge-dir") == 0); /* 5:ltran huge路径参数 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[6], "/mnt/hugepages") == 0); /* 6:ltran huge路径值 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[7], "--proc-type") == 0); /* 7:ltran进程类型参数 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[8], "auto") == 0); /* 8:ltran进程类型值 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[9], "-n") == 0); /* 9:ltran处理器socket内存通道数目 */ ++ CU_ASSERT(strcmp(ltran_conf.dpdk.dpdk_argv[10], "4") == 0); /* 10:ltran处理器socket内存通道数值 */ ++ CU_ASSERT(ltran_conf.dpdk.kni_switch == 0); ++ CU_ASSERT(strcmp(subnet_str, "192.168.1.0") == 0); ++ CU_ASSERT(ltran_conf.dispatcher.ipv4_subnet_length == 8); /* 8:ipv4子网长度, 表示ltran能识别的子网长度 */ ++ CU_ASSERT(ltran_conf.dispatcher.ipv4_subnet_size == 256); /* 256:ipv4子网大小 */ ++ CU_ASSERT(ltran_conf.dispatcher.ipv4_net_mask == 255); /* 255:ipv4掩码 */ ++ CU_ASSERT(ltran_conf.dispatcher.num_clients == 32); /* 32:client 数目 */ ++ check_bond_param(<ran_conf); ++ free(subnet_str); ++} +diff --git a/test/unitest/ltran/ltran_stack_test.c b/test/unitest/ltran/ltran_stack_test.c +new file mode 100644 +index 0000000..72af3ef +--- /dev/null ++++ b/test/unitest/ltran/ltran_stack_test.c +@@ -0,0 +1,75 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "ltran_stack.h" ++ ++void test_ltran_stack(void) ++{ ++ struct gazelle_stack *stack = NULL; ++ const struct gazelle_stack *exist_stack = NULL; ++ struct gazelle_stack_htable *stack_htable; ++ /* 1: tick init val */ ++ int32_t instance_cur_tick = 1; ++ ++ stack_htable = gazelle_stack_htable_create(GAZELLE_MAX_STACK_NUM); ++ CU_ASSERT(stack_htable != NULL); ++ gazelle_set_stack_htable(stack_htable); ++ ++ stack = gazelle_stack_add_by_tid(gazelle_get_stack_htable(), 1111); /* 1111:tid number */ ++ CU_ASSERT(stack != NULL); ++ CU_ASSERT(stack->tid == 1111); /* 1111: tid number */ ++ stack->instance_cur_tick = &instance_cur_tick; ++ /* 1: set instacn_cur_tick = instance_reg_tick indicate instance is on */ ++ stack->instance_reg_tick = 1; ++ ++ exist_stack = gazelle_stack_get_by_tid(gazelle_get_stack_htable(), 1111); /* 1111: tid number */ ++ ++ CU_ASSERT(exist_stack != NULL); ++ CU_ASSERT(exist_stack->tid == 1111); /* 1111:tid number */ ++ ++ gazelle_stack_del_by_tid(gazelle_get_stack_htable(), 1111); /* 1111:tid number */ ++ exist_stack = gazelle_stack_get_by_tid(gazelle_get_stack_htable(), 1111); /* 1111:tid number */ ++ ++ CU_ASSERT(exist_stack == NULL); ++ ++ gazelle_stack_del_by_tid(gazelle_get_stack_htable(), 1111); ++ ++ for (int i = 0; i <= stack_htable->max_stack_num; i++) { ++ stack = gazelle_stack_add_by_tid(gazelle_get_stack_htable(), i); ++ if (i < stack_htable->max_stack_num) { ++ CU_ASSERT(stack != NULL); ++ stack->instance_cur_tick = &instance_cur_tick; ++ /* 1: set instacn_cur_tick = instance_reg_tick indicate instance is on */ ++ stack->instance_reg_tick = 1; ++ } else { ++ CU_ASSERT(stack == NULL); ++ } ++ exist_stack = gazelle_stack_get_by_tid(gazelle_get_stack_htable(), i); ++ if (i < stack_htable->max_stack_num) { ++ CU_ASSERT(exist_stack != NULL); ++ } else { ++ CU_ASSERT(exist_stack == NULL); ++ } ++ } ++ ++ gazelle_stack_htable_destroy(); ++} +diff --git a/test/unitest/ltran/ltran_test_case.h b/test/unitest/ltran/ltran_test_case.h +new file mode 100644 +index 0000000..fd81a1b +--- /dev/null ++++ b/test/unitest/ltran/ltran_test_case.h +@@ -0,0 +1,29 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#ifndef __LTRAN_TEST_CASE_H__ ++#define __LTRAN_TEST_CASE_H__ ++ ++void test_ltran_stack(void); ++void test_ltran_instance(void); ++void test_ltran_normal_param(void); ++void test_ltran_bad_params_clients(void); ++void test_ltran_bad_params_port(void); ++void test_ltran_bad_params_subnet(void); ++void test_ltran_bad_params_bond_mode(void); ++void test_ltran_bad_params_bond_miimon(void); ++void test_ltran_bad_params_bond_mtu(void); ++void test_ltran_bad_params_macs(void); ++void test_tcp_conn(void); ++void test_tcp_sock(void); ++ ++#endif +diff --git a/test/unitest/ltran/main.c b/test/unitest/ltran/main.c +new file mode 100644 +index 0000000..c9d04f5 +--- /dev/null ++++ b/test/unitest/ltran/main.c +@@ -0,0 +1,80 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include "ltran_test_case.h" ++ ++typedef enum { ++ CUNIT_SCREEN = 0, ++ CUNIT_XMLFILE, ++ CUNIT_CONSOLE ++} CU_RunMode; ++ ++int main(int argc, char **argv) ++{ ++ CU_pSuite suite; ++ int num_failures; ++ CU_RunMode g_cunit_mode = CUNIT_SCREEN; ++ ++ if (argc > 1) { ++ g_cunit_mode = atoi(argv[1]); ++ } ++ ++ if (CU_initialize_registry() != CUE_SUCCESS) { ++ return CU_get_error(); ++ } ++ ++ suite = CU_add_suite("ltran", NULL, NULL); ++ if (suite == NULL) { ++ CU_cleanup_registry(); ++ return CU_get_error(); ++ } ++ ++ (void)CU_ADD_TEST(suite, test_ltran_instance); ++ (void)CU_ADD_TEST(suite, test_ltran_stack); ++ (void)CU_ADD_TEST(suite, test_ltran_normal_param); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_clients); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_port); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_subnet); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_bond_mode); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_bond_miimon); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_bond_mtu); ++ (void)CU_ADD_TEST(suite, test_ltran_bad_params_macs); ++ (void)CU_ADD_TEST(suite, test_tcp_conn); ++ (void)CU_ADD_TEST(suite, test_tcp_sock); ++ ++ switch (g_cunit_mode) { ++ case CUNIT_SCREEN: ++ CU_basic_set_mode(CU_BRM_VERBOSE); ++ CU_basic_run_tests(); ++ break; ++ case CUNIT_XMLFILE: ++ CU_set_output_filename("instance"); ++ CU_list_tests_to_file(); ++ CU_automated_run_tests(); ++ break; ++ case CUNIT_CONSOLE: ++ CU_console_run_tests(); ++ break; ++ default: ++ (void)printf("not suport mode=%d\n", g_cunit_mode); ++ CU_cleanup_registry(); ++ return CU_get_error(); ++ } ++ ++ num_failures = (int)CU_get_number_of_failures(); ++ CU_cleanup_registry(); ++ return num_failures; ++} +diff --git a/test/unitest/stub.c b/test/unitest/stub.c +new file mode 100644 +index 0000000..8f37c90 +--- /dev/null ++++ b/test/unitest/stub.c +@@ -0,0 +1,34 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++ * gazelle is licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include ++ ++uint64_t get_current_time(void) ++{ ++ return 0; ++} ++ ++int rte_pdump_init(void) ++{ ++ return 0; ++} ++ ++void *__wrap_rte_malloc(const char *type, size_t size, unsigned align) ++{ ++ return malloc(size); ++} ++ ++void __wrap_rte_free(void *ptr) ++{ ++ free(ptr); ++} +diff --git a/test/unitest/test.sh b/test/unitest/test.sh +new file mode 100644 +index 0000000..90fbbe6 +--- /dev/null ++++ b/test/unitest/test.sh +@@ -0,0 +1,279 @@ ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++# gazelle is licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++ ++usage() ++{ ++ echo "Usage: sh llt.sh [OPTIONS]" ++ echo "Use llt.sh to control llt operation" ++ echo ++ echo "Misc:" ++ echo " -h, --help Print this help, then exit" ++ echo ++ echo "Compile Options:" ++ echo " -m, --cmake