def _data_call_test(self, sub_id, generation):
self.dut.log.info(dict(self.result_info))
begin_time = get_device_epoch_time(self.dut)
start_qxdm_loggers(self.log, self.android_devices)
self.result_info["Network Change Request Total"] += 1
test_name = "%s_network_change_test_iter_%s" % (
self.test_name, self.result_info["Network Change Request Total"])
log_msg = "[Test Case] %s" % test_name
self.log.info("%s begin", log_msg)
self.dut.droid.logI("%s begin" % log_msg)
if not ensure_network_generation_for_subscription(
self.log, self.dut, sub_id,
generation) or not self._check_data():
self.result_info["Network Change Failure"] += 1
self.dut.droid.logI("%s end" % log_msg)
self.dut.log.info("%s end", log_msg)
try:
self._ad_take_extra_logs(self.dut, test_name, begin_time)
self._ad_take_bugreport(self.dut, test_name, begin_time)
except Exception as e:
self.log.warning(e)
return False
if not self._mobile_data_toggling(setup=None):
return False
return True
def _mobile_data_toggling(self, setup="volte"):
# ModePref change to non-LTE
begin_time = get_device_epoch_time(self.dut)
start_qxdm_loggers(self.log, self.android_devices)
result = True
self.result_info["Data Toggling Request Total"] += 1
test_name = "%s_data_toggling_iter_%s" % (
self.test_name, self.result_info["Data Toggling Request Total"])
log_msg = "[Test Case] %s" % test_name
self.log.info("%s begin", log_msg)
self.dut.droid.logI("%s begin" % log_msg)
self.dut.adb.shell("svc data disable")
time.sleep(WAIT_TIME_AFTER_MODE_CHANGE)
self.dut.adb.shell("svc data enable")
if not self._check_data():
result = False
elif setup == "volte" and not phone_idle_volte(self.log, self.dut):
result = False
self.dut.droid.logI("%s end" % log_msg)
self.dut.log.info("%s end", log_msg)
if not result:
self.result_info["Data Toggling Failure"] += 1
try:
self._ad_take_extra_logs(self.dut, test_name, begin_time)
self._ad_take_bugreport(self.dut, test_name, begin_time)
except Exception as e:
self.log.exception(e)
return False
else:
self.result_info["Data Toggling Success"] += 1
return True
def crash_check_test(self):
failure = 0
while time.time() < self.finishing_time:
try:
self.log.info(dict(self.result_info))
self._update_perf_json()
begin_time = get_device_epoch_time(self.dut)
run_time_in_seconds = (begin_time - self.begin_time) / 1000
test_name = "%s_crash_%s_seconds_after_start" % (
self.test_name, run_time_in_seconds)
time.sleep(self.crash_check_interval)
for ad in self.android_devices:
crash_report = ad.check_crash_report(
test_name, begin_time, log_crash_report=True)
if crash_report:
ad.log.error("Find new crash reports %s", crash_report)
failure += 1
self.result_info["Crashes"] += len(crash_report)
for crash in crash_report:
if "ramdump_modem" in crash:
self.result_info["Crashes-Modem"] += 1
try:
ad.take_bug_report(test_name, begin_time)
except Exception as e:
self.log.exception(e)
except Exception as e:
self.log.error("Exception error %s", str(e))
self.result_info["Exception Errors"] += 1
self.log.info("Crashes found: %s", failure)
if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE:
self.log.error("Too many exception errors, quit test")
return False
if failure:
return False
else:
return True
def _prefnetwork_mode_change(self, sub_id):
# ModePref change to non-LTE
begin_time = get_device_epoch_time(self.dut)
start_qxdm_loggers(self.log, self.android_devices)
self.result_info["Network Change Request Total"] += 1
test_name = "%s_network_change_iter_%s" % (
self.test_name, self.result_info["Network Change Request Total"])
log_msg = "[Test Case] %s" % test_name
self.log.info("%s begin", log_msg)
self.dut.droid.logI("%s begin" % log_msg)
network_preference_list = [
NETWORK_MODE_TDSCDMA_GSM_WCDMA, NETWORK_MODE_WCDMA_ONLY,
NETWORK_MODE_GLOBAL, NETWORK_MODE_CDMA, NETWORK_MODE_GSM_ONLY
]
network_preference = random.choice(network_preference_list)
set_preferred_network_mode_pref(self.log, self.dut, sub_id,
network_preference)
time.sleep(WAIT_TIME_AFTER_MODE_CHANGE)
self.dut.log.info("Current Voice RAT is %s",
get_current_voice_rat(self.log, self.dut))
# ModePref change back to with LTE
if not phone_setup_volte(self.log, self.dut):
self.dut.log.error("Phone failed to enable VoLTE.")
self.result_info["VoLTE Setup Failure"] += 1
self.dut.droid.logI("%s end" % log_msg)
self.dut.log.info("%s end", log_msg)
try:
self._ad_take_extra_logs(self.dut, test_name, begin_time)
self._ad_take_bugreport(self.dut, test_name, begin_time)
except Exception as e:
self.log.exception(e)
return False
else:
self.result_info["VoLTE Setup Success"] += 1
return True
def _cbrs_default_data_switch_timing(self, ad, method, validation=False):
result = True
callback_key = None
if not getattr(ad, "cbrs_droid", None):
ad.cbrs_droid, ad.cbrs_ed = ad.get_droid()
ad.cbrs_ed.start()
else:
try:
if not ad.cbrs_droid.is_live:
ad.cbrs_droid, ad.cbrs_ed = ad.get_droid()
ad.cbrs_ed.start()
else:
ad.cbrs_ed.clear_all_events()
ad.cbrs_droid.logI("Start test_stress_cbrsdataswitch test")
except Exception:
ad.log.info("Create new sl4a session for CBRS")
ad.cbrs_droid, ad.cbrs_ed = ad.get_droid()
ad.cbrs_ed.start()
if validation:
ad.cbrs_droid.telephonyStartTrackingActiveDataChange()
else:
callback_key = ad.cbrs_droid.connectivityRegisterDefaultNetworkCallback(
)
ad.cbrs_droid.connectivityNetworkCallbackStartListeningForEvent(
callback_key, NetworkCallbackAvailable)
time.sleep(WAIT_TIME_FOR_CBRS_DATA_SWITCH)
try:
ad.cbrs_ed.clear_events(EventActiveDataSubIdChanged)
ad.cbrs_ed.clear_events(EventNetworkCallback)
initiate_time_before = get_device_epoch_time(ad)
ad.log.debug("initiate_time_before: %d", initiate_time_before)
if method == "api":
ad.log.info("Setting DDS to default sub %s",
self.default_subid)
ad.droid.telephonySetPreferredOpportunisticDataSubscription(
2147483647, validation)
else:
ad.log.info("Making a Voice Call to %s", STORY_LINE)
ad.droid.telecomCallNumber(STORY_LINE, False)
try:
if validation:
events = ad.cbrs_ed.pop_events(
"(%s)" % (EventActiveDataSubIdChanged),
WAIT_TIME_FOR_CBRS_DATA_SWITCH)
for event in events:
ad.log.info("Got event %s", event["name"])
if event["name"] == EventActiveDataSubIdChanged:
if event.get("data") and \
event["data"] == self.default_subid:
ad.log.info("%s has data switched to: %s sub",
event["name"], event["data"])
initiate_time_after = event["time"]
break
else:
events = ad.cbrs_ed.pop_events(
"(%s)" % (EventNetworkCallback),
WAIT_TIME_FOR_CBRS_DATA_SWITCH)
for event in events:
ad.log.info("Got event %s", event["name"])
if event["name"] == EventNetworkCallback:
if event.get("data") and event["data"].get(
"networkCallbackEvent"):
ad.log.info(
"%s %s has data switched to: %s sub",
event["name"],
event["data"]["networkCallbackEvent"],
self.default_subid)
initiate_time_after = event["time"]
break
except Empty:
ad.log.error(
"No %s or %s event for DataSwitch received in %d seconds",
EventActiveDataSubIdChanged, EventNetworkCallback,
WAIT_TIME_FOR_CBRS_DATA_SWITCH)
return False
time_interval = (initiate_time_after - initiate_time_before) / 1000
self.switch_time_dict['cbrs_default_switch'].append(time_interval)
if time_interval > TIME_PERMITTED_FOR_CBRS_SWITCH:
ad.log.error("Time for CBRS->Default - %.2f secs",
time_interval)
result = False
else:
ad.log.info("Time for CBRS->Default - %.2f secs",
time_interval)
time.sleep(WAIT_TIME_BETWEEN_HANDOVER)
ad.cbrs_ed.clear_events(EventActiveDataSubIdChanged)
ad.cbrs_ed.clear_events(EventNetworkCallback)
hangup_time_before = get_device_epoch_time(ad)
ad.log.debug("hangup_time_before: %d", hangup_time_before)
if method == "api":
ad.log.info("Setting DDS to cbrs sub %s", self.cbrs_subid)
ad.droid.telephonySetPreferredOpportunisticDataSubscription(
self.cbrs_subid, validation)
else:
ad.log.info("Ending Call")
ad.droid.telecomEndCall()
try:
if validation:
events = ad.cbrs_ed.pop_events(
"(%s)" % (EventActiveDataSubIdChanged),
WAIT_TIME_FOR_CBRS_DATA_SWITCH)
for event in events:
ad.log.info("Got event %s", event["name"])
if event["name"] == EventActiveDataSubIdChanged:
if event.get("data") and \
event["data"] == self.cbrs_subid:
ad.log.info("%s has data switched to: %s sub",
event["name"], event["data"])
hangup_time_after = event["time"]
break
else:
events = ad.cbrs_ed.pop_events(
"(%s)" % (EventNetworkCallback),
WAIT_TIME_FOR_CBRS_DATA_SWITCH)
for event in events:
ad.log.info("Got event %s", event["name"])
if event["name"] == EventNetworkCallback:
if event.get("data") and event["data"].get(
"networkCallbackEvent"):
ad.log.info(
"%s %s has data switched to: %s sub",
event["name"],
event["data"]["networkCallbackEvent"],
self.cbrs_subid)
hangup_time_after = event["time"]
break
except Empty:
ad.log.error(
"No %s event for DataSwitch received in %d seconds",
EventActiveDataSubIdChanged,
WAIT_TIME_FOR_CBRS_DATA_SWITCH)
return False
time_interval = (hangup_time_after - hangup_time_before) / 1000
self.switch_time_dict['default_cbrs_switch'].append(time_interval)
if time_interval > TIME_PERMITTED_FOR_CBRS_SWITCH:
ad.log.error("Time for Default->CBRS - %.2f secs",
time_interval)
result = False
else:
ad.log.info("Time for Default->CBRS - %.2f secs",
time_interval)
except Exception as e:
self.log.error("Exception error %s", e)
raise
finally:
if validation:
ad.cbrs_droid.telephonyStopTrackingActiveDataChange()
elif callback_key:
ad.cbrs_droid.connectivityNetworkCallbackStopListeningForEvent(
callback_key, NetworkCallbackAvailable)
return result
def call_setup_and_connectivity_monitor_checking(self,
setup=None,
handover=None,
triggers=[],
expected_drop_reason="",
expected_trouble=None,
expected_action=None):
call_verification_function = None
begin_time = get_device_epoch_time(self.dut)
call_data_summary_before = self.parsing_call_summary()
call_statistics_before = self.parsing_call_statistics()
self.parsing_diagnostics()
self.parsing_troubleshooter_database()
bugreport_database_before = self.parsing_bugreport_database()
if expected_drop_reason:
expected_drop_reasons = set(expected_drop_reason.split("|"))
else:
expected_drop_reasons = set()
checking_counters = ["Calls"]
checking_reasons = []
result = True
if setup in ("wfc_apm", "wfc_non_apm"):
call_verification_function = is_phone_in_call_iwlan
elif setup == "volte":
call_verification_function = is_phone_in_call_volte
elif setup == "csfb":
call_verification_function = is_phone_in_call_csfb
elif setup == "3g":
call_verification_function = is_phone_in_call_3g
elif setup == "2g":
call_verification_function = is_phone_in_call_2g
technology = handover or setup
if technology in ("wfc_apm", "wfc_non_apm"):
if triggers and triggers[0] not in IGNORED_CALL_DROP_TRIGGERS:
checking_counters.extend(
["Calls_dropped", "VOWIFI", "VOWIFI_dropped"])
checking_reasons.append("VOWIFI_failure_reason")
elif call_data_summary_before.get("Calls_dropped", 0):
checking_counters.append("VOWIFI")
elif technology == "volte":
if triggers and triggers[0] not in IGNORED_CALL_DROP_TRIGGERS:
checking_counters.extend(
["Calls_dropped", "VOLTE", "VOLTE_dropped"])
checking_reasons.append("VOLTE_failure_reason")
elif call_data_summary_before.get("Calls_dropped", 0):
checking_counters.append("VOLTE")
elif technology in ("csfb", "3g", "2g"):
if triggers and triggers[0] not in IGNORED_CALL_DROP_TRIGGERS:
checking_counters.extend(["Calls_dropped", "CS", "CS_dropped"])
checking_reasons.append("CS_failure_reason")
elif call_data_summary_before.get("Calls_dropped", 0):
checking_counters.append("CS")
if setup == "vt":
if not video_call_setup_teardown(
self.log,
self.dut,
self.ad_reference,
None,
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_video_bidirectional,
verify_callee_func=is_phone_in_call_video_bidirectional):
raise signals.TestFailure("VT Call Failed.")
else:
if not call_setup_teardown(
self.log,
self.dut,
self.ad_reference,
ad_hangup=None,
verify_caller_func=call_verification_function,
wait_time_in_call=10):
raise signals.TestFailure("Call Setup Failed.")
for trigger in triggers:
if self.dut.droid.telecomIsInCall():
self.dut.log.info("Telecom is in call")
self.dut.log.info(
"Voice in RAT %s",
self.dut.droid.telephonyGetCurrentVoiceNetworkType())
else:
self.dut.log.info("Not in call")
# Trigger in-call event
if trigger and getattr(self, trigger, None):
trigger_func = getattr(self, trigger)
trigger_func()
time.sleep(MAX_WAIT_TIME_FOR_STATE_CHANGE)
if self.dut.droid.telecomIsInCall():
self.dut.log.info("Telecom is in call")
self.dut.log.info(
"Voice in RAT %s",
self.dut.droid.telephonyGetCurrentVoiceNetworkType())
else:
self.dut.log.info("Not in call")
if self.dut.droid.telecomIsInCall():
self.dut.log.info("Telecom is in call")
self.dut.log.info(
"Voice in RAT %s",
self.dut.droid.telephonyGetCurrentVoiceNetworkType())
else:
self.dut.log.info("Not in call")
drop_reason = last_call_drop_reason(self.dut, begin_time)
drop_reason = drop_reason.title()
if drop_reason:
expected_drop_reasons.add(drop_reason)
for ad in (self.ad_reference, self.dut):
try:
if ad.droid.telecomIsInCall():
if triggers:
ad.log.info("Still in call after triggers %s",
triggers)
result = False
hangup_call(self.log, ad)
time.sleep(MAX_WAIT_TIME_FOR_STATE_CHANGE)
except Exception as e:
ad.log.error(e)
call_data_summary_after = self.parsing_call_summary()
call_statistics_after = self.parsing_call_statistics()
diagnostics_after = self.parsing_diagnostics()
ts_database_after = self.parsing_troubleshooter_database()
for counter in checking_counters:
if call_data_summary_after.get(
counter,
0) != call_data_summary_before.get(counter, 0) + 1:
self.dut.log.error("Counter %s did not increase", counter)
result = False
else:
self.dut.log.info("Counter %s increased", counter)
if counter == "Calls":
if call_statistics_after.get("num_calls",
0) - call_statistics_before.get(
"num_calls", 0) < 1:
self.dut.log.warning(
"call_statistics num_calls didn't increase")
# result = False
else:
self.dut.log.info("call_statistics num_calls increased")
if "_dropped" in counter and counter != "Calls_dropped":
desc = counter.split("_")[0]
if desc == "VOWIFI":
stat_key = "recent_wfc_fail_count"
else:
stat_key = "recent_%s_fail_count" % desc.lower()
before = call_statistics_after.get(stat_key, 0)
after = call_statistics_after.get(stat_key, 0)
most_failure_call_type = call_statistics_after.get(
"call_type_with_most_failures")
diagnosis = diagnostics_after.get("diagnosis")
actions = diagnostics_after.get("actions")
if after - before < 1:
self.dut.log.warning("call_statistics %s didn't increase, "
"before %s, after %s" %
(stat_key, before, after))
# result = False
else:
self.dut.log.info("call_statistics %s increased", stat_key)
if most_failure_call_type != desc:
self.dut.log.warning(
"call_statistics call_type_with_most_failures "
"is %s, not %s", most_failure_call_type, desc)
else:
self.dut.log.info(
"call_statistics call_type_with_most_failures is %s",
most_failure_call_type)
dropped = call_data_summary_after.get("%s_dropped" % desc, 0)
drop_percentage = call_data_summary_after.get(
"%s_dropped_percentage" % desc, 0)
self.dut.log.info("%s_dropped = %s, percentage = %s", desc,
dropped, drop_percentage)
if expected_trouble and expected_trouble != diagnosis:
self.dut.log.warning("diagnoisis = %s, expecting %s",
diagnosis, expected_trouble)
if expected_action and expected_action != actions:
self.dut.log.error("actions = %s, expecting %s", actions,
expected_action)
result = False
if drop_percentage > CALL_TROUBLE_THRESHOLD and (
dropped > CONSECUTIVE_CALL_FAILS):
if diagnosis == "UNABLE_TO_TRIAGE":
self.dut.log.error(
"troubleshooter diagnosis is %s with %s dropped "
"and %s drop_percentage", diagnosis, dropped,
drop_percentage)
result = False
if actions == "NONE":
self.dut.log.error(
"troubleshooter failed to provide suggestion, "
"actions = %s", actions)
result = False
if expected_drop_reasons:
expected_drop_reason = "|".join(expected_drop_reasons)
for reason_key in checking_reasons:
if call_data_summary_after.get(reason_key, None):
drop_reason = call_data_summary_after[reason_key]
if expected_drop_reason and drop_reason not in expected_drop_reason:
self.dut.log.error("%s is: %s, expecting %s", reason_key,
drop_reason, expected_drop_reason)
result = False
else:
self.dut.log.info("%s is: %s as expected", reason_key,
drop_reason)
else:
self.dut.log.error("%s is not provided in summary report",
reason_key)
result = False
if not triggers or triggers[0] in IGNORED_CALL_DROP_TRIGGERS:
return result
if drop_reason in bugreport_database_before:
self.dut.log.info("%s is in bugreport database %s before call",
drop_reason, bugreport_database_before)
return result
else:
self.dut.log.info("%s is not in bugreport database %s before call",
drop_reason, bugreport_database_before)
if drop_reason in IGNORED_CALL_DROP_REASONS:
self.dut.log.info(
"Call drop with reason %s will skip bugreport notification",
drop_reason)
return result
else:
self.dut.log.info(
"Call drop %s should generate bugreport notification",
drop_reason)
# Parse logcat for UI notification only for the first failure
if self.dut.search_logcat("Bugreport notification title Call Drop:",
begin_time):
self.dut.log.info(
"Bugreport notification title Call Drop is seen in logcat")
return result
else:
self.dut.log.error(
"Bugreport notification title Call Drop is not seen in logcat")
return False
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)
def _make_phone_call(self, call_verification_func=None):
ads = self.android_devices[:]
if not self.single_phone_test:
random.shuffle(ads)
the_number = self.result_info["Call Total"] + 1
duration = random.randrange(self.min_phone_call_duration,
self.max_phone_call_duration)
result = True
test_name = "%s_No_%s_phone_call" % (self.test_name, the_number)
log_msg = "[Test Case] %s" % test_name
self.log.info("%s for %s seconds begin", log_msg, duration)
begin_time = get_device_epoch_time(ads[0])
for ad in self.android_devices:
if self.user_params.get("turn_on_tcpdump", True):
start_adb_tcpdump(ad, interface="any", mask="all")
if not getattr(ad, "droid", None):
ad.droid, ad.ed = ad.get_droid()
ad.ed.start()
else:
try:
if not ad.droid.is_live:
ad.droid, ad.ed = ad.get_droid()
ad.ed.start()
else:
ad.ed.clear_all_events()
except Exception:
ad.log.info("Create new sl4a session for phone call")
ad.droid, ad.ed = ad.get_droid()
ad.ed.start()
ad.droid.logI("%s begin" % log_msg)
start_qxdm_loggers(self.log, self.android_devices, begin_time)
failure_reasons = set()
self.dut_incall = True
if self.single_phone_test:
call_setup_result = initiate_call(
self.log,
self.dut,
self.call_server_number,
incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND
) and wait_for_in_call_active(self.dut, 60, 3)
else:
call_setup_result = call_setup_teardown(
self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=call_verification_func,
verify_callee_func=call_verification_func,
wait_time_in_call=0,
incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND)
if not call_setup_result:
call_logs = ads[0].search_logcat(
"ActivityManager: START u0 {act=android.intent.action.CALL",
begin_time)
messaging_logs = ads[0].search_logcat(
"com.google.android.apps.messaging/.ui.conversation.ConversationActivity",
begin_time)
if call_logs and messaging_logs:
if messaging_logs[-1]["datetime_obj"] - call_logs[-1]["datetime_obj"] < 5:
ads[0].log.info(
"Call setup failure due to simultaneous activities")
self.result_info[
"Call Setup Failure With Simultaneous Activity"] += 1
return True
self.log.error("%s: Setup Call failed.", log_msg)
failure_reasons.add("Setup")
result = False
else:
elapsed_time = 0
check_interval = 5
while (elapsed_time < duration):
check_interval = min(check_interval, duration - elapsed_time)
time.sleep(check_interval)
elapsed_time += check_interval
time_message = "at <%s>/<%s> second." % (elapsed_time,
duration)
for ad in ads:
if not call_verification_func(self.log, ad):
ad.log.warning("Call is NOT in correct %s state at %s",
call_verification_func.__name__,
time_message)
if call_verification_func.__name__ == "is_phone_in_call_iwlan":
if is_phone_in_call(self.log, ad):
if getattr(ad, "data_rat_state_error_count",
0) < 1:
setattr(ad, "data_rat_state_error_count",
1)
continue
failure_reasons.add("Maintenance")
last_call_drop_reason(ad, begin_time)
hangup_call(self.log, ads[0])
result = False
else:
ad.log.info("Call is in correct %s state at %s",
call_verification_func.__name__,
time_message)
if not result:
break
if not hangup_call(self.log, ads[0]):
failure_reasons.add("Teardown")
result = False
for ad in ads:
if not wait_for_call_id_clearing(ad,
[]) or ad.droid.telecomIsInCall():
ad.log.error("Fail to hang up call")
failure_reasons.add("Teardown")
result = False
self.result_info["Call Total"] += 1
for ad in self.android_devices:
try:
ad.droid.logI("%s end" % log_msg)
except:
pass
self.log.info("%s end", log_msg)
self.dut_incall = False
if not result:
self.log.info("%s failed", log_msg)
if self.gps_log_file:
gps_info = job.run(
"tail %s" % self.gps_log_file, ignore_status=True)
if gps_info.stdout:
gps_log_path = os.path.join(self.log_path, test_name,
"gps_logs.txt")
utils.create_dir(gps_log_path)
job.run(
"tail %s > %s" % (self.gps_log_file, gps_log_path),
ignore_status=True)
self.log.info("gps log:\n%s", gps_info.stdout)
else:
self.log.warning("Fail to get gps log %s",
self.user_params["gps_log_file"])
for reason in failure_reasons:
self.result_info["Call %s Failure" % reason] += 1
for ad in ads:
log_path = os.path.join(self.log_path, test_name,
"%s_binder_logs" % ad.serial)
utils.create_dir(log_path)
ad.pull_files(BINDER_LOGS, log_path)
try:
self._take_bug_report(test_name, begin_time)
except Exception as e:
self.log.exception(e)
for ad in ads:
if ad.droid.telecomIsInCall():
hangup_call_by_adb(ad)
else:
self.log.info("%s test succeed", log_msg)
self.result_info["Call Success"] += 1
if self.result_info["Call Total"] % 50 == 0:
for ad in ads:
synchronize_device_time(ad)
if not check_is_wifi_connected(self.log, ad,
self.wifi_network_ssid):
ensure_wifi_connected(self.log, ad,
self.wifi_network_ssid,
self.wifi_network_pass)
force_connectivity_metrics_upload(ad)
time.sleep(300)
wifi_toggle_state(self.log, ad, False)
if self.get_binder_logs:
log_path = os.path.join(self.log_path,
"%s_binder_logs" % test_name,
"%s_binder_logs" % ad.serial)
utils.create_dir(log_path)
ad.pull_files(BINDER_LOGS, log_path)
return result
def _send_message(self, max_wait_time=2 * MAX_WAIT_TIME_SMS_RECEIVE):
if self.single_phone_test:
ads = [self.dut, self.dut]
else:
ads = self.android_devices[:]
random.shuffle(ads)
selection = random.randrange(0, 2)
message_type_map = {0: "SMS", 1: "MMS"}
max_length_map = {0: self.max_sms_length, 1: self.max_mms_length}
min_length_map = {0: self.min_sms_length, 1: self.min_mms_length}
length = random.randrange(min_length_map[selection],
max_length_map[selection] + 1)
message_func_map = {
0: sms_send_receive_verify,
1: mms_send_receive_verify
}
rat = self.dut.adb.getprop("gsm.network.type")
self.dut.log.info("Network in RAT %s", rat)
if self.dut_incall and not is_rat_svd_capable(rat.upper()):
self.dut.log.info("In call data not supported, test SMS only")
selection = 0
message_type = message_type_map[selection]
the_number = self.result_info["%s Total" % message_type] + 1
begin_time = get_device_epoch_time(self.dut)
test_name = "%s_No_%s_%s" % (self.test_name, the_number, message_type)
start_qxdm_loggers(self.log, self.android_devices)
log_msg = "[Test Case] %s" % test_name
self.log.info("%s begin", log_msg)
for ad in self.android_devices:
if self.user_params.get("turn_on_tcpdump", True):
start_adb_tcpdump(ad, interface="any", mask="all")
if not getattr(ad, "messaging_droid", None):
ad.messaging_droid, ad.messaging_ed = ad.get_droid()
ad.messaging_ed.start()
else:
try:
if not ad.messaging_droid.is_live:
ad.messaging_droid, ad.messaging_ed = ad.get_droid()
ad.messaging_ed.start()
else:
ad.messaging_ed.clear_all_events()
except Exception:
ad.log.info("Create new sl4a session for messaging")
ad.messaging_droid, ad.messaging_ed = ad.get_droid()
ad.messaging_ed.start()
ad.messaging_droid.logI("%s begin" % log_msg)
text = "%s: " % test_name
text_length = len(text)
if length < text_length:
text = text[:length]
else:
text += rand_ascii_str(length - text_length)
message_content_map = {0: [text], 1: [(test_name, text, None)]}
result = message_func_map[selection](self.log, ads[0], ads[1],
message_content_map[selection],
max_wait_time)
self.log.info("%s end", log_msg)
for ad in self.android_devices:
ad.messaging_droid.logI("%s end" % log_msg)
if not result:
self.result_info["%s Total" % message_type] += 1
if message_type == "SMS":
self.log.error("%s fails", log_msg)
self.result_info["%s Failure" % message_type] += 1
else:
rat = self.dut.adb.getprop("gsm.network.type")
self.dut.log.info("Network in RAT %s", rat)
if self.dut_incall and not is_rat_svd_capable(rat.upper()):
self.dut.log.info(
"In call data not supported, MMS failure expected")
self.result_info["Expected In-call MMS failure"] += 1
return True
else:
self.log.error("%s fails", log_msg)
self.result_info["MMS Failure"] += 1
try:
self._take_bug_report(test_name, begin_time)
except Exception as e:
self.log.exception(e)
return False
else:
self.result_info["%s Total" % message_type] += 1
self.log.info("%s succeed", log_msg)
self.result_info["%s Success" % message_type] += 1
return True