def release_csfb_vc(self, time_to_wait_before_3g_idle=5):
"""
Release Voice Call
"""
if self.release_csfb_vc_type == "NR":
# Release previous call from the network
self._ns_3gsm_vc.voice_call_network_release()
else:
# Release previous call from the DUT
self._voicecall_api.release()
# If loss coverage of LTE cell is performed,
# need to check that DUT stays registered on 3GSM cell
if self._loss_coverage_side == "LTE":
if self._ns_3gsm_cell_tech == "3G":
# Check Data Connection State on 3GSM cell => PDP Active before timeout
# Check that DUT is registered on the good RAT
RegUtil.check_rat_and_data_connection_state(self._ns_3gsm_data,
"PDP_ACTIVE",
self._modem_api,
self._registration_timeout)
else:
# Force transition to CELL IDLE in order to release PDP context on 3G cell
if self._ns_3gsm_cell_tech == "3G":
# Wait 5 seconds while VC is ended on 8960
time.sleep(time_to_wait_before_3g_idle)
self._ns_3gsm_data.set_rrc_transition("IDLE")
# Check Data Connection State on LTE cell => CON before timeout
# Check that DUT is registered on the good RAT
RegUtil.check_rat_and_data_connection_state(self._ns_lte_data,
"CON",
self._modem_api,
self._registration_timeout)
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobility3gsmBase Set_up function
LabMobility3gsmBase.set_up(self)
# Set cell on
self._ns1_cell.set_cell_on()
# Disable flight mode
self._networking_api.set_flight_mode("off")
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout("PDP_ACTIVE",
self._ns1_cell,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=False,
blocking=False)
# Get RAT from Equipment
network_type = self._ns1_data.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(network_type, self._registration_timeout)
# Set NS2 cell on
self._ns2_cell.set_cell_on()
# Perform MO voice call on active network simulator
self._voicecall_api.dial(self._phone_number, True)
# Check call state "CONNECTED" before callSetupTimeout seconds
self._ns1_vc.check_call_connected(self._call_setup_time,
blocking=False)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobilityBase Setup function
LabMobilityBase.set_up(self)
# Set cell off
self._ns1_cell.set_cell_off()
# Set cell off
self._ns2_cell.set_cell_off()
# Set EPC off
self._ns1_data.set_epc_off()
self._ns2_data.set_epc_off()
# Call specific configuration functions
RegUtil.setup_cell_lte(self._ns1, self._ns1_mcc, self._ns1_mnc,
self._ns1_ip_dut, self._ns1_signal_mode,
self._ns1_cell_id, self._ns1_physical_cell_id,
self._ns1_mimo, self._ns1_cell_power_rf1,
self._ns1_cell_power_rf2,
self._ns1_scenario_path, self._ns1_cell_band,
self._ns1_lte_dl_earfcn, self._apn)
# Call specific configuration functions
RegUtil.setup_cell_lte(self._ns2, self._ns2_mcc, self._ns2_mnc,
self._ns2_ip_dut, self._ns2_signal_mode,
self._ns2_cell_id, self._ns2_physical_cell_id,
self._ns2_mimo, self._ns2_cell_power_rf1,
self._ns2_cell_power_rf2,
self._ns2_scenario_path, self._ns2_cell_band,
self._ns2_lte_dl_earfcn, self._apn)
# Set EPC on
self._ns1_data.set_epc_on()
self._ns2_data.set_epc_on()
# Set the APN
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobilityBase set_up function
LabMobilityBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
# Determinates the kind of registration state to wait
# by comparing test case MCC/MNC parameters to sim MCC/MNC
sim_info = self._modem_api.get_sim_operator_info()
if sim_info["MCC"] != self._ns_lte_mcc or \
sim_info["MNC"] != self._ns_lte_mnc:
self._wanted_reg_state = "roaming"
self._networking_api.set_roaming_mode("ON")
else:
self._wanted_reg_state = "registered"
# Disable data and PDP context
self._networking_api.deactivate_pdp_context()
# Enable flight mode
self._networking_api.set_flight_mode("on")
# Set the Network Simulators APIs instances
self._set_ns_apis_instances()
# Set the equipment application format depending on ACTIVE_CELL_TECH.
# If 4G switch to ""LTE FDD""
self._ns_lte.switch_app_format("LTE FDD")
# Perform full preset on LTE cell
self._ns_lte.perform_full_preset()
# Perform full preset on 3GSM cell
self._ns_3gsm.perform_full_preset()
# Set EPC off, not for CMW500 because DAU starting is a long lasting time operation
self._ns_lte_data.set_epc_off()
# Set cell off on LTE cell
self._ns_lte_cell.set_cell_off()
# Set cell off
self._ns_3gsm_cell.set_cell_off()
# Set IP addresses for the 3GSM NS
self._ns_3gsm.set_ip_addresses(
self._ns_3gsm_ip_lan1, self._ns_3gsm_ip_lan2,
self._ns_3gsm_ip_subnet_mask, self._ns_3gsm_ip_default_gateway,
self._ns_3gsm_ip_dut, self._ns_3gsm_ip_dns1, self._ns_3gsm_ip_dns2)
# Call specific configuration functions
# Some parameters are defined by function
RegUtil.setup_cell(self._ns_number, self._ns_model,
self._ns_3gsm_cell_tech, self._ns_3gsm_cell_band,
self._ns_3gsm_cell_rel, self._logger)
# Set Cell Band and ARFCN using 3GSM_CELL_BAND
# and 3GSM_ARFCN parameters
# Set cell service using 3GSM_CELL_SERVICE parameter
# Set Cell Power using 3GSM_CELL_POWER parameter
# Set Cell LAC using 3GSM_LAC_VALUE parameter
# Set Cell RAC using 3GSM_RAC_VALUE parameter
self._ns_3gsm_cell.configure_basic_cell_parameters(
self._ns_3gsm_cell_service, self._ns_3gsm_cell_band,
self._ns_3gsm_dl_arfcn, self._ns_3gsm_cell_power,
self._ns_3gsm_lac, self._ns_3gsm_rac)
# set mcc and mnc of 3gsm network
self._ns_3gsm_cell.set_mcc(self._ns_3gsm_mcc)
self._ns_3gsm_cell.set_mnc(self._ns_3gsm_mnc)
if self._ns_lte_duplex_type == "FDD":
# Call specific configuration functions for LTE Cell
RegUtil.setup_cell_lte(
self._ns_lte, self._ns_lte_mcc, self._ns_lte_mnc,
self._ns_lte_ip_dut, self._ns_lte_signal_mode,
self._ns_lte_cell_id, self._ns_lte_physical_cell_id,
self._ns_lte_mimo, self._ns_lte_cell_power_rf1,
self._ns_lte_cell_power_rf2, self._ns_lte_scenario_path,
self._ns_lte_cell_band, self._ns_lte_dl_earfcn, self._apn)
elif self._ns_lte_duplex_type == "TDD":
# Set the DUT IP address
self._ns_lte_data.set_dut_ip_address(self._ns_dut_ip_Address)
# Load LTE TDD optimal configuration
self._ns_lte.load_cell_config("TDD_COMMON", self._ns_number)
if hasattr(self, "_lte_tdd_config"):
self._ns_lte.load_cell_config(self._lte_tdd_config,
self._ns_number)
if self._cell_band is not None:
self._ns_lte_cell.set_cell_band(self._ns_lte_cell_band)
self._ns_lte_cell.set_downlink_earfcn(self._ns_lte_dl_earfcn)
# Set MIMO mode
self._ns_cell_4g.set_lte_tdd_configuration(self._antennas_number,
self._mimo)
# Set EPC on
self._ns_lte_data.set_epc_on()
# Deactivate E-DCH Cell and HSDPA Cell capabilities
# if 3GSM NS cell tech is 3G
if self._ns_3gsm_cell_tech == "3G":
self._ns_3gsm_data.set_edch_cell_capability("OFF")
self._ns_3gsm_data.set_hsdpa_cell_capability("OFF")
# if 3GSM NS cell tech is 2G
else:
# Set the multislot configuration
self._ns_3gsm_data.set_multislot_config(self._multislot)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# set usb charging on
self.em_api.set_usb_charging("on")
# Configure CMU
# Connect to cellular network simulator
self._ns.init()
# check that channel is allow for this band
self._conversion_toolbox.convert_wcdma_channelscript_to_array(
self._cell_band,
self._ul_uarfcn)
# Perform Full Preset
self._ns.perform_full_preset()
# Set cell band using CELL_BAND parameter
self._ns_3g.set_band("BAND" + self._cell_band)
# Set cell off
self._ns_3g.set_cell_off()
# Set Traffic Channel Arfcn using TCH_ARFCN parameter
self._ns_3g.set_uplink_arfcn(self._ul_uarfcn)
# Set mobile power using MOBILE_POWER parameter
self._ns_3g.set_ms_power(self._mobile_power)
# Set cell power using CELL_POWER parameter
self._ns_3g.set_cell_power(self._cell_power)
# init capacity
msic = self.update_battery_info()
# get capability targets
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_OFF_ON_VC_3G", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# init verdict value
if self._em_targets["MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"] is not None:
EMUtil.update_conf(
self._em_targets["MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"],
"hi_lim", msic["BATTERY"]["CHARGE_FULL_DESIGN"][0], "=")
# init verdict value
if self.tc_module is not None:
if self._em_targets["THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"] is None:
EMUtil.update_conf(
self._em_targets["THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
# Charge battery
self.em_core_module.monitor_charging(self.em_core_module.batt_max_capacity, self.em_core_module.charge_time,
self.__em_meas_tab)
# set CMU cell phone ON
self._ns_3g.set_cell_on()
# register phone
RegUtil.check_dut_registration_before_timeout(self._ns_3g,
self.networking_api,
self._logger,
None,
self._registration_timeout)
# Check registration status on DUT
self.modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# We won't use LabWcdmaSmsCsBase SetUp, because we don't want PDP active
# for this CS test case.
# log in acs logs
self._logger.info("")
self._logger.info("%s: Setup", self._name)
self._logger.info("")
# Connect to equipment
self._ns.init()
# Set the equipment Application Format = "WCDMA"
self._ns.switch_app_format("WCDMA")
# Perform full preset
self._ns.perform_full_preset()
# Deactivate HSUPA and HSDPA capabilities
self._ns_data_3g.set_edch_cell_capability("OFF")
self._ns_data_3g.set_hsdpa_cell_capability("OFF")
# Set cell off
self._ns_cell_3g.set_cell_off()
# Set cell power using CELL_POWER value
self._ns_cell_3g.set_cell_power(self._cell_power)
self._ns_cell_3g.set_bch_update_page_state("AUTO")
self._ns_cell_3g.set_drx_cycle(self._drx_cycle_length_cn)
self._ns_cell_3g.set_drx_cycle_utran(self._drx_cycle_length_utran)
self._ns_cell_3g.set_ctch_allocation_period(self._ctch_allocation_period)
# Set cell on
self._ns_cell_3g.set_cell_on()
# Check registration status before time out using
# registrationTimeout value from Device_Catalog.xml
time.sleep(self._wait_btwn_cmd)
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
RegUtil.check_dut_registration_before_timeout(self._ns_cell_3g,
self._networking_api,
self._logger,
dut_imsi,
self._registration_timeout)
# We should makesure data is disable for this use case
self._logger.info("Deactivation of the PDP Context")
self._networking_api.deactivate_pdp_context(self._ssid)
# Check Data Connection State => PDP Active before timeout
self._ns_data_3g.check_data_connection_state("ATTACHED",
self._registration_timeout,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml (Non blocking
# for this test if function isn't implemented on CDK)
time.sleep(self._wait_btwn_cmd)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set sender address using DESTINATION_NUMBER on Network simulator
self._ns_messaging_3g.set_sms_sender_address(self._destination_number)
self._ns_messaging_3g.set_cell_broadcast_message_identifier(
self._cell_broadcast_message_identifier,
self._cell_broadcast_message)
self._ns_messaging_3g.set_cell_broadcast_message_repetition_period(
self._repetition_period)
self._ns_messaging_3g.select_cell_broadcast_message_content(
self._content_type,
self._cell_broadcast_message)
self._ns_messaging_3g.set_cell_broadcast_message_update_number(
self._update_number,
self._cell_broadcast_message)
if self._content_type == "CTEX":
self._ns_messaging_3g.set_custom_cell_broadcast_text_message(
self._custom_cell_broadcast_text_message,
self._cell_broadcast_message)
elif self._content_type == "CDAT":
self._ns_messaging_3g.set_custom_cell_broadcast_data_string(
self._custom_cell_broadcast_text_message,
self._cell_broadcast_message)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobility3gsmBase Set_up function
LabMobility3gsmBase.set_up(self)
# Get the NS1 cell LAC in order
# to manage possible INTRA_LA test case
ns1_lac = self._ns1_cell.get_lac()
# Get the NS2 cell LAC in order
# to manage possible INTRA_LA test case
ns2_lac = self._ns2_cell.get_lac()
# IF NS1 and NS2 cells LAC are equals,
# don't call the random lac to stay in INTRA_LA mode
if ns1_lac != ns2_lac:
# Sets a random LAC excluding NS2 and NS1 LAC
self._ns1_cell.set_random_lac([ns1_lac, ns2_lac])
# Set cell on the NS1 cell
self._ns1_cell.set_cell_on()
# Disable flight mode
self._networking_api.set_flight_mode("off")
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"PDP_ACTIVE",
self._ns1_cell,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._wanted_reg_state = self._modem_api.get_network_registration_status(
)
self._modem_api.check_cdk_state_bfor_timeout(
self._wanted_reg_state, self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call use case base Setup function
UseCaseBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("on")
time.sleep(self._wait_btwn_cmd)
# Connect to equipment using GPIBAddress and GPIBBoardId
self._ns.init()
# Set the equipment Application Format = "WCDMA"
self._ns.switch_app_format("WCDMA")
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_3g.set_cell_off()
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# "Set Cell Service in function of the CELL_SERVICE value :
# ""CIRCUIT"" : paging service is AMR
# PS domain is ABSENT
# ""PACKET"" : paging service is GPRS
# PS domain is PRESENT
# ""CIRCUIT_PACKET"": paging service is AMR
# PS domain is PRESENT
# ""RBTEST"" : paging service is RBT"
self._ns_cell_3g.set_cell_service(self._cell_service)
# Set Cell Band UARFCN (downlink) using Band and DlUarfcn
self._ns_cell_3g.set_band_and_dl_arfcn("BAND" + str(self._band),
self._dl_uarfcn)
# Set Cell Band UARFCN (uplink) in auto mode
self._ns_cell_3g.set_uplink_channel_mode("ON")
# Set Audio codec using VOICE_CODER_RATE parameter
self._ns_voice_call_3g.set_audio_codec(self._voice_coder_rate)
# Set SRB Configuration Control to auto
self._ns_cell_3g.set_srb_config_control("ON")
# Set Cell Power using CELL_POWER parameter
self._ns_cell_3g.set_cell_power(self._cell_power)
# Set Cell on
self._ns_cell_3g.set_cell_on()
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
if self._cell_service not in "CIRCUIT":
# Adapt attachment procedure to CIRCUIT
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
RegUtil.check_dut_registration_before_timeout(
self._ns_cell_3g, self._networking_api, self._logger, dut_imsi,
self._registration_timeout)
# Get RAT from Equipment
network_type = self._ns_data_3g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Connect to equipment
self._ns.init()
# Set the equipment application format GSM/GPRS
self._ns.switch_app_format("GSM/GPRS")
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_2g.set_cell_off()
# Set serving cell to EGPRS
self._ns_cell_2g.set_cell_service("EGPRS")
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set the equipment IP address 1
self._ns.set_ip4_lan_address(self._ns_IP_Lan1)
# Set the equipment IP_Lan2 to the equipment
self._ns.set_ip4_lan_address2(self._ns_IP_Lan2)
# Set the equipment subnet mask
self._ns.set_ip4_subnet_mask(self._ns_Subnet_Mask)
# Set the equipment default gateway
self._ns.set_ip4_default_gateway(self._ns_Default_Gateway)
# Set the DUT IP address 1
self._ns_data_2g.set_dut_ip_address(1, self._ns_DUT_IP_Address)
# Set the DUT DNS1
self._ns_data_2g.set_dut_primary_dns(self._ns_DNS1)
# Set the DUT DNS2
self._ns_data_2g.set_dut_secondary_dns(self._ns_DNS2)
# Set Cell Power using CELL_POWER parameter
self._ns_cell_2g.set_cell_power(self._cell_power)
# Set VOICE_CODER_RATE
self._ns_voice_call_2g.set_audio_codec(self._voice_coder_rate)
# Set connection type to auto
self._ns_data_2g.set_connection_type("AUTO")
# Set Cell Band using CELL_BAND parameter
self._ns_cell_2g.set_band(self._band_name)
# Set Broadcast Channel Arfcn using BCH_ARFCN parameter
self._ns_cell_2g.set_bcch_arfcn(self._bch_arfcn)
# Set PDTCH Arfcn using PDTCH_ARFCN parameter
self._ns_cell_2g.set_pdtch_arfcn(self._pdtch_arfcn)
# Set the multislot configuration
self._ns_data_2g.set_multislot_config(self._multislot)
# Set the downlink and uplink Modulation Coding Schema
# (DL_MCS and UL_MCS)
self._ns_data_2g.set_pdtch_modulation_coding_scheme(
self._dl_mcs, self._ul_mcs)
# Set the Puncturing Modulation Coding Schema (PS_MCS)
self._ns_data_2g.set_pdtch_puncturing_scheme(self._ps_mcs)
# Set DTM state to ON
self._ns_cell_2g.set_dtm_state("ON")
# Set cell on
self._ns_cell_2g.set_cell_on()
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"ATTACHED", self._ns_cell_2g, self._networking_api, self._logger,
self._registration_timeout)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml (Non blocking
# for this test if function isn't implemented on CDK)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Get RAT from Equipment
network_type = self._ns_data_2g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid)
# Check Data Connection State => PDP Active before timeout
self._ns_data_2g.check_data_connection_state(
"PDP_ACTIVE", self._registration_timeout)
# Check that operator gave a valid Voice call number
# Perform MO voice call on active network simulator
if self._phone_number is None:
# Raise an error message as no valid phone number has been set by the operator
self._error.Msg = "Phone number has no valid value"
self._logger.error(self._error.Msg)
raise AcsConfigException(AcsConfigException.PROHIBITIVE_BEHAVIOR,
self._error.Msg)
return Global.SUCCESS, "No errors"
def go_out_of_coverage_and_cresel(self,
ns_camped_cell,
ns_neighbour_cell,
ns_neighbour_data,
ns_neighbour_cell_service,
cresel_power,
ns_neighbour_model,
cresel_timeout,
cresel_nocoverage_time):
"""
Decrease cell power in case of IDLE Cell Reselection
:type ns_camped_cell: str
:param ns_camped_cell: "Camped" Network Simulator Cell API
:type ns_neighbour_cell: str
:param ns_neighbour_cell: "NEIGHBOUR" Network Simulator Cell API
:type ns_neighbour_data: str
:param ns_neighbour_data: "NEIGHBOUR" Network Simulator Data API
:type cresel_power: float
:param cresel_power: cell power of the neighbour cell
:type cresel_timeout: float
:param cresel_timeout: time to go from no coverage to attach to a new cell
:type cresel_nocoverage_time: float
:param cresel_nocoverage_time: time to stay in no coverage
"""
# Set camped cell power to -115dBm
ns_camped_cell.set_cell_power(-115)
self._logger.info("Going to no coverage zone")
# stay a while unregistered
time.sleep(cresel_nocoverage_time)
# if the DUT is not unregistered test is failed
if self._modem_api.get_network_registration_status() != "unregistered":
msg = "DUT is not unregistered"
self._logger.error(msg)
# Return message and quit the method
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
# Set final Neighbour cell power to NS2_CELL_POWER
ns_neighbour_cell.set_cell_power(cresel_power)
# the Connection State to check we are using PXT or AGILENT8960
if ns_neighbour_model == "AGILENT_8960":
conn_state = "ATTACHED"
elif ns_neighbour_model == "AGILENT_E6621A":
conn_state = "CON"
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
if ns_neighbour_cell_service in ("GSM",
"WCDMA",
"PACKET"):
# Check phone registration on equipment before given CAMP_TIMEOUT
# (in loop compare every second the IMSI returned by the simulator
# and IMSI read on CDK until comparison is true or timeout expired)
if(RegUtil.check_dut_registration_before_timeout(ns_neighbour_cell,
self._networking_api,
self._logger,
dut_imsi,
cresel_timeout,
False,
False)):
# Log the cell reselection success
self._logger.info("Cell reselection succeeded")
# DUT Camped on neighbour cell, break function to quit the loop
else:
self.resel_error()
else:
# Check Data Connection State => conn_state before timeout
if(ns_neighbour_data.check_data_connection_state(conn_state,
cresel_timeout,
False)):
# Log the cell reselection success
self._logger.info("Cell reselection succeeded ")
# DUT Camped on neighbour cell, break function to quit the loop
else:
# Log that Cell Reselection has failed
self.resel_error()
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Activate the flight mode.
self._networking_api.set_flight_mode("on")
# Connect to equipment
self._ns.init()
# Set the equipment application format GSM/GPRS
self._ns.switch_app_format("GSM/GPRS")
time.sleep(self._wait_btwn_cmd)
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_2g.set_cell_off()
# Set serving cell to EGPRS
self._ns_cell_2g.set_cell_service("EGPRS")
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set the equipment IP address 1
self._ns.set_ip4_lan_address(self._ns_IP_Lan1)
# Set the equipment IP_Lan2 to the equipment
self._ns.set_ip4_lan_address2(self._ns_IP_Lan2)
# Set the equipment subnet mask
self._ns.set_ip4_subnet_mask(self._ns_Subnet_Mask)
# Set the equipment default gateway
self._ns.set_ip4_default_gateway(self._ns_Default_Gateway)
# Set the DUT IP address 1
self._ns_data_2g.set_dut_ip_address(1, self._ns_DUT_IP_Address)
# Set the DUT IP address 2 if not empty str.
if self._ns_DUT_IP_Address2 != "":
self._ns_data_2g.set_dut_ip_address(2, self._ns_DUT_IP_Address2)
# Set the DUT DNS1
self._ns_data_2g.set_dut_primary_dns(self._ns_DNS1)
# Set the DUT DNS2
self._ns_data_2g.set_dut_secondary_dns(self._ns_DNS2)
# Call specific configuration functions
# Some parameters are defined by function
RegUtil.setup_cell(self._ns_number, self._ns_model, self.ns_cell_tech,
self._band_name, self._ns_cell_rel, self._logger)
# Set Cell Power using CELL_POWER parameter
self._ns_cell_2g.set_cell_power(self._cell_power)
# Set connection type to auto
self._ns_data_2g.set_connection_type("AUTO")
# Set the multislot configuration
self._ns_data_2g.set_multislot_config(self._multislot)
# Set the downlink and uplink Modulation Coding Schema
# (DL_MCS and UL_MCS)
self._ns_data_2g.set_pdtch_modulation_coding_scheme(
self._dl_mcs, self._ul_mcs)
# Set the Puncturing Modulation Coding Schema (PS_MCS)
self._ns_data_2g.set_pdtch_puncturing_scheme(self._ps_mcs)
# Set cell on
self._ns_cell_2g.set_cell_on()
self._modem_api.check_cdk_no_registration_bfor_timeout(
self._registration_timeout)
# Deactivate the flight mode.
self._networking_api.set_flight_mode("off")
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml (Non blocking
# for this test if function isn't implemented on CDK)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => PDP Active before timeout
self._ns_data_2g.check_data_connection_state(
"PDP_ACTIVE", self._registration_timeout)
# Get RAT from Equipment
network_type = self._ns_data_2g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
return Global.SUCCESS, "No errors"
def decrease_cell_power_while_idle(self,
ns_camped_cell,
ns_camped_cell_power,
ns_neighbour_cell,
ns_neighbour_data,
ns_neighbour_cell_service,
decrementation_step_power,
decrementation_step_timer,
cresel_limit_power,
cresel_power,
ns_neighbour_model):
"""
Decrease cell power in case of IDLE Cell Reselection
:type ns_camped_cell: str
:param ns_camped_cell: "Camped" Network Simulator Cell API
:type ns_camped_cell_power: float
:param ns_camped_cell_power: "Camped" Network Simulator cell power
:type ns_neighbour_cell: str
:param ns_neighbour_cell: "NEIGHBOUR" Network Simulator Cell API
:type ns_neighbour_data: str
:param ns_neighbour_data: "NEIGHBOUR" Network Simulator Data API
:type ns_neighbour_cell_power: float
:param ns_neighbour_cell_power: cell power of the neighbour cell
:type decrementation_step_power: float
:param decrementation_step_power: Decrementation step for
NS1 cell power in dBm (must be positive, can be decimal value
like 0,20 or 2,6)
:type decrementation_step_timer: float
:param decrementation_step_timer: Decrementation step timer
in seconds between 2 steps (must be positive, can be
decimal value like 0,3 or 3,5)
:type cresel_power: float
:param cresel_power: cell power of the neighbour cell
:type cresel_limit_power: float
:param cresel_limit_power: Limit power to stop the cell
reselection power if reached
"""
self._logger.info("Set the neighbour cell power to %.2f dBm ", cresel_power)
# Set final Neighbour cell power to NS2_CELL_POWER
ns_neighbour_cell.set_cell_power(cresel_power)
# the Connection State to check we are using PXT or AGILENT8960
if ns_neighbour_model == "AGILENT_8960":
conn_state = "ATTACHED"
elif ns_neighbour_model == "AGILENT_E6621A":
conn_state = "CON"
# WHILE DUT is registered to the "Camped"
# cell AND ns_camped_cell_power <= cresel_limit_power
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
while True:
# Decrement active cell power
ns_camped_cell_power -= decrementation_step_power
ns_camped_cell.set_cell_power(ns_camped_cell_power)
# Wait during DECREMENTATION_STEP_TIMER
time.sleep(decrementation_step_timer)
if ns_neighbour_cell_service in ("GSM", "CIRCUIT"):
# Check phone registration on equipment before given CAMP_TIMEOUT
# (in loop compare every second the IMSI returned by the simulator
# and IMSI read on CDK until comparison is true or timeout expired)
if(RegUtil.check_dut_registration_before_timeout(ns_neighbour_cell,
self._networking_api,
self._logger,
dut_imsi,
decrementation_step_timer,
flightmode_cycle=False,
blocking=False)):
# Log the cell reselection success
self._logger.info(
"Cell reselection succeeded at %.2f dBm " +
"Camped cell power.",
ns_camped_cell_power)
# DUT Camped on neighbour cell, break function to quit the loop
break
else:
# Check Data Connection State => conn_state before timeout
if ns_neighbour_data.check_data_connection_state(conn_state, decrementation_step_timer, False):
# Log the cell reselection success
self._logger.info(
"Cell reselection succeeded at %.2f dBm " +
"Camped cell power.",
ns_camped_cell_power)
# DUT Camped on neighbour cell, break function to quit the loop
break
# IF ns_camped_cell_power < cresel_limit_power
if ns_camped_cell_power < cresel_limit_power:
# Log the cell reselection failure
msg = self._logger.error("The Power's limit has been reached %.2f dBm, Cell reselection has failed",
cresel_limit_power)
# Return message and quit the method
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
# IF DUT is registered to the Neighbour cell before registration timeout
# When in GSM there is no data connection but IMSI have already been checked
if ns_neighbour_cell_service in "GSM":
# Log that cell reselection is done
self._logger.info("Cell reselection success.")
ns_camped_cell.set_cell_power(cresel_limit_power)
elif ns_neighbour_data.check_data_connection_state(conn_state, decrementation_step_timer, False):
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(ns_neighbour_data.get_network_type(),
self._registration_timeout)
# Log that cell reselection is done
self._logger.info("Cell reselection success.")
ns_camped_cell.set_cell_power(cresel_limit_power)
else:
# Log that Cell Reselection has failed
msg = self._logger.error("Cell reselection has failed.")
# Return message and quit the method
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
def decrease_cell_power_while_idle_no_pdp(self,
ns_camped_cell,
ns_camped_cell_power,
ns_neighbour_cell,
ns_neighbour_data,
decrementation_step_power,
decrementation_step_timer,
cresel_limit_power,
cresel_power,
ns_neighbour_model):
"""
Decrease cell power in case of IDLE Cell Reselection with no PDP context
:type ns_camped_cell: str
:param ns_camped_cell: "Camped" Network Simulator Cell API
:type ns_camped_cell_power: float
:param ns_camped_cell_power: "Camped" Network Simulator cell power
:type ns_neighbour_cell: str
:param ns_neighbour_cell: "NEIGHBOUR" Network Simulator Cell API
:type ns_neighbour_data: str
:param ns_neighbour_data: "NEIGHBOUR" Network Simulator Data API
:type ns_neighbour_cell_power: float
:param ns_neighbour_cell_power: cell power of the neighbour cell
:type decrementation_step_power: float
:param decrementation_step_power: Decrementation step for
NS1 cell power in dBm (must be positive, can be decimal value
like 0,20 or 2,6)
:type decrementation_step_timer: float
:param decrementation_step_timer: Decrementation step timer
in seconds between 2 steps (must be positive, can be
decimal value like 0,3 or 3,5)
:type cresel_limit_power: float
:param cresel_limit_power: Limit power to stop the cell
:type cresel_power: float
:param cresel_power: cell power of the neighbour cell
reselection power if reached
"""
self._logger.info("Set the neighbour cell power to %.2f dBm ", cresel_power)
# Set final Neighbour cell power to NS2_CELL_POWER
ns_neighbour_cell.set_cell_power(cresel_power)
# WHILE DUT is registered to the "Camped"
# cell AND ns_camped_cell_power <= cresel_limit_power
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
while True:
# Wake up screen
self._phone_system_api.wake_screen()
# Decrement active cell power
ns_camped_cell_power -= decrementation_step_power
ns_camped_cell.set_cell_power(ns_camped_cell_power)
# Wait during DECREMENTATION_STEP_TIMER
time.sleep(decrementation_step_timer)
# Check that DUT is registered on the good RAT
if self._modem_api.check_network_type_before_timeout(ns_neighbour_data.get_network_type(),
decrementation_step_timer):
# Check phone registration on equipment before given CAMP_TIMEOUT
# (in loop compare every second the IMSI returned by the simulator
# and IMSI read on CDK until comparison is true or timeout expired)
if(RegUtil.check_dut_registration_before_timeout(ns_neighbour_cell,
self._networking_api,
self._logger,
dut_imsi,
decrementation_step_timer,
flightmode_cycle=False,
blocking=False)):
# Log the cell reselection success
self._logger.info(
"Cell reselection succeeded at %.2f dBm " +
"Camped cell power.",
ns_camped_cell_power)
# DUT Camped on neighbour cell, break function to quit the loop
# Log that cell reselection is done
self._logger.info("Cell reselection success.")
ns_camped_cell.set_cell_power(cresel_limit_power)
break
# IF ns_camped_cell_power < cresel_limit_power
if ns_camped_cell_power < cresel_limit_power:
# Log the cell reselection failure
msg = self._logger.error("The Power's limit has been reached %.2f dBm, Cell reselection has failed",
cresel_limit_power)
# Return message and quit the method
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Activate the flight mode.
self._networking_api.set_flight_mode("on")
# Connect to equipment
self._ns.init()
# Set the equipment application format WCDMA
self._ns.switch_app_format("WCDMA")
time.sleep(self._wait_btwn_cmd)
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_3g.set_cell_off()
# Set IP addresses for the 3GSM NS
self._ns.set_ip_addresses(self._ns_IP_Lan1, self._ns_IP_Lan2,
self._ns_Subnet_Mask,
self._ns_Default_Gateway,
self._ns_DUT_IP_Address, self._ns_DNS1,
self._ns_DNS2)
if self._ip_version == "IPV6":
# Setting the version of the first DUT IP to IPV6
self._ns_data_3g.set_dut_ip_version(1, "IP6")
# Setting the IPv6 Prefix and IID
self._ns_data_3g.set_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the DUT IPv6 Prefix and IID
self._ns_data_3g.set_dut_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the Agilent to IPV6 router mode.
self._ns.set_ipv6_router_mode("ON")
elif self._ip_version == "IPV4V6":
# Setting the version of the first DUT IP to IPV6
self._ns_data_3g.set_dut_ip_version(1, "DUAL")
# Setting the IPv6 Prefix and IID
self._ns_data_3g.set_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the DUT IPv6 Prefix and IID
self._ns_data_3g.set_dut_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the Agilent to IPV6 router mode.
self._ns.set_ipv6_router_mode("ON")
else:
# Setting the version of the first DUT IP to IPV4
self._ns_data_3g.set_dut_ip_version(1, "IP4")
# Setting the Agilent to IPV6 router mode.
self._ns.set_ipv6_router_mode("OFF")
# Set the DUT IP address 2 if not empty str.
if self._ns_DUT_IP_Address2 != "":
self._ns_data_3g.set_dut_ip_address(2, self._ns_DUT_IP_Address2)
# 3G default cell setup
RegUtil.setup_cell(self._ns_number, self._ns_model, "3G", self._band,
self._ns_cell_rel, self._logger)
# Set Cell Band and ARFCN using 3GSM_CELL_BAND
# and 3GSM_ARFCN parameters
# Set cell service using 3GSM_CELL_SERVICE parameter
# Set Cell Power using 3GSM_CELL_POWER parameter
# Set Cell LAC using 3GSM_LAC_VALUE parameter
# Set Cell RAC using 3GSM_RAC_VALUE parameter
self._ns_cell_3g.configure_basic_cell_parameters(
self._cell_service, self._band, self._dl_uarfcn, self._cell_power)
# Set BCH update page state to AUTO
self._ns_cell_3g.set_bch_update_page_state("AUTO")
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# If the fast dormancy parameter is set to disable do nothing to
# avoid regressions.
if self._ns_fast_dormancy.lower() == "enable":
# Setting fast dormancy support according to the parameter
# present in the bench config.
self._ns_data_3g.\
set_fast_dormancy_support("enable", self._rrc_inactivity_timer)
# Set Uplink channel mode control to auto
self._ns_cell_3g.set_uplink_channel_mode("ON")
# Active SRB Configuration Control to AUTO
self._ns_cell_3g.set_srb_config_control("ON")
# Set the initial PS Data RRC State to DCH
self._ns_data_3g.set_initial_ps_data_rrc_state("DCH")
# Sets the GPRS Radio Access Bearer
if self._ul_rab.find("HSUPA_CAT") != -1:
self._ns_data_3g.set_gprs_radio_access_bearer("HSUPA", "HSDPA")
else:
self._ns_data_3g.set_gprs_radio_access_bearer(
self._ul_rab, "HSDPA")
# Set the category configuration to AUTO
self._ns_data_3g.set_category_control_mode("ON")
# Set channel type, the default value is "HSPA"
self._ns_cell_3g.set_rbt_channel_type(self._rbt_channel_type)
# Call specific configuration functions
self._setup_high_categories(self._ns_number)
# configure HS-DSCH config type (FIXED, REPORTED, USER_DEFINED)
self._ns_data_3g.set_ps_data_configuration_type(self._cqi_scheme)
if self._cqi_scheme == "FIXED":
self._ns_data_3g.set_cqi_value(self._cqi)
# Set the TTI value
if self._tti:
self._ns_data_3g.set_hsupa_tti(self._tti)
# Call specific configuration functions
self._setup_cpc_feature(self._ns_number)
# Set Ps Data E-RGCH Information state to off
# Only if this param is overridden in the UC
# The default value is ON to transmit an E-RGCH from test set
if self._ps_data_ergch_information_state == "OFF":
self._ns_cell_3g.set_ps_data_ergch_information_state(
self._ps_data_ergch_information_state)
# Set PS Data HS-DSCH MAC-d PDU Size
self._ns_data_3g.set_macd_pdu_size(self._mac_d_pdu_size)
# Phone has to see the cell off!
self._modem_api.check_cdk_no_registration_bfor_timeout(
self._registration_timeout)
# Set cell on
self._ns_cell_3g.set_cell_on()
# Deactivate the flight mode.
self._networking_api.set_flight_mode("off")
# Check Data Connection State => ATTACHED before timeout
self._ns_data_3g.check_data_connection_state(
"ATTACHED", self._registration_timeout)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml (Non blocking
# for this test if function isn't implemented on CDK)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
# Increase cell power if needed
check_and_set_minimal_cell_power(self._ns_cell_3g, self._modem_api,
self._dut_config, self._cell_power)
if self._ip_version == "IPV6":
self._logger.info("Setting APN " + str(self._apn) + " on " +
str(self._ip_version))
self._networking_api.set_apn(self._ssid, self._apn, None, None,
self._ip_version)
elif self._ip_version == "IPV4V6":
self._logger.info("Setting APN " + str(self._apn) + " on " +
str(self._ip_version))
self._networking_api.set_apn(self._ssid, self._apn, None, None,
self._ip_version)
else:
self._logger.info("Setting APN " + str(self._apn) + " on IPV4 ")
self._networking_api.set_apn(self._ssid, self._apn)
RegUtil.configure_ims_for_8960(self._ns_data_3g, self._networking_api,
self._logger)
if self._pdp_activation.lower() == "true":
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, False)
# Force screen on to avoid end of PDP context due to fast dormancy
self._phone_system.wake_screen()
self._phone_system.set_phone_screen_lock_on(1)
# Check Data Connection State => PDP Active before timeout
self._ns_data_3g.check_data_connection_state(
"PDP_ACTIVE", self._registration_timeout, blocking=False)
# Get RAT from Equipment
network_type = self._ns_data_3g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
# Force screen on to avoid end of PDP context due to fast dormancy
self._phone_system.wake_screen()
self._phone_system.set_phone_screen_lock_on(1)
if self._ns_data_3g.get_data_connection_status() != "PDP_ACTIVE":
self._networking_api.reactivate_pdp_context(self._ssid, False)
self._ns_data_3g.check_data_connection_state(
"PDP_ACTIVE", self._registration_timeout, blocking=False)
# Check IP protocol if needed (not needed for KPI test)
if not self._kpi_test:
self._networking_api.check_ip_protocol(self._ip_version)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call use case base Setup function
UseCaseBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
# Determinates the kind of registration state to wait
# by comparing test case MCC/MNC parameters to sim MCC/MNC
sim_info = self._modem_api.get_sim_operator_info()
if sim_info["MCC"] != self._mcc or\
sim_info["MNC"] != self._mnc:
self._wanted_reg_state = "roaming"
else:
self._wanted_reg_state = "registered"
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Enable flight mode
self._networking_api.set_flight_mode("on")
# Connect to equipment using GPIBAddress and GPIBBoardId
self._ns.init()
# Set the equipment application format GSM/GPRS
self._ns.switch_app_format("GSM/GPRS")
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_2g.set_cell_off()
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set Cell Band using CELL_BAND parameter
self._ns_cell_2g.set_band(self._band_name)
# Set Broadcast Channel Arfcn using BCH_ARFCN parameter
self._ns_cell_2g.set_bcch_arfcn(self._bch_arfcn)
# Set Traffic Channel Arfcn using TCH_ARFCN parameter
self._ns_cell_2g.set_tch_arfcn(self._tch_arfcn)
# Set Mobile Country Code (MCC)
self._ns_cell_2g.set_mcc(self._mcc)
# Set Mobile Network Code (MNC)
self._ns_cell_2g.set_mnc(self._mnc)
# Set cell service using CELL_SERVICE parameter
self._ns_cell_2g.set_cell_service(self._cell_service)
# Set Cell Power using CELL_POWER parameter
self._ns_cell_2g.set_cell_power(self._cell_power)
# Set VOICE_CODER_RATE
self._ns_voice_call_2g.set_audio_codec(self._voice_coder_rate)
# Set DTM OFF
self._logger.info("Setting DTM OFF")
self._ns_cell_2g.set_dtm_state("OFF")
# Set cell on
self._ns_cell_2g.set_cell_on()
# Disable airplane mode
self._networking_api.set_flight_mode("off")
# Adapt attachment procedure to CIRCUIT or PACKET
if "GSM" not in self._cell_service:
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout("PDP_ACTIVE",
self._ns_cell_2g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._logger.info("Check network registration status is %s on DUT" %
self._wanted_reg_state)
if self._wanted_reg_state == "roaming":
self._modem_api.check_cdk_state_bfor_timeout(
self._wanted_reg_state,
self._registration_timeout)
else:
self._modem_api.check_cdk_registration_bfor_timeout(self._registration_timeout)
# Get RAT from Equipment
network_type = self._ns_data_2g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(network_type,
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
# Determinates the kind of registration state to wait
# by comparing test case MCC/MNC parameters to sim MCC/MNC
sim_info = self._modem_api.get_sim_operator_info()
if sim_info["MCC"] != self._mcc or\
sim_info["MNC"] != self._mnc:
self._wanted_reg_state = "roaming"
self._networking_api.set_roaming_mode("ON")
else:
self._wanted_reg_state = "registered"
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Activate the flight mode.
self._networking_api.set_flight_mode("on")
# Connect to equipment using GPIBAddress and GPIBBoardId
self._ns.init()
# Set the equipment application format WCDMA
self._ns.switch_app_format("WCDMA")
time.sleep(self._wait_btwn_cmd)
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_3g.set_cell_off()
# Set IP addresses for the 3GSM NS
self._ns.set_ip_addresses(self._ns_IP_Lan1, self._ns_IP_Lan2,
self._ns_Subnet_Mask,
self._ns_Default_Gateway,
self._ns_DUT_IP_Address, self._ns_DNS1,
self._ns_DNS2)
if self._ip_version == "IPV6":
# Setting the version of the first DUT IP to IPV6
self._ns_data_3g.set_dut_ip_version(1, "IP6")
# Setting the IPv6 Prefix and IID
self._ns_data_3g.set_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the DUT IPv6 Prefix and IID
self._ns_data_3g.set_dut_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the Agilent to IPV6 router mode.
self._ns.set_ipv6_router_mode("ON")
elif self._ip_version == "IPV4V6":
# Setting the version of the first DUT IP to IPV6
self._ns_data_3g.set_dut_ip_version(1, "DUAL")
# Setting the IPv6 Prefix and IID
self._ns_data_3g.set_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the DUT IPv6 Prefix and IID
self._ns_data_3g.set_dut_ip6_network_parameters(
self._server_ip_v6_address)
# Setting the Agilent to IPV6 router mode.
self._ns.set_ipv6_router_mode("ON")
# Set the DUT IP address 2 if not empty str.
if self._ns_DUT_IP_Address2 != "":
self._ns_data_3g.set_dut_ip_address(2, self._ns_DUT_IP_Address2)
# 3G default cell setup
RegUtil.setup_cell(self._ns_number, self._ns_model, "3G", self._band,
self._ns_cell_rel, self._logger)
# Set Cell Band and ARFCN using 3GSM_CELL_BAND
# and 3GSM_ARFCN parameters
# Set cell service using 3GSM_CELL_SERVICE parameter
# Set Cell Power using 3GSM_CELL_POWER parameter
# Set Cell LAC using 3GSM_LAC_VALUE parameter
# Set Cell RAC using 3GSM_RAC_VALUE parameter
self._ns_cell_3g.configure_basic_cell_parameters(
self._cell_service, self._band, self._dl_uarfcn, self._cell_power,
1, 1, self._mcc, self._mnc)
message = "Expected network registration state to be %s while " \
"HPMLN coverage is %s, MCCODE is %s and MNCODE is %s" % (
str(self._wanted_reg_state),
str(self._hplmn_coverage),
str(self._mcc),
str(self._mnc))
self._logger.info(message)
# Set BCH update page state to AUTO
self._ns_cell_3g.set_bch_update_page_state("AUTO")
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# If the fast dormancy parameter is set to disable do nothing to
# avoid regressions.
if self._ns_fast_dormancy.lower() == "enable":
# Setting fast dormancy support according to the parameter
# present in the bench config.
self._ns_data_3g.\
set_fast_dormancy_support("enable")
# Set Uplink channel mode control to auto
self._ns_cell_3g.set_uplink_channel_mode("ON")
# Active SRB Configuration Control to AUTO
self._ns_cell_3g.set_srb_config_control("ON")
# Set the initial PS Data RRC State to DCH
self._ns_data_3g.set_initial_ps_data_rrc_state("DCH")
# Sets the GPRS Radio Access Bearer
self._ns_data_3g.set_gprs_radio_access_bearer(self._ul_rab,
self._dl_rab)
# Deactivate HSUPA and HSDPA capabilities
self._ns_data_3g.set_edch_cell_capability("OFF")
self._ns_data_3g.set_hsdpa_cell_capability("OFF")
# Phone has to see the cell off!
self._modem_api.check_cdk_no_registration_bfor_timeout(
self._registration_timeout)
# Set cell on
self._ns_cell_3g.set_cell_on()
# Deactivate the flight mode.
self._networking_api.set_flight_mode("off")
# Check Data Connection State => ATTACHED before timeout
self._ns_data_3g.check_data_connection_state(
"ATTACHED", self._registration_timeout)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml (Non blocking
# for this test if function isn't implemented on CDK)
self._modem_api.check_cdk_state_bfor_timeout(
self._wanted_reg_state, self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
if self._ip_version == "IPV6":
self._logger.info("Setting APN " + str(self._apn) + " on " +
str(self._ip_version) + "...")
self._networking_api.set_apn(self._ssid, self._apn, None, None,
self._ip_version)
elif self._ip_version == "IPV4V6":
self._logger.info("Setting APN " + str(self._apn) + " on " +
str(self._ip_version) + "...")
self._networking_api.set_apn(self._ssid, self._apn, None, None,
self._ip_version)
else:
self._logger.info("Setting APN " + str(self._apn) + " on IPV4 ")
self._networking_api.set_apn(self._ssid, self._apn)
if self._wanted_reg_state == "registered":
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid)
# Check Data Connection State => PDP Active before timeout
self._ns_data_3g.check_data_connection_state(
"PDP_ACTIVE", self._registration_timeout, blocking=False)
# Get RAT from Equipment
network_type = self._ns_data_3g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call use case base Setup function
UseCaseBase.set_up(self)
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Connect to equipment
self._ns.init()
# Set the equipment Application Format = "GSM/GPRS"
self._ns.switch_app_format("GSM/GPRS")
# Perform full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_2g.set_cell_off()
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set serving cell to EGPRS
self._ns_cell_2g.set_cell_service("EGPRS")
# Set cell power using CELL_POWER value
self._ns_cell_2g.set_cell_power(self._cell_power)
# Select the band
self._ns_cell_2g.set_band(self._band_name)
# Set broadcast channel ARFCN using BCH_ARFCN value
self._ns_cell_2g.set_bcch_arfcn(self._bch_arfcn)
# Set packet data channel ARFCN using PDTCH_ARFCN value
self._ns_cell_2g.set_pdtch_arfcn(self._pdtch_arfcn)
# Set cell on
self._ns_cell_2g.set_cell_on()
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout("ATTACHED",
self._ns_cell_2g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid)
# Check Data Connection State => PDP Active before timeout
self._ns_data_2g.check_data_connection_state("PDP_ACTIVE",
self._registration_timeout,
blocking=False)
# Get RAT from Equipment
network_type = self._ns_data_2g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(network_type,
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
# Call UseCase base set_up function
UseCaseBase.set_up(self)
# get original audio output
self._origianl_audio_output = \
self._phonesystem_api.get_audio_output()
# get original silent mode and vibrate mode
self._original_silent_vibrate = \
self._phonesystem_api.get_silent_vibrate()
# Connect to equipment using GPIBBoardId and GPIBAddress parameters
self._ns.init()
# Set the equipment application format WCDMA
self._ns.switch_app_format("WCDMA")
# Perform a full preset
self._ns.perform_full_preset()
# Set Cell off
self._ns_cell_3g.set_cell_off()
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# "Set Cell Service in function of the CELL_SERVICE value :
# ""CIRCUIT"" : paging service is AMR
# PS domain is ABSENT
# ""PACKET"" : paging service is GPRS
# PS domain is PRESENT
# ""CIRCUIT_PACKET"": paging service is AMR
# PS domain is PRESENT
# ""RBTEST"" : paging service is RBT"
self._ns_cell_3g.set_cell_service(self._cell_service)
# Set Cell Band UARFCN (downlink) using Band and DlUarfcn
self._ns_cell_3g.set_band_and_dl_arfcn(
"BAND" + str(self._band), self._dl_uarfcn)
# Set Cell Band UARFCN (uplink) in auto mode
self._ns_cell_3g.set_uplink_channel_mode("ON")
# Set Audio codec using VOICE_CODER_RATE parameter
self._ns_voice_call_3g.set_audio_codec(self._voice_coder_rate)
# Set SRB Configuration Control to auto
self._ns_cell_3g.set_srb_config_control("ON")
# Set Cell Power using CELL_POWER parameter
self._ns_cell_3g.set_cell_power(self._cell_power)
# Set Cell on
self._ns_cell_3g.set_cell_on()
# Set ringtone time using RT_TIME parameter, no command in 8960 for
# this setting right now
# self._ns._voice_call_3g.set_mt_originate_call_timeout(self._rt_time)
# Adapt attachment procedure to CIRCUIT or PACKET
if self._cell_service == "CIRCUIT":
# Check phone registration on equipment before given CAMP_TIMEOUT
# (in loop compare every second the IMSI returned by the simulator
# and IMSI read on CDK until comparison is true or timeout expired)
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
RegUtil.check_dut_registration_before_timeout(self._ns_cell_3g,
self._networking_api,
self._logger,
dut_imsi,
self._registration_timeout)
else:
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout("ATTACHED",
self._ns_cell_3g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Get RAT from Equipment
network_type = self._ns_data_3g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(network_type,
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call UseCaseBase Setup function
UseCaseBase.set_up(self)
# Connect to cellular network simulator
self._ns.init()
# Set the equipment application format WCDMA
self._ns.switch_app_format("WCDMA")
if self._audio_analyzer_node.get_param_value("Model") in "RS_UPV":
# Connect to audio analyzer
self._audio_analyzer.init()
if self._aa_ref_file_path:
# Copy audio test file to UPV
self._audio_analyzer.copy_to_upv(self._host_ref_file_path,
self._aa_ref_file_path)
# Load setup on UPV
self._audio_analyzer.load_configuration(
self._name,
str(self._ns_node.get_param_value("Model")),
self._aa_ref_file_path,
self._codec_type,
self._option)
if not os.path.exists(os.path.join(self._aa_conf_path, "UPV_traces")):
os.mkdir(os.path.join(self._aa_conf_path, "UPV_traces"))
elif self._audio_analyzer_node.get_param_value("Model") in "AUDIO_FRAMEWORK":
AudioFramework.initialize_fwk(self._audio_framework)
# Perform Full Preset
self._ns.perform_full_preset()
# Set paging service to AMR VOICE
self._ns.get_cell_3g().set_cell_service(self._cell_service)
# Set cell off
self._ns_3g.set_cell_off()
# Set Cell Band UARFCN (downlink) using Band and DlUarfcn
self._ns.get_cell_3g().set_band_and_dl_arfcn(str(self._band), self._dl_uarfcn)
# Set voice call output
self._vc_3g.set_speech_configuration(self._ns_speech_source)
# Set cell on
self._ns_3g.set_cell_on()
# Adapt attachment procedure to CIRCUIT or PACKET
if self._cell_service == "CIRCUIT":
# Check phone registration on equipment before given CAMP_TIMEOUT
# (in loop compare every second the IMSI returned by the simulator
# and IMSI read on CDK until comparison is true or timeout expired)
dut_imsi = \
self._modem_api.get_imsi(self._registration_timeout)
RegUtil.check_dut_registration_before_timeout(self._ns.get_cell_3g(),
self._networking_api,
self._logger,
dut_imsi,
self._registration_timeout)
self._networking_api.deactivate_pdp_context()
else:
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout("PDP_ACTIVE",
self._ns.get_cell_3g(),
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration status before registrationTimeout (CDK)
self._modem_api.check_cdk_registration_bfor_timeout(self._registration_timeout)
# Release any previous call (Robustness)
self._voicecall_api.release()
# Set voice codec using CODEC parameter
self._vc_3g.set_audio_codec(self._codec)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
# Determinates the kind of registration state to wait
# by comparing test case MCC/MNC parameters to sim MCC/MNC
sim_info = self._modem_api.get_sim_operator_info()
if sim_info["MCC"] != self._mcc or\
sim_info["MNC"] != self._mnc:
self._wanted_reg_state = "roaming"
self._networking_api.set_roaming_mode("ON")
else:
self._wanted_reg_state = "registered"
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Flight mode activation
self._networking_api.set_flight_mode("on")
# Phone has to see the cell off!
self._modem_api.check_cdk_no_registration_bfor_timeout(
self._registration_timeout)
# Connect to equipment
self._ns.init()
# Perform a full preset
self._ns.perform_full_preset()
# Wait a while for the full preset
time.sleep(self._wait_btwn_cmd)
# Set EPC off, not for CMW500 because DAU starting is a long lasting time operation
if self._ns_model == "AGILENT_E6621A":
self._ns_data_4g.set_epc_off()
# Set cell off
self._ns_cell_4g.set_cell_off()
self._ns.configure_amplitude_offset_table()
self._check_ip_version()
if self._ip_version in ["IPV4V6", "IPV6"]:
self._ns_dut_ip_Address = self._ns_dut_ipv6_Address
# Perform setup for a FDD cell
if self._duplex_type == "FDD":
# Load Cell Configuration
self._ns.load_cell_config("COMMON_LTE", self._ns_number)
self._ns.load_cell_config(self._cell_band, self._ns_number)
if self._carrier_aggregation:
self._ns.load_cell_config("CAT6", self._ns_number)
if self._ims == "on":
self._ns.load_cell_config("COMMON_IMS", self._ns_number)
if self._ip_version != "IPV4":
self._ns_data_4g.set_ims_ip_version(self._ip_version)
# Call specific configuration functions
RegUtil.setup_cell_lte(self._ns, self._mcc, self._mnc,
self._ns_dut_ip_Address, self._signal_mode,
self._cell_id, self._physical_cell_id,
self._mimo, self._cell_power_rf1,
self._cell_power_rf2, self._scenario_path,
self._cell_band, self._dl_earfcn, self._apn)
# Set EPC on for Agilent PXT or DAU for RCW500
self._ns_data_4g.set_epc_on()
if self._ims == "on":
self._ns_cell_4g.set_ims_on()
time.sleep(self._wait_btwn_cmd)
# stop scenario to set cell parameters
self._ns.stop_scenario()
# set configuration for LTE
self._ns_cell_4g.set_lte_configuration(
self._antennas_number, self._bandwidth,
self._transmission_mode, self._type0_bitmap,
self._ul_grant_mode, self._dl_nb_rb, self._dl_i_mcs,
self._ul_nb_rb, self._ul_i_mcs, self._mimo,
self._carrier_aggregation)
# Set configugation on Secondary Component Carrier
if self._carrier_aggregation:
self._ns_cell_4g.set_secondary_carrier_configuration(
self._scc_band, self._scc_earfcn, self._scc_bandwidth,
self._cell_power_rf1, self._scc_dl_nb_rb,
self._scc_dl_i_mcs)
# Start the scenario
self._ns.start_scenario()
elif self._duplex_type == "TDD":
if self._ip_version in ["IPV4V6", "IPV6"]:
# Setting the IPv6 Prefix and IID on the CallBox
self._ns_data_4g.set_ip6_network_parameters(
self._server_ip_v6_address)
# Set the DUT IP address
self._ns_data_4g.set_dut_ip_address(self._ns_dut_ip_Address)
# Load LTE TDD optimal configuration
self._ns.load_cell_config("TDD_COMMON", self._ns_number)
if hasattr(self, "_lte_tdd_config"):
self._ns.load_cell_config(self._lte_tdd_config,
self._ns_number)
if self._cell_band is not None and not self._switch_tdd_fdd:
self._ns_cell_4g.set_cell_band(self._cell_band)
self._ns_cell_4g.set_downlink_earfcn(self._dl_earfcn)
# Set MIMO mode
self._ns_cell_4g.set_lte_tdd_configuration(self._antennas_number,
self._mimo)
else:
return Global.FAILURE, "Wrong duplex type for LTE: %s it must be FDD or TDD" % self._duplex_type
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobilityLte3gsmBase set_up function
LabMobilityLte3gsmBase.set_up(self)
# Setting the EPC OFF on PXT
self._ns_lte_data.set_epc_off()
# Set Network Simulator 3GSM cell on
self._ns_3gsm_cell.set_cell_on()
# Set the LTE cell on
self._ns_lte_cell.set_cell_on(self._ns_lte_mimo)
# Set entries in the equivalent PLMN list
self._ns_3gsm_cell.set_equivalent_plmn_list_points(
self._ns_lte_mcc, self._ns_lte_mnc)
# Disconnect from external EPC
self._ns_3gsm.disconnect_from_external_epc()
# Set External EPC connection
self._ns_3gsm_cell.set_external_epc_connection(self._ns_lte_ip_lan1,
self._ns_lte_dl_earfcn)
# Set EPC on
self._ns_lte_data.set_epc_on()
# STOP the scenario for PXT for allowing the DUT to camp on 3G/2G cell before
self._ns_lte.stop_scenario()
# Flight mode deactivation
self._networking_api.set_flight_mode("off")
# Set primary cell to first cell
self._cell_in_use = 1
self._logger.info("Check if DUT is attached to cell %d (DUT check)",
self._cell_in_use)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Check Data Connection State => ATTACHED before timeout
self._logger.info("Check if DUT is attached to cell %d (NW check)",
self._cell_in_use)
self._ns_3gsm_data.check_data_connection_state(
"ATTACHED", self._registration_timeout, blocking=False)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, False)
# Check Data Connection State => PDP_ACTIVE before timeout
wait_pdp_active_state_timeout = 100
regutil.check_dut_data_connection_state_before_timeout(
"PDP_ACTIVE",
self._ns_3gsm_cell,
self._networking_api,
self._logger,
wait_pdp_active_state_timeout,
flightmode_cycle=False,
blocking=False)
# Check that DUT is registered on the good RAT
self._logger.info(
"Check if DUT is attached to cell %d with the good RAT",
self._cell_in_use)
self._modem_api.check_network_type_before_timeout(
self._ns_3gsm_data.get_network_type(), self._registration_timeout)
# Because the DUT is normally 4G preferred, run the scenario on PXT only after the DUT
# is already registered on UTRAN cell
self._ns_lte.start_scenario()
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobilityBase Setup function
LabMobilityBase.set_up(self)
if self._ns1_cell_tech == "2G":
# Set the equipment application format depending on NS1_CELL_TECH.
# If 2G switch to ""GSM/GPRS""
self._ns1.switch_app_format("GSM/GPRS")
elif self._ns1_cell_tech == "3G":
# Set the equipment application format depending on NS1_CELL_TECH.
# If 3G switch to ""WCDMA""
self._ns1.switch_app_format("WCDMA")
if self._ns2_cell_tech == "2G":
# Set the equipment application format depending on NS2_CELL_TECH.
# If 2G switch to ""GSM/GPRS""
self._ns2.switch_app_format("GSM/GPRS")
elif self._ns2_cell_tech == "3G":
# Set the equipment application format depending on NS2_CELL_TECH.
# If 3G switch to ""WCDMA""
self._ns2.switch_app_format("WCDMA")
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
if self._category != "GSM":
# Read maxDlWcdmaRab, maxUlWcdmaRab, maxDlHspaRab, maxUlHspaRab from DeviceCatalog.xml
if self._category == "WCDMA":
max_dl_rab = str(self._dut_config.get("maxDlWcdmaRab"))
max_ul_rab = str(self._dut_config.get("maxUlWcdmaRab"))
elif self._category == "HSPA":
max_dl_rab = str(self._dut_config.get("maxDlHspaRab"))
max_ul_rab = str(self._dut_config.get("maxUlHspaRab"))
# Read the UL_RAB value from UseCase xml Parameter
# Check if this value is set to MAX or not
ul_rab_config = self._tc_parameters.get_param_value("UL_RAB", "MAX")
# Read the DL_RAB value from UseCase xml Parameter
# Check if this value is set to MAX or not
dl_rab_config = self._tc_parameters.get_param_value("DL_RAB", "MAX")
if ul_rab_config == "MAX":
self._ul_rab = max_ul_rab
else:
self._ul_rab = ul_rab_config
if dl_rab_config == "MAX":
self._dl_rab = max_dl_rab
else:
self._dl_rab = dl_rab_config
if self._category == "HSPA":
# Get the HSDPA category (only if user
# wants to use HSDPA.
if(self._dl_rab is not None) and self._category:
# Retrieve all after "HSDPA_CAT"
self._hsdpa_cat = self._dl_rab[9:]
else:
self._logger.debug("HSDPA Cat parameter not found "
"on TC parameters, retrieve from DeviceModel")
self._hsdpa_cat = \
int(self._dut_config.get("maxDlHspaRab"))
self._logger.debug("HSDPA CAT: " + str(self._hsdpa_cat))
# Get the HSUPA category (only if user
# wants to use HSUPA.
if self._ul_rab.find("HSUPA_CAT") != -1:
# Retrieve all after "HSUPA_CAT"
self._hsupa_cat = self._ul_rab[9:]
self._logger.debug("HSUPA CAT: " + str(self._hsupa_cat))
else:
self._hsupa_cat = None
# Initialize further parameters
self._rbt_channel_type = "HSPA"
# Disable data and PDP context
self._networking_api.deactivate_pdp_context()
# Enable flight mode
self._networking_api.set_flight_mode("on")
# Perform full preset on NS1 cell
self._ns1.perform_full_preset()
# Perform full preset on NS2 cell
self._ns2.perform_full_preset()
# Set cell off for the 2 network simulators
self._ns1_cell.set_cell_off()
self._ns2_cell.set_cell_off()
# Set IP addresses for the 2 network simulators
self._ns1.set_ip_addresses(self._ns1_ip_lan1,
self._ns1_ip_lan2,
self._ns1_ip_subnet_mask,
self._ns1_ip_default_gateway,
self._ns1_ip_dut,
self._ns1_ip_dns1,
self._ns1_ip_dns2)
self._ns2.set_ip_addresses(self._ns2_ip_lan1,
self._ns2_ip_lan2,
self._ns2_ip_subnet_mask,
self._ns2_ip_default_gateway,
self._ns2_ip_dut,
self._ns2_ip_dns1,
self._ns2_ip_dns2)
self.set_external_connection(self._ns1,
self._ns2,
self._ns1_ip_lan2,
self._ns2_ip_lan2)
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns1.configure_amplitude_offset_table()
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns2.configure_amplitude_offset_table()
# If the fast dormancy parameter is set to disable do nothing to
# avoid regressions.
if self._ns1_fast_dormancy.lower() == "enable" and (self._ns1_cell_tech == "3G"):
# Setting fast dormancy support according to the parameter
# present in the bench config.
self._ns1_data.\
set_fast_dormancy_support("enable")
if self._ns2_fast_dormancy.lower() == "enable" and (self._ns2_cell_tech == "3G"):
# Setting fast dormancy support according to the parameter
# present in the bench config.
self._ns2_data.\
set_fast_dormancy_support("enable")
# Call specific configuration functions
RegUtil.setup_cell(1,
self._ns1_model,
self._ns1_cell_tech,
self._ns1_cell_band,
self._ns1_cell_rel,
self._logger)
RegUtil.setup_cell(2,
self._ns2_model,
self._ns2_cell_tech,
self._ns2_cell_band,
self._ns2_cell_rel,
self._logger)
# Deactivate E-DCH Cell and HSDPA Cell capabilities
# if cell tech is 3G
if self._ns1_cell_tech == "3G":
self._ns1_data.set_edch_cell_capability("OFF")
self._ns1_data.set_hsdpa_cell_capability("OFF")
# if cell tech is 2G
else:
# Set the multislot configuration
self._ns1_data.set_multislot_config(self._multislot)
if self._ns2_cell_tech == "3G":
self._ns2_data.set_edch_cell_capability("OFF")
self._ns2_data.set_hsdpa_cell_capability("OFF")
# if cell tech is 2G
else:
# Set the multislot configuration
self._ns2_data.set_multislot_config(self._multislot)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
# Call UseCase base set_up function
UseCaseBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("on")
time.sleep(self._wait_btwn_cmd)
# Connect to equipment using GPIBBoardId and GPIBAddress parameters
self._ns.init()
# Set the equipment application format WCDMA
self._ns.switch_app_format("WCDMA")
# Perform a full preset
self._ns.perform_full_preset()
# Set Cell off
self._ns_cell_3g.set_cell_off()
# 3G default cell setup
RegUtil.setup_cell(self._ns_number, self._ns_model, "3G", self._band,
self._ns_cell_rel, self._logger)
# Set Cell Band and ARFCN using 3GSM_CELL_BAND
# and 3GSM_ARFCN parameters
# Set cell service using 3GSM_CELL_SERVICE parameter
# Set Cell Power using 3GSM_CELL_POWER parameter
# Set Cell LAC using 3GSM_LAC_VALUE parameter
# Set Cell RAC using 3GSM_RAC_VALUE parameter
self._ns_cell_3g.configure_basic_cell_parameters(
self._cell_service, self._band, self._dl_uarfcn, self._cell_power,
1, 1, self._mcc, self._mnc)
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set Cell Band UARFCN (uplink) in auto mode
self._ns_cell_3g.set_uplink_channel_mode("ON")
# Set Audio codec using VOICE_CODER_RATE parameter
self._ns_voice_call_3g.set_audio_codec(self._voice_coder_rate)
# Set SRB Configuration Control to auto
self._ns_cell_3g.set_srb_config_control("ON")
# Set Cell Power using CELL_POWER parameter
self._ns_cell_3g.set_cell_power(self._cell_power)
# Deactivate HSUPA and HSDPA capabilities
self._ns_data_3g.set_edch_cell_capability("OFF")
self._ns_data_3g.set_hsdpa_cell_capability("OFF")
# Set Cell on
self._ns_cell_3g.set_cell_on()
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Adapt attachment procedure to CIRCUIT or PACKET
if "CIRCUIT" not in self._cell_service:
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"PDP_ACTIVE",
self._ns_cell_3g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Get RAT from Equipment
network_type = self._ns_data_3g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# We won't use LabWcdmaSmsCsBase SetUp, because we don't want PDP active
# for this CS test case.
# log in acs logs
self._logger.info("")
self._logger.info("%s: Setup", self._name)
self._logger.info("")
# Connect to equipment
self._ns.init()
# Set the equipment Application Format = "WCDMA"
self._ns.switch_app_format("WCDMA")
# Perform full preset
self._ns.perform_full_preset()
# Deactivate HSUPA and HSDPA capabilities
self._ns_data_3g.set_edch_cell_capability("OFF")
self._ns_data_3g.set_hsdpa_cell_capability("OFF")
# Set cell off
self._ns_cell_3g.set_cell_off()
# Set cell power using CELL_POWER value
self._ns_cell_3g.set_cell_power(self._cell_power)
self._ns_cell_3g.set_bch_update_page_state("AUTO")
self._ns_cell_3g.set_drx_cycle(self._drx_cycle_length_cn)
self._ns_cell_3g.set_drx_cycle_utran(self._drx_cycle_length_utran)
self._ns_cell_3g.set_ctch_allocation_period(
self._ctch_allocation_period)
# Set cell on
self._ns_cell_3g.set_cell_on()
# Check registration status before time out using
# registrationTimeout value from Device_Catalog.xml
time.sleep(self._wait_btwn_cmd)
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
RegUtil.check_dut_registration_before_timeout(
self._ns_cell_3g, self._networking_api, self._logger, dut_imsi,
self._registration_timeout)
# We should makesure data is disable for this use case
self._logger.info("Deactivation of the PDP Context")
self._networking_api.deactivate_pdp_context(self._ssid)
# Check Data Connection State => PDP Active before timeout
self._ns_data_3g.check_data_connection_state(
"ATTACHED", self._registration_timeout, blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml (Non blocking
# for this test if function isn't implemented on CDK)
time.sleep(self._wait_btwn_cmd)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set sender address using DESTINATION_NUMBER on Network simulator
self._ns_messaging_3g.set_sms_sender_address(
self._sms_cb_destination_number)
self._ns_messaging_3g.set_cell_broadcast_message_identifier(
self._cell_broadcast_message_identifier,
self._cell_broadcast_message)
self._ns_messaging_3g.set_cell_broadcast_message_repetition_period(
self._repetition_period)
self._ns_messaging_3g.select_cell_broadcast_message_content(
self._content_type, self._cell_broadcast_message)
self._ns_messaging_3g.set_cell_broadcast_message_update_number(
self._update_number, self._cell_broadcast_message)
if self._content_type == "CTEX":
self._ns_messaging_3g.set_custom_cell_broadcast_text_message(
self._custom_cell_broadcast_text_message,
self._cell_broadcast_message)
elif self._content_type == "CDAT":
self._ns_messaging_3g.set_custom_cell_broadcast_data_string(
self._custom_cell_broadcast_text_message,
self._cell_broadcast_message)
if self._vc_type not in ("MO", "MT"):
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG,
"Invalid voice call type")
# Release any previous call (Robustness)
self._voicecall_api.release()
# Establish voice call
if self._vc_type == "MO":
# Dial using a dummy hard-coded phone number
self._logger.info("Calling distant party...")
self._voicecall_api.dial(self._distant_number)
elif self._vc_type == "MT":
# Initiate VoiceCall to CDK
self._vc_3g.mt_originate_call()
# pylint: disable=E1101
# Check call status is incoming before callSetupTimeout
self._voicecall_api.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.INCOMING,
self._call_setup_time)
# Answer incoming call
self._voicecall_api.answer()
# Check call status before callSetupTimeout (NS)
self._vc_3g.check_call_connected(self._call_setup_time)
# Check call status before callSetupTimeout (CDK)
self._voicecall_api.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.ACTIVE, # pylint: disable=E1101
self._call_setup_time)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
Execute the test
"""
# Call LabMobility3gsmBase Run function
LabMobility3gsmBase.run_test(self)
# Initialize local variables used for Handovers
ns1_vc = self._ns1_vc
ns2_vc = self._ns2_vc
nb_success_hand = 0
ns1_cell = self._ns1_cell
ns1_data = self._ns1_data
ns2_cell = self._ns2_cell
ns2_data = self._ns2_data
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"PDP_ACTIVE",
ns1_cell,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
ns1_data.get_network_type(), self._registration_timeout)
# Set cell on
ns2_cell.set_cell_on()
# Perform try catch in order to catch errors during the for iteration.
# If this try catch isn't done here and a crash appears during the for
# iteration, the Tear Down will be called without recording Use Case
# verdict and maybe 1 or more succeeded handovers.
try:
# For iteration 0 to HANDOVER_NUMBER:
while nb_success_hand != self._jump_num:
# Start an ftp tranfer
self._ftp_task_id = \
self._networking_api.start_ftp_xfer(
self._ftp_direction,
self._server_ip_address,
self._server_username,
self._server_password,
self._ftp_filename,
self._device.get_ftpdir_path())
# wait 20 seconds for ensure that transfer is established
self._logger.info(
"Wait 20 seconds for ensure that transfer is established")
time.sleep(20)
# Check that operator gave a valid Voice call number
# Perform MO voice call on NS1
if self._is_phone_number_checked:
if self._phone_number is None:
self._logger.warning(
"Operator Phone Number cannot be used to perform a voice call \
due to invalid test parameter value (Phone Number %s)"
% (str(
self._tc_parameters.get_param_value(
"PHONE_NUMBER"))))
else:
self._voicecall_api.dial(self._phone_number)
else:
# Raise an error message as no valid phone number has been set by the operator
self._error.Msg = "Phone number has no valid value (%s) so voice call can not be performed" % \
self._phone_number
self._logger.error(self._error.Msg)
raise AcsConfigException(
AcsConfigException.INVALID_PARAMETER, self._error.Msg)
# Check call state "CONNECTED" before callSetupTimeout seconds
ns1_vc.check_call_connected(self._call_setup_time,
blocking=False)
# Check data state "TRANSFERRING" before timeout
ns1_data.check_data_connection_transferring(
self._check_data_transfer_state_timeout)
# Perform handover using 60 seconds timeout
ns1_cell.execute_external_handover()
self._logger.info("Wait 60 seconds for ensure that" +
" external handover is done")
time.sleep(60)
# Switch NS1 and NS2 network simulators
# (when the handover finishes, the roles are reversed)
tmp_cell = ns1_cell
tmp_data = ns1_data
ns1_cell = ns2_cell
ns1_data = ns2_data
ns2_cell = tmp_cell
ns2_data = tmp_data
tmp_vc = ns1_vc
ns1_vc = ns2_vc
ns2_vc = tmp_vc
# Check data state "TRANSFERRING" before timeout
ns1_data.check_data_connection_transferring(
self._check_data_transfer_state_timeout,
False,
blocking=False)
# Check call state "CONNECTED" before timeout to validate handover
ns1_vc.check_call_connected(
self._check_voice_call_state_timeout, blocking=False)
# Get RAT from Equipment
network_type = ns1_data.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
# Increment number of succeeded handovers
nb_success_hand += 1
# Stop ftp transfer
self._networking_api.stop_ftp_xfer(self._ftp_task_id)
# Release the voice call
ns1_vc.voice_call_network_release()
# End For
# Catch a possible exception
except TestEquipmentException as ex:
msg = "The handover number %d failed " % (nb_success_hand + 1)
msg += "(%d succeeded handovers on %d)." \
% (nb_success_hand, self._jump_num)
self._logger.error(msg)
raise TestEquipmentException(
TestEquipmentException.PROHIBITIVE_BEHAVIOR,
"Exception during handover process: %s (%s)" %
(ex.get_error_message(), msg))
except AcsBaseException as ex:
# if nb_success_hand < self._jump_num
# raise an exception
# else only log the error
if nb_success_hand < self._jump_num:
msg = "The handover number %d failed " % (nb_success_hand + 1)
msg += "(%d succeeded handovers on %d)." \
% (nb_success_hand, self._jump_num)
self._logger.error(msg)
raise DeviceException(
DeviceException.PROHIBITIVE_BEHAVIOR,
"Exception during handover due to board: %s (%s)" %
(ex.get_error_message(), msg))
else:
# log error as a warning, but no Usecase exception
# is raised because the purpose of the Usecase has been reached
self._logger.warning(ex.get_error_message())
finally:
# Stop ftp tranfer if an error occurs
self._networking_api.stop_ftp_xfer(self._ftp_task_id)
# Compute final verdict
msg = "%d handovers done." % nb_success_hand
return Global.SUCCESS, msg
def set_up(self):
"""
Set up the test configuration
"""
# Call LabMobility3gsmBase Setup function
LabMobility3gsmBase.set_up(self)
# Set default variables to switch equipments
# during several cell reselections
# Set cell service using ns1_CELL_SERVICE parameter
# Set Cell Power using ns1_CELL_POWER parameter
self._ns1_cell.set_cell_service(self._ns1_cell_service)
self._ns1_cell.set_cell_power(self._ns_camped_power)
# Set cell service using TARGET_CELL_SERVICE parameter
# Set Cell Power using TARGET_CELL_POWER parameter
self._ns2_cell.set_cell_service(self._ns2_cell_service)
self._ns2_cell.set_cell_power(self._ns2_cell_power)
# Set ns1_LAC and ns2_LAC parameters
self._ns1_cell.set_lac(self._ns1_lac)
self._ns2_cell.set_lac(self._ns2_lac)
# Set ns1_RAC and ns2_RAC parameters
self._ns1_cell.set_rac(self._ns1_rac)
self._ns2_cell.set_rac(self._ns2_rac)
# Set scrambling code for 3G cells
if self._ns1_cell_tech == "3G":
self._ns1_cell.set_scrambling_code(self._ns1_psc)
if self._ns2_cell_tech == "3G":
self._ns2_cell.set_scrambling_code(self._ns2_psc)
# Set cell on
self._ns1_cell.set_cell_on()
self._ns2_cell.set_cell_on()
# Disable flight mode
self._networking_api.set_flight_mode("off")
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._logger.info("Check if DUT is attached to cell %d (DUT check)",
self._cell_in_use)
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set primary cell to first cell
self._cell_in_use = 1
# Check Data Connection State => ATTACHED before timeout
self._logger.info("Check if DUT is attached to cell %d (NW check)",
self._cell_in_use)
self._ns1_data.check_data_connection_state("ATTACHED",
self._cresel_timeout,
blocking=False)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid, check=False)
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"PDP_ACTIVE",
self._ns1_cell,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=False,
blocking=False)
# Check that DUT is registered on the good RAT
self._logger.info(
"Check if DUT is attached to cell %d with the good RAT",
self._cell_in_use)
self._modem_api.check_network_type_before_timeout(
self._ns1_data.get_network_type(), self._registration_timeout)
return (Global.SUCCESS, "No errors")
def set_up(self):
"""
Set up the test configuration
"""
# Call UseCase base Setup function
UseCaseBase.set_up(self)
# Ensure flight mode off so that GSM sim operator info can be retrieved
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
# Determinates the kind of registration state to wait
# by comparing test case MCC/MNC parameters to sim MCC/MNC
sim_info = self._modem_api.get_sim_operator_info()
if sim_info["MCC"] != self._mcc or\
sim_info["MNC"] != self._mnc:
self._wanted_reg_state = "roaming"
else:
self._wanted_reg_state = "registered"
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
if self._switch_mode == "airplane":
# Switch off according to the mode chosen
self.phoneonoff_util.switch_off(self._switch_mode)
# Initialize cellular network simulator
self._ns.init()
# Set the equipment application format WCDMA
self._ns.switch_app_format("WCDMA")
# Perform a full preset
self._ns.perform_full_preset()
# Set Cell off
self._ns_cell_3g.set_cell_off()
# 3G default cell setup
RegUtil.setup_cell(self._ns_number, self._ns_model, "3G", self._band,
self._ns_cell_rel, self._logger)
# Set Cell Band and ARFCN using 3GSM_CELL_BAND
# and 3GSM_ARFCN parameters
# Set cell service using 3GSM_CELL_SERVICE parameter
# Set Cell Power using 3GSM_CELL_POWER parameter
# Set Cell LAC using 3GSM_LAC_VALUE parameter
# Set Cell RAC using 3GSM_RAC_VALUE parameter
self._ns_cell_3g.configure_basic_cell_parameters(
self._cell_service, self._band, self._dl_uarfcn, self._cell_power,
1, 1, self._mcc, self._mnc)
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set Cell Band UARFCN (uplink) in auto mode
self._ns_cell_3g.set_uplink_channel_mode("ON")
# Set SRB Configuration Control to auto
self._ns_cell_3g.set_srb_config_control("ON")
# Deactivate HSUPA and HSDPA capabilities
self._ns_data_3g.set_edch_cell_capability("OFF")
self._ns_data_3g.set_hsdpa_cell_capability("OFF")
self._modem_api.check_cdk_no_registration_bfor_timeout(
self._registration_timeout)
# Set Cell on
self._ns_cell_3g.set_cell_on()
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call use case base Setup function
UseCaseBase.set_up(self)
# get original audio output
self._origianl_audio_output = \
self._phonesystem_api.get_audio_output()
# get original silent mode and vibrate mode
self._original_silent_vibrate = \
self._phonesystem_api.get_silent_vibrate()
# Connect to equipment using GPIBAddress and GPIBBoardId
self._ns.init()
# Set the equipment application format GSM/GPRS
self._ns.switch_app_format("GSM/GPRS")
# Perform a full preset
self._ns.perform_full_preset()
# Set cell off
self._ns_cell_2g.set_cell_off()
# Set Frequency points using frequency list
# Set Amplitude Offset correction using offset list
# Turning amplitude offset state to ON
self._ns.configure_amplitude_offset_table()
# Set Cell Band using CELL_BAND parameter
self._ns_cell_2g.set_band(self._band_name)
# Set Broadcast Channel Arfcn using BCH_ARFCN parameter
self._ns_cell_2g.set_bcch_arfcn(self._bch_arfcn)
# Set Traffic Channel Arfcn using TCH_ARFCN parameter
self._ns_cell_2g.set_tch_arfcn(self._tch_arfcn)
# Set cell service using CELL_SERVICE parameter
self._ns_cell_2g.set_cell_service(self._cell_service)
# Set Cell Power using CELL_POWER parameter
self._ns_cell_2g.set_cell_power(self._cell_power)
# Set VOICE_CODER_RATE
self._ns_voice_call_2g.set_audio_codec(self._voice_coder_rate)
# Set ringtone time using RT_TIME parameter
self._ns_voice_call_2g.set_mt_originate_call_timeout(self._rt_time)
# Set cell on
self._ns_cell_2g.set_cell_on()
# Adapt attachment procedure to CIRCUIT or PACKET
if self._cell_service == "GSM":
# Check phone registration on equipment before given CAMP_TIMEOUT
# (in loop compare every second the IMSI returned by the simulator
# and IMSI read on CDK until comparison is true or timeout expired)
dut_imsi = self._modem_api.get_imsi(self._registration_timeout)
RegUtil.check_dut_registration_before_timeout(
self._ns_cell_2g, self._networking_api, self._logger, dut_imsi,
self._registration_timeout)
else:
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"ATTACHED",
self._ns_cell_2g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Get RAT from Equipment
network_type = self._ns_data_2g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
Execute the test
"""
# Call UseCase base run_test function
UseCaseBase.run_test(self)
if self._switch_mode == "airplane":
# Switch on according to the mode chosen
self.phoneonoff_util.switch_on(self._switch_mode)
elif self._switch_mode in ("hardshutdown", "softshutdown"):
# Reboot according to the mode chosen
self.phoneonoff_util.reboot(self._switch_mode)
else:
self._logger.info("No actions required to do a switch On/Off")
# save initial time
init_time = time.time()
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._logger.info("Check network registration status is %s on DUT" %
self._wanted_reg_state)
self._modem_api.check_cdk_state_bfor_timeout(
self._wanted_reg_state, self._registration_timeout)
# time needed to reach registered state
reg_time = time.time() - init_time
self._logger.info("DUT registered in less than %3.2f seconds!",
reg_time)
# Adapt attachment procedure to CIRCUIT or PACKET
if self._cell_service != "GSM":
if self._pdp_activation:
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid,
check=False)
# Check Data Connection State => PDP_ACTIVE before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"PDP_ACTIVE",
self._ns_cell_2g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=False,
blocking=False)
else:
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout(
"ATTACHED",
self._ns_cell_2g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=False,
blocking=False)
# time needed to reach attach state after registration
attach_time = time.time() - init_time
self._logger.info("DUT attached in less than %3.2f seconds!",
attach_time)
# Get RAT from Equipment
network_type = self._ns_data_2g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(
network_type, self._registration_timeout)
if self._switch_mode == "airplane":
# Switch off according to the switch mode chosen
self.phoneonoff_util.switch_off(self._switch_mode)
# Check that DUT is no longer camped on Network
self._modem_api.check_cdk_no_registration_bfor_timeout(
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Set up the test configuration
"""
# Call use case base Setup function
UseCaseBase.set_up(self)
# Clear all data connections
self._networking_api.clean_all_data_connections()
time.sleep(self._wait_btwn_cmd)
# Connect to equipment
self._ns.init()
# Set the equipment Application Format = "WCDMA"
self._ns.switch_app_format("WCDMA")
# Perform full preset
self._ns.perform_full_preset()
# Deactivate HSUPA and HSDPA capabilities
self._ns_data_3g.set_edch_cell_capability("OFF")
self._ns_data_3g.set_hsdpa_cell_capability("OFF")
# Set cell off
self._ns_cell_3g.set_cell_off()
# 3G default cell setup
RegUtil.setup_cell(self._ns_number,
self._ns_model,
"3G",
self._band,
self._ns_cell_rel,
self._logger)
# Set Frequency points using frequency list
self._ns.configure_amplitude_offset_table()
# Set cell power using CELL_POWER value
self._ns_cell_3g.set_cell_power(self._cell_power)
# Set serving cell to PACKET
self._ns_cell_3g.set_cell_service("PACKET")
# Set downlink UARFCN using DL_UARFCN value
self._ns_cell_3g.set_band_and_dl_arfcn(
"BAND" + str(self._band), self._dl_uarfcn)
# Set cell on
self._ns_cell_3g.set_cell_on()
# Check Data Connection State => ATTACHED before timeout
RegUtil.check_dut_data_connection_state_before_timeout("ATTACHED",
self._ns_cell_3g,
self._networking_api,
self._logger,
self._registration_timeout,
flightmode_cycle=True,
blocking=False)
# Check registration state is connected using
# registrationTimeout from Device_Catalog.xml
self._modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# Set the APN
time.sleep(self._wait_btwn_cmd)
self._logger.info("Setting APN " + str(self._apn) + "...")
self._networking_api.set_apn(self._ssid, self._apn)
# Activate PDP context
time.sleep(self._wait_btwn_cmd)
self._logger.info("Active PDP Context...")
self._networking_api.activate_pdp_context(self._ssid)
# Check Data Connection State => PDP Active before timeout
self._ns_data_3g.check_data_connection_state("PDP_ACTIVE",
self._registration_timeout,
blocking=False)
# Get RAT from Equipment
network_type = self._ns_data_3g.get_network_type()
# Check that DUT is registered on the good RAT
self._modem_api.check_network_type_before_timeout(network_type,
self._registration_timeout)
return Global.SUCCESS, "No errors"