| #!/usr/bin/env python3 |
| # |
| # Copyright 2016 - The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import time |
| |
| from queue import Empty |
| from datetime import datetime |
| from acts.controllers.anritsu_lib import band_constants |
| from acts.controllers.anritsu_lib._anritsu_utils import AnritsuUtils |
| from acts.controllers.anritsu_lib.md8475a import BtsNumber |
| from acts.controllers.anritsu_lib.md8475a import BtsNwNameEnable |
| from acts.controllers.anritsu_lib.md8475a import BtsServiceState |
| from acts.controllers.anritsu_lib.md8475a import BtsTechnology |
| from acts.controllers.anritsu_lib.md8475a import CsfbType |
| from acts.controllers.anritsu_lib.md8475a import ImsCscfCall |
| from acts.controllers.anritsu_lib.md8475a import ImsCscfStatus |
| from acts.controllers.anritsu_lib.md8475a import MD8475A |
| from acts.controllers.anritsu_lib.md8475a import ReturnToEUTRAN |
| from acts.controllers.anritsu_lib.md8475a import VirtualPhoneStatus |
| from acts.controllers.anritsu_lib.md8475a import TestProcedure |
| from acts.controllers.anritsu_lib.md8475a import TestPowerControl |
| from acts.controllers.anritsu_lib.md8475a import TestMeasurement |
| from acts.controllers.anritsu_lib.md8475a import Switch |
| from acts.controllers.anritsu_lib.md8475a import BtsPacketRate |
| from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_PHONE |
| from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_REMOTE |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_CALL_DROP |
| from acts_contrib.test_utils.tel.tel_defines import RAT_1XRTT |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_LONG |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_FOR_IMS |
| from acts_contrib.test_utils.tel.tel_defines import EventCmasReceived |
| from acts_contrib.test_utils.tel.tel_defines import EventEtwsReceived |
| from acts_contrib.test_utils.tel.tel_defines import EventSmsDeliverSuccess |
| from acts_contrib.test_utils.tel.tel_defines import EventSmsSentSuccess |
| from acts_contrib.test_utils.tel.tel_defines import EventSmsReceived |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_phone_idle |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_droid_not_in_call |
| from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call |
| from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call |
| from acts_contrib.test_utils.tel.tel_voice_utils import wait_and_answer_call |
| |
| # Timers |
| # Time to wait after registration before sending a command to Anritsu |
| # to ensure the phone has sufficient time to reconfigure based on new |
| # network in Anritsu |
| WAIT_TIME_ANRITSU_REG_AND_OPER = 10 |
| # Time to wait after registration to ensure the phone |
| # has sufficient time to reconfigure based on new network in Anritsu |
| WAIT_TIME_ANRITSU_REG_AND_CALL = 10 |
| # Max time to wait for Anritsu's virtual phone state change |
| MAX_WAIT_TIME_VIRTUAL_PHONE_STATE = 45 |
| # Time to wait for Anritsu's IMS CSCF state change |
| MAX_WAIT_TIME_IMS_CSCF_STATE = 30 |
| # Time to wait for before aSRVCC |
| WAIT_TIME_IN_ALERT = 5 |
| |
| # SIM card names |
| P0250Ax = "P0250Ax" |
| VzW12349 = "VzW12349" |
| P0135Ax = "P0135Ax" |
| FiTMO = "FiTMO" |
| FiSPR = "FiSPR" |
| FiUSCC = "FiUSCC" |
| |
| # Test PLMN information |
| TEST_PLMN_LTE_NAME = "MD8475A_LTE" |
| TEST_PLMN_WCDMA_NAME = "MD8475A_WCDMA" |
| TEST_PLMN_GSM_NAME = "MD8475A_GSM" |
| TEST_PLMN_1X_NAME = "MD8475A_1X" |
| TEST_PLMN_1_MCC = "001" |
| TEST_PLMN_1_MNC = "01" |
| DEFAULT_MCC = "310" |
| DEFAULT_MNC = "260" |
| DEFAULT_RAC = 1 |
| DEFAULT_LAC = 1 |
| VzW_MCC = "311" |
| VzW_MNC = "480" |
| TMO_MCC = "310" |
| TMO_MNC = "260" |
| Fi_TMO_MCC = "310" |
| Fi_TMO_MNC = "260" |
| Fi_SPR_MCC = "310" |
| Fi_SPR_MNC = "120" |
| Fi_USCC_MCC = "311" |
| Fi_USCC_MNC = "580" |
| |
| # IP address information for internet sharing |
| #GATEWAY_IPV4_ADDR = "192.168.137.1" |
| #UE_IPV4_ADDR_1 = "192.168.137.2" |
| #UE_IPV4_ADDR_2 = "192.168.137.3" |
| #UE_IPV4_ADDR_3 = "192.168.137.4" |
| #DNS_IPV4_ADDR = "192.168.137.1" |
| #CSCF_IPV4_ADDR = "192.168.137.1" |
| |
| # Default IP address in Smart Studio, work for Internet Sharing with and |
| # without WLAN ePDG server. Remember to add 192.168.1.2 to Ethernet 0 |
| # on MD8475A after turn on Windows' Internet Coonection Sharing |
| GATEWAY_IPV4_ADDR = "192.168.1.2" |
| UE_IPV4_ADDR_1 = "192.168.1.1" |
| UE_IPV4_ADDR_2 = "192.168.1.11" |
| UE_IPV4_ADDR_3 = "192.168.1.21" |
| UE_IPV6_ADDR_1 = "2001:0:0:1::1" |
| UE_IPV6_ADDR_2 = "2001:0:0:2::1" |
| UE_IPV6_ADDR_3 = "2001:0:0:3::1" |
| DNS_IPV4_ADDR = "192.168.1.12" |
| CSCF_IPV4_ADDR = "192.168.1.2" |
| CSCF_IPV6_ADDR = "2001:0:0:1::2" |
| CSCF_IPV6_ADDR_2 = "2001:0:0:2::2" |
| CSCF_IPV6_ADDR_3 = "2001:0:0:3::2" |
| |
| # Google Fi IP Config: |
| |
| Fi_GATEWAY_IPV4_ADDR_Data = "100.107.235.94" |
| Fi_GATEWAY_IPV6_ADDR_Data = "fe80::aef2:c5ff:fe71:4b9" |
| Fi_GATEWAY_IPV4_ADDR_IMS_911 = "192.168.1.2" |
| Fi_GATEWAY_IPV6_ADDR_IMS_911 = "2001:0:0:1::2" |
| |
| Fi_UE_IPV4_ADDR_Data = "100.107.235.81" |
| Fi_UE_IPV4_ADDR_IMS = "192.168.1.1" |
| Fi_UE_IPV4_ADDR_911 = "192.168.1.11" |
| Fi_UE_IPV6_ADDR_Data = "2620::1000:1551:1140:c0f9:d6a8:44eb" |
| Fi_UE_IPV6_ADDR_IMS = "2001:0:0:1::1" |
| Fi_UE_IPV6_ADDR_911 = "2001:0:0:2::1" |
| |
| Fi_DNS_IPV4_ADDR_Pri = "8.8.8.8" |
| Fi_DNS_IPV4_ADDR_Sec = "8.8.8.4" |
| Fi_DNS_IPV6_ADDR = "2001:4860:4860::8888" |
| |
| Fi_CSCF_IPV4_ADDR_Data = "192.168.1.2" |
| Fi_CSCF_IPV6_ADDR_Data = "2001:0:0:1::2" |
| Fi_CSCF_IPV4_ADDR_IMS = "192.168.1.2" |
| Fi_CSCF_IPV6_ADDR_IMS = "2001:0:0:1::3" |
| Fi_CSCF_IPV4_ADDR_911 = "192.168.1.12" |
| Fi_CSCF_IPV6_ADDR_911 = "2001:0:0:2::2" |
| |
| # Default Cell Parameters |
| DEFAULT_OUTPUT_LEVEL = -30 |
| DEFAULT_1X_OUTPUT_LEVEL = -35 |
| DEFAULT_INPUT_LEVEL = 0 |
| DEFAULT_LTE_BAND = [2, 4] |
| Fi_LTE_TMO_BAND = [4] |
| Fi_LTE_SPR_BAND = [25] |
| Fi_LTE_USCC_BAND = [12] |
| Fi_GSM_TMO_BAND = band_constants.GSM_BAND_PGSM900 |
| DEFAULT_WCDMA_BAND = 1 |
| DEFAULT_WCDMA_PACKET_RATE = BtsPacketRate.WCDMA_DLHSAUTO_REL7_ULHSAUTO |
| DEFAULT_GSM_BAND = band_constants.GSM_BAND_GSM850 |
| |
| #Google Fi CDMA Bands |
| |
| Fi_USCC1X_MCC = 209 |
| Fi_USCC1X_BAND = 1 |
| Fi_USCC1X_CH = 600 |
| Fi_USCC1X_SID = 5 |
| Fi_USCC1X_NID = 21 |
| |
| Fi_SPR1X_MCC = 320 |
| Fi_SPR1X_BAND = 1 |
| Fi_SPR1X_CH = 600 |
| Fi_SPR1X_SID = 4183 |
| Fi_SPR1X_NID = 233 |
| |
| Fi_EVDO_BAND = 1 |
| Fi_EVDO_CH = 625 |
| Fi_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000" |
| |
| DEFAULT_CDMA1X_BAND = 0 |
| DEFAULT_CDMA1X_CH = 356 |
| DEFAULT_CDMA1X_SID = 0 |
| DEFAULT_CDMA1X_NID = 65535 |
| DEFAULT_EVDO_BAND = 0 |
| DEFAULT_EVDO_CH = 356 |
| DEFAULT_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000" |
| VzW_CDMA1x_BAND = 1 |
| VzW_CDMA1x_CH = 150 |
| VzW_CDMA1X_SID = 26 |
| VzW_CDMA1X_NID = 65535 |
| VzW_EVDO_BAND = 0 |
| VzW_EVDO_CH = 384 |
| VzW_EVDO_SECTOR_ID = "12345678,00000000,00000000,00000000" |
| DEFAULT_T_MODE = "TM1" |
| DEFAULT_DL_ANTENNA = 1 |
| |
| # CMAS Message IDs |
| CMAS_MESSAGE_PRESIDENTIAL_ALERT = hex(0x1112) |
| CMAS_MESSAGE_EXTREME_IMMEDIATE_OBSERVED = hex(0x1113) |
| CMAS_MESSAGE_EXTREME_IMMEDIATE_LIKELY = hex(0x1114) |
| CMAS_MESSAGE_EXTREME_EXPECTED_OBSERVED = hex(0x1115) |
| CMAS_MESSAGE_EXTREME_EXPECTED_LIKELY = hex(0x1116) |
| CMAS_MESSAGE_SEVERE_IMMEDIATE_OBSERVED = hex(0x1117) |
| CMAS_MESSAGE_SEVERE_IMMEDIATE_LIKELY = hex(0x1118) |
| CMAS_MESSAGE_SEVERE_EXPECTED_OBSERVED = hex(0x1119) |
| CMAS_MESSAGE_SEVERE_EXPECTED_LIKELY = hex(0x111A) |
| CMAS_MESSAGE_CHILD_ABDUCTION_EMERGENCY = hex(0x111B) |
| CMAS_MESSAGE_MONTHLY_TEST = hex(0x111C) |
| CMAS_MESSAGE_CMAS_EXECERCISE = hex(0x111D) |
| |
| # ETWS Message IDs |
| ETWS_WARNING_EARTHQUAKE = hex(0x1100) |
| ETWS_WARNING_TSUNAMI = hex(0x1101) |
| ETWS_WARNING_EARTHQUAKETSUNAMI = hex(0x1102) |
| ETWS_WARNING_TEST_MESSAGE = hex(0x1103) |
| ETWS_WARNING_OTHER_EMERGENCY = hex(0x1104) |
| |
| # C2K CMAS Message Constants |
| CMAS_C2K_CATEGORY_PRESIDENTIAL = "Presidential" |
| CMAS_C2K_CATEGORY_EXTREME = "Extreme" |
| CMAS_C2K_CATEGORY_SEVERE = "Severe" |
| CMAS_C2K_CATEGORY_AMBER = "AMBER" |
| CMAS_C2K_CATEGORY_CMASTEST = "CMASTest" |
| |
| CMAS_C2K_PRIORITY_NORMAL = "Normal" |
| CMAS_C2K_PRIORITY_INTERACTIVE = "Interactive" |
| CMAS_C2K_PRIORITY_URGENT = "Urgent" |
| CMAS_C2K_PRIORITY_EMERGENCY = "Emergency" |
| |
| CMAS_C2K_RESPONSETYPE_SHELTER = "Shelter" |
| CMAS_C2K_RESPONSETYPE_EVACUATE = "Evacuate" |
| CMAS_C2K_RESPONSETYPE_PREPARE = "Prepare" |
| CMAS_C2K_RESPONSETYPE_EXECUTE = "Execute" |
| CMAS_C2K_RESPONSETYPE_MONITOR = "Monitor" |
| CMAS_C2K_RESPONSETYPE_AVOID = "Avoid" |
| CMAS_C2K_RESPONSETYPE_ASSESS = "Assess" |
| CMAS_C2K_RESPONSETYPE_NONE = "None" |
| |
| CMAS_C2K_SEVERITY_EXTREME = "Extreme" |
| CMAS_C2K_SEVERITY_SEVERE = "Severe" |
| |
| CMAS_C2K_URGENCY_IMMEDIATE = "Immediate" |
| CMAS_C2K_URGENCY_EXPECTED = "Expected" |
| |
| CMAS_C2K_CERTIANTY_OBSERVED = "Observed" |
| CMAS_C2K_CERTIANTY_LIKELY = "Likely" |
| |
| #PDN Numbers |
| PDN_NO_1 = 1 |
| PDN_NO_2 = 2 |
| PDN_NO_3 = 3 |
| PDN_NO_4 = 4 |
| PDN_NO_5 = 5 |
| |
| # IMS Services parameters |
| DEFAULT_VNID = 1 |
| NDP_NIC_NAME = '"Intel(R) 82577LM Gigabit Network Connection"' |
| CSCF_Monitoring_UA_URI = '"sip:+11234567890@test.3gpp.com"' |
| TMO_CSCF_Monitoring_UA_URI = '"sip:001010123456789@msg.lab.t-mobile.com"' |
| CSCF_Virtual_UA_URI = '"sip:+11234567891@test.3gpp.com"' |
| TMO_CSCF_Virtual_UA_URI = '"sip:0123456789@ims.mnc01.mcc001.3gppnetwork.org"' |
| CSCF_HOSTNAME = '"ims.mnc01.mcc001.3gppnetwork.org"' |
| TMO_USERLIST_NAME = "310260123456789@msg.lab.t-mobile.com" |
| VZW_USERLIST_NAME = "001010123456789@test.3gpp.com" |
| |
| # Google Fi IMS Services parameters |
| Fi_CSCF_Monitoring_UA_URI = '"sip:310260971239432@ims.mnc260.mcc310.3gppnetwork.org"' |
| Fi_CSCF_Virtual_UA_URI = '"sip:0123456789@msg.pc.t-mobile.com"' |
| Fi_CSCF_HOSTNAME = '"ims.mnc260.mcc310.3gppnetwork.org"' |
| Fi_USERLIST_NAME = "310260971239432@msg.pc.t-mobile.com" |
| |
| #Cell Numbers |
| CELL_1 = 1 |
| CELL_2 = 2 |
| |
| # default ims virtual network id for Anritsu ims call test. |
| DEFAULT_IMS_VIRTUAL_NETWORK_ID = 1 |
| |
| def cb_serial_number(): |
| """ CMAS/ETWS serial number generator """ |
| i = 0x3000 |
| while True: |
| yield i |
| i += 1 |
| |
| |
| def set_usim_parameters(anritsu_handle, sim_card): |
| """ set USIM parameters in MD8475A simulationn parameter |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| sim_card : "P0250Ax" or "12349" |
| |
| Returns: |
| None |
| """ |
| if sim_card == P0250Ax: |
| anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F" |
| elif sim_card == P0135Ax: |
| anritsu_handle.usim_key = "00112233445566778899AABBCCDDEEFF" |
| elif sim_card == VzW12349: |
| anritsu_handle.usim_key = "465B5CE8B199B49FAA5F0A2EE238A6BC" |
| anritsu_handle.send_command("IMSI 311480012345678") |
| anritsu_handle.send_command("SECURITY3G MILENAGE") |
| anritsu_handle.send_command( |
| "MILENAGEOP 5F1D289C5D354D0A140C2548F5F3E3BA") |
| elif sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F" |
| |
| |
| def save_anritsu_log_files(anritsu_handle, test_name, user_params): |
| """ saves the anritsu smart studio log files |
| The logs should be saved in Anritsu system. Need to provide |
| log folder path in Anritsu system |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| test_name: test case name |
| user_params : user supplied parameters list |
| |
| Returns: |
| None |
| """ |
| md8475a_log_folder = user_params["anritsu_log_file_path"] |
| file_name = getfilenamewithtimestamp(test_name) |
| seq_logfile = "{}\\{}_seq.csv".format(md8475a_log_folder, file_name) |
| msg_logfile = "{}\\{}_msg.csv".format(md8475a_log_folder, file_name) |
| trace_logfile = "{}\\{}_trace.lgex".format(md8475a_log_folder, file_name) |
| anritsu_handle.save_sequence_log(seq_logfile) |
| anritsu_handle.save_message_log(msg_logfile) |
| anritsu_handle.save_trace_log(trace_logfile, "BINARY", 1, 0, 0) |
| anritsu_handle.clear_sequence_log() |
| anritsu_handle.clear_message_log() |
| |
| |
| def getfilenamewithtimestamp(test_name): |
| """ Gets the test name appended with current time |
| |
| Args: |
| test_name : test case name |
| |
| Returns: |
| string of test name appended with current time |
| """ |
| time_stamp = datetime.now().strftime("%m-%d-%Y_%H-%M-%S") |
| return "{}_{}".format(test_name, time_stamp) |
| |
| |
| def _init_lte_bts(bts, user_params, cell_no, sim_card): |
| """ initializes the LTE BTS |
| All BTS parameters should be set here |
| |
| Args: |
| bts: BTS object. |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| None |
| """ |
| bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE |
| bts.nw_fullname = TEST_PLMN_LTE_NAME |
| bts.mcc = get_lte_mcc(user_params, cell_no, sim_card) |
| bts.mnc = get_lte_mnc(user_params, cell_no, sim_card) |
| bts.band = get_lte_band(user_params, cell_no, sim_card) |
| bts.transmode = get_transmission_mode(user_params, cell_no) |
| bts.dl_antenna = get_dl_antenna(user_params, cell_no) |
| bts.output_level = DEFAULT_OUTPUT_LEVEL |
| bts.input_level = DEFAULT_INPUT_LEVEL |
| |
| |
| def _init_wcdma_bts(bts, user_params, cell_no, sim_card): |
| """ initializes the WCDMA BTS |
| All BTS parameters should be set here |
| |
| Args: |
| bts: BTS object. |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| None |
| """ |
| bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE |
| bts.nw_fullname = TEST_PLMN_WCDMA_NAME |
| bts.mcc = get_wcdma_mcc(user_params, cell_no, sim_card) |
| bts.mnc = get_wcdma_mnc(user_params, cell_no, sim_card) |
| bts.band = get_wcdma_band(user_params, cell_no) |
| bts.rac = get_wcdma_rac(user_params, cell_no) |
| bts.lac = get_wcdma_lac(user_params, cell_no) |
| bts.output_level = DEFAULT_OUTPUT_LEVEL |
| bts.input_level = DEFAULT_INPUT_LEVEL |
| bts.packet_rate = DEFAULT_WCDMA_PACKET_RATE |
| |
| |
| def _init_gsm_bts(bts, user_params, cell_no, sim_card): |
| """ initializes the GSM BTS |
| All BTS parameters should be set here |
| |
| Args: |
| bts: BTS object. |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| None |
| """ |
| bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE |
| bts.nw_fullname = TEST_PLMN_GSM_NAME |
| bts.mcc = get_gsm_mcc(user_params, cell_no, sim_card) |
| bts.mnc = get_gsm_mnc(user_params, cell_no, sim_card) |
| bts.band = get_gsm_band(user_params, cell_no, sim_card) |
| bts.rac = get_gsm_rac(user_params, cell_no) |
| bts.lac = get_gsm_lac(user_params, cell_no) |
| bts.output_level = DEFAULT_OUTPUT_LEVEL |
| bts.input_level = DEFAULT_INPUT_LEVEL |
| |
| |
| def _init_1x_bts(bts, user_params, cell_no, sim_card): |
| """ initializes the 1X BTS |
| All BTS parameters should be set here |
| |
| Args: |
| bts: BTS object. |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| None |
| """ |
| bts.sector1_mcc = get_1x_mcc(user_params, cell_no, sim_card) |
| bts.band = get_1x_band(user_params, cell_no, sim_card) |
| bts.dl_channel = get_1x_channel(user_params, cell_no, sim_card) |
| bts.sector1_sid = get_1x_sid(user_params, cell_no, sim_card) |
| bts.sector1_nid = get_1x_nid(user_params, cell_no, sim_card) |
| bts.output_level = DEFAULT_1X_OUTPUT_LEVEL |
| |
| |
| def _init_evdo_bts(bts, user_params, cell_no, sim_card): |
| """ initializes the EVDO BTS |
| All BTS parameters should be set here |
| |
| Args: |
| bts: BTS object. |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| None |
| """ |
| bts.band = get_evdo_band(user_params, cell_no, sim_card) |
| bts.dl_channel = get_evdo_channel(user_params, cell_no, sim_card) |
| bts.evdo_sid = get_evdo_sid(user_params, cell_no, sim_card) |
| bts.output_level = DEFAULT_1X_OUTPUT_LEVEL |
| |
| |
| def _init_PDN(anritsu_handle, |
| sim_card, |
| pdn, |
| ipv4, |
| ipv6, |
| ims_binding, |
| vnid_number=DEFAULT_VNID): |
| """ initializes the PDN parameters |
| All PDN parameters should be set here |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| pdn: pdn object |
| ip_address : UE IP address |
| ims_binding: to bind with IMS VNID(1) or not |
| |
| Returns: |
| None |
| """ |
| # Setting IP address for internet connection sharing |
| # Google Fi _init_PDN |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn.ue_address_ipv4 = ipv4 |
| pdn.ue_address_ipv6 = ipv6 |
| if ims_binding: |
| pdn.pdn_ims = Switch.ENABLE |
| pdn.pdn_vnid = vnid_number |
| pdn.pdn_DG_selection = 'USER' |
| pdn.pdn_gateway_ipv4addr = Fi_GATEWAY_IPV4_ADDR_IMS_911 |
| pdn.pdn_gateway_ipv6addr = Fi_GATEWAY_IPV6_ADDR_IMS_911 |
| |
| else: |
| anritsu_handle.gateway_ipv4addr = Fi_GATEWAY_IPV4_ADDR_Data |
| anritsu_handle.gateway_ipv6addr = Fi_GATEWAY_IPV6_ADDR_Data |
| pdn.primary_dns_address_ipv4 = Fi_DNS_IPV4_ADDR_Pri |
| pdn.secondary_dns_address_ipv4 = Fi_DNS_IPV4_ADDR_Sec |
| pdn.dns_address_ipv6 = Fi_DNS_IPV6_ADDR |
| pdn.cscf_address_ipv4 = Fi_CSCF_IPV4_ADDR_Data |
| pdn.cscf_address_ipv6 = Fi_CSCF_IPV6_ADDR_Data |
| # Pixel Lab _init_PDN_ |
| else: |
| anritsu_handle.gateway_ipv4addr = GATEWAY_IPV4_ADDR |
| pdn.ue_address_ipv4 = ipv4 |
| pdn.ue_address_ipv6 = ipv6 |
| if ims_binding: |
| pdn.pdn_ims = Switch.ENABLE |
| pdn.pdn_vnid = vnid_number |
| else: |
| pdn.primary_dns_address_ipv4 = DNS_IPV4_ADDR |
| pdn.secondary_dns_address_ipv4 = DNS_IPV4_ADDR |
| pdn.cscf_address_ipv4 = CSCF_IPV4_ADDR |
| |
| |
| def _init_IMS(anritsu_handle, |
| vnid, |
| sim_card=None, |
| ipv4_address=CSCF_IPV4_ADDR, |
| ipv6_address=CSCF_IPV6_ADDR, |
| ip_type="IPV4V6", |
| auth=False): |
| """ initializes the IMS VNID parameters |
| All IMS parameters should be set here |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| vnid: IMS Services object |
| |
| Returns: |
| None |
| """ |
| # vnid.sync = Switch.ENABLE # supported in 6.40a release |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| vnid.cscf_address_ipv4 = ipv4_address |
| vnid.cscf_address_ipv6 = ipv6_address |
| vnid.imscscf_iptype = ip_type |
| vnid.dns = Switch.DISABLE |
| vnid.ndp_nic = NDP_NIC_NAME |
| vnid.ndp_prefix = ipv6_address |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| vnid.cscf_monitoring_ua = Fi_CSCF_Monitoring_UA_URI |
| vnid.cscf_virtual_ua = Fi_CSCF_Virtual_UA_URI |
| vnid.cscf_host_name = Fi_CSCF_HOSTNAME |
| vnid.cscf_ims_authentication = "ENABLE" |
| if auth: |
| vnid.cscf_ims_authentication = "ENABLE" |
| vnid.fi_cscf_userslist_add = Fi_USERLIST_NAME |
| else: |
| vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI |
| vnid.psap = Switch.ENABLE |
| vnid.psap_auto_answer = Switch.ENABLE |
| else: |
| vnid.cscf_address_ipv4 = CSCF_IPV4_ADDR |
| vnid.cscf_address_ipv6 = ipv6_address |
| vnid.imscscf_iptype = ip_type |
| vnid.dns = Switch.DISABLE |
| vnid.ndp_nic = NDP_NIC_NAME |
| vnid.ndp_prefix = ipv6_address |
| if sim_card == P0135Ax: |
| vnid.cscf_monitoring_ua = TMO_CSCF_Monitoring_UA_URI |
| vnid.cscf_virtual_ua = TMO_CSCF_Virtual_UA_URI |
| vnid.cscf_host_name = CSCF_HOSTNAME |
| vnid.cscf_precondition = "ENABLE" |
| vnid.cscf_ims_authentication = "DISABLE" |
| if auth: |
| vnid.cscf_ims_authentication = "ENABLE" |
| vnid.tmo_cscf_userslist_add = TMO_USERLIST_NAME |
| elif sim_card == VzW12349: |
| vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI |
| vnid.cscf_virtual_ua = CSCF_Virtual_UA_URI |
| vnid.cscf_ims_authentication = "DISABLE" |
| if auth: |
| vnid.cscf_ims_authentication = "ENABLE" |
| vnid.vzw_cscf_userslist_add = VZW_USERLIST_NAME |
| else: |
| vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI |
| vnid.psap = Switch.ENABLE |
| vnid.psap_auto_answer = Switch.ENABLE |
| |
| |
| def set_system_model_lte_lte(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for LTE and LTE simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte and Wcdma BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.LTE, |
| BtsTechnology.LTE) |
| # setting BTS parameters |
| lte1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| lte2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_lte_bts(lte1_bts, user_params, CELL_1, sim_card) |
| _init_lte_bts(lte2_bts, user_params, CELL_2, sim_card) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| pdn4 = anritsu_handle.get_PDN(PDN_NO_4) |
| pdn5 = anritsu_handle.get_PDN(PDN_NO_5) |
| |
| # Initialize PDN IP address for internet connection sharing |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS, |
| Fi_UE_IPV6_ADDR_IMS, |
| True) |
| _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911, |
| Fi_UE_IPV6_ADDR_911, |
| True) |
| vnid1 = anritsu_handle.get_IMS(1) |
| vnid2 = anritsu_handle.get_IMS(2) |
| # _init_IMS( |
| # anritsu_handle, |
| # vnid1, |
| # sim_card, |
| # ipv4_address=CSCF_IPV4_ADDR, |
| # ipv6_address=CSCF_IPV6_ADDR, |
| # auth=False) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_IMS, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_IMS, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_911, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_911, |
| auth=False) |
| else: |
| _init_lte_bts(lte1_bts, user_params, CELL_1, sim_card) |
| _init_lte_bts(lte2_bts, user_params, CELL_2, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| # Initialize PDN IP address for internet connection sharing |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True) |
| _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True) |
| vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID) |
| if sim_card == P0135Ax: |
| vnid2 = anritsu_handle.get_IMS(2) |
| vnid3 = anritsu_handle.get_IMS(3) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_2, |
| ip_type="IPV6") |
| _init_IMS( |
| anritsu_handle, |
| vnid3, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_3, |
| ip_type="IPV6") |
| elif sim_card == VzW12349: |
| _init_IMS(anritsu_handle, vnid1, sim_card, auth=True) |
| else: |
| _init_IMS(anritsu_handle, vnid1, sim_card) |
| return [lte1_bts, lte2_bts] |
| |
| |
| def set_system_model_wcdma_wcdma(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for WCDMA and WCDMA simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte and Wcdma BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.WCDMA, |
| BtsTechnology.WCDMA) |
| # setting BTS parameters |
| wcdma1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| wcdma2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_wcdma_bts(wcdma1_bts, user_params, CELL_1, sim_card) |
| _init_wcdma_bts(wcdma2_bts, user_params, CELL_2, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, Fi_UE_IPV6_ADDR_Data, |
| False) |
| else: |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [wcdma1_bts, wcdma2_bts] |
| |
| |
| def set_system_model_lte_wcdma(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for LTE and WCDMA simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte and Wcdma BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.WCDMA) |
| # setting BTS parameters |
| lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_lte_bts(lte_bts, user_params, CELL_1, sim_card) |
| _init_wcdma_bts(wcdma_bts, user_params, CELL_2, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| pdn4 = anritsu_handle.get_PDN(PDN_NO_4) |
| pdn5 = anritsu_handle.get_PDN(PDN_NO_5) |
| # Initialize PDN IP address. |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS, |
| Fi_UE_IPV6_ADDR_IMS, |
| True) |
| _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911, |
| Fi_UE_IPV6_ADDR_911, |
| True) |
| vnid1 = anritsu_handle.get_IMS(1) |
| vnid2 = anritsu_handle.get_IMS(2) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_IMS, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_IMS, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_911, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_911, |
| auth=False) |
| return [lte_bts, wcdma_bts] |
| else: |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True) |
| _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True) |
| vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID) |
| if sim_card == P0135Ax: |
| vnid2 = anritsu_handle.get_IMS(2) |
| vnid3 = anritsu_handle.get_IMS(3) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_2, |
| ip_type="IPV6") |
| _init_IMS( |
| anritsu_handle, |
| vnid3, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_3, |
| ip_type="IPV6") |
| elif sim_card == VzW12349: |
| _init_IMS(anritsu_handle, vnid1, sim_card, auth=True) |
| else: |
| _init_IMS(anritsu_handle, vnid1, sim_card) |
| return [lte_bts, wcdma_bts] |
| |
| |
| def set_system_model_lte_gsm(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for LTE and GSM simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte and Wcdma BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.GSM) |
| # setting BTS parameters |
| lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_lte_bts(lte_bts, user_params, CELL_1, sim_card) |
| _init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| pdn4 = anritsu_handle.get_PDN(PDN_NO_4) |
| pdn5 = anritsu_handle.get_PDN(PDN_NO_5) |
| # Initialize PDN IP address. |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS, |
| Fi_UE_IPV6_ADDR_IMS, |
| True) |
| _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911, |
| Fi_UE_IPV6_ADDR_911, |
| True) |
| vnid1 = anritsu_handle.get_IMS(1) |
| vnid2 = anritsu_handle.get_IMS(2) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_IMS, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_IMS, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_911, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_911, |
| auth=False) |
| return [lte_bts, gsm_bts] |
| else: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| # Initialize PDN IP address for internet connection sharing |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True) |
| _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True) |
| vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID) |
| if sim_card == P0135Ax: |
| vnid2 = anritsu_handle.get_IMS(2) |
| vnid3 = anritsu_handle.get_IMS(3) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_2, |
| ip_type="IPV6") |
| _init_IMS( |
| anritsu_handle, |
| vnid3, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_3, |
| ip_type="IPV6") |
| elif sim_card == VzW12349: |
| _init_IMS(anritsu_handle, vnid1, sim_card, auth=True) |
| else: |
| _init_IMS(anritsu_handle, vnid1, sim_card) |
| return [lte_bts, gsm_bts] |
| |
| |
| def set_system_model_lte_1x(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for LTE and 1x simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte and 1x BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.LTE, |
| BtsTechnology.CDMA1X) |
| # setting BTS parameters |
| lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_lte_bts(lte_bts, user_params, CELL_1, sim_card) |
| _init_1x_bts(cdma1x_bts, user_params, CELL_2, sim_card) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| pdn4 = anritsu_handle.get_PDN(PDN_NO_4) |
| pdn5 = anritsu_handle.get_PDN(PDN_NO_5) |
| # Initialize PDN IP address. |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS, |
| Fi_UE_IPV6_ADDR_IMS, |
| True) |
| _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911, |
| Fi_UE_IPV6_ADDR_911, |
| True) |
| vnid1 = anritsu_handle.get_IMS(1) |
| vnid2 = anritsu_handle.get_IMS(2) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_IMS, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_IMS, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_911, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_911, |
| auth=False) |
| return [lte_bts, cdma1x_bts] |
| else: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| # Initialize PDN IP address for internet connection sharing |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True) |
| _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True) |
| vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID) |
| if sim_card == P0135Ax: |
| vnid2 = anritsu_handle.get_IMS(2) |
| vnid3 = anritsu_handle.get_IMS(3) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_2, |
| ip_type="IPV6") |
| _init_IMS( |
| anritsu_handle, |
| vnid3, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_3, |
| ip_type="IPV6") |
| elif sim_card == VzW12349: |
| _init_IMS(anritsu_handle, vnid1, sim_card, auth=True) |
| else: |
| _init_IMS(anritsu_handle, vnid1, sim_card) |
| return [lte_bts, cdma1x_bts] |
| |
| |
| def set_system_model_lte_evdo(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for LTE and EVDO simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte and 1x BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.EVDO) |
| # setting BTS parameters |
| lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_lte_bts(lte_bts, user_params, CELL_1, sim_card) |
| _init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| pdn4 = anritsu_handle.get_PDN(PDN_NO_4) |
| pdn5 = anritsu_handle.get_PDN(PDN_NO_5) |
| # Initialize PDN IP address. |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS, |
| Fi_UE_IPV6_ADDR_IMS, |
| True) |
| _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911, |
| Fi_UE_IPV6_ADDR_911, |
| True) |
| vnid1 = anritsu_handle.get_IMS(1) |
| vnid2 = anritsu_handle.get_IMS(2) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_IMS, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_IMS, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_911, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_911, |
| auth=False) |
| return [lte_bts, evdo_bts] |
| else: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| # Initialize PDN IP address for internet connection sharing |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True) |
| _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False) |
| _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True) |
| vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID) |
| if sim_card == P0135Ax: |
| vnid2 = anritsu_handle.get_IMS(2) |
| vnid3 = anritsu_handle.get_IMS(3) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_2, |
| ip_type="IPV6") |
| _init_IMS( |
| anritsu_handle, |
| vnid3, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_3, |
| ip_type="IPV6") |
| elif sim_card == VzW12349: |
| _init_IMS(anritsu_handle, vnid1, sim_card, auth=True) |
| else: |
| _init_IMS(anritsu_handle, vnid1, sim_card) |
| return [lte_bts, evdo_bts] |
| |
| |
| def set_system_model_wcdma_gsm(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for WCDMA and GSM simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Wcdma and Gsm BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.WCDMA, BtsTechnology.GSM) |
| # setting BTS parameters |
| wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card) |
| _init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| else: |
| _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [wcdma_bts, gsm_bts] |
| |
| |
| def set_system_model_gsm_gsm(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for GSM and GSM simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Wcdma and Gsm BTS objects |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.GSM, BtsTechnology.GSM) |
| # setting BTS parameters |
| gsm1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| gsm2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_gsm_bts(gsm1_bts, user_params, CELL_1, sim_card) |
| _init_gsm_bts(gsm2_bts, user_params, CELL_2, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| else: |
| _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [gsm1_bts, gsm2_bts] |
| |
| |
| def set_system_model_lte(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for LTE simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Lte BTS object |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.LTE) |
| # setting Fi BTS parameters |
| lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| _init_lte_bts(lte_bts, user_params, CELL_1, sim_card) |
| |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| pdn4 = anritsu_handle.get_PDN(PDN_NO_4) |
| pdn5 = anritsu_handle.get_PDN(PDN_NO_5) |
| # Initialize PDN IP address. |
| _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle,sim_card, pdn2, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle,sim_card, pdn3, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS, |
| Fi_UE_IPV6_ADDR_IMS, |
| True) |
| _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911, |
| Fi_UE_IPV6_ADDR_911, |
| True) |
| vnid1 = anritsu_handle.get_IMS(1) |
| vnid2 = anritsu_handle.get_IMS(2) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_IMS, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_IMS, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv4_address=Fi_CSCF_IPV4_ADDR_911, |
| ipv6_address=Fi_CSCF_IPV6_ADDR_911, |
| auth=False) |
| return [lte_bts] |
| else: |
| # setting BTS parameters |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| pdn2 = anritsu_handle.get_PDN(PDN_NO_2) |
| pdn3 = anritsu_handle.get_PDN(PDN_NO_3) |
| # Initialize PDN IP address for internet connection sharing |
| _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True) |
| _init_PDN(anritsu_handle,sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False) |
| _init_PDN(anritsu_handle,sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True) |
| vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID) |
| if sim_card == P0135Ax: |
| vnid2 = anritsu_handle.get_IMS(2) |
| vnid3 = anritsu_handle.get_IMS(3) |
| _init_IMS( |
| anritsu_handle, |
| vnid1, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR, |
| auth=True) |
| _init_IMS( |
| anritsu_handle, |
| vnid2, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_2, |
| ip_type="IPV6") |
| _init_IMS( |
| anritsu_handle, |
| vnid3, |
| sim_card, |
| ipv6_address=CSCF_IPV6_ADDR_3, |
| ip_type="IPV6") |
| elif sim_card == VzW12349: |
| _init_IMS(anritsu_handle, vnid1, sim_card, auth=True) |
| else: |
| _init_IMS(anritsu_handle, vnid1, sim_card) |
| return [lte_bts] |
| |
| |
| def set_system_model_wcdma(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for WCDMA simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Wcdma BTS object |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.WCDMA) |
| # setting BTS parameters |
| wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| _init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| else: |
| _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [wcdma_bts] |
| |
| |
| def set_system_model_gsm(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for GSM simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Gsm BTS object |
| """ |
| anritsu_handle.set_simulation_model(BtsTechnology.GSM) |
| # setting BTS parameters |
| gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| _init_gsm_bts(gsm_bts, user_params, CELL_1, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_NO_1) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| else: |
| _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [gsm_bts] |
| |
| |
| def set_system_model_1x(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for CDMA 1X simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Cdma 1x BTS object |
| """ |
| PDN_ONE = 1 |
| anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X) |
| # setting BTS parameters |
| cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| _init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_ONE) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| else: |
| _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [cdma1x_bts] |
| |
| |
| def set_system_model_1x_evdo(anritsu_handle, user_params, sim_card): |
| """ Configures Anritsu system for CDMA 1X simulation |
| |
| Args: |
| anritsu_handle: anritusu device object. |
| user_params: pointer to user supplied parameters |
| |
| Returns: |
| Cdma 1x BTS object |
| """ |
| PDN_ONE = 1 |
| anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X, |
| BtsTechnology.EVDO) |
| # setting BTS parameters |
| cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1) |
| evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2) |
| _init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card) |
| _init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card) |
| pdn1 = anritsu_handle.get_PDN(PDN_ONE) |
| # Initialize PDN IP address for internet connection sharing |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, |
| Fi_UE_IPV6_ADDR_Data, False) |
| else: |
| _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False) |
| return [cdma1x_bts] |
| |
| |
| def wait_for_bts_state(log, btsnumber, state, timeout=30): |
| """ Waits for BTS to be in the specified state ("IN" or "OUT") |
| |
| Args: |
| btsnumber: BTS number. |
| state: expected state |
| |
| Returns: |
| True for success False for failure |
| """ |
| # state value are "IN" and "OUT" |
| status = False |
| sleep_interval = 1 |
| wait_time = timeout |
| |
| if state == "IN": |
| service_state = BtsServiceState.SERVICE_STATE_IN |
| elif state == "OUT": |
| service_state = BtsServiceState.SERVICE_STATE_OUT |
| else: |
| log.info("wrong state value") |
| return status |
| |
| if btsnumber.service_state is service_state: |
| log.info("BTS state is already in {}".format(state)) |
| return True |
| |
| # set to desired service state |
| btsnumber.service_state = service_state |
| |
| while wait_time > 0: |
| if service_state == btsnumber.service_state: |
| status = True |
| break |
| time.sleep(sleep_interval) |
| wait_time = wait_time - sleep_interval |
| |
| if not status: |
| log.info("Timeout: Expected BTS state is not received.") |
| return status |
| |
| |
| class _CallSequenceException(Exception): |
| pass |
| |
| |
| def call_mo_setup_teardown( |
| log, |
| ad, |
| anritsu_handle, |
| callee_number, |
| teardown_side=CALL_TEARDOWN_PHONE, |
| is_emergency=False, |
| wait_time_in_call=WAIT_TIME_IN_CALL_LONG, |
| is_ims_call=False, |
| ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID): |
| """ Makes a MO call and tear down the call |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritsu object. |
| callee_number: Number to be called. |
| teardown_side: the side to end the call (Phone or remote). |
| is_emergency: is the call an emergency call. |
| wait_time_in_call: Time to wait when phone in call. |
| is_ims_call: is the call expected to be ims call. |
| ims_virtual_network_id: ims virtual network id. |
| |
| Returns: |
| True for success False for failure |
| """ |
| |
| log.info("Making Call to " + callee_number) |
| virtual_phone_handle = anritsu_handle.get_VirtualPhone() |
| |
| try: |
| # for an IMS call we either check CSCF or *nothing* (no virtual phone). |
| if is_ims_call: |
| # we only need pre-call registration in a non-emergency case |
| if not is_emergency: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not idle.") |
| else: |
| if not wait_for_virtualphone_state(log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise _CallSequenceException("Virtual Phone not idle.") |
| |
| if not initiate_call(log, ad, callee_number, is_emergency): |
| raise _CallSequenceException("Initiate call failed.") |
| |
| if is_ims_call: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CALLING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not calling.") |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CONNECTED.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not connected.") |
| else: |
| # check Virtual phone answered the call |
| if not wait_for_virtualphone_state( |
| log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_VOICECALL_INPROGRESS): |
| raise _CallSequenceException("Virtual Phone not in call.") |
| |
| time.sleep(wait_time_in_call) |
| |
| if not ad.droid.telecomIsInCall(): |
| raise _CallSequenceException("Call ended before delay_in_call.") |
| |
| if teardown_side is CALL_TEARDOWN_REMOTE: |
| log.info("Disconnecting the call from Remote") |
| if is_ims_call: |
| anritsu_handle.ims_cscf_call_action(ims_virtual_network_id, |
| ImsCscfCall.END.value) |
| else: |
| virtual_phone_handle.set_voice_on_hook() |
| if not wait_for_droid_not_in_call(log, ad, |
| MAX_WAIT_TIME_CALL_DROP): |
| raise _CallSequenceException("DUT call not drop.") |
| else: |
| log.info("Disconnecting the call from DUT") |
| if not hangup_call(log, ad, is_emergency): |
| raise _CallSequenceException( |
| "Error in Hanging-Up Call on DUT.") |
| |
| if is_ims_call: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException("Phone IMS status is not idle.") |
| else: |
| if not wait_for_virtualphone_state(log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise _CallSequenceException( |
| "Virtual Phone not idle after hangup.") |
| return True |
| |
| except _CallSequenceException as e: |
| log.error(e) |
| return False |
| finally: |
| try: |
| if ad.droid.telecomIsInCall(): |
| ad.droid.telecomEndCall() |
| except Exception as e: |
| log.error(str(e)) |
| |
| |
| def handover_tc(log, |
| anritsu_handle, |
| wait_time=0, |
| s_bts=BtsNumber.BTS1, |
| t_bts=BtsNumber.BTS2, |
| timeout=60): |
| """ Setup and perform a handover test case in MD8475A |
| |
| Args: |
| anritsu_handle: Anritsu object. |
| s_bts: Serving (originating) BTS |
| t_bts: Target (destination) BTS |
| wait_time: time to wait before handover |
| |
| Returns: |
| True for success False for failure |
| """ |
| log.info("Starting HO test case procedure") |
| log.info("Serving BTS = {}, Target BTS = {}".format(s_bts, t_bts)) |
| time.sleep(wait_time) |
| ho_tc = anritsu_handle.get_AnritsuTestCases() |
| ho_tc.procedure = TestProcedure.PROCEDURE_HO |
| ho_tc.bts_direction = (s_bts, t_bts) |
| ho_tc.power_control = TestPowerControl.POWER_CONTROL_DISABLE |
| ho_tc.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE |
| anritsu_handle.start_testcase() |
| status = anritsu_handle.get_testcase_status() |
| timer = 0 |
| while status == "0": |
| time.sleep(1) |
| status = anritsu_handle.get_testcase_status() |
| timer += 1 |
| if timer > timeout: |
| return "Handover Test Case time out in {} sec!".format(timeout) |
| return status |
| |
| |
| def make_ims_call(log, |
| ad, |
| anritsu_handle, |
| callee_number, |
| is_emergency=False, |
| check_ims_reg=True, |
| check_ims_calling=True, |
| mo=True, |
| ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID): |
| """ Makes a MO call after IMS registred |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritsu object. |
| callee_number: Number to be called. |
| check_ims_reg: check if Anritsu cscf server state is "SIPIDLE". |
| check_ims_calling: check if Anritsu cscf server state is "CALLING". |
| mo: Mobile originated call |
| ims_virtual_network_id: ims virtual network id. |
| |
| Returns: |
| True for success False for failure |
| """ |
| |
| try: |
| # confirm ims registration |
| if check_ims_reg: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException("IMS/CSCF status is not idle.") |
| if mo: # make MO call |
| log.info("Making Call to " + callee_number) |
| if not initiate_call(log, ad, callee_number, is_emergency): |
| raise _CallSequenceException("Initiate call failed.") |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CALLING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not calling.") |
| else: # make MT call |
| log.info("Making IMS Call to UE from MD8475A...") |
| anritsu_handle.ims_cscf_call_action(ims_virtual_network_id, |
| ImsCscfCall.MAKE.value) |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.RINGING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not ringing.") |
| # answer the call on the UE |
| if not wait_and_answer_call(log, ad): |
| raise _CallSequenceException("UE Answer call Fail") |
| |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CONNECTED.value): |
| raise _CallSequenceException( |
| "MD8475A IMS status is not connected.") |
| return True |
| |
| except _CallSequenceException as e: |
| log.error(e) |
| return False |
| |
| |
| def tear_down_call(log, |
| ad, |
| anritsu_handle, |
| ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID): |
| """ Check and End a VoLTE call |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritsu object. |
| ims_virtual_network_id: ims virtual network id. |
| |
| Returns: |
| True for success False for failure |
| """ |
| try: |
| # end the call from phone |
| log.info("Disconnecting the call from DUT") |
| if not hangup_call(log, ad): |
| raise _CallSequenceException("Error in Hanging-Up Call on DUT.") |
| # confirm if CSCF status is back to idle |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException("IMS/CSCF status is not idle.") |
| return True |
| |
| except _CallSequenceException as e: |
| log.error(e) |
| return False |
| finally: |
| try: |
| if ad.droid.telecomIsInCall(): |
| ad.droid.telecomEndCall() |
| except Exception as e: |
| log.error(str(e)) |
| |
| |
| # This procedure is for VoLTE mobility test cases |
| def ims_call_ho(log, |
| ad, |
| anritsu_handle, |
| callee_number, |
| is_emergency=False, |
| check_ims_reg=True, |
| check_ims_calling=True, |
| mo=True, |
| wait_time_in_volte=WAIT_TIME_IN_CALL_FOR_IMS, |
| ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID): |
| """ Makes a MO call after IMS registred, then handover |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritsu object. |
| callee_number: Number to be called. |
| check_ims_reg: check if Anritsu cscf server state is "SIPIDLE". |
| check_ims_calling: check if Anritsu cscf server state is "CALLING". |
| mo: Mobile originated call |
| wait_time_in_volte: Time for phone in VoLTE call, not used for SRLTE |
| ims_virtual_network_id: ims virtual network id. |
| |
| Returns: |
| True for success False for failure |
| """ |
| |
| try: |
| # confirm ims registration |
| if check_ims_reg: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException("IMS/CSCF status is not idle.") |
| if mo: # make MO call |
| log.info("Making Call to " + callee_number) |
| if not initiate_call(log, ad, callee_number, is_emergency): |
| raise _CallSequenceException("Initiate call failed.") |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CALLING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not calling.") |
| else: # make MT call |
| log.info("Making IMS Call to UE from MD8475A...") |
| anritsu_handle.ims_cscf_call_action(ims_virtual_network_id, |
| ImsCscfCall.MAKE.value) |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.RINGING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not ringing.") |
| # answer the call on the UE |
| if not wait_and_answer_call(log, ad): |
| raise _CallSequenceException("UE Answer call Fail") |
| |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CONNECTED.value): |
| raise _CallSequenceException("Phone IMS status is not connected.") |
| log.info( |
| "Wait for {} seconds before handover".format(wait_time_in_volte)) |
| time.sleep(wait_time_in_volte) |
| |
| # Once VoLTE call is connected, then Handover |
| log.info("Starting handover procedure...") |
| result = handover_tc(anritsu_handle, BtsNumber.BTS1, BtsNumber.BTS2) |
| log.info("Handover procedure ends with result code {}".format(result)) |
| log.info( |
| "Wait for {} seconds after handover".format(wait_time_in_volte)) |
| time.sleep(wait_time_in_volte) |
| |
| # check if the phone stay in call |
| if not ad.droid.telecomIsInCall(): |
| raise _CallSequenceException("Call ended before delay_in_call.") |
| # end the call from phone |
| log.info("Disconnecting the call from DUT") |
| if not hangup_call(log, ad, is_emergency): |
| raise _CallSequenceException("Error in Hanging-Up Call on DUT.") |
| # confirm if CSCF status is back to idle |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException("IMS/CSCF status is not idle.") |
| |
| return True |
| |
| except _CallSequenceException as e: |
| log.error(e) |
| return False |
| finally: |
| try: |
| if ad.droid.telecomIsInCall(): |
| ad.droid.telecomEndCall() |
| except Exception as e: |
| log.error(str(e)) |
| |
| |
| # This procedure is for SRLTE CSFB and SRVCC test cases |
| def ims_call_cs_teardown( |
| log, |
| ad, |
| anritsu_handle, |
| callee_number, |
| teardown_side=CALL_TEARDOWN_PHONE, |
| is_emergency=False, |
| check_ims_reg=True, |
| check_ims_calling=True, |
| srvcc=None, |
| mo=True, |
| wait_time_in_volte=WAIT_TIME_IN_CALL_FOR_IMS, |
| wait_time_in_cs=WAIT_TIME_IN_CALL, |
| wait_time_in_alert=WAIT_TIME_IN_ALERT, |
| ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID): |
| """ Makes a MO call after IMS registred, transit to CS, tear down the call |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritsu object. |
| callee_number: Number to be called. |
| teardown_side: the side to end the call (Phone or remote). |
| is_emergency: to make emergency call on the phone. |
| check_ims_reg: check if Anritsu cscf server state is "SIPIDLE". |
| check_ims_calling: check if Anritsu cscf server state is "CALLING". |
| srvcc: is the test case a SRVCC call. |
| mo: Mobile originated call |
| wait_time_in_volte: Time for phone in VoLTE call, not used for SRLTE |
| wait_time_in_cs: Time for phone in CS call. |
| ims_virtual_network_id: ims virtual network id. |
| |
| Returns: |
| True for success False for failure |
| """ |
| |
| virtual_phone_handle = anritsu_handle.get_VirtualPhone() |
| |
| try: |
| # confirm ims registration |
| if check_ims_reg: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.SIPIDLE.value): |
| raise _CallSequenceException("IMS/CSCF status is not idle.") |
| # confirm virtual phone in idle |
| if not wait_for_virtualphone_state(log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise _CallSequenceException("Virtual Phone not idle.") |
| if mo: # make MO call |
| log.info("Making Call to " + callee_number) |
| if not initiate_call(log, ad, callee_number, is_emergency): |
| raise _CallSequenceException("Initiate call failed.") |
| else: # make MT call |
| log.info("Making IMS Call to UE from MD8475A...") |
| anritsu_handle.ims_cscf_call_action(ims_virtual_network_id, |
| ImsCscfCall.MAKE.value) |
| # if check ims calling is required |
| if check_ims_calling: |
| if mo: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.CALLING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not calling.") |
| else: |
| if not wait_for_ims_cscf_status(log, anritsu_handle, |
| ims_virtual_network_id, |
| ImsCscfStatus.RINGING.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not ringing.") |
| |
| # if SRVCC, check if VoLTE call is connected, then Handover |
| if srvcc != None: |
| if srvcc == "InCall": |
| if not wait_for_ims_cscf_status( |
| log, anritsu_handle, ims_virtual_network_id, |
| ImsCscfStatus.CONNECTED.value): |
| raise _CallSequenceException( |
| "Phone IMS status is not connected.") |
| # stay in call for "wait_time_in_volte" seconds |
| time.sleep(wait_time_in_volte) |
| elif srvcc == "Alert": |
| # ring for WAIT_TIME_IN_ALERT seconds |
| time.sleep(WAIT_TIME_IN_ALERT) |
| # SRVCC by handover test case procedure |
| srvcc_tc = anritsu_handle.get_AnritsuTestCases() |
| srvcc_tc.procedure = TestProcedure.PROCEDURE_HO |
| srvcc_tc.bts_direction = (BtsNumber.BTS1, BtsNumber.BTS2) |
| srvcc_tc.power_control = TestPowerControl.POWER_CONTROL_DISABLE |
| srvcc_tc.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE |
| anritsu_handle.start_testcase() |
| time.sleep(5) |
| if not mo: |
| # answer the call on the UE |
| if not wait_and_answer_call(log, ad): |
| raise _CallSequenceException("UE Answer call Fail") |
| # check if Virtual phone in the call |
| if not wait_for_virtualphone_state( |
| log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_VOICECALL_INPROGRESS): |
| raise _CallSequenceException("Virtual Phone not in call.") |
| # stay in call for "wait_time_in_cs" seconds |
| time.sleep(wait_time_in_cs) |
| # check if the phone stay in call |
| if not ad.droid.telecomIsInCall(): |
| raise _CallSequenceException("Call ended before delay_in_call.") |
| # end the call |
| if teardown_side is CALL_TEARDOWN_REMOTE: |
| log.info("Disconnecting the call from Remote") |
| virtual_phone_handle.set_voice_on_hook() |
| if not wait_for_droid_not_in_call(log, ad, |
| MAX_WAIT_TIME_CALL_DROP): |
| raise _CallSequenceException("DUT call not drop.") |
| else: |
| log.info("Disconnecting the call from DUT") |
| if not hangup_call(log, ad, is_emergency): |
| raise _CallSequenceException( |
| "Error in Hanging-Up Call on DUT.") |
| # confirm if virtual phone status is back to idle |
| if not wait_for_virtualphone_state(log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise _CallSequenceException( |
| "Virtual Phone not idle after hangup.") |
| return True |
| |
| except _CallSequenceException as e: |
| log.error(e) |
| return False |
| finally: |
| try: |
| if ad.droid.telecomIsInCall(): |
| ad.droid.telecomEndCall() |
| except Exception as e: |
| log.error(str(e)) |
| |
| |
| def call_mt_setup_teardown(log, |
| ad, |
| virtual_phone_handle, |
| caller_number=None, |
| teardown_side=CALL_TEARDOWN_PHONE, |
| rat=""): |
| """ Makes a call from Anritsu Virtual phone to device and tear down the call |
| |
| Args: |
| ad: Android device object. |
| virtual_phone_handle: Anritsu virtual phone handle |
| caller_number = Caller number |
| teardown_side = specifiy the side to end the call (Phone or remote) |
| |
| Returns: |
| True for success False for failure |
| """ |
| log.info("Receive MT Call - Making a call to the phone from remote") |
| try: |
| if not wait_for_virtualphone_state(log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise Exception("Virtual Phone is not in a state to start call") |
| if caller_number is not None: |
| if rat == RAT_1XRTT: |
| virtual_phone_handle.id_c2k = caller_number |
| else: |
| virtual_phone_handle.id = caller_number |
| virtual_phone_handle.set_voice_off_hook() |
| |
| if not wait_and_answer_call(log, ad, caller_number): |
| raise Exception("Answer call Fail") |
| |
| time.sleep(WAIT_TIME_IN_CALL) |
| |
| if not ad.droid.telecomIsInCall(): |
| raise Exception("Call ended before delay_in_call.") |
| except Exception: |
| return False |
| |
| if ad.droid.telecomIsInCall(): |
| if teardown_side is CALL_TEARDOWN_REMOTE: |
| log.info("Disconnecting the call from Remote") |
| virtual_phone_handle.set_voice_on_hook() |
| else: |
| log.info("Disconnecting the call from Phone") |
| ad.droid.telecomEndCall() |
| |
| wait_for_virtualphone_state(log, virtual_phone_handle, |
| VirtualPhoneStatus.STATUS_IDLE) |
| ensure_phone_idle(log, ad) |
| |
| return True |
| |
| |
| def wait_for_sms_deliver_success(log, ad, time_to_wait=60): |
| sms_deliver_event = EventSmsDeliverSuccess |
| sleep_interval = 2 |
| status = False |
| event = None |
| |
| try: |
| event = ad.ed.pop_event(sms_deliver_event, time_to_wait) |
| status = True |
| except Empty: |
| log.info("Timeout: Expected event is not received.") |
| return status |
| |
| |
| def wait_for_sms_sent_success(log, ad, time_to_wait=60): |
| sms_sent_event = EventSmsSentSuccess |
| sleep_interval = 2 |
| status = False |
| event = None |
| |
| try: |
| event = ad.ed.pop_event(sms_sent_event, time_to_wait) |
| log.info(event) |
| status = True |
| except Empty: |
| log.info("Timeout: Expected event is not received.") |
| return status |
| |
| |
| def wait_for_incoming_sms(log, ad, time_to_wait=60): |
| sms_received_event = EventSmsReceived |
| sleep_interval = 2 |
| status = False |
| event = None |
| |
| try: |
| event = ad.ed.pop_event(sms_received_event, time_to_wait) |
| log.info(event) |
| status = True |
| except Empty: |
| log.info("Timeout: Expected event is not received.") |
| return status, event |
| |
| |
| def verify_anritsu_received_sms(log, vp_handle, receiver_number, message, rat): |
| if rat == RAT_1XRTT: |
| receive_sms = vp_handle.receiveSms_c2k() |
| else: |
| receive_sms = vp_handle.receiveSms() |
| |
| if receive_sms == "NONE": |
| return False |
| split = receive_sms.split('&') |
| text = "" |
| if rat == RAT_1XRTT: |
| # TODO: b/26296388 There is some problem when retrieving message with é |
| # from Anritsu. |
| return True |
| for i in range(len(split)): |
| if split[i].startswith('Text='): |
| text = split[i][5:] |
| text = AnritsuUtils.gsm_decode(text) |
| break |
| # TODO: b/26296388 Verify Phone number |
| if text != message: |
| log.error("Wrong message received") |
| return False |
| return True |
| |
| |
| def sms_mo_send(log, ad, vp_handle, receiver_number, message, rat=""): |
| try: |
| if not wait_for_virtualphone_state(log, vp_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise Exception("Virtual Phone is not in a state to receive SMS") |
| log.info("Sending SMS to " + receiver_number) |
| ad.droid.smsSendTextMessage(receiver_number, message, False) |
| log.info("Waiting for SMS sent event") |
| test_status = wait_for_sms_sent_success(log, ad) |
| if not test_status: |
| raise Exception("Failed to send SMS") |
| if not verify_anritsu_received_sms(log, vp_handle, receiver_number, |
| message, rat): |
| raise Exception("Anritsu didn't receive message") |
| except Exception as e: |
| log.error("Exception :" + str(e)) |
| return False |
| return True |
| |
| |
| def sms_mt_receive_verify(log, ad, vp_handle, sender_number, message, rat=""): |
| ad.droid.smsStartTrackingIncomingMessage() |
| try: |
| if not wait_for_virtualphone_state(log, vp_handle, |
| VirtualPhoneStatus.STATUS_IDLE): |
| raise Exception("Virtual Phone is not in a state to receive SMS") |
| log.info("Waiting for Incoming SMS from " + sender_number) |
| if rat == RAT_1XRTT: |
| vp_handle.sendSms_c2k(sender_number, message) |
| else: |
| vp_handle.sendSms(sender_number, message) |
| test_status, event = wait_for_incoming_sms(log, ad) |
| if not test_status: |
| raise Exception("Failed to receive SMS") |
| log.info("Incoming SMS: Sender " + event['data']['Sender']) |
| log.info("Incoming SMS: Message " + event['data']['Text']) |
| if event['data']['Sender'] != sender_number: |
| raise Exception("Wrong sender Number") |
| if event['data']['Text'] != message: |
| raise Exception("Wrong message") |
| except Exception as e: |
| log.error("exception: " + str(e)) |
| return False |
| finally: |
| ad.droid.smsStopTrackingIncomingMessage() |
| return True |
| |
| |
| def wait_for_ims_cscf_status(log, |
| anritsu_handle, |
| virtual_network_id, |
| status, |
| timeout=MAX_WAIT_TIME_IMS_CSCF_STATE): |
| """ Wait for IMS CSCF to be in expected state. |
| |
| Args: |
| log: log object |
| anritsu_handle: anritsu object |
| virtual_network_id: virtual network id to be monitored |
| status: expected status |
| timeout: wait time |
| """ |
| sleep_interval = 1 |
| wait_time = timeout |
| while wait_time > 0: |
| if status == anritsu_handle.get_ims_cscf_status(virtual_network_id): |
| return True |
| time.sleep(sleep_interval) |
| wait_time = wait_time - sleep_interval |
| return False |
| |
| |
| def wait_for_virtualphone_state(log, |
| vp_handle, |
| state, |
| timeout=MAX_WAIT_TIME_VIRTUAL_PHONE_STATE): |
| """ Waits for Anritsu Virtual phone to be in expected state |
| |
| Args: |
| ad: Android device object. |
| vp_handle: Anritus virtual phone handle |
| state = expected state |
| |
| Returns: |
| True for success False for failure |
| """ |
| status = False |
| sleep_interval = 1 |
| wait_time = timeout |
| while wait_time > 0: |
| if vp_handle.status == state: |
| log.info(vp_handle.status) |
| status = True |
| break |
| time.sleep(sleep_interval) |
| wait_time = wait_time - sleep_interval |
| |
| if not status: |
| log.info("Timeout: Expected state is not received.") |
| return status |
| |
| |
| # There is a difference between CMAS/ETWS message formation in LTE/WCDMA and CDMA 1X |
| # LTE and CDMA : 3GPP |
| # CDMA 1X: 3GPP2 |
| # hence different functions |
| def cmas_receive_verify_message_lte_wcdma( |
| log, ad, anritsu_handle, serial_number, message_id, warning_message): |
| """ Makes Anritsu to send a CMAS message and phone and verifies phone |
| receives the message on LTE/WCDMA |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritus device object |
| serial_number = serial number of CMAS message |
| message_id = CMAS message ID |
| warning_message = CMAS warning message |
| |
| Returns: |
| True for success False for failure |
| """ |
| status = False |
| event = None |
| ad.droid.smsStartTrackingGsmEmergencyCBMessage() |
| anritsu_handle.send_cmas_lte_wcdma( |
| hex(serial_number), message_id, warning_message) |
| try: |
| log.info("Waiting for CMAS Message") |
| event = ad.ed.pop_event(EventCmasReceived, 60) |
| status = True |
| log.info(event) |
| if warning_message != event['data']['message']: |
| log.info("Wrong warning messgae received") |
| status = False |
| if message_id != hex(event['data']['serviceCategory']): |
| log.info("Wrong warning messgae received") |
| status = False |
| except Empty: |
| log.info("Timeout: Expected event is not received.") |
| |
| ad.droid.smsStopTrackingGsmEmergencyCBMessage() |
| return status |
| |
| |
| def cmas_receive_verify_message_cdma1x( |
| log, |
| ad, |
| anritsu_handle, |
| message_id, |
| service_category, |
| alert_text, |
| response_type=CMAS_C2K_RESPONSETYPE_SHELTER, |
| severity=CMAS_C2K_SEVERITY_EXTREME, |
| urgency=CMAS_C2K_URGENCY_IMMEDIATE, |
| certainty=CMAS_C2K_CERTIANTY_OBSERVED): |
| """ Makes Anritsu to send a CMAS message and phone and verifies phone |
| receives the message on CDMA 1X |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritus device object |
| serial_number = serial number of CMAS message |
| message_id = CMAS message ID |
| warning_message = CMAS warning message |
| |
| Returns: |
| True for success False for failure |
| """ |
| status = False |
| event = None |
| ad.droid.smsStartTrackingCdmaEmergencyCBMessage() |
| anritsu_handle.send_cmas_etws_cdma1x(message_id, service_category, |
| alert_text, response_type, severity, |
| urgency, certainty) |
| try: |
| log.info("Waiting for CMAS Message") |
| event = ad.ed.pop_event(EventCmasReceived, 60) |
| status = True |
| log.info(event) |
| if alert_text != event['data']['message']: |
| log.info("Wrong alert messgae received") |
| status = False |
| |
| if event['data']['cmasResponseType'].lower() != response_type.lower(): |
| log.info("Wrong response type received") |
| status = False |
| |
| if event['data']['cmasUrgency'].lower() != urgency.lower(): |
| log.info("Wrong cmasUrgency received") |
| status = False |
| |
| if event['data']['cmasSeverity'].lower() != severity.lower(): |
| log.info("Wrong cmasSeverity received") |
| status = False |
| except Empty: |
| log.info("Timeout: Expected event is not received.") |
| |
| ad.droid.smsStopTrackingCdmaEmergencyCBMessage() |
| return status |
| |
| |
| def etws_receive_verify_message_lte_wcdma( |
| log, ad, anritsu_handle, serial_number, message_id, warning_message): |
| """ Makes Anritsu to send a ETWS message and phone and verifies phone |
| receives the message on LTE/WCDMA |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritus device object |
| serial_number = serial number of ETWS message |
| message_id = ETWS message ID |
| warning_message = ETWS warning message |
| |
| Returns: |
| True for success False for failure |
| """ |
| status = False |
| event = None |
| if message_id == ETWS_WARNING_EARTHQUAKE: |
| warning_type = "Earthquake" |
| elif message_id == ETWS_WARNING_EARTHQUAKETSUNAMI: |
| warning_type = "EarthquakeandTsunami" |
| elif message_id == ETWS_WARNING_TSUNAMI: |
| warning_type = "Tsunami" |
| elif message_id == ETWS_WARNING_TEST_MESSAGE: |
| warning_type = "test" |
| elif message_id == ETWS_WARNING_OTHER_EMERGENCY: |
| warning_type = "other" |
| ad.droid.smsStartTrackingGsmEmergencyCBMessage() |
| anritsu_handle.send_etws_lte_wcdma( |
| hex(serial_number), message_id, warning_type, warning_message, "ON", |
| "ON") |
| try: |
| log.info("Waiting for ETWS Message") |
| event = ad.ed.pop_event(EventEtwsReceived, 60) |
| status = True |
| log.info(event) |
| # TODO: b/26296388 Event data verification |
| except Empty: |
| log.info("Timeout: Expected event is not received.") |
| |
| ad.droid.smsStopTrackingGsmEmergencyCBMessage() |
| return status |
| |
| |
| def etws_receive_verify_message_cdma1x(log, ad, anritsu_handle, serial_number, |
| message_id, warning_message): |
| """ Makes Anritsu to send a ETWS message and phone and verifies phone |
| receives the message on CDMA1X |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritus device object |
| serial_number = serial number of ETWS message |
| message_id = ETWS message ID |
| warning_message = ETWS warning message |
| |
| Returns: |
| True for success False for failure |
| """ |
| status = False |
| event = None |
| # TODO: b/26296388 need to add logic to check etws. |
| return status |
| |
| |
| def read_ue_identity(log, ad, anritsu_handle, identity_type): |
| """ Get the UE identity IMSI, IMEI, IMEISV |
| |
| Args: |
| ad: Android device object. |
| anritsu_handle: Anritus device object |
| identity_type: Identity type(IMSI/IMEI/IMEISV) |
| |
| Returns: |
| Requested Identity value |
| """ |
| return anritsu_handle.get_ue_identity(identity_type) |
| |
| |
| def get_transmission_mode(user_params, cell_no): |
| """ Returns the TRANSMODE to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| TM to be used |
| """ |
| key = "cell{}_transmission_mode".format(cell_no) |
| transmission_mode = user_params.get(key, DEFAULT_T_MODE) |
| return transmission_mode |
| |
| |
| def get_dl_antenna(user_params, cell_no): |
| """ Returns the DL ANTENNA to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| number of DL ANTENNAS to be used |
| """ |
| key = "cell{}_dl_antenna".format(cell_no) |
| dl_antenna = user_params.get(key, DEFAULT_DL_ANTENNA) |
| return dl_antenna |
| |
| |
| def get_lte_band(user_params, cell_no, sim_card): |
| """ Returns the LTE BAND to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| LTE BAND to be used |
| """ |
| key = "cell{}_lte_band".format(cell_no) |
| if sim_card == FiTMO: |
| band = Fi_LTE_TMO_BAND[cell_no - 1] |
| elif sim_card == FiSPR: |
| band = Fi_LTE_SPR_BAND[cell_no - 1] |
| elif sim_card == FiUSCC: |
| band = Fi_LTE_USCC_BAND[cell_no - 1] |
| else: |
| band = DEFAULT_LTE_BAND[cell_no - 1] |
| return user_params.get(key, band) |
| |
| |
| def get_wcdma_band(user_params, cell_no): |
| """ Returns the WCDMA BAND to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| WCDMA BAND to be used |
| """ |
| key = "cell{}_wcdma_band".format(cell_no) |
| wcdma_band = user_params.get(key, DEFAULT_WCDMA_BAND) |
| return wcdma_band |
| |
| |
| def get_gsm_band(user_params, cell_no, sim_card): |
| """ Returns the GSM BAND to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| GSM BAND to be used |
| """ |
| key = "cell{}_gsm_band".format(cell_no) |
| if sim_card == FiTMO: |
| gsm_band = Fi_GSM_TMO_BAND |
| else: |
| gsm_band = user_params.get(key, DEFAULT_GSM_BAND) |
| return gsm_band |
| |
| |
| def get_1x_band(user_params, cell_no, sim_card): |
| """ Returns the 1X BAND to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| 1X BAND to be used |
| """ |
| key = "cell{}_1x_band".format(cell_no) |
| if sim_card == FiSPR: |
| band = Fi_SPR1X_BAND |
| elif sim_card == FiUSCC: |
| band = Fi_USCC1X_BAND |
| elif sim_card == VzW12349: |
| band = VzW_CDMA1x_BAND |
| else: |
| band = DEFAULT_CDMA1X_BAND |
| return user_params.get(key, band) |
| |
| |
| def get_evdo_band(user_params, cell_no, sim_card): |
| """ Returns the EVDO BAND to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| EVDO BAND to be used |
| """ |
| key = "cell{}_evdo_band".format(cell_no) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| band = Fi_EVDO_BAND |
| elif sim_card == VzW12349: |
| band = VzW_EVDO_BAND |
| else: |
| band = DEFAULT_EVDO_BAND |
| return user_params.get(key, band) |
| |
| |
| def get_wcdma_rac(user_params, cell_no): |
| """ Returns the WCDMA RAC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| WCDMA RAC to be used |
| """ |
| key = "cell{}_wcdma_rac".format(cell_no) |
| try: |
| wcdma_rac = user_params[key] |
| except KeyError: |
| wcdma_rac = DEFAULT_RAC |
| return wcdma_rac |
| |
| |
| def get_gsm_rac(user_params, cell_no): |
| """ Returns the GSM RAC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| GSM RAC to be used |
| """ |
| key = "cell{}_gsm_rac".format(cell_no) |
| try: |
| gsm_rac = user_params[key] |
| except KeyError: |
| gsm_rac = DEFAULT_RAC |
| return gsm_rac |
| |
| |
| def get_wcdma_lac(user_params, cell_no): |
| """ Returns the WCDMA LAC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| WCDMA LAC to be used |
| """ |
| key = "cell{}_wcdma_lac".format(cell_no) |
| try: |
| wcdma_lac = user_params[key] |
| except KeyError: |
| wcdma_lac = DEFAULT_LAC |
| return wcdma_lac |
| |
| |
| def get_gsm_lac(user_params, cell_no): |
| """ Returns the GSM LAC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| GSM LAC to be used |
| """ |
| key = "cell{}_gsm_lac".format(cell_no) |
| try: |
| gsm_lac = user_params[key] |
| except KeyError: |
| gsm_lac = DEFAULT_LAC |
| return gsm_lac |
| |
| |
| def get_lte_mcc(user_params, cell_no, sim_card): |
| """ Returns the LTE MCC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| LTE MCC to be used |
| """ |
| |
| key = "cell{}_lte_mcc".format(cell_no) |
| if sim_card == FiTMO: |
| mcc = Fi_TMO_MCC |
| elif sim_card == FiSPR: |
| mcc = Fi_SPR_MCC |
| elif sim_card == FiUSCC: |
| mcc = Fi_USCC_MCC |
| elif sim_card == VzW12349: |
| mcc = VzW_MCC |
| else: |
| mcc = DEFAULT_MCC |
| return user_params.get(key, mcc) |
| |
| |
| def get_lte_mnc(user_params, cell_no, sim_card): |
| """ Returns the LTE MNC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| LTE MNC to be used |
| """ |
| key = "cell{}_lte_mnc".format(cell_no) |
| if sim_card == FiTMO: |
| mnc = Fi_TMO_MNC |
| elif sim_card == FiSPR: |
| mnc = Fi_SPR_MNC |
| elif sim_card == FiUSCC: |
| mnc = Fi_USCC_MNC |
| elif sim_card == VzW12349: |
| mnc = VzW_MNC |
| else: |
| mnc = DEFAULT_MNC |
| return user_params.get(key, mnc) |
| |
| |
| def get_wcdma_mcc(user_params, cell_no, sim_card): |
| """ Returns the WCDMA MCC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| WCDMA MCC to be used |
| """ |
| key = "cell{}_wcdma_mcc".format(cell_no) |
| mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC |
| return user_params.get(key, mcc) |
| |
| |
| def get_wcdma_mnc(user_params, cell_no, sim_card): |
| """ Returns the WCDMA MNC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| WCDMA MNC to be used |
| """ |
| key = "cell{}_wcdma_mnc".format(cell_no) |
| mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC |
| return user_params.get(key, mnc) |
| |
| |
| def get_gsm_mcc(user_params, cell_no, sim_card): |
| """ Returns the GSM MCC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| GSM MCC to be used |
| """ |
| key = "cell{}_gsm_mcc".format(cell_no) |
| mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC |
| return user_params.get(key, mcc) |
| |
| |
| def get_gsm_mnc(user_params, cell_no, sim_card): |
| """ Returns the GSM MNC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| GSM MNC to be used |
| """ |
| key = "cell{}_gsm_mnc".format(cell_no) |
| mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC |
| return user_params.get(key, mnc) |
| |
| |
| def get_1x_mcc(user_params, cell_no, sim_card): |
| """ Returns the 1X MCC to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| 1X MCC to be used |
| """ |
| key = "cell{}_1x_mcc".format(cell_no) |
| if sim_card == FiSPR: |
| mcc = Fi_SPR1X_MCC |
| elif sim_card == FiUSCC: |
| mcc = Fi_USCC1X_MCC |
| elif sim_card == VzW12349: |
| mcc = VzW_MCC |
| else: |
| mcc = DEFAULT_MCC |
| return user_params.get(key, mcc) |
| |
| |
| def get_1x_channel(user_params, cell_no, sim_card): |
| """ Returns the 1X Channel to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| 1X Channel to be used |
| """ |
| key = "cell{}_1x_channel".format(cell_no) |
| if sim_card == FiSPR: |
| ch = Fi_SPR1X_CH |
| elif sim_card == FiUSCC: |
| ch = Fi_USCC1X_CH |
| elif sim_card == VzW12349: |
| ch = VzW_CDMA1x_CH |
| else: |
| ch = DEFAULT_CDMA1X_CH |
| return user_params.get(key, ch) |
| |
| |
| def get_1x_sid(user_params, cell_no, sim_card): |
| """ Returns the 1X SID to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| 1X SID to be used |
| """ |
| key = "cell{}_1x_sid".format(cell_no) |
| if sim_card == FiSPR: |
| sid = Fi_SPR1X_SID |
| elif sim_card == FiUSCC: |
| sid = Fi_USCC1X_SID |
| elif sim_card == VzW12349: |
| sid = VzW_CDMA1X_SID |
| else: |
| sid = DEFAULT_CDMA1X_SID |
| return user_params.get(key, sid) |
| |
| |
| def get_1x_nid(user_params, cell_no, sim_card): |
| """ Returns the 1X NID to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| 1X NID to be used |
| """ |
| key = "cell{}_1x_nid".format(cell_no) |
| if sim_card == FiSPR: |
| nid = Fi_SPR1X_NID |
| elif sim_card == FiUSCC: |
| nid = Fi_USCC1X_NID |
| elif sim_card == VzW12349: |
| nid = VzW_CDMA1X_NID |
| else: |
| nid = DEFAULT_CDMA1X_NID |
| return user_params.get(key, nid) |
| |
| |
| def get_evdo_channel(user_params, cell_no, sim_card): |
| """ Returns the EVDO Channel to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| EVDO Channel to be used |
| """ |
| key = "cell{}_evdo_channel".format(cell_no) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| ch = Fi_EVDO_CH |
| elif sim_card == VzW12349: |
| ch = VzW_EVDO_CH |
| else: |
| ch = DEFAULT_EVDO_CH |
| return user_params.get(key, ch) |
| |
| |
| def get_evdo_sid(user_params, cell_no, sim_card): |
| """ Returns the EVDO SID to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| EVDO SID to be used |
| """ |
| key = "cell{}_evdo_sid".format(cell_no) |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| sid = Fi_EVDO_SECTOR_ID |
| elif sim_card == VzW12349: |
| sid = VzW_EVDO_SECTOR_ID |
| else: |
| sid = DEFAULT_EVDO_SECTOR_ID |
| return user_params.get(key, sid) |
| |
| |
| def get_csfb_type(user_params): |
| """ Returns the CSFB Type to be used from the user specified parameters |
| or default value |
| |
| Args: |
| user_params: pointer to user supplied parameters |
| cell_no: specify the cell number this BTS is configured |
| Anritsu supports two cells. so cell_1 or cell_2 |
| |
| Returns: |
| CSFB Type to be used |
| """ |
| try: |
| csfb_type = user_params["csfb_type"] |
| except KeyError: |
| csfb_type = CsfbType.CSFB_TYPE_REDIRECTION |
| return csfb_type |
| |
| |
| def set_post_sim_params(anritsu_handle, user_params, sim_card): |
| if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC: |
| anritsu_handle.send_command("PDNCHECKAPN 1,h2g2") |
| anritsu_handle.send_command("PDNCHECKAPN 2,n.nv.ispsn") |
| anritsu_handle.send_command("PDNCHECKAPN 3,fast.t-mobile.com") |
| anritsu_handle.send_command("PDNCHECKAPN 4,ims") |
| anritsu_handle.send_command("PDNCHECKAPN 5,*") |
| anritsu_handle.send_command("PDNIMS 1,DISABLE") |
| anritsu_handle.send_command("PDNIMS 2,DISABLE") |
| anritsu_handle.send_command("PDNIMS 3,DISABLE") |
| anritsu_handle.send_command("PDNIMS 4,ENABLE") |
| anritsu_handle.send_command("PDNVNID 4,1") |
| anritsu_handle.send_command("PDNIMS 5,ENABLE") |
| anritsu_handle.send_command("PDNVNID 5,2") |
| if sim_card == P0135Ax: |
| anritsu_handle.send_command("PDNCHECKAPN 1,ims") |
| anritsu_handle.send_command("PDNCHECKAPN 2,fast.t-mobile.com") |
| anritsu_handle.send_command("PDNIMS 1,ENABLE") |
| anritsu_handle.send_command("PDNVNID 1,1") |
| anritsu_handle.send_command("PDNIMS 2,ENABLE") |
| anritsu_handle.send_command("PDNIMS 3,ENABLE") |
| anritsu_handle.send_command("PDNVNID 3,1") |
| if sim_card == VzW12349: |
| anritsu_handle.send_command("PDNCHECKAPN 1,IMS") |
| anritsu_handle.send_command("PDNCHECKAPN 2,VZWINTERNET") |
| anritsu_handle.send_command("PDNIMS 1,ENABLE") |
| anritsu_handle.send_command("PDNVNID 1,1") |
| anritsu_handle.send_command("PDNIMS 3,ENABLE") |
| anritsu_handle.send_command("PDNVNID 3,1") |