| /***************************************************************************** |
| * 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 */ |