def _phone_setup_gsm(self, ad):
return ensure_network_rat(
self.log,
ad,
NETWORK_MODE_GSM_ONLY,
RAT_FAMILY_GSM,
toggle_apm_after_setting=True)
def _phone_setup_1x(self, ad):
return ensure_network_rat(
self.log,
ad,
NETWORK_MODE_CDMA,
RAT_FAMILY_CDMA2000,
toggle_apm_after_setting=True)
def _phone_setup_lte_1x(self, ad):
return ensure_network_rat(
self.log,
ad,
NETWORK_MODE_LTE_CDMA_EVDO,
RAT_FAMILY_LTE,
toggle_apm_after_setting=True)
def _phone_setup_wcdma(self, ad):
return ensure_network_rat(
self.log,
ad,
NETWORK_MODE_GSM_UMTS,
RAT_FAMILY_UMTS,
toggle_apm_after_setting=True)
def _phone_setup_lte_wcdma(self, ad):
toggle_volte(self.log, ad, False)
return ensure_network_rat(self.log,
ad,
NETWORK_MODE_LTE_GSM_WCDMA,
RAT_FAMILY_LTE,
toggle_apm_after_setting=True)
def _phone_setup_volte(self, ad):
ad.droid.telephonyToggleDataConnection(True)
toggle_volte(self.log, ad, True)
return ensure_network_rat(self.log,
ad,
NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA,
RAT_FAMILY_LTE,
toggle_apm_after_setting=True)
def _send_receive_etws_message(self, set_simulation_func, rat, message_id,
warning_message):
try:
[self.bts1] = set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
set_usim_parameters(self.anritsu, self.ad.sim_card)
if rat == RAT_LTE:
set_post_sim_params(self.anritsu, self.user_params,
self.ad.sim_card)
self.anritsu.start_simulation()
if rat == RAT_LTE:
preferred_network_setting = NETWORK_MODE_LTE_GSM_WCDMA
rat_family = RAT_FAMILY_LTE
elif rat == RAT_WCDMA:
self.bts1.wcdma_ctch = CTCHSetup.CTCH_ENABLE
self.ad.droid.telephonyToggleDataConnection(False)
preferred_network_setting = NETWORK_MODE_GSM_UMTS
rat_family = RAT_FAMILY_UMTS
elif rat == RAT_GSM:
self.bts1.gsm_cbch = CBCHSetup.CBCH_ENABLE
self.ad.droid.telephonyToggleDataConnection(False)
preferred_network_setting = NETWORK_MODE_GSM_ONLY
rat_family = RAT_FAMILY_GSM
elif rat == RAT_1XRTT:
preferred_network_setting = NETWORK_MODE_CDMA
rat_family = RAT_FAMILY_CDMA2000
else:
self.log.error("No valid RAT provided for ETWS test.")
return False
if not ensure_network_rat(self.log,
self.ad,
preferred_network_setting,
rat_family,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
rat_family, preferred_network_setting))
return False
self.anritsu.wait_for_registration_state()
if not etws_receive_verify_message_lte_wcdma(
self.log, self.ad, self.anritsu,
next(TelLabEtwsTest.SERIAL_NO), message_id,
warning_message):
self.log.error(
"Phone {} Failed to receive ETWS message".format(
self.ad.serial))
return False
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during ETWS send/receive: " + str(e))
return False
return True
def _read_identity(self, set_simulation_func, rat, identity_type):
try:
self.anritsu.reset()
self.anritsu.load_cell_paramfile(self.CELL_PARAM_FILE)
set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
self.anritsu.start_simulation()
if rat == RAT_LTE:
preferred_network_setting = NETWORK_MODE_LTE_GSM_WCDMA
rat_family = RAT_FAMILY_LTE
elif rat == RAT_WCDMA:
preferred_network_setting = NETWORK_MODE_GSM_UMTS
rat_family = RAT_FAMILY_UMTS
elif rat == RAT_GSM:
preferred_network_setting = NETWORK_MODE_GSM_ONLY
rat_family = RAT_FAMILY_GSM
elif rat == RAT_1XRTT:
preferred_network_setting = NETWORK_MODE_CDMA
rat_family = RAT_FAMILY_CDMA2000
else:
self.log.error("Invalid RAT - Please specify a valid RAT")
return False
self.ad.droid.telephonyToggleDataConnection(True)
if not ensure_network_rat(self.log,
self.ad,
preferred_network_setting,
rat_family,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
rat_family, preferred_network_setting))
return False
self.anritsu.wait_for_registration_state()
time.sleep(WAIT_TIME_ANRITSU_REG_AND_OPER)
identity = read_ue_identity(self.log, self.ad, self.anritsu,
identity_type)
if identity is None:
self.log.error("Phone {} Failed to get {}".format(
self.ad.serial, identity_type.value))
return False
else:
self.log.info("{}".format(identity))
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during reading identity: " + str(e))
return False
return True
def _setup_data(self, set_simulation_func, rat):
try:
[self.bts1] = set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
set_usim_parameters(self.anritsu, self.ad.sim_card)
set_post_sim_params(self.anritsu, self.user_params,
self.ad.sim_card)
if self.lte_bandwidth == 20:
self.bts1.bandwidth = BtsBandwidth.LTE_BANDWIDTH_20MHz
elif self.lte_bandwidth == 15:
self.bts1.bandwidth = BtsBandwidth.LTE_BANDWIDTH_15MHz
elif self.lte_bandwidth == 10:
self.bts1.bandwidth = BtsBandwidth.LTE_BANDWIDTH_10MHz
else:
self.bts1.bandwidth = BtsBandwidth.LTE_BANDWIDTH_5MHz
self.anritsu.start_simulation()
if rat == RAT_LTE:
preferred_network_setting = NETWORK_MODE_LTE_CDMA_EVDO
rat_family = RAT_FAMILY_LTE
elif rat == RAT_WCDMA:
preferred_network_setting = NETWORK_MODE_GSM_UMTS
rat_family = RAT_FAMILY_UMTS
elif rat == RAT_GSM:
preferred_network_setting = NETWORK_MODE_GSM_ONLY
rat_family = RAT_FAMILY_GSM
elif rat == RAT_1XRTT:
preferred_network_setting = NETWORK_MODE_CDMA
rat_family = RAT_FAMILY_CDMA2000
else:
self.log.error("No valid RAT provided for SMS test.")
return False
if not ensure_network_rat(
self.log,
self.ad,
preferred_network_setting,
rat_family,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
rat_family, preferred_network_setting))
return False
self.anritsu.wait_for_registration_state()
time.sleep(self.SETTLING_TIME)
# Fetch IP address of the host machine
cmd = "|".join(("ifconfig", "grep eth0 -A1", "grep inet",
"cut -d ':' -f2", "cut -d ' ' -f 1"))
destination_ip = exe_cmd(cmd)
destination_ip = (destination_ip.decode("utf-8")).split("\n")[0]
self.log.info("Dest IP is %s", destination_ip)
if not adb_shell_ping(self.ad, DEFAULT_PING_DURATION,
destination_ip):
self.log.error("Pings failed to Destination.")
return False
self.bts1.output_level = self.start_power_level
# Power, iperf, file output, power change
for iteration in range(1, self.MAX_ITERATIONS + 1):
self.log.info("------- Current Iteration: %d / %d -------",
iteration, self.MAX_ITERATIONS)
current_power = self.bts1.output_level
self.log.info("Current Power Level is %s", current_power)
self.ip_server.start()
tput_dict = {"Uplink": 0, "Downlink": 0}
if iperf_test_by_adb(
self.log,
self.ad,
destination_ip,
self.port_num,
True,
10,
rate_dict=tput_dict):
uplink = tput_dict["Uplink"]
downlink = tput_dict["Downlink"]
else:
self.log.error("iperf failed to Destination.")
self.log.info("Iteration %d Failed", iteration)
if float(current_power) < -55.0:
return True
else:
return False
self.ip_server.stop()
self.log.info("Iteration %d Passed", iteration)
self.logpath = os.path.join(logging.log_path, "power_tput.txt")
line = "Power " + current_power + " DL TPUT " + str(downlink)
with open(self.logpath, "a") as tput_file:
tput_file.write(line)
tput_file.write("\n")
current_power = float(current_power)
new_power = current_power - self.step_size
self.log.info("Setting Power Level to %f", new_power)
self.bts1.output_level = new_power
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during Data procedure: " + str(e))
return False
return True
def _send_receive_cmas_message(
self,
set_simulation_func,
rat,
message_id,
warning_message,
c2k_response_type=CMAS_C2K_RESPONSETYPE_SHELTER,
c2k_severity=CMAS_C2K_SEVERITY_EXTREME,
c2k_urgency=CMAS_C2K_URGENCY_IMMEDIATE,
c2k_certainty=CMAS_C2K_CERTIANTY_OBSERVED):
try:
[self.bts1] = set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
set_usim_parameters(self.anritsu, self.ad.sim_card)
self.anritsu.start_simulation()
if rat == RAT_LTE:
preferred_network_setting = NETWORK_MODE_LTE_GSM_WCDMA
rat_family = RAT_FAMILY_LTE
elif rat == RAT_WCDMA:
self.bts1.wcdma_ctch = CTCHSetup.CTCH_ENABLE
self.ad.droid.telephonyToggleDataConnection(False)
preferred_network_setting = NETWORK_MODE_GSM_UMTS
rat_family = RAT_FAMILY_UMTS
elif rat == RAT_GSM:
self.bts1.gsm_cbch = CBCHSetup.CBCH_ENABLE
self.ad.droid.telephonyToggleDataConnection(False)
preferred_network_setting = NETWORK_MODE_GSM_ONLY
rat_family = RAT_FAMILY_GSM
elif rat == RAT_1XRTT:
preferred_network_setting = NETWORK_MODE_CDMA
rat_family = RAT_FAMILY_CDMA2000
else:
self.log.error("No valid RAT provided for CMAS test.")
return False
if not ensure_network_rat(self.log,
self.ad,
preferred_network_setting,
rat_family,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
rat_family, preferred_network_setting))
return False
self.anritsu.wait_for_registration_state()
if rat != RAT_1XRTT:
if not cmas_receive_verify_message_lte_wcdma(
self.log, self.ad, self.anritsu,
next(TelLabCmasTest.SERIAL_NO), message_id,
warning_message):
self.log.error(
"Phone {} Failed to receive CMAS message".format(
self.ad.serial))
return False
else:
if not cmas_receive_verify_message_cdma1x(
self.log, self.ad, self.anritsu,
next(TelLabCmasTest.SERIAL_NO), message_id,
warning_message, c2k_response_type, c2k_severity,
c2k_urgency, c2k_certainty):
self.log.error(
"Phone {} Failed to receive CMAS message".format(
self.ad.serial))
return False
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during CMAS send/receive: " + str(e))
return False
return True
def _setup_sms(self,
set_simulation_func,
rat,
phone_number,
message,
mo_mt=DIRECTION_MOBILE_ORIGINATED):
try:
self.anritsu.reset()
self.anritsu.load_cell_paramfile(self.CELL_PARAM_FILE)
set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
self.anritsu.start_simulation()
if rat == RAT_LTE:
preferred_network_setting = NETWORK_MODE_LTE_GSM_WCDMA
rat_family = RAT_FAMILY_LTE
elif rat == RAT_WCDMA:
preferred_network_setting = NETWORK_MODE_GSM_UMTS
rat_family = RAT_FAMILY_UMTS
elif rat == RAT_GSM:
preferred_network_setting = NETWORK_MODE_GSM_ONLY
rat_family = RAT_FAMILY_GSM
elif rat == RAT_1XRTT:
preferred_network_setting = NETWORK_MODE_CDMA
rat_family = RAT_FAMILY_CDMA2000
else:
self.log.error("No valid RAT provided for SMS test.")
return False
if not ensure_network_rat(self.log,
self.ad,
preferred_network_setting,
rat_family,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
rat_family, preferred_network_setting))
return False
self.anritsu.wait_for_registration_state()
time.sleep(self.SETTLING_TIME)
if mo_mt == DIRECTION_MOBILE_ORIGINATED:
if not sms_mo_send(self.log, self.ad, self.virtualPhoneHandle,
phone_number, message, rat):
self.log.error("Phone {} Failed to send SMS".format(
self.ad.serial))
return False
else:
if not sms_mt_receive_verify(self.log, self.ad,
self.virtualPhoneHandle,
phone_number, message, rat):
self.log.error("Phone {} Failed to receive MT SMS".format(
self.ad.serial))
return False
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during emergency call procedure: " +
str(e))
return False
return True
def LTE_WCDMA_data_roaming(self, mcc, mnc):
try:
[self.bts1,
self.bts2] = set_system_model_lte_wcdma(self.anritsu,
self.user_params,
self.ad.sim_card)
set_usim_parameters(self.anritsu, self.ad.sim_card)
self.bts1.mcc = mcc
self.bts1.mnc = mnc
self.bts2.mcc = mcc
self.bts2.mnc = mnc
self.bts2.packet_rate = BtsPacketRate.WCDMA_DLHSAUTO_REL7_ULHSAUTO
self.anritsu.start_simulation()
self.bts2.service_state = BtsServiceState.SERVICE_STATE_OUT
self.log.info("Toggle Mobile Data On")
self.ad.droid.telephonyToggleDataConnection(True)
if not ensure_network_rat(self.log,
self.ad,
NETWORK_MODE_LTE_GSM_WCDMA,
RAT_FAMILY_LTE,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
RAT_FAMILY_LTE, NETWORK_MODE_LTE_GSM_WCDMA))
return False
toggle_cell_data_roaming(self.ad, True)
self.anritsu.wait_for_registration_state(1) # for BTS1 LTE
time.sleep(TIME_TO_WAIT_BEFORE_PING)
if not adb_shell_ping(self.ad, PING_DURATION, PING_TARGET):
self.log.error(
"Test Fail: Phone {} can not ping {} with Data Roaming On".
format(self.ad.serial, PING_TARGET))
return False
toggle_cell_data_roaming(self.ad, False)
time.sleep(TIME_TO_WAIT_BEFORE_PING)
if adb_shell_ping(self.ad, PING_DURATION, PING_TARGET):
self.log.error(
"Test Fail: Phone {} can ping {} with Data Roaming Off".
format(self.ad.serial, PING_TARGET))
return False
toggle_airplane_mode(self.log, self.ad, True)
time.sleep(2)
self.bts2.service_state = BtsServiceState.SERVICE_STATE_IN
self.bts1.service_state = BtsServiceState.SERVICE_STATE_OUT
toggle_airplane_mode(self.log, self.ad, False)
toggle_cell_data_roaming(self.ad, True)
self.anritsu.wait_for_registration_state(2) # for BTS2 WCDMA
time.sleep(TIME_TO_WAIT_BEFORE_PING)
if not adb_shell_ping(self.ad, PING_DURATION, PING_TARGET):
self.log.error(
"Test Fail: Phone {} can not ping {} with Data Roaming On".
format(self.ad.serial, PING_TARGET))
return False
toggle_cell_data_roaming(self.ad, False)
time.sleep(TIME_TO_WAIT_BEFORE_PING)
if adb_shell_ping(self.ad, PING_DURATION, PING_TARGET):
self.log.error(
"Test Fail: Phone {} can ping {} with Data Roaming Off".
format(self.ad.serial, PING_TARGET))
return False
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during data roaming: " + str(e))
return False
return True
def phone_setup_data_roaming(self):
return ensure_network_rat(self.log,
self.ad,
NETWORK_MODE_LTE_GSM_WCDMA,
RAT_FAMILY_LTE,
toggle_apm_after_setting=True)
def _data_stall_detection_recovery(self, set_simulation_func, rat):
try:
[self.bts1] = set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
set_usim_parameters(self.anritsu, self.ad.sim_card)
set_post_sim_params(self.anritsu, self.user_params,
self.ad.sim_card)
self.anritsu.start_simulation()
if rat == RAT_LTE:
preferred_network_setting = NETWORK_MODE_LTE_CDMA_EVDO
rat_family = RAT_FAMILY_LTE
elif rat == RAT_WCDMA:
preferred_network_setting = NETWORK_MODE_GSM_UMTS
rat_family = RAT_FAMILY_UMTS
elif rat == RAT_GSM:
preferred_network_setting = NETWORK_MODE_GSM_ONLY
rat_family = RAT_FAMILY_GSM
elif rat == RAT_1XRTT:
preferred_network_setting = NETWORK_MODE_CDMA
rat_family = RAT_FAMILY_CDMA2000
else:
self.log.error("No valid RAT provided for Data Stall test.")
return False
if not ensure_network_rat(self.log,
self.ad,
preferred_network_setting,
rat_family,
toggle_apm_after_setting=True):
self.log.error(
"Failed to set rat family {}, preferred network:{}".format(
rat_family, preferred_network_setting))
return False
self.anritsu.wait_for_registration_state()
time.sleep(self.SETTLING_TIME)
self.bts1.output_level = self.start_power_level
cmd = ('ss -l -p -n | grep "tcp.*droid_script" | tr -s " " '
'| cut -d " " -f 5 | sed s/.*://g')
sl4a_port = self.ad.adb.shell(cmd)
if not test_data_browsing_success_using_sl4a(self.log, self.ad):
self.ad.log.error("Browsing failed before the test, aborting!")
return False
begin_time = get_device_epoch_time(self.ad)
break_internet_except_sl4a_port(self.ad, sl4a_port)
if not test_data_browsing_failure_using_sl4a(self.log, self.ad):
self.ad.log.error("Browsing success even after breaking " \
"the internet, aborting!")
return False
if not check_data_stall_detection(self.ad):
self.ad.log.error("NetworkMonitor unable to detect Data Stall")
if not check_network_validation_fail(self.ad, begin_time):
self.ad.log.error("Unable to detect NW validation fail")
return False
if not check_data_stall_recovery(self.ad, begin_time):
self.ad.log.error("Recovery was not triggerred")
return False
resume_internet_with_sl4a_port(self.ad, sl4a_port)
if not test_data_browsing_success_using_sl4a(self.log, self.ad):
self.ad.log.error("Browsing failed after resuming internet")
return False
self.ad.log.info("Triggering Out of Service Sceanrio")
self.bts1.output_level = POWER_LEVEL_OUT_OF_SERVICE
time.sleep(30)
begin_time = get_device_epoch_time(self.ad)
if not test_data_browsing_failure_using_sl4a(self.log, self.ad):
self.ad.log.error("Browsing success even in OOS, aborting!")
return False
if not check_network_validation_fail(self.ad, begin_time):
self.ad.log.error("Unable to detect NW validation fail")
return False
if check_data_stall_recovery(self.ad, begin_time):
self.ad.log.error("FAILURE - Data Recovery was performed")
return False
self.ad.log.info("SUCCESS - Data Recovery was not performed")
self.ad.log.info("Bringing up Strong Cellular Signal")
self.bts1.output_level = POWER_LEVEL_FULL_SERVICE
time.sleep(30)
if not test_data_browsing_success_using_sl4a(self.log, self.ad):
self.ad.log.error("Browsing failed after full service")
return False
return True
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during Data procedure: " + str(e))
return False
finally:
resume_internet_with_sl4a_port(self.ad, sl4a_port)
