| #!/usr/bin/env python3.4 |
| # |
| # Copyright 2016 - 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. |
| """ |
| Test Script for Telephony Pre Check In Sanity |
| """ |
| |
| import collections |
| import time |
| |
| from acts import signals |
| from acts.test_decorators import test_tracker_info |
| from acts.controllers.sl4a_lib.sl4a_types import Sl4aNetworkInfo |
| from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest |
| from acts_contrib.test_utils.tel.tel_data_utils import wifi_tethering_setup_teardown |
| 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 CAPABILITY_OMADM |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_TETHERING_ENTITLEMENT_CHECK |
| from acts_contrib.test_utils.tel.tel_defines import NETWORK_SERVICE_DATA |
| from acts_contrib.test_utils.tel.tel_defines import GEN_4G |
| from acts_contrib.test_utils.tel.tel_defines import RAT_FAMILY_WLAN |
| from acts_contrib.test_utils.tel.tel_defines import TETHERING_MODE_WIFI |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_AFTER_REBOOT |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_AFTER_CRASH |
| from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_CELLULAR_PREFERRED |
| 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_data_utils import wait_for_wifi_data_connection |
| from acts_contrib.test_utils.tel.tel_message_utils import sms_send_receive_verify |
| from acts_contrib.test_utils.tel.tel_message_utils import mms_send_receive_verify |
| from acts_contrib.test_utils.tel.tel_ims_utils import wait_for_wfc_enabled |
| from acts_contrib.test_utils.tel.tel_subscription_utils import get_slot_index_from_subid |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_volte |
| 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_phone_setup_utils import ensure_phone_subscription |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_network_generation |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_network_rat |
| from acts_contrib.test_utils.tel.tel_test_utils import get_model_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 is_droid_in_network_generation |
| from acts_contrib.test_utils.tel.tel_test_utils import is_sim_locked |
| from acts_contrib.test_utils.tel.tel_test_utils import power_off_sim |
| from acts_contrib.test_utils.tel.tel_test_utils import power_on_sim |
| from acts_contrib.test_utils.tel.tel_test_utils import reboot_device |
| 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_test_utils import unlock_sim |
| from acts_contrib.test_utils.tel.tel_data_utils import wait_for_cell_data_connection |
| from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection |
| from acts_contrib.test_utils.tel.tel_test_utils import wait_for_state |
| from acts_contrib.test_utils.tel.tel_voice_utils import call_setup_teardown |
| 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_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.utils import get_current_epoch_time |
| from acts.utils import rand_ascii_str |
| |
| |
| class TelLiveRebootStressTest(TelephonyBaseTest): |
| def setup_class(self): |
| TelephonyBaseTest.setup_class(self) |
| |
| self.stress_test_number = int( |
| self.user_params.get("stress_test_number", 10)) |
| self.skip_reset_between_cases = False |
| |
| self.dut = self.android_devices[0] |
| self.ad_reference = self.android_devices[1] if len( |
| self.android_devices) > 1 else None |
| self.dut_model = get_model_name(self.dut) |
| self.user_params["check_crash"] = False |
| self.skip_reset_between_cases = False |
| |
| 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.default_testing_func_names = [] |
| for method in ("_check_volte", "_check_3g"): |
| func = getattr(self, method) |
| try: |
| check_result = func() |
| except Exception as e: |
| self.dut.log.error("%s failed with %s", method, e) |
| check_result = False |
| self.dut.log.info("%s is %s before tests start", method, |
| check_result) |
| if check_result: |
| self.default_testing_func_names.append(method) |
| self.dut.log.info("To be tested: %s", self.default_testing_func_names) |
| |
| def teardown_test(self): |
| self._set_volte_provisioning() |
| |
| def feature_validator(self, *args): |
| failed_tests = [] |
| for method in ("_check_subscription", "_check_data", |
| "_check_call_setup_teardown", "_check_sms"): |
| func = getattr(self, method) |
| if not func(): |
| self.log.error("%s failed", method) |
| failed_tests.append(method) |
| self.log.info("Wait 5s before each function check.") |
| time.sleep(5) |
| self.log.info("Wait 30s before NW mode switch.") |
| time.sleep(30) |
| for method in args: |
| func = getattr(self, method) |
| try: |
| func_result = func() |
| except Exception as e: |
| self.log.error("%s check failed with %s", method, e) |
| func_result = False |
| if not func_result: |
| self.log.error("%s failed", method) |
| failed_tests.append(method) |
| else: |
| self.log.info("%s succeeded", method) |
| if failed_tests: |
| self.log.error("%s failed", failed_tests) |
| return failed_tests |
| |
| def _check_subscription(self): |
| if not ensure_phone_subscription(self.log, self.dut): |
| self.dut.log.error("Subscription check failed") |
| return False |
| else: |
| return True |
| |
| def _check_volte_provisioning(self): |
| if CAPABILITY_OMADM in self.dut_capabilities: |
| if not wait_for_state(self.dut.droid.imsIsVolteProvisionedOnDevice, |
| True): |
| self.dut.log.error("VoLTE provisioning is disabled.") |
| return False |
| else: |
| self.dut.log.info("VoLTE provision is enabled") |
| return True |
| return True |
| |
| def _check_volte_provisioning_disabled(self): |
| if CAPABILITY_OMADM in self.dut_capabilities: |
| if not wait_for_state(self.dut.droid.imsIsVolteProvisionedOnDevice, |
| False): |
| self.dut.log.error("VoLTE provisioning is not disabled.") |
| return False |
| else: |
| self.dut.log.info("VoLTE provision is disabled") |
| return True |
| return True |
| |
| def _set_volte_provisioning(self): |
| if CAPABILITY_OMADM in self.dut_capabilities: |
| provisioned = self.dut.droid.imsIsVolteProvisionedOnDevice() |
| if provisioned: |
| self.dut.log.info("Volte is provioned") |
| return |
| self.dut.log.info("Volte is not provisioned") |
| self.dut.log.info("Set VoLTE Provisioning bit") |
| self.dut.droid.imsSetVolteProvisioning(True) |
| |
| def _clear_volte_provisioning(self): |
| if CAPABILITY_OMADM in self.dut_capabilities: |
| self.dut.log.info("Clear VoLTE Provisioning bit") |
| self.dut.droid.imsSetVolteProvisioning(False) |
| if self.dut.droid.imsIsVolteProvisionedOnDevice(): |
| self.dut.log.error("VoLTE is still provisioned") |
| return False |
| else: |
| self.dut.log.info("VoLTE provisioning is disabled") |
| return True |
| |
| def _check_call_setup_teardown(self): |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut): |
| self.log.error("Phone call test failed.") |
| return False |
| return True |
| |
| def _check_sms(self): |
| if not sms_send_receive_verify(self.log, self.dut, self.ad_reference, |
| [rand_ascii_str(180)]): |
| self.log.error("SMS send test failed") |
| return False |
| else: |
| self.log.info("SMS send test passed") |
| return True |
| |
| def _check_mms(self): |
| message_array = [("Test Message", rand_ascii_str(180), None)] |
| if not mms_send_receive_verify(self.log, self.dut, self.ad_reference, |
| message_array): |
| self.log.error("MMS test sendfailed") |
| return False |
| else: |
| self.log.info("MMS send test passed") |
| return True |
| |
| def _check_sms_mt(self): |
| if not sms_send_receive_verify(self.log, self.ad_reference, self.dut, |
| [rand_ascii_str(180)]): |
| self.log.error("SMS receive test failed") |
| return False |
| else: |
| self.log.info("SMS receive test passed") |
| return True |
| |
| def _check_mms_mt(self): |
| message_array = [("Test Message", rand_ascii_str(180), None)] |
| if not mms_send_receive_verify(self.log, self.ad_reference, self.dut, |
| message_array): |
| self.log.error("MMS receive test failed") |
| return False |
| else: |
| self.log.info("MMS receive test passed") |
| return True |
| |
| def _check_data(self): |
| if not verify_internet_connection(self.log, self.dut): |
| self.dut.log.error("Data connection is not available.") |
| return False |
| return True |
| |
| def _get_list_average(self, input_list): |
| total_sum = float(sum(input_list)) |
| total_count = float(len(input_list)) |
| if input_list == []: |
| return False |
| return float(total_sum / total_count) |
| |
| def _check_lte_data(self): |
| if not is_droid_in_network_generation(self.log, self.dut, GEN_4G, |
| NETWORK_SERVICE_DATA): |
| self.dut.log.error("Data is not on 4G network") |
| return False |
| if not verify_internet_connection(self.log, self.dut): |
| self.log.error("Data not available on cell.") |
| return False |
| return True |
| |
| def _check_volte(self): |
| if CAPABILITY_VOLTE in self.dut_capabilities: |
| self._set_volte_provisioning() |
| if not self._check_volte_provisioning(): |
| return False |
| self.log.info("Check VoLTE") |
| if not wait_for_state(self.dut.droid.imsIsVolteProvisionedOnDevice, |
| True): |
| self.dut.log.error("VoLTE provisioning is disabled.") |
| return False |
| if not phone_setup_volte(self.log, self.dut): |
| self.log.error("Failed to setup VoLTE.") |
| return False |
| time.sleep(5) |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_volte): |
| self.log.error("VoLTE Call Failed.") |
| return False |
| if not self._check_lte_data(): |
| return False |
| else: |
| self.dut.log.info("VoLTE is not supported") |
| return False |
| return True |
| |
| def _check_csfb(self): |
| if not phone_setup_csfb(self.log, self.dut): |
| self.log.error("Failed to setup CSFB.") |
| return False |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_csfb): |
| self.dut.log.error("CSFB Call Failed.") |
| return False |
| if not wait_for_network_generation( |
| self.log, self.dut, GEN_4G, |
| voice_or_data=NETWORK_SERVICE_DATA): |
| self.dut.log.error("Data service failed to camp to 4G") |
| return False |
| if not verify_internet_connection(self.log, self.dut): |
| self.log.error("Data not available on cell.") |
| return False |
| return True |
| |
| def _check_volte_enabled(self): |
| if phone_idle_volte(self.log, self.dut): |
| self.dut.log.info("VoLTE is enabled") |
| else: |
| self.dut.log.error("VoLTE is not enabled") |
| return False |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_volte): |
| self.log.error("VoLTE Call Failed.") |
| return False |
| if not self._check_lte_data(): |
| return False |
| return True |
| |
| def _check_csfb_enabled(self): |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_csfb): |
| self.log.error("CSFB Call Failed.") |
| return False |
| if not wait_for_network_generation( |
| self.log, self.dut, GEN_4G, |
| voice_or_data=NETWORK_SERVICE_DATA): |
| self.dut.log.error("Data service failed to camp to 4G") |
| return False |
| if not verify_internet_connection(self.log, self.dut): |
| self.log.error("Data not available on cell.") |
| return False |
| return True |
| |
| def _check_vt(self): |
| if CAPABILITY_VT in self.dut_capabilities: |
| self.log.info("Check VT") |
| 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 |
| 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 |
| else: |
| return True |
| return False |
| |
| 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_wfc_apm(self): |
| if CAPABILITY_WFC in self.dut_capabilities: |
| self.log.info("Check WFC in APM") |
| if not phone_setup_iwlan( |
| self.log, self.dut, True, WFC_MODE_CELLULAR_PREFERRED, |
| self.wifi_network_ssid, self.wifi_network_pass): |
| self.log.error("Failed to setup WFC.") |
| return False |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_iwlan): |
| self.log.error("WFC Call Failed.") |
| return False |
| else: |
| return True |
| return False |
| |
| def _check_wfc_nonapm(self): |
| if CAPABILITY_WFC not in self.dut_capabilities and ( |
| WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes): |
| return False |
| self.log.info("Check WFC in NonAPM") |
| if not phone_setup_iwlan( |
| self.log, self.dut, False, WFC_MODE_WIFI_PREFERRED, |
| self.wifi_network_ssid, self.wifi_network_pass): |
| self.log.error("Failed to setup WFC.") |
| return False |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_iwlan): |
| self.log.error("WFC Call Failed.") |
| return False |
| else: |
| return True |
| |
| def _check_wfc_enabled(self): |
| if not wait_for_wifi_data_connection(self.log, self.dut, True): |
| self.dut.log.error("Failed to connect to WIFI") |
| return False |
| if not wait_for_wfc_enabled(self.log, self.dut): |
| self.dut.log.error("WFC is not enabled") |
| return False |
| if not wait_for_network_rat( |
| self.log, |
| self.dut, |
| RAT_FAMILY_WLAN, |
| voice_or_data=NETWORK_SERVICE_DATA): |
| ad.log.info("Data rat can not go to iwlan mode successfully") |
| return False |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_iwlan): |
| self.log.error("WFC Call Failed.") |
| return False |
| return True |
| |
| def _check_3g(self): |
| self.log.info("Check 3G data and CS call") |
| if not phone_setup_voice_3g(self.log, self.dut): |
| self.log.error("Failed to setup 3G") |
| return False |
| if not verify_internet_connection(self.log, self.dut): |
| self.log.error("Data not available on cell.") |
| return False |
| if not call_setup_teardown(self.log, self.dut, self.ad_reference, |
| self.dut, is_phone_in_call_3g): |
| self.log.error("WFC Call Failed.") |
| return False |
| if not sms_send_receive_verify(self.log, self.dut, self.ad_reference, |
| [rand_ascii_str(50)]): |
| self.log.error("SMS failed in 3G") |
| return False |
| return True |
| |
| def _check_tethering(self): |
| self.log.info("Check tethering") |
| for i in range(3): |
| try: |
| if not self.dut.droid.carrierConfigIsTetheringModeAllowed( |
| TETHERING_MODE_WIFI, |
| MAX_WAIT_TIME_TETHERING_ENTITLEMENT_CHECK): |
| self.log.error("Tethering Entitlement check failed.") |
| if i == 2: return False |
| time.sleep(10) |
| except Exception as e: |
| if i == 2: |
| self.dut.log.error(e) |
| return False |
| time.sleep(10) |
| if not wifi_tethering_setup_teardown( |
| self.log, |
| self.dut, [self.ad_reference], |
| check_interval=5, |
| check_iteration=1): |
| self.log.error("Tethering check failed.") |
| return False |
| return True |
| |
| def _check_data_roaming_status(self): |
| if not self.dut.droid.telephonyIsDataEnabled(): |
| self.log.info("Enabling Cellular Data") |
| telephonyToggleDataConnection(True) |
| else: |
| self.log.info("Cell Data is Enabled") |
| self.log.info("Waiting for cellular data to be connected") |
| if not wait_for_cell_data_connection(self.log, self.dut, state=True): |
| self.log.error("Failed to enable cell data") |
| return False |
| self.log.info("Cellular data connected, checking NetworkInfos") |
| roaming_state = self.dut.droid.telephonyCheckNetworkRoaming() |
| for network_info in self.dut.droid.connectivityNetworkGetAllInfo(): |
| sl4a_network_info = Sl4aNetworkInfo.from_dict(network_info) |
| if sl4a_network_info.isRoaming: |
| self.log.warning("We don't expect to be roaming") |
| if sl4a_network_info.isRoaming != roaming_state: |
| self.log.error( |
| "Mismatched Roaming Status Information Telephony: {}, NetworkInfo {}". |
| format(roaming_state, sl4a_network_info.isRoaming)) |
| self.log.error(network_info) |
| return False |
| return True |
| |
| def _reboot_stress_test(self, *args): |
| """Reboot Reliability Test |
| |
| Arguments: |
| function_name: function to be checked |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| self.number_of_devices = 2 |
| fail_count = collections.defaultdict(int) |
| test_result = True |
| |
| for i in range(1, self.stress_test_number + 1): |
| begin_time = get_current_epoch_time() |
| test_name = "%s_iteration_%s" % (self.test_name, i) |
| log_msg = "[Test Case] %s" % test_name |
| self.log.info("%s begin", log_msg) |
| self.dut.droid.logI("%s begin" % log_msg) |
| test_msg = "Reboot Stress Test %s Iteration <%s> / <%s>" % ( |
| self.test_name, i, self.stress_test_number) |
| self.log.info(test_msg) |
| reboot_device(self.dut) |
| self.log.info("{} wait {}s for radio up.".format( |
| self.dut.serial, WAIT_TIME_AFTER_REBOOT)) |
| time.sleep(WAIT_TIME_AFTER_REBOOT) |
| failed_tests = self.feature_validator(*args) |
| for test in failed_tests: |
| fail_count[test] += 1 |
| |
| crash_report = self.dut.check_crash_report( |
| "%s_%s" % (self.test_name, i), |
| begin_time, |
| log_crash_report=True) |
| if crash_report: |
| fail_count["crashes"] += 1 |
| if failed_tests or crash_report: |
| self.log.error("%s FAIL with %s and crashes %s", test_msg, |
| failed_tests, crash_report) |
| self._take_bug_report(test_name, begin_time) |
| else: |
| self.log.info("%s PASS", test_msg) |
| self.log.info("Total failure count: %s", dict(fail_count)) |
| self.log.info("%s end", log_msg) |
| self.dut.droid.logI("%s end" % log_msg) |
| |
| for failure, count in fail_count.items(): |
| if count: |
| self.log.error("%s failure count = %s in total %s iterations", |
| failure, count, self.stress_test_number) |
| test_result = False |
| return test_result |
| |
| def _crash_recovery_test(self, process, *args): |
| """Crash Recovery Test |
| |
| Arguments: |
| process: the process to be killed. For example: |
| "rild", "netmgrd", "com.android.phone", "imsqmidaemon", |
| "imsdatadaemon", "ims_rtp_daemon", |
| "com.android.ims.rcsservice", "system_server", "cnd", |
| "modem" |
| |
| Expected Results: |
| All Features should work as intended post crash recovery |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| self.number_of_devices = 2 |
| |
| try: |
| self.dut.droid.logI("======== Trigger %s crash ========" % process) |
| except: |
| pass |
| if process == "modem": |
| self.user_params["check_crash"] = False |
| self.dut.log.info("======== Crash modem from kernal ========") |
| trigger_modem_crash(self.dut) |
| elif process == "modem-crash": |
| self.user_params["check_crash"] = False |
| self.dut.log.info("======== Crash modem from modem ========") |
| trigger_modem_crash_by_modem(self.dut) |
| elif process == "sim": |
| self.dut.log.info("======== Power cycle SIM slot ========") |
| self.user_params["check_crash"] = True |
| sub_id = get_outgoing_voice_sub_id(self.dut) |
| slot_index = get_slot_index_from_subid(self.dut, sub_id) |
| if not power_off_sim(self.dut, slot_index): |
| self.dut.log.warning("Fail to power off SIM") |
| raise signals.TestSkip("Power cycle SIM not working") |
| if not power_on_sim(self.dut, slot_index): |
| self.dut.log.error("Fail to power on SIM slot") |
| setattr(self.dut, "reboot_to_recover", True) |
| return False |
| else: |
| if process == "rild": |
| if int(self.dut.adb.getprop( |
| "ro.product.first_api_level")) >= 28: |
| process = "qcrild" |
| self.dut.log.info("======== Killing process <%s> ========", |
| process) |
| process_pid = self.dut.adb.shell("pidof %s" % process) |
| self.dut.log.info("Pid of %s is %s", process, process_pid) |
| if not process_pid: |
| self.dut.log.error("Process %s not running", process) |
| return False |
| if process in ("netd", "system_server"): |
| self.dut.stop_services() |
| self.dut.adb.shell("kill -9 %s" % process_pid, ignore_status=True) |
| self.dut.log.info("Wait %s sec for process %s come up.", |
| WAIT_TIME_AFTER_CRASH, process) |
| time.sleep(WAIT_TIME_AFTER_CRASH) |
| if process in ("netd", "system_server"): |
| self.dut.ensure_screen_on() |
| try: |
| self.dut.start_services() |
| except Exception as e: |
| self.dut.log.warning(e) |
| process_pid_new = self.dut.adb.shell("pidof %s" % process) |
| if process_pid == process_pid_new: |
| self.dut.log.error( |
| "Process %s has the same pid: old:%s new:%s", process, |
| process_pid, process_pid_new) |
| try: |
| self.dut.droid.logI( |
| "======== Start testing after triggering %s crash ========" % |
| process) |
| except Exception: |
| self.dut.ensure_screen_on() |
| self.dut.start_services() |
| if is_sim_locked(self.dut): |
| unlock_sim(self.dut) |
| |
| if process == "ims_rtp_daemon": |
| if not self._check_wfc_enabled: |
| failed_tests = ["_check_wfc_enabled"] |
| else: |
| failed_tests = [] |
| else: |
| failed_tests = [] |
| |
| begin_time = get_current_epoch_time() |
| failed_tests.extend(self.feature_validator(*args)) |
| crash_report = self.dut.check_crash_report( |
| self.test_name, begin_time, log_crash_report=True) |
| if failed_tests or crash_report: |
| if failed_tests: |
| self.dut.log.error("%s failed after %s restart", failed_tests, |
| process) |
| setattr(self.dut, "reboot_to_recover", True) |
| if crash_report: |
| self.dut.log.error("Crash %s found after %s restart", |
| crash_report, process) |
| return False |
| else: |
| return True |
| |
| """ Tests Begin """ |
| |
| @test_tracker_info(uuid="4d9b425b-f804-45f4-8f47-0ba3f01a426b") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress(self): |
| """Reboot with VoLTE Test |
| |
| Steps: |
| 1. Reboot DUT. |
| 2. Wait for DUT to camp |
| 3. Verify Subscription, Call, Data, Messaging, Tethering |
| 4. Check crashes. |
| 5. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._reboot_stress_test(*self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="8b0e2c06-02bf-40fd-a374-08860e482757") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress_check_phone_call_only(self): |
| """Reboot with VoLTE Test |
| |
| Steps: |
| 1. Reboot DUT with volte enabled. |
| 2. Wait for DUT to camp on LTE, Verify Data. |
| 3. Check VoLTE is enabled by default, check IMS registration. |
| Wait for DUT report VoLTE enabled, make VoLTE call. |
| And verify VoLTE SMS. (if support VoLTE) |
| 4. Check crashes. |
| 5. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if not self._check_call_setup_teardown(): |
| self.dut.log.error("Call setup test failed before reboot test") |
| return False |
| func_names = [ |
| "_check_subscription", "_check_data", "_check_call_setup_teardown" |
| ] |
| return self._reboot_stress_test(*func_names) |
| |
| @test_tracker_info(uuid="39a822e5-0360-44ce-97c7-f75468eba8d7") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress_volte_enabled(self): |
| """Reboot with VoLTE Test |
| |
| Steps: |
| 1. Reboot DUT with volte enabled. |
| 2. Wait for DUT to camp on LTE, Verify Data. |
| 3. Check VoLTE is enabled by default, check IMS registration. |
| Wait for DUT report VoLTE enabled, make VoLTE call. |
| And verify VoLTE SMS. (if support VoLTE) |
| 4. Check crashes. |
| 5. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if CAPABILITY_VOLTE not in self.dut_capabilities: |
| raise signals.TestSkip("VOLTE is not supported") |
| if not self._check_volte(): |
| self.dut.log.error("VoLTE test failed before reboot test") |
| return False |
| func_names = ["_check_volte_enabled"] |
| if "_check_vt" in self.default_testing_func_names: |
| func_names.append("_check_vt_enabled") |
| return self._reboot_stress_test(*func_names) |
| |
| @test_tracker_info(uuid="3dace255-01a6-46ba-87e0-35396d406c95") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress_csfb(self): |
| """Reboot with VoLTE Test |
| |
| Steps: |
| 1. Reboot DUT with CSFB. |
| 2. Wait for DUT to camp on LTE, Verify Data. |
| 3. Check call in CSFB after rebooting. |
| 4. Check crashes. |
| 5. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if not self._check_csfb(): |
| self.dut.log.error("CSFB test failed before reboot test") |
| return False |
| func_names = ["_check_csfb_enabled"] |
| return self._reboot_stress_test(*func_names) |
| |
| @test_tracker_info(uuid="326f5ba4-8819-49bc-af87-6b3c07532de3") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress_volte_provisioning_disabled(self): |
| """Reboot with VoLTE Test |
| |
| Steps: |
| 1. Reboot DUT with volte provisioning disabled. |
| 2. Wait for DUT to camp on LTE, Verify Data. |
| 3. Check VoLTE is disabled after rebooting. |
| 4. Check crashes. |
| 5. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if CAPABILITY_OMADM not in self.dut_capabilities: |
| raise signals.TestSkip("OMADM is not supported") |
| self._clear_volte_provisioning() |
| if not self._check_csfb(): |
| self.dut.log.error("CSFB test failed before reboot test") |
| return False |
| func_names = [ |
| "_check_volte_provisioning_disabled", "_check_csfb_enabled" |
| ] |
| return self._reboot_stress_test(*func_names) |
| |
| @test_tracker_info(uuid="6c243b53-379a-4cda-9848-84fcec4019bd") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress_wfc_apm(self): |
| """Reboot with WFC in APM Test |
| |
| Steps: |
| 1. Reboot DUT with wfc in apm mode. |
| 2. Check phone call. |
| 3. Check crashes. |
| 4. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if CAPABILITY_WFC not in self.dut_capabilities: |
| raise signals.TestSkip("WFC is not supported") |
| if "_check_wfc_apm" not in self.default_testing_func_names: |
| raise signals.TestSkip("WFC in airplane mode is not supported") |
| func_names = ["_check_data", "_check_wfc_enabled"] |
| if "_check_vt" in self.default_testing_func_names: |
| func_names.append("_check_vt_enabled") |
| if not self._check_wfc_apm(): |
| self.dut.log.error("WFC in APM test failed before reboot test") |
| return False |
| return self._reboot_stress_test(*func_names) |
| |
| @test_tracker_info(uuid="d0439c53-98fa-4303-b097-12ba2462295d") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_reboot_stress_wfc_nonapm(self): |
| """Reboot with WFC in APM Test |
| |
| Steps: |
| 1. Reboot DUT with wfc in apm mode. |
| 2. Check phone call . |
| 3. Check crashes. |
| 4. Repeat Step 1~4 for N times. (before reboot, clear Provisioning |
| bit if provisioning is supported) |
| |
| Expected Results: |
| No crash happens in stress test. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if CAPABILITY_WFC not in self.dut_capabilities and ( |
| WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes): |
| raise signals.TestSkip("WFC_NONAPM is not supported") |
| if "_check_wfc_nonapm" not in self.default_testing_func_names: |
| raise signals.TestSkip("WFC in non-airplane mode is not working") |
| func_names = ["_check_wfc_enabled"] |
| if "_check_vt" in self.default_testing_func_names: |
| func_names.append("_check_vt_enabled") |
| if not self._check_wfc_nonapm(): |
| self.dut.log.error("WFC test failed before reboot test") |
| return False |
| return self._reboot_stress_test(*func_names) |
| |
| @test_tracker_info(uuid="08752fac-dbdb-4d5b-91f6-4ffc3a3ac6d6") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_modem(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash modem |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("modem", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="ce5f4d63-7f3d-48b7-831d-2c1d5db60733") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_crash_modem_from_modem(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash modem |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| 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"): |
| raise signals.TestSkip( |
| "com.google.mdstest not installed or supported") |
| return self._crash_recovery_test("modem-crash", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="489284e8-77c9-4961-97c8-b6f1a833ff90") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_rild(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash rild |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("rild", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="e1b34b2c-99e6-4966-a11c-88cedc953b47") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_netmgrd(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash netmgrd |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("netmgrd", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="6d6908b7-7eca-42e3-b165-2621714f1822") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_qtidataservice(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash qtidataservice |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if int(self.dut.adb.getprop( |
| "ro.product.first_api_level")) > 28: |
| return self._crash_recovery_test(".qtidataservices", |
| *self.default_testing_func_names) |
| |
| return self._crash_recovery_test(".dataservices", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="fa34f994-bc49-4444-9187-87691c94b4f4") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_phone(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash com.android.phone |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("com.android.phone", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="6f5a24bb-3cf3-4362-9675-36a6be90282f") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_imsqmidaemon(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash imsqmidaemon |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("imsqmidaemon", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="7a8dc971-054b-47e7-9e57-3bb7b39937d3") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_imsdatadaemon(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash imsdatadaemon |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("imsdatadaemon", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="350ca58c-01f2-4a61-baff-530b8b24f1f6") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_ims_rtp_daemon(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash imsdatadaemon |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if CAPABILITY_WFC not in self.dut_capabilities: |
| raise signals.TestSkip("WFC is not supported") |
| if WFC_MODE_WIFI_PREFERRED in self.dut_wfc_modes: |
| self._check_wfc_nonapm() |
| else: |
| self._check_wfc_apm() |
| return self._crash_recovery_test("ims_rtp_daemon", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="af78f33a-2b50-4c55-a302-3701b655c557") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_ims_rcsservice(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash imsdatadaemon |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("com.android.ims.rcsservice", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="8119aeef-84ba-415c-88ea-6eba35bd91fd") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_system_server(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash system_server |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("system_server", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="c3891aca-9e1a-4e37-9f2f-23f12ef0a86f") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_crash_recovery_cnd(self): |
| """Crash Recovery Test |
| |
| Steps: |
| 1. Crash cnd |
| 2. Post crash recovery, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| return self._crash_recovery_test("cnd", |
| *self.default_testing_func_names) |
| |
| @test_tracker_info(uuid="c1b661b9-d5cf-4a22-90a9-3fd55ddc2f3f") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_sim_slot_power_cycle(self): |
| """SIM slot power cycle Test |
| |
| Steps: |
| 1. Power cycle SIM slot to simulate SIM resit |
| 2. Post power cycle SIM, verify Voice, Data, SMS, VoLTE, VT |
| |
| Expected Results: |
| No crash happens in functional test, features work fine. |
| |
| Returns: |
| True is pass, False if fail. |
| """ |
| if self.dut.adb.getprop("ro.build.version.release")[0] in ( |
| "8", "O", "7", "N") or self.dut.model in ("angler", "bullhead", |
| "marlin", |
| "sailfish"): |
| raise signals.TestSkip("Power off SIM is not supported") |
| return self._crash_recovery_test("sim", |
| *self.default_testing_func_names) |
| |
| |
| """ Tests End """ |
