def tear_down(self):
"""
End and dispose the test
"""
# Call LabMobilityBase tear_down function
LabMobilityBase.tear_down(self)
try:
# Activate the flight mode.
self._networking_api.set_flight_mode("on")
except:
pass
# Disconnect from external EPC
self._ns_3gsm.disconnect_from_external_epc()
# Set cell off on Both NS
self._ns_3gsm_cell.set_cell_off()
self._ns_lte_cell.set_cell_off()
# Disconnect from equipments
self._ns_3gsm.release()
self._ns_lte.release()
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 tear_down(self):
"""
End and dispose the test
"""
try:
# Call LabMobilityBase tear_down function
LabMobilityBase.tear_down(self)
# Clear all data connections
self._networking_api.deactivate_pdp_context()
time.sleep(self._wait_btwn_cmd)
# Activate the flight mode.
self._networking_api.set_flight_mode("on")
except:
pass
# Set cell off
self._ns1_cell.set_cell_off()
# Set cell off
self._ns2_cell.set_cell_off()
# Disconnect from external 8960
self._ns1.disconnect_from_external_device()
# Disconnect from external 8960
self._ns2.disconnect_from_external_device()
# Verify ethernet disconnection
self._ns2.check_external_device_disconnection(1, 5)
# Release equipment NS1 resource
self._ns1.release()
# Release equipment NS2 resource
self._ns2.release()
return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Added Messaging management
LabMobilityBase.__init__(self, tc_name, global_config)
# Read NS1_CELL_TECH from test case xml file (In str)
self._ns1_cell_tech = \
str(self._tc_parameters.get_param_value("NS1_CELL_TECH"))
# Read NS2_CELL_TECH from test case xml file (In str)
self._ns2_cell_tech = \
str(self._tc_parameters.get_param_value("NS2_CELL_TECH"))
# Read NS1_CELL_BAND from test case xml file (In str)
self._ns1_cell_band = str(self._tc_parameters.get_param_value("NS1_CELL_BAND"))
# Read NS2_CELL_BAND from test case xml file (In str)
self._ns2_cell_band = str(self._tc_parameters.get_param_value("NS2_CELL_BAND"))
# NS1_CELL_REL
self._ns1_cell_rel = 7
# NS2_CELL_REL
self._ns2_cell_rel = 7
# Set APIs instances for NS1
if self._ns1_cell_tech == "2G":
self._ns1_cell = self._ns1.get_cell_2g()
self._ns1_vc = self._ns1_cell.get_voice_call()
self._ns1_data = self._ns1_cell.get_data()
self._ns1_messaging = self._ns1_cell.get_messaging()
elif self._ns1_cell_tech == "3G":
self._ns1_cell = self._ns1.get_cell_3g()
self._ns1_vc = self._ns1_cell.get_voice_call()
self._ns1_data = self._ns1_cell.get_data()
self._ns1_messaging = self._ns1_cell.get_messaging()
else:
self._error.Msg = "Unknown Cell Radio Access Technology"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, self._error.Msg)
# Set APIs instances for NS2
if self._ns2_cell_tech == "2G":
self._ns2_cell = self._ns2.get_cell_2g()
self._ns2_vc = self._ns2_cell.get_voice_call()
self._ns2_data = self._ns2_cell.get_data()
self._ns2_messaging = self._ns2_cell.get_messaging()
elif self._ns2_cell_tech == "3G":
self._ns2_cell = self._ns2.get_cell_3g()
self._ns2_vc = self._ns2_cell.get_voice_call()
self._ns2_data = self._ns2_cell.get_data()
self._ns2_messaging = self._ns2_cell.get_messaging()
else:
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
"Unknown Cell Radio Access Technology")
# Read CATEGORY from testcase xml parameters
self._category = \
str(self._tc_parameters.get_param_value("CATEGORY", "WCDMA"))
# Read fast dormancy parameter
self._ns1_fast_dormancy = \
self._ns1_node.get_param_value("Fast_Dormancy", "disable")
self._ns2_fast_dormancy = \
self._ns2_node.get_param_value("Fast_Dormancy", "disable")
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 __init__(self, tc_name, global_config):
"""
Constructor
"""
LabMobilityBase.__init__(self, tc_name, global_config)
# Read the xml Template for LTE Cell Configuration
# Read LTE_MIMO from test case xml file
self._ns_lte_mimo_temp = self._tc_parameters.get_param_value(
"LTE_MIMO")
if self._ns_lte_mimo_temp not in (None, ''):
self._ns_lte_mimo = (str(self._ns_lte_mimo_temp).lower() == "true")
# Read LTE_SIGNAL_MODE from test case xml file
self._ns_lte_signal_mode = str(
self._tc_parameters.get_param_value("LTE_SIGNAL_MODE"))
# Read LTE_PHYSICAL_CELL_ID from test case xml file
self._ns_lte_physical_cell_id = str(
self._tc_parameters.get_param_value("LTE_PHYSICAL_CELL_ID"))
# Read LTE_CELL_ID from test case xml file
self._ns_lte_cell_id = str(
self._tc_parameters.get_param_value("LTE_CELL_ID"))
# Read LTE_CELL_POWER_RFO1 from test case xml file
self._ns_lte_cell_power_rf1 = float(
self._tc_parameters.get_param_value("LTE_CELL_POWER_RFO1"))
# Read LTE_CELL_POWER_RFO2 from test case xml file
self._ns_lte_cell_power_rf2 = float(
self._tc_parameters.get_param_value("LTE_CELL_POWER_RFO2"))
# Read NS1 Mobile Country Code (MCC) from test case xml file
self._ns_lte_mcc = int(self._tc_parameters.get_param_value("LTE_MCC"))
# Read NS1 Mobile Network Code (MNC) from test case xml file
self._ns_lte_mnc = int(self._tc_parameters.get_param_value("LTE_MNC"))
# Read NS2 Mobile Country Code (MCC) from test case xml file
self._ns_3gsm_mcc = int(
self._tc_parameters.get_param_value("3GSM_MCC", "1"))
# Read NS2 Mobile Network Code (MNC) from test case xml file
self._ns_3gsm_mnc = int(
self._tc_parameters.get_param_value("3GSM_MNC", "1"))
# Read LTE_CELL_BAND from test case xml file
self._ns_lte_cell_band = int(
self._tc_parameters.get_param_value("LTE_CELL_BAND"))
# Read LTE_DL_EARFCN from test case xml file
self._ns_lte_dl_earfcn = int(
self._tc_parameters.get_param_value("LTE_DL_EARFCN"))
# Read Duplex type (Frequency Division Duplex (FDD) or Time Division Duplex (TDD)) from test case xml file
self._ns_lte_duplex_type = self._tc_parameters.get_param_value(
"DUPLEX_TYPE", "FDD")
# Read ANTENNAS NUMBER from test case xml file
self._antennas_number = self._tc_parameters.get_param_value(
"ANTENNAS_NUMBER", '')
# Read LTE_SCENARIO_PATH from test case xml file
self._ns_lte_scenario_path = str(
self._tc_parameters.get_param_value("LTE_SCENARIO_PATH"))
# Read the xml Template for 3GSM Cell Configuration
# Read 3GSM_CELL_TECH from test case xml file
self._ns_3gsm_cell_tech = str(
self._tc_parameters.get_param_value("3GSM_CELL_TECH"))
# Read 3GSM_CELL_BAND from test case xml file
self._ns_3gsm_cell_band = str(
self._tc_parameters.get_param_value("3GSM_CELL_BAND"))
# NS1_CELL_REL
self._ns_3gsm_cell_rel = 8
# Read 3GSM_DL_EARFCN from test case xml file
self._ns_3gsm_dl_arfcn = int(
self._tc_parameters.get_param_value("3GSM_DL_ARFCN"))
# Read 3GSM_CELL_SERVICE from test case xml file
self._ns_3gsm_cell_service = str(
self._tc_parameters.get_param_value("3GSM_CELL_SERVICE"))
# Read 3GSM_CELL_POWER from test case xml file
self._ns_3gsm_cell_power = float(
self._tc_parameters.get_param_value("3GSM_CELL_POWER"))
# Read 3GSM_LAC_VALUE from test case xml file
self._ns_3gsm_lac = int(
self._tc_parameters.get_param_value("3GSM_LAC"))
# Read 3GSM_RAC_VALUE from test case xml file
self._ns_3gsm_rac = int(
self._tc_parameters.get_param_value("3GSM_RAC"))
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 __init__(self, tc_name, global_config):
"""
Constructor
"""
LabMobilityBase.__init__(self, tc_name, global_config)
# Read the xml Template for NS1 Configuration
# Read NS1_MIMO from test case xml file
self._ns1_mimo_temp = self._tc_parameters.get_param_value("NS1_MIMO")
if self._ns1_mimo_temp not in (None, ''):
self._ns1_mimo = (str(self._ns1_mimo_temp).lower() == "true")
# Read NS1_SIGNAL_MODE from test case xml file
self._ns1_signal_mode = \
str(self._tc_parameters.get_param_value("NS1_SIGNAL_MODE"))
# Read NS1_PHYSICAL_CELL_ID from test case xml file
self._ns1_physical_cell_id = \
str(self._tc_parameters.get_param_value("NS1_PHYSICAL_CELL_ID"))
# Read NS1_CELL_ID from test case xml file
self._ns1_cell_id = \
str(self._tc_parameters.get_param_value("NS1_CELL_ID"))
# Read NS1_CELL_POWER_RFO1 from test case xml file
self._ns1_cell_power_rf1 = \
str(self._tc_parameters.get_param_value("NS1_CELL_POWER_RFO1"))
# Read NS1_CELL_POWER_RFO2 from test case xml file
self._ns1_cell_power_rf2 = \
str(self._tc_parameters.get_param_value("NS1_CELL_POWER_RFO2"))
# Read NS1 Mobile Country Code (MCC) from test case xml file
self._ns1_mcc = \
int(self._tc_parameters.get_param_value("NS1_MCC"))
# Read NS1 Mobile Network Code (MNC) from test case xml file
self._ns1_mnc = \
int(self._tc_parameters.get_param_value("NS1_MNC"))
# Read NS1_CELL_BAND from test case xml file
self._ns1_cell_band = \
int(self._tc_parameters.get_param_value("NS1_CELL_BAND"))
# Read NS1_DL_EARFCN from test case xml file
self._ns1_lte_dl_earfcn = \
int(self._tc_parameters.get_param_value("NS1_DL_EARFCN"))
# Read NS1_SCENARIO_PATH from test case xml file
self._ns1_scenario_path = \
str(self._tc_parameters.get_param_value("NS1_SCENARIO_PATH"))
# Read the xml Template for NS2 Configuration
# Read NS2_MIMO from test case xml file
self._ns2_mimo_temp = self._tc_parameters.get_param_value("NS2_MIMO")
if self._ns2_mimo_temp not in (None, ''):
self._ns2_mimo = (str(self._ns2_mimo_temp).lower() == "true")
# Read NS2_SIGNAL_MODE from test case xml file
self._ns2_signal_mode = \
str(self._tc_parameters.get_param_value("NS2_SIGNAL_MODE"))
# Read NS2_PHYSICAL_CELL_ID from test case xml file
self._ns2_physical_cell_id = \
str(self._tc_parameters.get_param_value("NS2_PHYSICAL_CELL_ID"))
# Read NS2_CELL_ID from test case xml file
self._ns2_cell_id = \
str(self._tc_parameters.get_param_value("NS2_CELL_ID"))
# Read NS2_CELL_POWER_RFO1 from test case xml file
self._ns2_cell_power_rf1 = \
str(self._tc_parameters.get_param_value("NS2_CELL_POWER_RFO1"))
# Read NS2_CELL_POWER_RFO2 from test case xml file
self._ns2_cell_power_rf2 = \
str(self._tc_parameters.get_param_value("NS2_CELL_POWER_RFO2"))
# Read NS2 Mobile Country Code (MCC) from test case xml file
self._ns2_mcc = \
int(self._tc_parameters.get_param_value("NS2_MCC"))
# Read NS2 Mobile Network Code (MNC) from test case xml file
self._ns2_mnc = \
int(self._tc_parameters.get_param_value("NS2_MNC"))
# Read NS2_CELL_BAND from test case xml file
self._ns2_cell_band = \
int(self._tc_parameters.get_param_value("NS2_CELL_BAND"))
# Read NS2_DL_EARFCN from test case xml file
self._ns2_lte_dl_earfcn = \
int(self._tc_parameters.get_param_value("NS2_DL_EARFCN"))
# Read NS2_SCENARIO_PATH from test case xml file
self._ns2_scenario_path = \
str(self._tc_parameters.get_param_value("NS2_SCENARIO_PATH"))
if self._ns1_model == "AGILENT_E6621A" and self._ns2_model == "AGILENT_E6621A":
self._logger.debug(
"Bench configuration is supported by the Usecase using %s as NS1 \
and %s as NS2" % self._ns1_model,
self._ns2_model)
else:
# Set NS1 APIs instance
self._ns1_cell = self._ns1.get_cell_4g()
self._ns1_data = self._ns1_cell.get_data()
# Set the equipment application format depending on ACTIVE_CELL_TECH.
# For 4G switch to ""LTE FDD""
self._ns1.switch_app_format("LTE FDD")
# Set NS2 APIs instance
self._ns2_cell = self._ns2.get_cell_4g()
self._ns2_data = self._ns2_cell.get_data()
# Set the equipment application format depending on IDLE_CELL_TECH.
# For 4G switch to ""LTE FDD""
self._ns2.switch_app_format("LTE FDD")
self._error.Msg = "Bench configuration is not supported by the Usecase"
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG,
self._error.Msg)