def test_sms_mt_in_call_vt(self):
""" Test MT SMS, Phone in ongoing VT call.
Make Sure PhoneA and PhoneB in LTE and can make VT call.
Make Video Call from PhoneA to PhoneB, accept on PhoneB as Video Call.
Receive SMS on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
tasks = [(phone_setup_video, (self.log, ads[0])), (phone_setup_video,
(self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
if not video_call_setup_teardown(
self.log,
ads[0],
ads[1],
None,
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_video_bidirectional,
verify_callee_func=is_phone_in_call_video_bidirectional):
self.log.error("Failed to setup a call")
return False
return self._sms_test_mt(ads)
def _check_vt_enabled(self):
if not video_call_setup_teardown(
self.log,
self.dut,
self.ad_reference,
self.dut,
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_video_bidirectional,
verify_callee_func=is_phone_in_call_video_bidirectional):
self.log.error("VT Call Failed.")
return False
return True
def _check_vt(self):
if (CAPABILITY_VT in operator_capabilities[self.dut_operator]):
self.log.info("Check VT")
if not phone_setup_video(self.log, self.dut):
self.log.error("Failed to setup VT.")
return False
time.sleep(5)
if not video_call_setup_teardown(
self.log,
self.dut,
self.ad_reference,
self.dut,
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_video_bidirectional,
verify_callee_func=is_phone_in_call_video_bidirectional):
self.log.error("VT Call Failed.")
return False
return True
def call_drop_by_modem_crash(self,
call_verification_function=None,
vt=False):
if 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):
self.dut.log.error("VT Call Failed.")
return False
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):
self.log.error("Call setup failed")
return False
# Modem SSR
self.modem_crash()
try:
if self.dut.droid.telecomIsInCall():
self.dut.log.info("Still in call after trigger modem crash")
return False
else:
reasons = self.dut.search_logcat(
"qcril_qmi_voice_map_qmi_to_ril_last_call_failure_cause")
if reasons:
self.dut.log.info(reasons[-1]["log_message"])
except Exception as e:
self.dut.log.error(e)
def test_internet_access_during_video_call(self):
""" Test Internet access during VT<->VT call.
Make Sure PhoneA is in LTE mode (with Video Calling).
Make Sure PhoneB is in LTE mode (with Video Calling).
Call from PhoneA to PhoneB as Bi-Directional Video,
Accept on PhoneB as video call.
Verify PhoneA have Internet access.
Hang up on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
tasks = [(phone_setup_video, (self.log, ads[0])),
(phone_setup_video, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
self.log.info("Step1: Make MO VT call.")
if not video_call_setup_teardown(
self.log,
ads[0],
ads[1],
None,
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_video_bidirectional,
verify_callee_func=is_phone_in_call_video_bidirectional):
self.log.error("Failed to setup+teardown a call")
return False
self.log.info("Step2: Verify Internet on PhoneA.")
if not verify_http_connection(self.log, ads[0]):
self.log.error("Verify Internet on PhoneA failed.")
return False
return hangup_call(self.log, ads[0])
def test_call_video_to_video_wifi_preferred_apm(self):
""" Test ViWifi<->ViWifi call functionality in APM Mode.
Make Sure PhoneA is in iWLAN mode (with Video Calling).
Make Sure PhoneB is in iWLAN mode (with Video Calling).
Turn on APM Mode
Connect to Wifi
Call from PhoneA to PhoneB as Bi-Directional Video,
Accept on PhoneB as video call, hang up on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
tasks = [
(phone_setup_iwlan,
(self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass)),
(phone_setup_iwlan,
(self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass)),
]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
if not video_call_setup_teardown(
self.log,
ads[0],
ads[1],
ads[0],
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_viwifi_bidirectional,
verify_callee_func=is_phone_in_call_viwifi_bidirectional):
self.log.error("Failed to setup+teardown a call")
return False
return True
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