[Feature][Modem]Update MTK MODEM V1.6 baseline version: MOLY.NR15.R3.MD700.IVT.MP1MR3.MP.V1.6
MTK modem version: MT2735_IVT_MOLY.NR15.R3.MD700.IVT.MP1MR3.MP.V1.6.tar.gz
RF modem version: NA
Change-Id: I45a4c2752fa9d1a618beacd5d40737fb39ab64fb
diff --git a/mcu/protocol/dispatcher/src/dispatcher_ut.c b/mcu/protocol/dispatcher/src/dispatcher_ut.c
new file mode 100644
index 0000000..14a47a8
--- /dev/null
+++ b/mcu/protocol/dispatcher/src/dispatcher_ut.c
@@ -0,0 +1,1398 @@
+/*****************************************************************************
+* Copyright Statement:
+* --------------------
+* This software is protected by Copyright and the information contained
+* herein is confidential. The software may not be copied and the information
+* contained herein may not be used or disclosed except with the written
+* permission of MediaTek Inc. (C) 2012
+*
+* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
+* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
+* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
+* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
+* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
+* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
+* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
+* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
+*
+* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
+* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
+* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
+* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
+* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+*
+* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
+* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
+* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
+* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
+* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
+*
+*****************************************************************************/
+
+/*******************************************************************************
+ * Filename:
+ * ---------
+ * dispatcher_ut.c
+ *
+ * Project:
+ * --------
+ * VMOLY
+ *
+ * Description:
+ * ------------
+ * DISPATCHER unit test implementation.
+ *
+ * Author:
+ * -------
+ * -------
+ *
+ *******************************************************************************/
+
+#ifdef ATEST_SYS_DISPATCHER
+
+#include "kal_public_api.h"
+#include "sys_test.h"
+#include "n3epc_dispatcher_struct.h"
+#include "ipcore_dispatcher_struct.h"
+#include "dispatcher_struct.h"
+#include "dispatcher_if.h"
+#include "dispatcher_msgid.h"
+
+#define DISPATCHER_UT_CASE(_func, _param) { #_func, _func, _param }
+#define DISPATCHER_UT_TEST_BEARERID 14
+#define DISPATCHER_UT_TEST_INVALID_BEARERID 18 /*graeter than 15*/
+#define DISPATCHER_UT_TEST_PDNID 15 //as current meta does not store above 32 so taken 15 to check current code
+#define DISPATCHER_UT_TEST_CID 100 //any temp cid value
+#define DISPATCHER_UT_TEST_NWID 4 //any temp nw_id value
+#define DISPATCHER_UT_TEST_NON_WIFI_PDNID 20
+
+static kal_uint8 dispatcher_ut_ipv4_dns_packet[] = {
+ 0x45, 0x00, 0x00, 0x45, 0x50, 0x9e, 0x00, 0x00, 0x80, 0x11, 0x96, 0x3a, 0xac, 0x16, 0x97, 0x53,
+ 0xac, 0x15, 0x64, 0x50, 0xc0, 0x51, 0x00, 0x35, 0x00, 0x31, 0x7d, 0x15, 0x2d, 0x89, 0x01, 0x00,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x50, 0x43, 0x31, 0x30, 0x30, 0x36, 0x30,
+ 0x30, 0x31, 0x34, 0x08, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6b, 0x03, 0x69, 0x6e, 0x63,
+ 0x00, 0x00, 0x1c, 0x00, 0x01};
+
+static kal_uint8 dispatcher_ut_ipv6_dhcp_ul_packet[] = {
+ 0x60, 0x00, 0x00, 0x00, 0x00, 0x56, 0x11, 0x80, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x02, 0x13, 0xd4, 0xff, 0xfe, 0x80, 0x56, 0x15, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x02, 0x22, 0x02, 0x23, 0x00, 0x56, 0x98, 0x9b,
+ 0x01, 0x00, 0x12, 0x69, 0x00, 0x01, 0x00, 0x0e, 0x00, 0x01, 0x00, 0x06, 0x18, 0xc5, 0xe1, 0xd2,
+ 0x00, 0x13, 0xd4, 0x80, 0x56, 0x15, 0x00, 0x03, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x02, 0x00, 0x17};
+
+
+
+typedef struct {
+ kal_uint32 type_idx;
+ kal_uint8 *base_addr;
+ kal_uint8 read_idx;
+ kal_uint8 write_idx;
+ kal_uint8 *buff_addr_base;
+}dispatcher_ut_meta_queue_t;
+
+typedef enum {
+ DISPATCHER_UT_LHIF_META_AP0 = 0,
+ DISPATCHER_UT_META_QUEUE_NUM_MAX,
+}dispatcher_ut_meta_type_e;
+
+#define DISPATCHER_UT_META_TABLE_SIZE 70
+static lhif_meta_tbl_t dispatcher_ut_meta_tbl_s[DISPATCHER_UT_META_TABLE_SIZE];
+
+static dispatcher_ut_meta_queue_t dispatcher_ut_meta_queues[DISPATCHER_UT_META_QUEUE_NUM_MAX];
+
+kal_uint8 g_ul_wtunnel_forwarded_gpd_count;
+kal_uint8 g_dl_ipcore_forward_did_count;
+kal_uint8 g_dl_drop_did_count;
+kal_uint8 g_ul_drop_gpd_count;
+kal_uint8 g_ul_upcm_forward_gpd_count;
+kal_uint8 g_ul_total_ignr_count;
+kal_bool dispatcher_ut_assert_flag = KAL_FALSE;
+typedef struct {
+ kal_uint8 cid;
+ kal_bool result;
+ ps_cause_enum error_code;
+}dispatcher_bind_cnf_struct;
+
+typedef struct {
+ kal_uint8 cid;
+ kal_bool result;
+ ps_cause_enum error_code;
+}dispatcher_unbind_cnf_struct;
+
+dispatcher_bind_cnf_struct g_curr_bind_cnf;
+dispatcher_bind_cnf_struct g_curr_unbind_cnf;
+
+kal_bool dispatcher_ut_test_first(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz) {
+ /*temp test case*/
+ return KAL_TRUE;
+}
+
+void dispatcher_ut_bearer_act_req_only(void)
+{
+
+ n3epc_dispatcher_bearer_act_req_struct req_struct;
+ req_struct.bearer_id = DISPATCHER_UT_TEST_BEARERID;
+ req_struct.linked_bearer_id = DISPATCHER_UT_TEST_BEARERID;
+ req_struct.context_id = DISPATCHER_UT_TEST_CID;
+ n3epc_dispatcher_bearer_act_req(&req_struct);
+
+}
+
+void dispatcher_ut_invalid_bearer_act_req_only(int bearer_id)
+{
+
+ n3epc_dispatcher_bearer_act_req_struct req_struct;
+ req_struct.bearer_id = bearer_id;
+ req_struct.linked_bearer_id = bearer_id;
+ req_struct.context_id = DISPATCHER_UT_TEST_CID;
+ n3epc_dispatcher_bearer_act_req(&req_struct);
+
+}
+
+void dispatcher_ut_bearer_deact_req_only(void)
+{
+ n3epc_dispatcher_bearer_deact_req_struct bearer_deact_req_struct;
+ bearer_deact_req_struct.bearer_id = DISPATCHER_UT_TEST_BEARERID;
+ bearer_deact_req_struct.context_id = DISPATCHER_UT_TEST_CID;
+ n3epc_dispatcher_bearer_deact_req(&bearer_deact_req_struct);
+}
+
+
+void dispatcher_ut_invalid_bearer_deact_req_only(int bearer_id)
+{
+ n3epc_dispatcher_bearer_deact_req_struct bearer_deact_req_struct;
+ bearer_deact_req_struct.bearer_id = bearer_id;
+ bearer_deact_req_struct.context_id = DISPATCHER_UT_TEST_CID;
+ n3epc_dispatcher_bearer_deact_req(&bearer_deact_req_struct);
+}
+
+kal_bool dispatcher_ut_bearer_act_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+
+ kal_bool is_active = KAL_FALSE;
+ /**********reset dispatcher full context************/
+ dispatcher_reset();
+
+ /*activate bearer with invalid value 0 */
+ is_active = dispatcher_check_is_bearer_active_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ dispatcher_ut_invalid_bearer_act_req_only(0);
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+
+ /*activate bearer with invalid value 18 */
+ dispatcher_ut_invalid_bearer_act_req_only(DISPATCHER_UT_TEST_INVALID_BEARERID);
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+ /*valid bearer activate*/
+ dispatcher_ut_bearer_act_req_only();
+ /*check if bearer is really active*/
+ is_active = dispatcher_check_is_bearer_active_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (is_active != KAL_TRUE) {
+ return KAL_FALSE;
+ }
+
+ /*bearer is activate, now try do duplicate bearer req*/
+ dispatcher_ut_bearer_act_req_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+ /*deactivate the activated bearer, kind of reset*/
+ dispatcher_ut_bearer_deact_req_only();
+ return KAL_TRUE;
+}
+
+
+
+kal_bool dispatcher_ut_bearer_deact_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ kal_bool is_active = KAL_FALSE;
+
+ dispatcher_reset();
+ /*********reset dispatcher full context************/
+
+ /*invalid req*/
+ dispatcher_ut_invalid_bearer_deact_req_only(0);
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+ /*activate bearer with invalid value 18 */
+ dispatcher_ut_invalid_bearer_deact_req_only(DISPATCHER_UT_TEST_INVALID_BEARERID);
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+
+ /*activate a valid bearer*/
+ dispatcher_ut_bearer_act_req_only();
+ is_active = dispatcher_check_is_bearer_active_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+
+ dispatcher_ut_bearer_deact_req_only();
+ /*check if bearer is really deactive*/
+ is_active = dispatcher_check_is_bearer_active_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (is_active != KAL_FALSE) {
+ return KAL_FALSE;
+ }
+ return KAL_TRUE;
+}
+
+void dispatcher_ut_pdn_bind_req_only(void)
+{
+ n3epc_dispatcher_pdn_bind_req_struct pdn_bind_struct;
+ pdn_bind_struct.context_id = DISPATCHER_UT_TEST_CID;
+ pdn_bind_struct.network_interface_id = DISPATCHER_UT_TEST_NWID;
+ n3epc_dispatcher_pdn_bind_req(&pdn_bind_struct,MOD_DISPATCHER);
+}
+
+void dispatcher_ut_pdn_unbind_req_only(void)
+{
+ n3epc_dispatcher_pdn_unbind_req_struct pdn_unbind_struct;
+ pdn_unbind_struct.context_id = DISPATCHER_UT_TEST_CID;
+ n3epc_dispatcher_pdn_unbind_req(&pdn_unbind_struct, MOD_DISPATCHER);
+}
+
+void dispatcher_ut_pdn_bind_ipc_rsp_only(void)
+{
+ /*ipcore bind OK rsp*/
+ ipcore_dispatcher_pdn_bind_rsp_struct ipc_bind_rsp_struct;
+ ipc_bind_rsp_struct.network_interface_id = DISPATCHER_UT_TEST_NWID;
+ ipc_bind_rsp_struct.pdn_id = DISPATCHER_UT_TEST_PDNID;
+ ipc_bind_rsp_struct.result= HIF_IPC_OK;
+ ipc_bind_rsp_struct.back_info.context_id = DISPATCHER_UT_TEST_CID;
+ ipc_bind_rsp_struct.back_info.reply_dest_mod_id = MOD_DISPATCHER;
+ ipcore_dispatcher_pdn_bind_rsp(&ipc_bind_rsp_struct);
+}
+
+void dispatcher_ut_pdn_bind_ipc_error_rsp_only(void)
+{
+ /*ipcore bind OK rsp*/
+ ipcore_dispatcher_pdn_bind_rsp_struct ipc_bind_rsp_struct;
+ ipc_bind_rsp_struct.network_interface_id = DISPATCHER_UT_TEST_NWID;
+ ipc_bind_rsp_struct.pdn_id = DISPATCHER_UT_TEST_PDNID;
+ ipc_bind_rsp_struct.result= !(HIF_IPC_OK);
+ ipc_bind_rsp_struct.back_info.context_id = DISPATCHER_UT_TEST_CID;
+ ipc_bind_rsp_struct.back_info.reply_dest_mod_id = MOD_DISPATCHER;
+ ipcore_dispatcher_pdn_bind_rsp(&ipc_bind_rsp_struct);
+}
+
+kal_bool dispatcher_ut_return_compare_bind_cnf(kal_bool result, ps_cause_enum error_code) {
+
+ if (g_curr_bind_cnf.result == KAL_TRUE) {
+ return KAL_TRUE;
+ } else {
+ if (g_curr_bind_cnf.error_code == error_code) {
+ return KAL_TRUE;
+ } else {
+ return KAL_FALSE;
+ }
+ }
+}
+
+kal_bool dispatcher_ut_return_compare_unbind_cnf(kal_bool result, ps_cause_enum error_code) {
+
+ if (g_curr_unbind_cnf.result == KAL_TRUE) {
+ return KAL_TRUE;
+ } else {
+ if (g_curr_unbind_cnf.error_code == error_code) {
+ return KAL_TRUE;
+ } else {
+ return KAL_FALSE;
+ }
+ }
+}
+
+kal_bool dispatcher_ut_pdn_bind_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ kal_bool is_continue = KAL_FALSE;
+ dispatcher_bind_state_enum state;
+
+ /**********reset dispatcher full context************/
+ dispatcher_reset();
+
+ //TEST CASE1
+ /*do pdn bind without bearer activation*/
+ dispatcher_ut_pdn_bind_req_only();
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, N3EPC_DISPATCHER_BIND_ERROR_AS_BEARER_NOT_ACTIVATED_BEFORE)) {
+ return KAL_FALSE;
+ }
+
+ /* TEST CASE2 bearer act+ pdn bind req+ bind rsp from ipc*/
+ kal_mem_set(&g_curr_bind_cnf, 0, sizeof(g_curr_bind_cnf));
+ dispatcher_reset();
+
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+
+ /*at binding stage send duplicate bearer act req*/
+ dispatcher_ut_bearer_act_req_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+ /*at dispatcher binding state send another bind req*/
+ dispatcher_ut_pdn_bind_req_only();
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, N3EPC_DISPATCHER_BIND_ERROR_AS_PREV_BIND_IN_PROGRESS)) {
+ return KAL_FALSE;
+ }
+
+ /*simulate ipc bind rsp*/
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BIND) {
+ return KAL_FALSE;
+ }
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_TRUE, 0)) {
+ return KAL_FALSE;
+ }
+
+ /*at bind stage send duplicate bearer act req*/
+ dispatcher_ut_bearer_act_req_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+
+ /*TEST CASE3 pdn bind success,test remaining 1. send duplicate bind req*/
+ kal_mem_set(&g_curr_bind_cnf, 0, sizeof(g_curr_bind_cnf));
+ dispatcher_ut_pdn_bind_req_only();
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, N3EPC_DISPATCHER_BIND_ERROR_AS_PDN_ALREADY_BIND)) {
+ return KAL_FALSE;
+ }
+
+ /*TEST CASE4 */
+ /*for BIND state, bearer deact req, send the bearer act req, check assert flag*/
+ kal_mem_set(&g_curr_bind_cnf, 0, sizeof(g_curr_bind_cnf));
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_bearer_act_req_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+
+ /*TEST CASE5 */
+ /*binding going to unbind , bearer deact then bearer act, assert fail as state does not allow bearer to activate here*/
+ kal_mem_set(&g_curr_bind_cnf, 0, sizeof(g_curr_bind_cnf));
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_unbind_req_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING_GOING_TO_UNBIND) {
+ return KAL_FALSE;
+ }
+
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_bearer_act_req_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+
+
+ /*TEST CASE5 */
+ /*BIND state , bearer deact then bearer act, assert fail as state does not allow bearer to activate here*/
+ kal_mem_set(&g_curr_bind_cnf, 0, sizeof(g_curr_bind_cnf));
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BIND) {
+ return KAL_FALSE;
+ }
+
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_bearer_act_req_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BIND) {
+ return KAL_FALSE;
+ }
+ /*test pdn bind rsp for unexpected state already bind, assert flag will become true*/
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ if (dispatcher_ut_assert_flag) {
+ dispatcher_ut_assert_flag = KAL_FALSE;
+ } else {
+ return KAL_FALSE;
+ }
+ return KAL_TRUE;
+
+}
+
+
+
+kal_bool dispatcher_ut_pdn_unbind_normal_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ kal_bool is_continue = KAL_FALSE;
+ dispatcher_bind_state_enum state;
+ dispatcher_reset();
+ /*TEST CASE 1*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();/*binding state*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ /*at binding state send ipc bind rsp failure--->state will become UNBIND*/
+ dispatcher_ut_pdn_bind_ipc_error_rsp_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, 0)) {
+ return KAL_FALSE;
+ }
+
+
+ /*TEST CASE 2*/
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();/*binding state*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_unbind_req_only();/*this will trigger state binding_going_to_unbind*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING_GOING_TO_UNBIND) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_unbind_req_only();/*another unbind req @ binding_going_to_unbind state*/
+ if (!dispatcher_ut_return_compare_unbind_cnf(KAL_FALSE, N3EPC_DISPATCHER_UNBIND_ERROR_AS_DUPLICATE_UNBIND_REQ)) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_req_only();/*bind req @ binding going to unbind state*/
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, N3EPC_DISPATCHER_BINDING_GOING_TO_UNBIND_ERROR_AS_PREV_BIND_IN_PROGRESS)) {
+ return KAL_FALSE;
+ }
+ /*dispatcher state is binding going to unbind , so send ipc bind rsp failure*/
+ dispatcher_ut_pdn_bind_ipc_error_rsp_only();
+ /*check both rsp bind cnf as well as unbind cnf along with pdn bind state should become unbind*/
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, 0)) {
+ return KAL_FALSE;
+ }
+ if (!dispatcher_ut_return_compare_unbind_cnf(KAL_TRUE, 0)) {
+ return KAL_FALSE;
+ }
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+
+ /*send unbind at unbind state*/
+ dispatcher_ut_pdn_unbind_req_only();
+ if (!dispatcher_ut_return_compare_unbind_cnf(KAL_FALSE, N3EPC_DISPATCHER_UNBIND_ERROR_AS_DUPLICATE_UNBIND_REQ)) {
+ return KAL_FALSE;
+ }
+
+ /*TEST CASE 3 ipc rsp success at binding state*/
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();/*binding state*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ /*state should be BIND*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BIND) {
+ return KAL_FALSE;
+ }
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_TRUE, 0)) {
+ return KAL_FALSE;
+ }
+
+
+ /*TEST CASE 4 ipc rsp success at binding_going_to_unbind state*/
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();/*binding state*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_unbind_req_only();/*another unbind req @ binding_going_to_unbind state*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING_GOING_TO_UNBIND) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ /*check both rsp bind cnf as well as unbind cnf along with pdn bind state should become unbind*/
+ if (!dispatcher_ut_return_compare_bind_cnf(KAL_FALSE, HIF_CAUSE_START)) {
+ return KAL_FALSE;
+ }
+ if (!dispatcher_ut_return_compare_unbind_cnf(KAL_TRUE, 0)) {
+ return KAL_FALSE;
+ }
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+
+ /*check some other condition*/
+ /*pdn state is binding or binding going to unbind, then bearer deactivate*/
+ /*as bearer can be deactivated any time so there should be no assert*/
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();/*binding state*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_bearer_deact_req_only();
+ if (dispatcher_ut_assert_flag) {
+ return KAL_FALSE;
+ }
+
+
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();/*binding state*/
+ dispatcher_ut_pdn_unbind_req_only();/*binding going to unbind*/
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BINDING_GOING_TO_UNBIND) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_bearer_deact_req_only();
+ if (dispatcher_ut_assert_flag) {
+ return KAL_FALSE;
+ }
+
+ return KAL_TRUE;
+}
+
+kal_bool dispatcher_ut_pdn_unbind_handover_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ /*first do bind*/
+ kal_bool is_continue = KAL_FALSE;
+ dispatcher_bind_state_enum state;
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_BIND) {
+ return KAL_FALSE;
+ }
+ /*for handover case unbind will happen before bearre deact*/
+ dispatcher_ut_pdn_unbind_req_only();
+ state = dispatcher_get_bind_state_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+
+ is_continue = dispatcher_check_is_bearer_active_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (is_continue != KAL_TRUE) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_bearer_deact_req_only();
+ is_continue = dispatcher_check_is_bearer_active_by_bearerid(DISPATCHER_UT_TEST_BEARERID, 0);
+ if (is_continue != KAL_FALSE) {
+ return KAL_FALSE;
+ }
+ return KAL_TRUE;
+}
+
+
+void dispatcher_ut_prepare_ul_gpd_list(ip_type_e ip, kal_uint32 pkt_count, qbm_gpd **head_gpd, qbm_gpd **tail_gpd)
+{
+ qbm_gpd *curr_gpd;
+ qbm_gpd *bd;
+ kal_uint8 *packet_buf;
+ kal_uint32 packet_len;
+ kal_uint32 idx;
+ if (pkt_count != qbmt_alloc_q(
+ QBM_TYPE_NET_UL_SHRD,
+ pkt_count,
+ (void **)(head_gpd),
+ (void **)(tail_gpd))) {
+ return;
+ }
+
+ curr_gpd = *head_gpd;
+ for (idx = 0; idx < pkt_count; idx++)
+ {
+ bd = QBM_DES_GET_DATAPTR(curr_gpd);
+ if(ip == IP_TYPE_V4) {
+ packet_buf = dispatcher_ut_ipv4_dns_packet;
+ packet_len = sizeof(dispatcher_ut_ipv4_dns_packet);
+ }
+ if(ip == IP_TYPE_V6) {
+ packet_buf = dispatcher_ut_ipv6_dhcp_ul_packet;
+ packet_len = sizeof(dispatcher_ut_ipv6_dhcp_ul_packet);
+ }
+ kal_mem_cpy(QBM_DES_GET_DATAPTR(bd), packet_buf, packet_len);
+ QBM_DES_SET_DATALEN(bd, packet_len);
+ QBM_DES_SET_DATALEN(curr_gpd, packet_len);
+ curr_gpd = (qbm_gpd *)QBM_DES_GET_NEXT(curr_gpd);
+ }
+}
+
+kal_bool dispatcher_ut_prepare_and_recv_gpd_test_case_non_wifipdnId(void)
+{
+ kal_uint32 ipv4_cnt = 2;
+ qbm_gpd *head_gpd;
+ qbm_gpd *tail_gpd;
+ kal_uint8 non_wifi_pdn = DISPATCHER_UT_TEST_NON_WIFI_PDNID;
+ kal_uint8 proto_idx = 0;
+ dispatcher_ut_prepare_ul_gpd_list(1, ipv4_cnt, &head_gpd, &tail_gpd);
+ dispatcher_rcv_ul_gpd_by_pdn((ip_type_e)1, non_wifi_pdn, head_gpd, tail_gpd, proto_idx);
+ if (g_ul_upcm_forward_gpd_count != ipv4_cnt) {
+ return KAL_FALSE;
+ }
+ return KAL_TRUE;
+}
+
+
+kal_bool dispatcher_ut_prepare_and_recv_gpd_test_case()
+{
+ kal_uint32 ipv4_cnt = 2;
+ kal_uint32 ipv6_cnt = 2;
+ qbm_gpd *head_gpd;
+ qbm_gpd *tail_gpd;
+ kal_uint8 test_pdn_id = DISPATCHER_UT_TEST_PDNID;
+ kal_uint8 proto_idx = 0;
+
+ dispatcher_bind_state_enum bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, proto_idx);
+ kal_bool is_bearer_active = dispatcher_check_is_bearer_active_by_pdnid(DISPATCHER_UT_TEST_PDNID, proto_idx);
+
+ if (ipv4_cnt > 0) {
+ dispatcher_ut_prepare_ul_gpd_list(1, ipv4_cnt, &head_gpd, &tail_gpd);
+ dispatcher_rcv_ul_gpd_by_pdn((ip_type_e)1, test_pdn_id, head_gpd, tail_gpd, proto_idx);
+ if((bind_state == DISPATCHER_PDN_ST_BIND) && is_bearer_active) {
+ if(g_ul_wtunnel_forwarded_gpd_count != ipv4_cnt) {
+ return KAL_FALSE;
+ }
+ g_ul_wtunnel_forwarded_gpd_count = 0;
+ } else {
+ if(g_ul_drop_gpd_count != ipv4_cnt) {
+ return KAL_FALSE;
+ }
+ g_ul_drop_gpd_count = 0;
+ }
+
+ }
+ if (ipv6_cnt > 0) {
+ dispatcher_ut_prepare_ul_gpd_list(2, ipv4_cnt, &head_gpd, &tail_gpd);
+ dispatcher_rcv_ul_gpd_by_pdn((ip_type_e)2, test_pdn_id, head_gpd, tail_gpd, proto_idx);
+ if((bind_state == DISPATCHER_PDN_ST_BIND) && is_bearer_active) {
+ if(g_ul_wtunnel_forwarded_gpd_count != ipv6_cnt) {
+ return KAL_FALSE;
+ }
+ g_ul_wtunnel_forwarded_gpd_count = 0;
+ } else {
+ if(g_ul_drop_gpd_count != ipv6_cnt) {
+ return KAL_FALSE;
+ }
+ g_ul_drop_gpd_count = 0;
+ }
+
+ }
+ return KAL_TRUE;
+
+}
+
+kal_bool dispatcher_ut_ul_gpd_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ /*1.bearer active + bind
+ 2.prepare UL GPD list
+ 3.run the UL GPD test case
+ 4. bearer deact & unbind*/
+ dispatcher_reset();
+ /*first do bind*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+
+ if (!dispatcher_ut_prepare_and_recv_gpd_test_case()) {
+ return KAL_FALSE;
+ }
+
+
+ /*bearer deact & unbind in advance for next test case*/
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_pdn_unbind_req_only();
+
+
+ //now unbind or bearer inactive check ul for drop gpd list
+ if (!dispatcher_ut_prepare_and_recv_gpd_test_case()) {
+ return KAL_FALSE;
+ }
+
+ //a test case to check non wifi pdn id ul gpd req forwardig to UPCM
+ if (!dispatcher_ut_prepare_and_recv_gpd_test_case_non_wifipdnId()) {
+ return KAL_FALSE;
+ }
+
+ return KAL_TRUE;
+}
+
+
+kal_uint32 dispatcher_ut_prepare_did_list(kal_uint8 count, upcm_did** p_head, upcm_did** p_tail)
+{
+ kal_bool end_of_list = KAL_FALSE;
+ upcm_did *did;
+ upcm_did *prev_did = NULL;
+ upcm_did *next_did;
+ kal_uint8 alloc_num = upcm_did_alloc_q(count, p_head, p_tail);
+
+ for (did = *p_head; did && !end_of_list; did = next_did) {
+ next_did = UPCM_DID_GET_NEXT(did);
+ end_of_list = (did == *p_tail);
+
+ if (prev_did) {
+ UPCM_DID_SET_NEXT(prev_did, did);
+ }
+ prev_did = did;
+ }
+
+ return alloc_num;
+}
+
+
+kal_bool dispatcher_ut_dl_did_req_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ /*1. bearer active + bind
+ 2.prepare DL Did list
+ 3.run the DL test case
+ 4. bearer deact & unbind*/
+
+ kal_uint32 allocated_count = 0;
+ kal_uint8 proto_idx = 0;
+ upcm_did* p_head;
+ upcm_did* p_tail;
+ kal_uint8 count = 2;
+
+ dispatcher_reset();
+
+ /*TEST CASE 1*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ /*DL cbk is not registered sp these DID will be dropped*/
+ dispatcher_ut_prepare_did_list(count, &p_head, &p_tail);
+ dispatcher_on_dl_did_cbk(DISPATCHER_UT_TEST_BEARERID, p_head, p_tail, proto_idx);
+ if (g_dl_drop_did_count != count) {
+ return KAL_FALSE;
+ }
+ g_dl_drop_did_count = 0;
+
+
+ /*TEST CASE 2*/
+ /*now register DL cbk of ipcore simulation*/
+ count = 4;
+ dispatcher_reg_cbk_dlvr_dl_did(dispatcher_ut_forward_dl_did_to_ipc);
+ dispatcher_ut_prepare_did_list(count, &p_head, &p_tail);
+ dispatcher_on_dl_did_cbk(DISPATCHER_UT_TEST_BEARERID, p_head, p_tail, proto_idx);
+ if (g_dl_ipcore_forward_did_count != count) {
+ return KAL_FALSE;
+ }
+ g_dl_ipcore_forward_did_count = 0;
+
+ /*TEST CASE 3*/
+ /*bearer deact & unbind in advance for next test case*/
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_pdn_unbind_req_only();
+ // not bind or bearer deact so try again for drop test.
+ count = 3;
+ allocated_count = dispatcher_ut_prepare_did_list(count, &p_head, &p_tail);
+ dispatcher_on_dl_did_cbk(DISPATCHER_UT_TEST_BEARERID, p_head, p_tail, proto_idx);
+ if (g_dl_drop_did_count != count) {
+ return KAL_FALSE;
+ }
+ g_dl_drop_did_count = 0;
+ return KAL_TRUE;
+
+}
+
+void dispatcher_ut_init_meta(void) {
+ /*reset Q property*/
+ kal_mem_set(dispatcher_ut_meta_queues, 0, sizeof(dispatcher_ut_meta_queue_t));
+ /*reset meta tbl values*/
+ kal_mem_set(dispatcher_ut_meta_tbl_s, 0, sizeof(dispatcher_ut_meta_tbl_s));
+ /*init the Q type & Q base address*/
+ dispatcher_ut_meta_queues[DISPATCHER_UT_LHIF_META_AP0].base_addr = (kal_uint8*)dispatcher_ut_meta_tbl_s;
+ dispatcher_ut_meta_queues[DISPATCHER_UT_LHIF_META_AP0].type_idx = DISPATCHER_UT_LHIF_META_AP0;
+}
+
+kal_uint32 dispatcher_ut_alloc_meta(
+ dispatcher_ut_meta_type_e q_type,
+ kal_uint32 request_num,
+ kal_uint32 *p_head_idx,
+ kal_uint32 *p_tail_idx) {
+ kal_uint32 alloc_num, used_num, remain_num;
+
+ kal_uint8 write_idx, read_idx;
+
+ write_idx = dispatcher_ut_meta_queues[q_type].write_idx;
+ read_idx = dispatcher_ut_meta_queues[q_type].read_idx;
+
+ used_num = (write_idx >= read_idx)
+ ? (write_idx - read_idx) :
+ (DISPATCHER_UT_META_TABLE_SIZE - read_idx + write_idx);
+ remain_num = DISPATCHER_UT_META_TABLE_SIZE - used_num - 1;
+ alloc_num = (request_num > remain_num) ? remain_num : request_num;
+
+ *p_head_idx = write_idx;
+ write_idx += alloc_num;
+ if (write_idx >= DISPATCHER_UT_META_TABLE_SIZE) {
+ write_idx -= DISPATCHER_UT_META_TABLE_SIZE;
+ }
+ *p_tail_idx = write_idx;
+
+ dispatcher_ut_meta_queues[q_type].write_idx = write_idx;
+
+ return alloc_num;
+}
+
+void dispatcher_ut_prepare_ul_meta_list(
+ kal_uint8 v4_wifi_pdn_meta_cnt,
+ kal_uint8 v6_wifi_pdn_meta_cnt,
+ kal_uint32 ipv4_cnt,
+ kal_uint32 ipv6_cnt,
+ kal_uint32 *p_head_idx,
+ kal_uint32 *p_tail_idx,
+ LHIF_QUEUE_TYPE *q_type,
+ kal_uint8 proto_idx,
+ kal_uint8 v4_igr_cnt,
+ kal_uint8 v6_igr_cnt) {
+
+ kal_uint32 total_cnt = ipv4_cnt + ipv6_cnt;
+
+ kal_uint8 v4_igr = v4_igr_cnt;
+ kal_uint8 v6_igr = v6_igr_cnt;
+ kal_uint8 v4_wifi_meta = v4_wifi_pdn_meta_cnt;
+ kal_uint8 v6_wifi_meta = v6_wifi_pdn_meta_cnt;
+ kal_uint8 *packet_buf;
+ kal_uint32 packet_len;
+ kal_uint8 sequence = 0;
+ kal_uint32 curr_meta_idx;
+ lhif_meta_tbl_t *curr_meta;
+ kal_uint32 idx;
+ dispatcher_ut_alloc_meta(DISPATCHER_UT_LHIF_META_AP0, total_cnt, p_head_idx, p_tail_idx);
+ *q_type = DISPATCHER_UT_LHIF_META_AP0;
+
+
+ /*now fill each meta as per choice*/
+ /*IPV4 first*/
+ curr_meta_idx = *p_head_idx;
+ for (idx = 0; idx < ipv4_cnt; idx++) {
+ curr_meta = &dispatcher_ut_meta_tbl_s[curr_meta_idx];
+ packet_buf = dispatcher_ut_ipv4_dns_packet;
+ packet_len = sizeof(dispatcher_ut_ipv4_dns_packet);
+ curr_meta->vrb_addr = packet_buf;
+ curr_meta->length = packet_len;
+ curr_meta->psn = sequence;
+ if (v4_wifi_meta > 0)
+ {
+ curr_meta->pdn = DISPATCHER_UT_TEST_PDNID;
+ v4_wifi_meta --;
+ }
+ else
+ {
+ curr_meta->pdn = DISPATCHER_UT_TEST_NON_WIFI_PDNID;
+ }
+ curr_meta->protocol_idx = proto_idx;
+ if (v4_igr >0)
+ {
+ curr_meta->ignore = KAL_TRUE;
+ v4_igr --;
+ }
+ sequence ++;
+ curr_meta_idx ++;
+ if (curr_meta_idx == DISPATCHER_UT_META_TABLE_SIZE) {
+ curr_meta_idx = 0;
+ }
+ if (curr_meta_idx == *p_tail_idx) {
+ return;
+ }
+ }
+ /*IPV6*/
+ for (idx = 0; idx < ipv6_cnt; idx++) {
+ curr_meta = &dispatcher_ut_meta_tbl_s[curr_meta_idx];
+ packet_buf = dispatcher_ut_ipv6_dhcp_ul_packet;
+ packet_len = sizeof(dispatcher_ut_ipv6_dhcp_ul_packet);
+ curr_meta->vrb_addr = packet_buf;
+ curr_meta->length = packet_len;
+ curr_meta->psn = sequence;
+ if (v6_wifi_meta > 0)
+ {
+ curr_meta->pdn = DISPATCHER_UT_TEST_PDNID;
+ v6_wifi_meta --;
+ }
+ else
+ {
+ curr_meta->pdn = DISPATCHER_UT_TEST_NON_WIFI_PDNID;
+ }
+ if (v6_igr >0)
+ {
+ curr_meta->ignore = KAL_TRUE;
+ v6_igr --;
+ }
+ curr_meta->protocol_idx = proto_idx;
+ sequence ++;
+
+ curr_meta_idx ++;
+ if (curr_meta_idx == DISPATCHER_UT_META_TABLE_SIZE) {
+ curr_meta_idx = 0;
+ }
+ if (curr_meta_idx == *p_tail_idx) {
+ return;
+ }
+ }
+
+}
+
+kal_bool dispatcher_ut_ul_meta_req(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ kal_uint32 ipv4_cnt = 5;
+ kal_uint32 ipv6_cnt = 5;
+ kal_uint32 head_idx;
+ kal_uint32 tail_idx;
+ LHIF_QUEUE_TYPE q_type;
+ kal_uint8 proto_idx = 0;
+ kal_uint8 v4_ignore = 1;
+ kal_uint8 v6_ignore = 1;
+ kal_uint8 ipv4_wifi_pdn_meta = 2;
+ kal_uint8 ipv6_wifi_pdn_meta = 2;
+ kal_uint8 expected_forward_count = 0;
+ kal_uint8 expected_igr_count = 0;
+
+ dispatcher_reset();
+
+ /*first do bind*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+
+ dispatcher_ut_init_meta();
+ dispatcher_ut_prepare_ul_meta_list(ipv4_wifi_pdn_meta, ipv6_wifi_pdn_meta, ipv4_cnt, ipv6_cnt, &head_idx, &tail_idx, &q_type, proto_idx, v4_ignore, v6_ignore);
+ /*test uplink flow*/
+ dispatcher_rcv_ul_meta_queue(head_idx, tail_idx, q_type);
+ expected_forward_count = ipv4_wifi_pdn_meta - v4_ignore + ipv6_wifi_pdn_meta - v6_ignore;
+ expected_igr_count = v4_ignore + v6_ignore + expected_forward_count;
+ ASSERT(expected_forward_count == g_ul_wtunnel_forwarded_gpd_count);
+ ASSERT(g_ul_total_ignr_count == g_ul_total_ignr_count);
+ g_ul_total_ignr_count = 0;
+ g_ul_wtunnel_forwarded_gpd_count = 0;
+
+ /*bearer deact & unbind in advance for next test case*/
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_pdn_unbind_req_only();
+
+
+ /*first do bind*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+
+ dispatcher_ut_init_meta();
+ dispatcher_ut_pdn_unbind_req_only();
+ /*bearer active but state unbind*/
+ dispatcher_ut_prepare_ul_meta_list(ipv4_wifi_pdn_meta, ipv6_wifi_pdn_meta, ipv4_cnt, ipv6_cnt, &head_idx, &tail_idx, &q_type, proto_idx, v4_ignore, v6_ignore);
+ /*test uplink flow*/
+ dispatcher_rcv_ul_meta_queue(head_idx, tail_idx, q_type);
+ expected_forward_count = 0;
+ expected_igr_count = v4_ignore + v6_ignore + (ipv4_wifi_pdn_meta - v4_ignore) + (ipv6_wifi_pdn_meta - v6_ignore);
+ ASSERT(expected_forward_count == g_ul_wtunnel_forwarded_gpd_count);
+ ASSERT(g_ul_total_ignr_count == g_ul_total_ignr_count);
+ g_ul_total_ignr_count = 0;
+ g_ul_wtunnel_forwarded_gpd_count = 0;
+ /*deactivate bearer*/
+ dispatcher_ut_bearer_deact_req_only();
+ return KAL_TRUE;
+
+}
+
+kal_bool dispatcher_ut_ul_gpd_bearer_act_and_no_binding(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ /*only bearer act , pdn is unbind
+ prepare gpd list & execute TC
+ Expected tc to check drop the gpd list*/
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ if (!dispatcher_ut_prepare_and_recv_gpd_test_case()) {
+ return KAL_FALSE;
+ }
+
+ /*bearer deact & unbind in advance for next test case*/
+ dispatcher_ut_bearer_deact_req_only();
+ return KAL_TRUE;
+
+}
+
+kal_bool dispatcher_ut_ul_gpd_bearer_act_bind_then_bearer_deact(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ dispatcher_reset();
+ /*first do bind*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+
+ /*deactivate bearer*/
+ dispatcher_ut_bearer_deact_req_only();
+
+ /*bearer deactive & pdn bind, UL GPD recv, Drop the gpd*/
+ if (!dispatcher_ut_prepare_and_recv_gpd_test_case()) {
+ return KAL_FALSE;
+ }
+
+ /*reset by unbinding here*/
+ dispatcher_ut_pdn_unbind_req_only();
+
+ return KAL_TRUE;
+}
+
+kal_bool dispatcher_ut_ul_meta_burst_packet_req(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ kal_uint32 ipv4_cnt = 30;
+ kal_uint32 ipv6_cnt = 30;
+ kal_uint32 head_idx;
+ kal_uint32 tail_idx;
+ LHIF_QUEUE_TYPE q_type;
+ kal_uint8 proto_idx = 0;
+ kal_uint8 v4_ignore = 0;
+ kal_uint8 v6_ignore = 0;
+ kal_uint8 ipv4_wifi_pdn_meta = 30;
+ kal_uint8 ipv6_wifi_pdn_meta = 30;
+ kal_uint8 expected_forward_count = 0;
+ kal_uint8 expected_igr_count = 0;
+ kal_uint8 expected_drop_pkt = 0;
+
+ dispatcher_reset();
+
+ /*first do bind*/
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+
+ dispatcher_ut_init_meta();
+ dispatcher_ut_prepare_ul_meta_list(ipv4_wifi_pdn_meta, ipv6_wifi_pdn_meta, ipv4_cnt, ipv6_cnt, &head_idx, &tail_idx, &q_type, proto_idx, v4_ignore, v6_ignore);
+ /*test uplink flow*/
+ dispatcher_rcv_ul_meta_queue(head_idx, tail_idx, q_type);
+ expected_forward_count = ipv4_wifi_pdn_meta - v4_ignore + ipv6_wifi_pdn_meta - v6_ignore;
+ expected_drop_pkt = expected_forward_count - g_ul_wtunnel_forwarded_gpd_count;
+ expected_igr_count = v4_ignore + v6_ignore + expected_forward_count;
+ ASSERT(expected_igr_count == g_ul_total_ignr_count);
+ g_ul_total_ignr_count = 0;
+ g_ul_wtunnel_forwarded_gpd_count = 0;
+
+ /*bearer deact & unbind in advance for next test case*/
+ dispatcher_ut_bearer_deact_req_only();
+ dispatcher_ut_pdn_unbind_req_only();
+
+ return KAL_TRUE;
+}
+
+kal_bool dispatcher_ut_pdn_binding_ipc_rsp_test(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz)
+{
+ dispatcher_bind_state_enum bind_state;
+ // BINDING ->IPC RSP OK ->BIND
+ dispatcher_reset();
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BIND) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_unbind_req_only();
+ dispatcher_ut_bearer_deact_req_only();
+
+ // BINDING ->IPC RSP FAIL ->UNBIND
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_ipc_error_rsp_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+ //already unbind so just deactivate bearer
+ dispatcher_ut_bearer_deact_req_only();
+
+ // BINDING->BINDING_GOING_TO_UNBIND ->IPC RSP OK ->UNBIND
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_unbind_req_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BINDING_GOING_TO_UNBIND) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_ipc_rsp_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+ //already unbind so just deactivate bearer
+ dispatcher_ut_bearer_deact_req_only();
+
+
+ // BINDING->BINDING_GOING_TO_UNBIND ->IPC RSP FAIL->UNBIND
+ dispatcher_ut_bearer_act_req_only();
+ dispatcher_ut_pdn_bind_req_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BINDING) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_unbind_req_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_BINDING_GOING_TO_UNBIND) {
+ return KAL_FALSE;
+ }
+ dispatcher_ut_pdn_bind_ipc_error_rsp_only();
+ bind_state = dispatcher_get_bind_state_by_pdnid(DISPATCHER_UT_TEST_PDNID, 0);
+ if (bind_state != DISPATCHER_PDN_ST_UNBIND) {
+ return KAL_FALSE;
+ }
+ //already unbind so just deactivate bearer
+ dispatcher_ut_bearer_deact_req_only();
+
+ return KAL_TRUE;
+}
+
+kal_bool dispatcher_ut_query_meta_table(kal_uint32 **base_addr, kal_uint16 *size, LHIF_QUEUE_TYPE queue_type) {
+ *base_addr = (kal_uint32 *)dispatcher_ut_meta_tbl_s;
+ *size = DISPATCHER_UT_META_TABLE_SIZE;
+
+ return KAL_TRUE;
+}
+
+kal_bool dispatcher_ut_st_create(void) {
+ static ST_TCASE_T dispatcher_ut_cases_s[] = {
+ DISPATCHER_UT_CASE(dispatcher_ut_test_first, NULL),
+ /*only bearer active*/
+ DISPATCHER_UT_CASE(dispatcher_ut_bearer_act_req_test, NULL),
+ /*same bearer deactive*/
+ DISPATCHER_UT_CASE(dispatcher_ut_bearer_deact_req_test, NULL),
+ /* bearer act + bind*/
+ DISPATCHER_UT_CASE(dispatcher_ut_pdn_bind_req_test, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_pdn_unbind_normal_req_test, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_pdn_unbind_handover_req_test, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_pdn_binding_ipc_rsp_test, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_ul_gpd_req_test, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_dl_did_req_test, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_ul_meta_req, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_ul_gpd_bearer_act_and_no_binding, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_ul_gpd_bearer_act_bind_then_bearer_deact, NULL),
+ DISPATCHER_UT_CASE(dispatcher_ut_ul_meta_burst_packet_req, NULL),
+
+ };
+ return st_reg_test("DISPATCHER", &(dispatcher_ut_cases_s[0]), (sizeof(dispatcher_ut_cases_s)/sizeof(ST_TCASE_T)));
+}
+
+kal_bool dispatcher_ut_register_dl_cbk(dispatcher_dlvr_dl_did_f1 pf_dlvr_did) {
+ /*do nothing*/
+ return KAL_TRUE;
+}
+
+void dispatcher_ut_forward_dl_did_to_ipc(kal_uint32 pdn_id, upcm_did* p_head,
+ upcm_did* p_tail, kal_uint8 protocol_idx)
+{
+ upcm_did *did;
+ kal_bool end_of_list = KAL_FALSE;
+ upcm_did *next_did;
+ kal_uint8 count = 0;
+
+ for (did = p_head; did && !end_of_list; did = next_did) {
+ next_did = UPCM_DID_GET_NEXT(did);
+ count++;
+ end_of_list = (did == p_tail);
+ }
+ upcm_did_dest_q(p_head, p_tail);
+ g_dl_ipcore_forward_did_count = count;
+
+}
+
+void dispatcher_ut_drop_dl_did(kal_uint8 bearer_id, upcm_did* p_head,
+ upcm_did* p_tail, kal_uint8 protocol_idx)
+{
+ /*dispatcher UT is dropping DID due to invalid bearer ID or bearer not active or no cbk set*/
+
+ upcm_did *did;
+ kal_bool end_of_list = KAL_FALSE;
+ upcm_did *next_did;
+ kal_uint8 count = 0;
+
+ for (did = p_head; did && !end_of_list; did = next_did) {
+ next_did = UPCM_DID_GET_NEXT(did);
+ count++;
+ end_of_list = (did == p_tail);
+ }
+ upcm_did_dest_q(p_head, p_tail);
+ g_dl_drop_did_count = count;
+}
+
+void dispatcher_ut_forward_upcm_ul_meta(kal_uint16 start_idx, kal_uint16 end_idx, LHIF_QUEUE_TYPE q_type)
+{
+ /*dispatcher has processed the queue , now can check the processing of meta is expected or not*/
+ kal_uint16 read_idx;
+ kal_uint8 igr_count = 0;
+ kal_uint16 wifi_pdn_meta_cnt = 0;
+ kal_uint16 non_wifi_pdn_meta_cnt = 0;
+ lhif_meta_tbl_t *meta_tbl;
+ lhif_meta_tbl_t *meta;
+ kal_uint16 tbl_size;
+ dispatcher_ut_query_meta_table((kal_uint32 **)&meta_tbl, &tbl_size, q_type);
+ read_idx = start_idx;
+
+ do {
+ meta = &meta_tbl[read_idx];
+ //meta is not ignore & pdn state is bind
+
+ if (meta->ignore) {
+ igr_count ++;
+ }
+
+ read_idx ++;
+ if(read_idx == tbl_size) {
+ read_idx = 0;
+ }
+ }while(read_idx != end_idx);
+ g_ul_total_ignr_count = igr_count;
+
+}
+
+void dispatcher_ut_forward_upcm_ul_gpd(ip_type_e ip_type,
+ kal_uint32 pdn_id,
+ qbm_gpd* p_head,
+ qbm_gpd* p_tail,
+ kal_uint8 protocol_idx)
+{
+ /*dispatcher is going to forward the gpd queue to upcm as PDN ID is not of WIFI*/
+
+ kal_uint8 count = qbmt_dest_q(p_head, p_tail);
+ if (IS_PDNID_OF_WIFI(pdn_id)) {
+ ASSERT(0);
+ }
+ g_ul_upcm_forward_gpd_count = count;
+
+}
+
+
+void dispatcher_ut_forward_upcm_ul_gpd_by_ebi(kal_uint32 ebi, qbm_gpd* p_head, qbm_gpd* p_tail, kal_uint8 protocol_idx)
+{
+ /*dispatcher is going to forward the gpd queue to upcm as PDN ID is not of WIFI*/
+
+ kal_uint8 count = qbmt_dest_q(p_head, p_tail);
+
+ g_ul_upcm_forward_gpd_count = count;
+
+}
+
+void dispatcher_ut_forward_wtunnel_ul_gpd(kal_uint8 bearer_id,
+ qbm_gpd* p_head,
+ qbm_gpd* p_tail,
+ kal_uint8 protocol_idx)
+{
+ /*dispatcher is going to forward the gpd queue to wifi tunnel as PDN ID is of WIFI & bearer active & bind*/
+ kal_uint8 pdn_id = 0;
+ dispatcher_bind_state_enum bind_state;
+ kal_bool is_bearer_active;
+ kal_uint32 forwarded_gpd_count = qbmt_dest_q(p_head, p_tail);
+
+ DISPATCHER_CONVERT_BEARERID_TO_PDNID(bearer_id, pdn_id);
+ bind_state = dispatcher_get_bind_state_by_pdnid(pdn_id, protocol_idx);
+ is_bearer_active = dispatcher_check_is_bearer_active_by_pdnid(pdn_id, protocol_idx);
+ if(!((bind_state == DISPATCHER_PDN_ST_BIND) && (is_bearer_active== KAL_TRUE))) {
+ ASSERT(0);
+ }
+ g_ul_wtunnel_forwarded_gpd_count += forwarded_gpd_count;
+
+}
+
+void dispatcher_ut_drop_ul_gpd(kal_uint32 pdn_id,
+ qbm_gpd* p_head, qbm_gpd* p_tail,
+ kal_uint8 protocol_idx)
+{
+ /*dispatcher is going to drop the gpd queue to bearer not active or unbind*/
+ kal_uint8 count = qbmt_dest_q(p_head, p_tail);
+ dispatcher_bind_state_enum bind_state = dispatcher_get_bind_state_by_pdnid(pdn_id, protocol_idx);
+ kal_bool is_bearer_active = dispatcher_check_is_bearer_active_by_pdnid(pdn_id, protocol_idx);
+ if (!((bind_state != DISPATCHER_PDN_ST_BIND) || (is_bearer_active == KAL_FALSE)))
+ {
+ ASSERT(0);
+ }
+ g_ul_drop_gpd_count = count;
+
+}
+
+void dispatcher_ut_pdn_bind_cnf_handling(n3epc_dispatcher_pdn_bind_cnf_struct* local_para) {
+ g_curr_bind_cnf.cid = local_para->context_id;
+ g_curr_bind_cnf.result = local_para->is_successful;
+ g_curr_bind_cnf.error_code = local_para->error_result;
+}
+
+
+void dispatcher_ut_pdn_unbind_cnf_handling(n3epc_dispatcher_pdn_unbind_cnf_struct* local_para) {
+ g_curr_unbind_cnf.cid = local_para->context_id;
+ g_curr_unbind_cnf.result = local_para->is_successful;
+ g_curr_unbind_cnf.error_code = local_para->error_result;
+}
+
+void dispatcher_ut_handling_n3epc_ilm(ilm_struct *p_ilm) {
+ switch (p_ilm->msg_id) {
+ /*WO<-DISPATCHER bind cnf*/
+ case MSG_ID_N3EPC_DISPATCHER_PDN_BIND_CNF:
+ dispatcher_ut_pdn_bind_cnf_handling((n3epc_dispatcher_pdn_bind_cnf_struct*)p_ilm->local_para_ptr);
+ break;
+ /*WO<-DISPATCHER unbind cnf*/
+ case MSG_ID_N3EPC_DISPATCHER_PDN_UNBIND_CNF:
+ dispatcher_ut_pdn_unbind_cnf_handling((n3epc_dispatcher_pdn_unbind_cnf_struct*)p_ilm->local_para_ptr);
+ break;
+
+ default:
+ break;
+ }
+}
+
+#endif /* ATEST_SYS_DISPATCHER */