#!/usr/bin/env python3.4 # # Copyright 2018 - Google # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Connectivity Monitor and Telephony Troubleshooter Tests """ import os import re import time from acts import signals from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest from acts_contrib.test_utils.tel.tel_defines import CAPABILITY_VOLTE from acts_contrib.test_utils.tel.tel_defines import CAPABILITY_VT from acts_contrib.test_utils.tel.tel_defines import CAPABILITY_WFC from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_FOR_STATE_CHANGE from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED from acts_contrib.test_utils.tel.tel_defines import VT_STATE_BIDIRECTIONAL from acts_contrib.test_utils.tel.tel_bootloader_utils import fastboot_wipe from acts_contrib.test_utils.tel.tel_ims_utils import toggle_volte from acts_contrib.test_utils.tel.tel_ims_utils import toggle_wfc from acts_contrib.test_utils.tel.tel_ims_utils import wait_for_wfc_enabled from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_voice_2g from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_voice_3g from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_csfb from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_iwlan from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_volte from acts_contrib.test_utils.tel.tel_test_utils import bring_up_connectivity_monitor from acts_contrib.test_utils.tel.tel_test_utils import get_device_epoch_time from acts_contrib.test_utils.tel.tel_test_utils import get_model_name from acts_contrib.test_utils.tel.tel_test_utils import get_operator_name from acts_contrib.test_utils.tel.tel_test_utils import get_outgoing_voice_sub_id from acts_contrib.test_utils.tel.tel_test_utils import reboot_device from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode from acts_contrib.test_utils.tel.tel_test_utils import trigger_modem_crash from acts_contrib.test_utils.tel.tel_test_utils import trigger_modem_crash_by_modem from acts_contrib.test_utils.tel.tel_video_utils import video_call_setup_teardown from acts_contrib.test_utils.tel.tel_video_utils import phone_setup_video from acts_contrib.test_utils.tel.tel_video_utils import is_phone_in_call_video_bidirectional from acts_contrib.test_utils.tel.tel_voice_utils import call_setup_teardown from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_2g from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_3g from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_csfb from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_volte from acts_contrib.test_utils.tel.tel_voice_utils import last_call_drop_reason from acts_contrib.test_utils.tel.tel_wifi_utils import ensure_wifi_connected from acts_contrib.test_utils.tel.tel_wifi_utils import wifi_toggle_state CALL_DROP_CODE_MAPPING = { 373: "Radio Internal Error", 175: "Invalid Transaction Identifier V02", 159: "Temporary Failure", 135: "Rejected by Network V02", 118: "SS Not Available", 115: "Call Barred V02", 42: "Access Block V02", 41: "Incompatible V02" } CONSECUTIVE_CALL_FAILS = 5 CALL_TROUBLE_THRESHOLD = 25 TROUBLES = { 1: "WIFI_CALL_DROPS_IN_BAD_WIFI_SIGNAL", 2: "WIFI_CALL_DROPS_IN_GOOD_WIFI_SIGNAL_ON_SPECIFIC_WIFI_NETWORK", 3: "WIFI_CALL_DROPS_WITH_SPECIFIC_REASON_IN_GOOD_WIFI_SIGNAL", 4: "WIFI_CALL_DROPS_WITH_RANDOM_FAILURES_IN_GOOD_WIFI_SIGNAL", 5: "VOLTE_CALL_DROPS_IN_BAD_LTE_SIGNAL_AREAS", 6: "VOLTE_CALL_DROPS_IN_GOOD_LTE_SIGNAL_AREAS", 7: "CS_CALL_DROPS_IMS_DISABLED", 8: "CS_CALL_DROPS_WFC_DISABLED", 9: "CS_CALL_DROPS_IMS_REGISTRATION_FAILURES", 10: "CS_CALL_DROPS_DURING_SRVCC", 11: "CS_CALL_DROPS_IN_BAD_RF_CONDITIONS", 12: "CS_CALL_DROPS_IN_GOOD_RF_CONDITIONS_WITH_SPECIFIC_REASON", 13: "UNABLE_TO_TRIAGE" } ACTIONS = { 1: "CHECK_BLUETOOTH", 2: "CHECK_HEADSET", 3: "SWITCH_FROM_WIFI_PREFERRED_TO_CELLULAR_PREFERRED", 4: "SWITCH_FROM_CELLULAR_PREFERRED_TO_WIFI_PREFERRED", 5: "ENABLE_ADVANCED_4G_CALLING", 6: "DISABLE_ADVANCED_4G_CALLING", 7: "TOGGLE_AIRPLANE_MODE_TWICE", 8: "REBOOT_THE_PHONE", 9: "ENABLE_WIFI_CALLING", 10: "DISABLE_WIFI_CALLING", 11: "DISABLE_AIRPLANE_MODE", 12: "NONE" } IGNORED_CALL_DROP_REASONS = ["Radio Link Lost", "Media Timeout"] CALL_DATA_LOGS = ( "/data/data/com.google.android.connectivitymonitor/databases") IGNORED_CALL_DROP_TRIGGERS = ["toggle_apm", "toggle_wifi"] class TelLiveConnectivityMonitorBaseTest(TelephonyBaseTest): def setup_class(self): TelephonyBaseTest.setup_class(self) self.user_params["enable_connectivity_metrics"] = False self.user_params["telephony_auto_rerun"] = 0 self.consecutive_failure_limit = 5 self.dut = self.android_devices[0] self.ad_reference = self.android_devices[1] self.dut_model = get_model_name(self.dut) self.dut_operator = get_operator_name(self.log, self.dut) self.dut_subID = get_outgoing_voice_sub_id(self.dut) self.dut_capabilities = self.dut.telephony["subscription"][self.dut_subID].get("capabilities", []) self.dut_wfc_modes = self.dut.telephony["subscription"][self.dut_subID].get("wfc_modes", []) self.ad_reference_subID = get_outgoing_voice_sub_id(self.ad_reference) self.reference_capabilities = self.ad_reference.telephony["subscription"][self.ad_reference_subID].get( "capabilities", []) self.dut.log.info("DUT capabilities: %s", self.dut_capabilities) self.skip_reset_between_cases = False self.user_params["telephony_auto_rerun"] = 0 self.number_of_devices = 1 self.call_drop_override_code = self.user_params.get( "call_drop_override_code", 373) def setup_test(self): TelephonyBaseTest.setup_test(self) bring_up_connectivity_monitor(self.dut) ## Work around for WFC not working issue on 2018 devices if "Permissive" not in self.dut.adb.shell("su root getenforce"): self.dut.adb.shell("su root setenforce 0") def on_fail(self, test_name, begin_time): self.dut.log.info("Pulling %s", CALL_DATA_LOGS) log_path = os.path.join(self.dut.log_path, test_name, "ConnectivityMonitorLogs_%s" % self.dut.serial) os.makedirs(log_path, exist_ok=True) self.dut.pull_files([CALL_DATA_LOGS], log_path) self._take_bug_report(test_name, begin_time) def teardown_test(self): self.set_drop_reason_override(override_code=None) TelephonyBaseTest.teardown_test(self) def connect_to_wifi(self): if not ensure_wifi_connected(self.log, self.dut, self.wifi_network_ssid, self.wifi_network_pass): self.dut.log.error("Fail to connected to WiFi") return False else: self.dut.log.info("Connected to WiFi") return True def is_wfc_enabled(self): return wait_for_wfc_enabled(self.log, self.dut) def enable_volte(self): if CAPABILITY_VOLTE not in self.dut_capabilities: raise signals.TestSkip("VoLTE is not supported, abort test.") toggle_volte(self.log, self.dut, True) def enable_wfc(self): if CAPABILITY_WFC not in self.dut_capabilities: raise signals.TestSkip("WFC is not supported, abort test.") toggle_wfc(self.log, self.dut, True) def disable_volte(self): if CAPABILITY_VOLTE not in self.dut_capabilities: raise signals.TestSkip("VoLTE is not supported, abort test.") toggle_volte(self.log, self.dut, False) def disable_wfc(self): if CAPABILITY_WFC not in self.dut_capabilities: raise signals.TestSkip("WFC is not supported, abort test.") toggle_wfc(self.log, self.dut, False) def setup_wfc_non_apm(self): if CAPABILITY_WFC not in self.dut_capabilities and ( WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes): raise signals.TestSkip( "WFC in non-APM is not supported, abort test.") if not phone_setup_iwlan( self.log, self.dut, False, WFC_MODE_WIFI_PREFERRED, self.wifi_network_ssid, self.wifi_network_pass): self.dut.log.error("Failed to setup WFC.") raise signals.TestFailure("Failed to setup WFC in non-APM") self.dut.log.info("Phone is in WFC enabled state.") return True def setup_wfc_apm(self): if CAPABILITY_WFC not in self.dut_capabilities: raise signals.TestSkip("WFC is not supported, abort test.") if not phone_setup_iwlan(self.log, self.dut, True, self.dut_wfc_modes[0], self.wifi_network_ssid, self.wifi_network_pass): self.dut.log.error("Failed to setup WFC.") raise signals.TestFailure("Failed to setup WFC in APM") self.dut.log.info("Phone is in WFC enabled state.") return True def setup_volte(self): if CAPABILITY_VOLTE not in self.dut_capabilities: raise signals.TestSkip("VoLTE is not supported, abort test.") if not phone_setup_volte(self.log, self.dut): self.dut.log.error("Phone failed to enable VoLTE.") raise signals.TestFailure("Failed to enable VoLTE") self.dut.log.info("Phone VOLTE is enabled successfully.") return True def setup_csfb(self): if not phone_setup_csfb(self.log, self.dut): self.dut.log.error("Phone failed to setup CSFB.") raise signals.TestFailure("Failed to setup CSFB") self.dut.log.info("Phone CSFB is enabled successfully.") return True def setup_3g(self): if not phone_setup_voice_3g(self.log, self.dut): self.dut.log.error("Phone failed to setup 3G.") raise signals.TestFailure("Faile to setup 3G") self.dut.log.info("Phone RAT 3G is enabled successfully.") return True def setup_2g(self): if self.dut_operator not in ("tmo", "uk_ee"): raise signals.TestSkip("2G is not supported, abort test.") if not phone_setup_voice_2g(self.log, self.dut): self.dut.log.error("Phone failed to setup 2G.") raise signals.TestFailure("Failed to setup 2G") self.dut.log.info("RAT 2G is enabled successfully.") return True def setup_vt(self): if CAPABILITY_VT not in self.dut_capabilities or ( CAPABILITY_VT not in self.reference_capabilities): raise signals.TestSkip("VT is not supported, abort test.") for ad in (self.dut, self.ad_reference): if not phone_setup_video(self.log, ad): ad.log.error("Failed to setup VT.") return False return True def set_drop_reason_override(self, override_code=None): if not override_code: if self.dut.adb.shell("getprop vendor.radio.call_end_reason"): self.dut.adb.shell("setprop vendor.radio.call_end_reason ''") else: if self.dut.adb.shell("getprop vendor.radio.call_end_reason" ) != str(override_code): cmd = "setprop vendor.radio.call_end_reason %s" \ % override_code self.dut.log.info("====== %s ======", cmd) self.dut.adb.shell(cmd) def modem_crash(self): # Modem SSR self.user_params["check_crash"] = False self.dut.log.info("Triggering ModemSSR") try: self.dut.droid.logI("======== Trigger modem crash ========") except Exception: pass if (not self.dut.is_apk_installed("com.google.mdstest") ) or self.dut.adb.getprop("ro.build.version.release")[0] in ( "8", "O", "7", "N") or self.dut.model in ("angler", "bullhead", "sailfish", "marlin"): trigger_modem_crash(self.dut) else: trigger_modem_crash_by_modem(self.dut) 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 toggle_apm(self): toggle_airplane_mode(self.log, self.dut, new_state=None) def toggle_wifi(self): wifi_toggle_state(self.log, self.dut, None) def drop_reason_override(self): hangup_call(self.log, self.ad_reference) def clearn_up_bugreport_database(self): self.dut.adb.shell( "rm /data/data/com.google.android.connectivitymonitor/" "shared_prefs/ConnectivityMonitor_BugReport.xml") def clearn_up_troubleshooter_database(self): self.dut.adb.shell( "rm /data/data/com.google.android.connectivitymonitor/" "shared_prefs/ConnectivityMonitor_TroubleshooterResult.xml") def parsing_bugreport_database(self): output = self.dut.adb.shell( "cat /data/data/com.google.android.connectivitymonitor/" "shared_prefs/ConnectivityMonitor_BugReport.xml") bugreport_database = re.findall(r">Call Drop:\s+(.*)<", output) self.dut.log.info("bugreport_database = %s", bugreport_database) return bugreport_database def parsing_troubleshooter_database(self): output = self.dut.adb.shell( "cat /data/data/com.google.android.connectivitymonitor/" "shared_prefs/ConnectivityMonitor_TroubleshooterResult.xml") results = re.findall(r"name=\"(\S+)\">(\S+)<", output) troubleshooter_database = {} for result in results: if "count" in result[0] or "num_calls" in result[0]: troubleshooter_database[result[0]] = int(result[1]) else: troubleshooter_database[result[0]] = result[1] self.dut.log.info("TroubleshooterResult=%s", sorted(troubleshooter_database.items())) return troubleshooter_database def parsing_call_summary(self): call_summary = self.dut.adb.shell( "dumpsys activity service com.google.android.connectivitymonitor/" ".ConnectivityMonitorService") self.dut.log.info(call_summary) call_summary_info = {} results = re.findall( r"(\S+): (\d+) out of (\d+) calls dropped, percentage=(\S+)", call_summary) for result in results: call_summary_info[result[0]] = int(result[2]) call_summary_info["%s_dropped" % result[0]] = int(result[1]) if result[3] == "NaN": call_summary_info["%s_dropped_percentage" % result[0]] = 0 else: call_summary_info["%s_dropped_percentage" % result[0]] = float( result[3]) results = re.findall(r"(\S+): predominant failure reason=(.+)", call_summary) for result in results: call_summary_info["%s_failure_reason" % result[0]] = result[1] self.dut.log.info("call summary dumpsys = %s", sorted(call_summary_info.items())) return call_summary_info def parsing_call_statistics(self): call_statistics_info = {} call_statistics = self.dut.adb.shell( "content query --uri content://com.google.android." "connectivitymonitor.troubleshooterprovider/call_statistics") self.dut.log.info("troubleshooterprovider call_statistics:\n%s", call_statistics) results = re.findall(r"KEY=(\S+), VALUE=(\S+)", call_statistics) for result in results: if ("count" in result[0] or "num_calls" in result[0]): if result[1] == "NULL": call_statistics_info[result[0]] = 0 else: call_statistics_info[result[0]] = int(result[1]) else: call_statistics_info[result[0]] = result[1] self.dut.log.info("troubleshooterprovider call_statistics: %s", sorted(call_statistics_info.items())) return call_statistics_info def parsing_diagnostics(self): diagnostics_info = {} diagnostics = self.dut.adb.shell( "content query --uri content://com.google.android." "connectivitymonitor.troubleshooterprovider/diagnostics") self.dut.log.info("troubleshooterprovider diagnostics:\n%s", diagnostics) results = re.findall(r"KEY=(\S+), VALUE=(\S+)", diagnostics) for result in results: diagnostics_info[result[0]] = result[1] self.dut.log.info("troubleshooterprovider diagnostics: %s", sorted(diagnostics_info.items())) return diagnostics_info 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 call_drop_test(self, setup=None, handover=None, count=CONSECUTIVE_CALL_FAILS, triggers=[], expected_drop_reason=None, expected_trouble=None, expected_action=None): if not triggers: if self.dut.model in ("marlin", "sailfish", "walleye", "taimen"): triggers = ["modem_crash"] expected_drop_reason = "Error Unspecified" else: triggers = ["drop_reason_override"] if "drop_reason_override" in triggers: self.set_drop_reason_override( override_code=self.call_drop_override_code) expected_drop_reason = CALL_DROP_CODE_MAPPING[int( self.call_drop_override_code)] for iter in range(count): self.dut.log.info("===== %s_iter_%s =====", self.test_name, iter + 1) if iter < count - 1: action = None trouble = None else: action = expected_action trouble = expected_trouble if not self.call_setup_and_connectivity_monitor_checking( setup=setup, handover=handover, triggers=triggers, expected_drop_reason=expected_drop_reason, expected_trouble=trouble, expected_action=action): return False return True def call_drop_triggered_suggestion_test(self, setup=None, handover=None, triggers=[], expected_drop_reason=None, expected_trouble=None, expected_action=None): call_summary = self.parsing_call_summary() diagnostics = self.parsing_diagnostics() diagnosis = diagnostics.get("diagnosis") actions = diagnostics.get("actions") self.dut.log.info("Expected trouble = %s, action = %s", expected_trouble, expected_action) if expected_trouble and diagnosis == expected_trouble and not handover: self.dut.log.info("Diagnosis is the expected %s", trouble) if expected_action and expected_action != actions: self.dut.log.error("Action is %s, expecting %s", actions, expected_action) result = False if setup in ("wfc_apm", "wfc_non_apm"): desc = "VOWIFI" elif setup == "volte": desc = "VOLTE" elif setup in ("csfb", "3g", "2g"): desc = "CS" drops = call_summary.get("%s_dropped" % desc, 0) drop_percentage = call_summary.get("%s_dropped_percentage" % desc, 0) if drops < CONSECUTIVE_CALL_FAILS or drop_percentage < 25: self.dut.log.error( "Should NOT get %s for %s %s_dropped and %s %s_dropped_percentage", trouble, drops, desc, drop_percentage, desc) return False else: return True else: self.dut.log.info("Generate %s consecutive call drops", CONSECUTIVE_CALL_FAILS) return self.call_drop_test( setup=setup, handover=handover, count=CONSECUTIVE_CALL_FAILS, triggers=triggers, expected_drop_reason=expected_drop_reason, expected_trouble=expected_trouble, expected_action=expected_action) def healthy_call_test(self, setup=None, handover=None, count=1, triggers=[], expected_trouble=None, expected_action=None): if self.dut.model not in ("marlin", "sailfish", "walleye", "taimen"): self.set_drop_reason_override(override_code=25) result = True for iter in range(count): if not self.call_setup_and_connectivity_monitor_checking( setup=setup, handover=handover, triggers=triggers, expected_trouble=expected_trouble, expected_action=expected_action): return False return True def forced_call_drop_test(self, setup=None, handover=None, triggers=None, expected_drop_reason=None): expected_trouble = None expected_action = None technology = handover or setup if setup: setup_func = getattr(self, "setup_%s" % setup) if not setup_func(): return False if technology == "volte": expected_trouble = TROUBLES[6], expected_action = ACTIONS[6] elif technology == "csfb": if CAPABILITY_VOLTE in self.dut_capabilities: expected_action = ACTIONS[5] else: expected_action = ACTIONS[7] expected_trouble = TROUBLES[7] elif technology == "3g": if CAPABILITY_VOLTE in self.dut_capabilities: expected_action = ACTIONS[5] else: expected_action = ACTIONS[7] expected_trouble = TROUBLES[7] elif technology == "2g": if CAPABILITY_VOLTE in self.dut_capabilities: expected_action = ACTIONS[5] else: expected_action = ACTIONS[7] expected_trouble = TROUBLES[7] elif technology == "wfc_apm": expected_trouble = TROUBLES[3] expected_action = ACTIONS[11] elif technology == "wfc_non_apm": expected_trouble = TROUBLES[3] expected_action = ACTIONS[3] return self.call_drop_triggered_suggestion_test( setup=setup, handover=handover, triggers=triggers, expected_drop_reason=expected_drop_reason, expected_trouble=expected_trouble, expected_action=expected_action) def call_drop_test_after_wipe(self, setup=None): if setup: setup_func = getattr(self, "setup_%s" % setup) if not setup_func(): return False fastboot_wipe(self.dut) bring_up_connectivity_monitor(self.dut) return self.forced_call_drop_test(setup=setup) def call_drop_test_after_reboot(self, setup=None): self.forced_call_drop_test(setup=setup) self.healthy_call_test(setup=setup, count=1) reboot_device(self.dut) return self.forced_call_drop_test(setup=setup)