#!/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 Stress Call Test """ import collections import time from acts.test_decorators import test_tracker_info from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest from acts.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED from acts.test_utils.tel.tel_defines import VT_STATE_BIDIRECTIONAL from acts.test_utils.tel.tel_test_utils import call_setup_teardown from acts.test_utils.tel.tel_test_utils import ensure_phone_subscription from acts.test_utils.tel.tel_test_utils import ensure_phones_idle from acts.test_utils.tel.tel_test_utils import ensure_wifi_connected from acts.test_utils.tel.tel_test_utils import hangup_call from acts.test_utils.tel.tel_test_utils import set_wfc_mode from acts.test_utils.tel.tel_test_utils import sms_send_receive_verify from acts.test_utils.tel.tel_test_utils import start_qxdm_loggers from acts.test_utils.tel.tel_test_utils import verify_incall_state from acts.test_utils.tel.tel_test_utils import multithread_func from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_3g from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_2g from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_csfb from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_volte from acts.test_utils.tel.tel_voice_utils import phone_setup_csfb from acts.test_utils.tel.tel_voice_utils import phone_setup_iwlan from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_3g from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_2g from acts.test_utils.tel.tel_voice_utils import phone_setup_volte from acts.test_utils.tel.tel_voice_utils import phone_idle_iwlan from acts.test_utils.tel.tel_video_utils import phone_setup_video from acts.test_utils.tel.tel_video_utils import video_call_setup from acts.test_utils.tel.tel_video_utils import \ is_phone_in_call_video_bidirectional from acts.logger import epoch_to_log_line_timestamp from acts.utils import get_current_epoch_time from acts.utils import rand_ascii_str class TelLiveStressCallTest(TelephonyBaseTest): def setup_class(self): super(TelLiveStressCallTest, self).setup_class() self.caller = self.android_devices[0] self.callee = self.android_devices[1] self.number_of_devices = 2 self.user_params["telephony_auto_rerun"] = False self.wifi_network_ssid = self.user_params.get( "wifi_network_ssid") or self.user_params.get("wifi_network_ssid_2g") self.wifi_network_pass = self.user_params.get( "wifi_network_pass") or self.user_params.get("wifi_network_pass_2g") self.phone_call_iteration = int( self.user_params.get("phone_call_iteration", 500)) self.phone_call_duration = int( self.user_params.get("phone_call_duration", 60)) self.sleep_time_between_test_iterations = int( self.user_params.get("sleep_time_between_test_iterations", 0)) return True def on_fail(self, test_name, begin_time): pass def _setup_wfc(self): for ad in self.android_devices: if not ensure_wifi_connected( ad.log, ad, self.wifi_network_ssid, self.wifi_network_pass, retries=3): ad.log.error("Phone Wifi connection fails.") return False ad.log.info("Phone WIFI is connected successfully.") if not set_wfc_mode(self.log, ad, WFC_MODE_WIFI_PREFERRED): ad.log.error("Phone failed to enable Wifi-Calling.") return False ad.log.info("Phone is set in Wifi-Calling successfully.") if not phone_idle_iwlan(self.log, ad): ad.log.error("Phone is not in WFC enabled state.") return False ad.log.info("Phone is in WFC enabled state.") return True def _setup_wfc_apm(self): for ad in self.android_devices: toggle_airplane_mode(ad.log, ad, True) if not ensure_wifi_connected( ad.log, ad, self.wifi_network_ssid, self.wifi_network_pass, retries=3): ad.log.error("Phone Wifi connection fails.") return False ad.log.info("Phone WIFI is connected successfully.") if not set_wfc_mode(self.log, ad, WFC_MODE_WIFI_PREFERRED): ad.log.error("Phone failed to enable Wifi-Calling.") return False ad.log.info("Phone is set in Wifi-Calling successfully.") if not phone_idle_iwlan(self.log, ad): ad.log.error("Phone is not in WFC enabled state.") return False ad.log.info("Phone is in WFC enabled state.") return True def _setup_vt(self): 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 return True def _setup_lte_volte_enabled(self): for ad in self.android_devices: if not phone_setup_volte(self.log, ad): ad.log.error("Phone failed to enable VoLTE.") return False ad.log.info("Phone VOLTE is enabled successfully.") return True def _setup_lte_volte_disabled(self): for ad in self.android_devices: if not phone_setup_csfb(self.log, ad): ad.log.error("Phone failed to setup CSFB.") return False ad.log.info("Phone VOLTE is disabled successfully.") return True def _setup_3g(self): for ad in self.android_devices: if not phone_setup_voice_3g(self.log, ad): ad.log.error("Phone failed to setup 3g.") return False ad.log.info("Phone RAT 3G is enabled successfully.") return True def _setup_2g(self): for ad in self.android_devices: if not phone_setup_voice_2g(self.log, ad): ad.log.error("Phone failed to setup 2g.") return False ad.log.info("RAT 2G is enabled successfully.") return True def _setup_phone_call(self, test_video): if test_video: if not video_call_setup( self.log, self.android_devices[0], self.android_devices[1], ): self.log.error("Failed to setup Video call") return False else: if not call_setup_teardown( self.log, self.caller, self.callee, ad_hangup=None): self.log.error("Setup Call failed.") return False self.log.info("Setup call successfully.") return True def _hangup_call(self): for ad in self.android_devices: hangup_call(self.log, ad) def stress_test(self, setup_func=None, network_check_func=None, test_sms=False, test_video=False): for ad in self.android_devices: #check for sim and service ensure_phone_subscription(self.log, ad) if setup_func and not setup_func(): self.log.error("Test setup %s failed", setup_func.__name__) return False fail_count = collections.defaultdict(int) for i in range(1, self.phone_call_iteration + 1): msg = "Stress Call Test %s Iteration: <%s> / <%s>" % ( self.test_name, i, self.phone_call_iteration) begin_time = get_current_epoch_time() self.log.info(msg) iteration_result = True ensure_phones_idle(self.log, self.android_devices) if not self._setup_phone_call(test_video): fail_count["dialing"] += 1 iteration_result = False self.log.error("%s call dialing failure.", msg) else: if network_check_func and not network_check_func( self.log, self.caller): fail_count["caller_network_check"] += 1 reasons = self.caller.search_logcat( "qcril_qmi_voice_map_qmi_to_ril_last_call_failure_cause", begin_time) if reasons: self.caller.log.info(reasons[-1]["log_message"]) iteration_result = False self.log.error("%s network check %s failure.", msg, network_check_func.__name__) if network_check_func and not network_check_func( self.log, self.callee): fail_count["callee_network_check"] += 1 reasons = self.callee.search_logcat( "qcril_qmi_voice_map_qmi_to_ril_last_call_failure_cause", begin_time) if reasons: self.callee.log.info(reasons[-1]["log_message"]) iteration_result = False self.log.error("%s network check failure.", msg) time.sleep(self.phone_call_duration) if not verify_incall_state(self.log, [self.caller, self.callee], True): self.log.error("%s call dropped.", msg) iteration_result = False fail_count["drop"] += 1 self._hangup_call() if test_sms and not sms_send_receive_verify( self.log, self.caller, self.callee, [rand_ascii_str(180)]): fail_count["sms"] += 1 self.log.info("%s %s", msg, iteration_result) if not iteration_result: self._take_bug_report("%s_CallNo_%s" % (self.test_name, i), begin_time) start_qxdm_loggers(self.log, self.android_devices) if self.sleep_time_between_test_iterations: self.caller.droid.goToSleepNow() self.callee.droid.goToSleepNow() time.sleep(self.sleep_time_between_test_iterations) test_result = True for failure, count in fail_count.items(): if count: self.log.error("%s: %s %s failures in %s iterations", self.test_name, count, failure, self.phone_call_iteration) test_result = False return test_result """ Tests Begin """ @test_tracker_info(uuid="3c3daa08-e66a-451a-a772-634ec522c965") @TelephonyBaseTest.tel_test_wrap def test_call_default_stress(self): """ Default state call stress test Steps: 1. Make Sure PhoneA and PhoneB in default mode. 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test() @test_tracker_info(uuid="b7fd730a-d4c7-444c-9e36-12389679b430") @TelephonyBaseTest.tel_test_wrap def test_call_and_sms_longevity(self): """ Default state call stress test Steps: 1. Make Sure PhoneA and PhoneB in default mode. 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3. Send a text message from PhoneA to PhoneB. 4. Bring phone to sleep for x seconds based on the config setup. 5, Repeat 2 around N times based on the config setup Expected Results: 1. Phone calls and text messages are successfully made Returns: True if pass; False if fail. """ return self.stress_test(test_sms=True) @test_tracker_info(uuid="3b711843-de27-4b0a-a163-8c439c901e24") @TelephonyBaseTest.tel_test_wrap def test_call_volte_stress(self): """ VoLTE call stress test Steps: 1. Make Sure PhoneA and PhoneB in VoLTE mode. 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_lte_volte_enabled, network_check_func=is_phone_in_call_volte) @test_tracker_info(uuid="518516ea-1c0a-494d-ad44-272f21075d39") @TelephonyBaseTest.tel_test_wrap def test_call_csfb_stress(self): """ LTE CSFB call stress test Steps: 1. Make Sure PhoneA in LTE CSFB mode. 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_lte_volte_disabled, network_check_func=is_phone_in_call_csfb) @test_tracker_info(uuid="887608cb-e5c6-4b19-b02b-3461c1e78f2d") @TelephonyBaseTest.tel_test_wrap def test_call_wifi_calling_stress(self): """ Wifi calling call stress test Steps: 1. Make Sure PhoneA and PhoneB in WFC On + Wifi Connected 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_wfc, network_check_func=is_phone_in_call_iwlan) @test_tracker_info(uuid="be45c620-b45b-4a06-8424-b17d744d0735") @TelephonyBaseTest.tel_test_wrap def test_call_wifi_calling_stress_apm(self): """ Wifi calling in AirPlaneMode call stress test Steps: 1. Make Sure PhoneA and PhoneB in WFC On + APM ON + Wifi Connected 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_wfc_apm, network_check_func=is_phone_in_call_iwlan) @test_tracker_info(uuid="8af0454b-b4db-46d8-b5cc-e13ec5bc59ab") @TelephonyBaseTest.tel_test_wrap def test_call_3g_stress(self): """ 3G call stress test Steps: 1. Make Sure PhoneA and PhoneB in 3G mode. 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_3g, network_check_func=is_phone_in_call_3g) @test_tracker_info(uuid="12380823-2e7f-4c41-95c0-5f8c483f9510") @TelephonyBaseTest.tel_test_wrap def test_call_2g_stress(self): """ 2G call stress test Steps: 1. Make Sure PhoneA and PhoneB in 3G mode. 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_2g, network_check_func=is_phone_in_call_2g) @test_tracker_info(uuid="28a88b44-f239-4b77-b01f-e9068373d749") @TelephonyBaseTest.tel_test_wrap def test_call_video_stress(self): """ VT call stress test Steps: 1. Make Sure PhoneA and PhoneB in VoLTE mode (ViLTE provisioned). 2. Call from PhoneA to PhoneB, hang up on PhoneA. 3, Repeat 2 around N times based on the config setup Expected Results: 1, Verify phone is at IDLE state 2, Verify the phone is at ACTIVE, if it is in dialing, then we retry 3, Verify the phone is IDLE after hung up Returns: True if pass; False if fail. """ return self.stress_test( setup_func=self._setup_vt, network_check_func=is_phone_in_call_video_bidirectional, test_video=True) """ Tests End """