1#!/usr/bin/env python3.4 2# 3# Copyright 2017 - Google 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16""" 17 Test Script for Telephony Stress Call Test 18""" 19 20import collections 21import json 22import os 23import random 24import time 25 26from acts import context 27from acts import signals 28from acts.libs.proc import job 29from acts.test_decorators import test_tracker_info 30from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest 31from acts.test_utils.tel.tel_defines import CAPABILITY_VOLTE 32from acts.test_utils.tel.tel_defines import CAPABILITY_WFC 33from acts.test_utils.tel.tel_defines import GEN_3G 34from acts.test_utils.tel.tel_defines import GEN_4G 35from acts.test_utils.tel.tel_defines import INCALL_UI_DISPLAY_BACKGROUND 36from acts.test_utils.tel.tel_defines import MAX_WAIT_TIME_SMS_RECEIVE 37from acts.test_utils.tel.tel_defines import NETWORK_MODE_WCDMA_ONLY 38from acts.test_utils.tel.tel_defines import NETWORK_MODE_GLOBAL 39from acts.test_utils.tel.tel_defines import NETWORK_MODE_CDMA 40from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_ONLY 41from acts.test_utils.tel.tel_defines import NETWORK_MODE_TDSCDMA_GSM_WCDMA 42from acts.test_utils.tel.tel_defines import WAIT_TIME_AFTER_MODE_CHANGE 43from acts.test_utils.tel.tel_defines import WFC_MODE_CELLULAR_PREFERRED 44from acts.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED 45from acts.test_utils.tel.tel_defines import WAIT_TIME_CHANGE_MESSAGE_SUB_ID 46from acts.test_utils.tel.tel_defines import WAIT_TIME_CHANGE_VOICE_SUB_ID 47from acts.test_utils.tel.tel_defines import WAIT_TIME_FOR_CBRS_DATA_SWITCH 48from acts.test_utils.tel.tel_lookup_tables import is_rat_svd_capable 49from acts.test_utils.tel.tel_test_utils import STORY_LINE 50from acts.test_utils.tel.tel_test_utils import active_file_download_test 51from acts.test_utils.tel.tel_test_utils import is_phone_in_call 52from acts.test_utils.tel.tel_test_utils import call_setup_teardown 53from acts.test_utils.tel.tel_test_utils import ensure_network_generation_for_subscription 54from acts.test_utils.tel.tel_test_utils import ensure_wifi_connected 55from acts.test_utils.tel.tel_test_utils import extract_test_log 56from acts.test_utils.tel.tel_test_utils import force_connectivity_metrics_upload 57from acts.test_utils.tel.tel_test_utils import get_device_epoch_time 58from acts.test_utils.tel.tel_test_utils import get_telephony_signal_strength 59from acts.test_utils.tel.tel_test_utils import hangup_call 60from acts.test_utils.tel.tel_test_utils import hangup_call_by_adb 61from acts.test_utils.tel.tel_test_utils import initiate_call 62from acts.test_utils.tel.tel_test_utils import last_call_drop_reason 63from acts.test_utils.tel.tel_test_utils import run_multithread_func 64from acts.test_utils.tel.tel_test_utils import set_wfc_mode 65from acts.test_utils.tel.tel_test_utils import sms_send_receive_verify 66from acts.test_utils.tel.tel_test_utils import start_qxdm_loggers 67from acts.test_utils.tel.tel_test_utils import start_sdm_loggers 68from acts.test_utils.tel.tel_test_utils import start_adb_tcpdump 69from acts.test_utils.tel.tel_test_utils import synchronize_device_time 70from acts.test_utils.tel.tel_test_utils import mms_send_receive_verify 71from acts.test_utils.tel.tel_test_utils import set_preferred_network_mode_pref 72from acts.test_utils.tel.tel_test_utils import verify_internet_connection 73from acts.test_utils.tel.tel_test_utils import verify_internet_connection_by_ping 74from acts.test_utils.tel.tel_test_utils import verify_http_connection 75from acts.test_utils.tel.tel_test_utils import wait_for_call_id_clearing 76from acts.test_utils.tel.tel_test_utils import wait_for_data_connection 77from acts.test_utils.tel.tel_test_utils import wait_for_in_call_active 78from acts.test_utils.tel.tel_test_utils import is_current_data_on_cbrs 79from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_3g 80from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_2g 81from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_csfb 82from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan 83from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_volte 84from acts.test_utils.tel.tel_voice_utils import phone_setup_csfb 85from acts.test_utils.tel.tel_voice_utils import phone_setup_iwlan 86from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_3g 87from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_2g 88from acts.test_utils.tel.tel_voice_utils import phone_setup_volte 89from acts.test_utils.tel.tel_voice_utils import phone_idle_iwlan 90from acts.test_utils.tel.tel_voice_utils import phone_idle_volte 91from acts.test_utils.tel.tel_voice_utils import get_current_voice_rat 92from acts.test_utils.tel.tel_subscription_utils import get_subid_from_slot_index 93from acts.test_utils.tel.tel_subscription_utils import get_operatorname_from_slot_index 94from acts.test_utils.tel.tel_subscription_utils import get_carrierid_from_slot_index 95from acts.test_utils.tel.tel_subscription_utils import set_subid_for_data 96from acts.test_utils.tel.tel_subscription_utils import set_subid_for_message 97from acts.test_utils.tel.tel_subscription_utils import set_subid_for_outgoing_call 98from acts.test_utils.tel.tel_subscription_utils import set_slways_allow_mms_data 99from acts.utils import get_current_epoch_time 100from acts.utils import rand_ascii_str 101 102EXCEPTION_TOLERANCE = 5 103BINDER_LOGS = ["/sys/kernel/debug/binder"] 104 105 106class TelLiveStressTest(TelephonyBaseTest): 107 def setup_class(self): 108 super(TelLiveStressTest, self).setup_class() 109 self.dut = self.android_devices[0] 110 self.single_phone_test = self.user_params.get("single_phone_test", 111 False) 112 # supported file download methods: chrome, sl4a, curl 113 self.file_download_method = self.user_params.get( 114 "file_download_method", "curl") 115 self.get_binder_logs = self.user_params.get("get_binder_logs", False) 116 if len(self.android_devices) == 1: 117 self.single_phone_test = True 118 if self.single_phone_test: 119 self.android_devices = self.android_devices[:1] 120 self.call_server_number = self.user_params.get( 121 "call_server_number", STORY_LINE) 122 if self.file_download_method == "sl4a": 123 # with single device, do not use sl4a file download 124 # due to stability issue 125 self.file_download_method = "curl" 126 else: 127 self.android_devices = self.android_devices[:2] 128 self.sdm_log = self.user_params.get("sdm_log", False) 129 for ad in self.android_devices: 130 setattr(ad, "sdm_log", self.sdm_log) 131 ad.adb.shell("setprop nfc.debug_enable 1") 132 if self.user_params.get("turn_on_tcpdump", False): 133 start_adb_tcpdump(ad, interface="any", mask="all") 134 self.user_params["telephony_auto_rerun"] = 0 135 self.phone_call_iteration = int( 136 self.user_params.get("phone_call_iteration", 500)) 137 self.max_phone_call_duration = int( 138 self.user_params.get("max_phone_call_duration", 600)) 139 self.min_sleep_time = int(self.user_params.get("min_sleep_time", 30)) 140 self.max_sleep_time = int(self.user_params.get("max_sleep_time", 60)) 141 self.max_run_time = int(self.user_params.get("max_run_time", 14400)) 142 self.max_sms_length = int(self.user_params.get("max_sms_length", 1000)) 143 self.max_mms_length = int(self.user_params.get("max_mms_length", 160)) 144 self.min_sms_length = int(self.user_params.get("min_sms_length", 1)) 145 self.min_mms_length = int(self.user_params.get("min_mms_length", 1)) 146 self.min_phone_call_duration = int( 147 self.user_params.get("min_phone_call_duration", 10)) 148 self.crash_check_interval = int( 149 self.user_params.get("crash_check_interval", 300)) 150 self.cbrs_check_interval = int( 151 self.user_params.get("cbrs_check_interval", 100)) 152 self.dut_incall = False 153 self.dsds_esim = self.user_params.get("dsds_esim", False) 154 self.cbrs_esim = self.user_params.get("cbrs_esim", False) 155 telephony_info = getattr(self.dut, "telephony", {}) 156 self.dut_capabilities = telephony_info.get("capabilities", []) 157 self.dut_wfc_modes = telephony_info.get("wfc_modes", []) 158 self.gps_log_file = self.user_params.get("gps_log_file", None) 159 return True 160 161 def setup_test(self): 162 super(TelLiveStressTest, self).setup_test() 163 self.result_info = collections.defaultdict(int) 164 self._init_perf_json() 165 self.internet_connection_check_method = verify_internet_connection 166 167 def on_fail(self, test_name, begin_time): 168 pass 169 170 def _take_bug_report(self, test_name, begin_time): 171 if self._skip_bug_report(test_name): 172 return 173 src_dir = context.get_current_context().get_full_output_path() 174 dst_dir = os.path.join(self.log_path, test_name) 175 176 # Extract test_run_info.txt, test_run_debug.txt 177 for file_name in ("test_run_info.txt", "test_run_debug.txt"): 178 extract_test_log(self.log, os.path.join(src_dir, file_name), 179 os.path.join(dst_dir, 180 "%s_%s" % (test_name, file_name)), 181 "\[Test Case\] %s " % test_name) 182 super()._take_bug_report(test_name, begin_time) 183 184 def _ad_take_extra_logs(self, ad, test_name, begin_time): 185 src_file = os.path.join(ad.device_log_path, 186 'adblog_%s_debug.txt' % ad.serial) 187 dst_file = os.path.join(ad.device_log_path, test_name, 188 "%s_%s.logcat" % (ad.serial, test_name)) 189 extract_test_log(self.log, src_file, dst_file, test_name) 190 return super()._ad_take_extra_logs(ad, test_name, begin_time) 191 192 def _setup_wfc(self): 193 for ad in self.android_devices: 194 if not ensure_wifi_connected( 195 self.log, 196 ad, 197 self.wifi_network_ssid, 198 self.wifi_network_pass, 199 retries=3): 200 ad.log.error("Bringing up Wifi connection fails.") 201 return False 202 ad.log.info("Phone WIFI is connected successfully.") 203 if not set_wfc_mode(self.log, ad, WFC_MODE_WIFI_PREFERRED): 204 ad.log.error("Phone failed to enable Wifi-Calling.") 205 return False 206 ad.log.info("Phone is set in Wifi-Calling successfully.") 207 if not phone_idle_iwlan(self.log, ad): 208 ad.log.error("Phone is not in WFC enabled state.") 209 return False 210 ad.log.info("Phone is in WFC enabled state.") 211 return True 212 213 def _setup_wfc_apm(self): 214 for ad in self.android_devices: 215 if not phone_setup_iwlan( 216 self.log, ad, True, WFC_MODE_CELLULAR_PREFERRED, 217 self.wifi_network_ssid, self.wifi_network_pass): 218 ad.log.error("Failed to setup WFC.") 219 return False 220 return True 221 222 def _setup_lte_volte_enabled(self): 223 for ad in self.android_devices: 224 if not phone_setup_volte(self.log, ad): 225 ad.log.error("Phone failed to enable VoLTE.") 226 return False 227 ad.log.info("Phone VOLTE is enabled successfully.") 228 return True 229 230 def _setup_lte_volte_disabled(self): 231 for ad in self.android_devices: 232 if not phone_setup_csfb(self.log, ad): 233 ad.log.error("Phone failed to setup CSFB.") 234 return False 235 ad.log.info("Phone VOLTE is disabled successfully.") 236 return True 237 238 def _setup_3g(self): 239 for ad in self.android_devices: 240 if not phone_setup_voice_3g(self.log, ad): 241 ad.log.error("Phone failed to setup 3g.") 242 return False 243 ad.log.info("Phone RAT 3G is enabled successfully.") 244 return True 245 246 def _setup_2g(self): 247 for ad in self.android_devices: 248 if not phone_setup_voice_2g(self.log, ad): 249 ad.log.error("Phone failed to setup 2g.") 250 return False 251 ad.log.info("RAT 2G is enabled successfully.") 252 return True 253 254 def _get_network_rat(self, slot_id): 255 rat = self.dut.adb.getprop("gsm.network.type") 256 if "," in rat: 257 if self.dsds_esim: 258 rat = rat.split(',')[slot_id] 259 else: 260 (rat1, rat2) = rat.split(',') 261 if rat1 == "Unknown": 262 rat = rat2 263 else: 264 rat = rat1 265 return rat 266 267 def _send_message(self, max_wait_time=2 * MAX_WAIT_TIME_SMS_RECEIVE): 268 slot_id_rx = None 269 if self.single_phone_test: 270 ads = [self.dut, self.dut] 271 else: 272 ads = self.android_devices[:] 273 random.shuffle(ads) 274 slot_id = random.randint(0,1) 275 if self.dsds_esim: 276 sub_id = get_subid_from_slot_index(self.log, ads[0], slot_id) 277 ads[0].log.info("Message - MO - slot_Id %d", slot_id) 278 set_subid_for_message(ads[0], sub_id) 279 time.sleep(WAIT_TIME_CHANGE_MESSAGE_SUB_ID) 280 slot_id_rx = random.randint(0,1) 281 ads[1].log.info("Message - MT - slot_id %d", slot_id_rx) 282 selection = random.randrange(0, 2) 283 message_type_map = {0: "SMS", 1: "MMS"} 284 max_length_map = {0: self.max_sms_length, 1: self.max_mms_length} 285 min_length_map = {0: self.min_sms_length, 1: self.min_mms_length} 286 length = random.randrange(min_length_map[selection], 287 max_length_map[selection] + 1) 288 message_func_map = { 289 0: sms_send_receive_verify, 290 1: mms_send_receive_verify 291 } 292 rat = self._get_network_rat(slot_id) 293 self.dut.log.info("Network in RAT %s", rat) 294 if self.dut_incall and not is_rat_svd_capable(rat.upper()): 295 self.dut.log.info("In call data not supported, test SMS only") 296 selection = 0 297 message_type = message_type_map[selection] 298 the_number = self.result_info["%s Total" % message_type] + 1 299 begin_time = get_device_epoch_time(self.dut) 300 test_name = "%s_No_%s_%s" % (self.test_name, the_number, message_type) 301 if self.sdm_log: 302 start_sdm_loggers(self.log, self.android_devices) 303 else: 304 start_qxdm_loggers(self.log, self.android_devices) 305 log_msg = "[Test Case] %s" % test_name 306 self.log.info("%s begin", log_msg) 307 for ad in self.android_devices: 308 if self.user_params.get("turn_on_tcpdump", False): 309 start_adb_tcpdump(ad, interface="any", mask="all") 310 if not getattr(ad, "messaging_droid", None): 311 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 312 ad.messaging_ed.start() 313 else: 314 try: 315 if not ad.messaging_droid.is_live: 316 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 317 ad.messaging_ed.start() 318 else: 319 ad.messaging_ed.clear_all_events() 320 except Exception: 321 ad.log.info("Create new sl4a session for messaging") 322 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 323 ad.messaging_ed.start() 324 ad.messaging_droid.logI("[BEGIN]%s" % log_msg) 325 326 text = "%s:" % test_name 327 text_length = len(text) 328 if length < text_length: 329 text = text[:length] 330 else: 331 text += rand_ascii_str(length - text_length) 332 message_content_map = {0: [text], 1: [(test_name, text, None)]} 333 334 result = message_func_map[selection](self.log, ads[0], ads[1], 335 message_content_map[selection], 336 max_wait_time, 337 slot_id_rx=slot_id_rx) 338 self.log.info("%s end", log_msg) 339 for ad in self.android_devices: 340 ad.messaging_droid.logI("[END]%s" % log_msg) 341 if not result: 342 self.result_info["%s Total" % message_type] += 1 343 if message_type == "SMS": 344 self.log.error("%s fails", log_msg) 345 self.result_info["%s Failure" % message_type] += 1 346 else: 347 rat = self._get_network_rat(slot_id) 348 self.dut.log.info("Network in RAT %s", rat) 349 if self.dut_incall and not is_rat_svd_capable(rat.upper()): 350 self.dut.log.info( 351 "In call data not supported, MMS failure expected") 352 self.result_info["Expected In-call MMS failure"] += 1 353 return True 354 else: 355 self.log.error("%s fails", log_msg) 356 self.result_info["MMS Failure"] += 1 357 try: 358 self._take_bug_report(test_name, begin_time) 359 except Exception as e: 360 self.log.exception(e) 361 return False 362 else: 363 self.result_info["%s Total" % message_type] += 1 364 self.log.info("%s succeed", log_msg) 365 self.result_info["%s Success" % message_type] += 1 366 return True 367 368 def _make_phone_call(self, call_verification_func=None): 369 ads = self.android_devices[:] 370 slot_id_callee = None 371 if not self.single_phone_test: 372 random.shuffle(ads) 373 if self.dsds_esim: 374 slot_id = random.randint(0,1) 375 sub_id = get_subid_from_slot_index(self.log, ads[0], slot_id) 376 ads[0].log.info("Voice - MO - slot_Id %d", slot_id) 377 set_subid_for_outgoing_call(ads[0], sub_id) 378 time.sleep(WAIT_TIME_CHANGE_VOICE_SUB_ID) 379 slot_id_callee = random.randint(0,1) 380 ads[1].log.info("Voice - MT - slot_id %d", slot_id_callee) 381 the_number = self.result_info["Call Total"] + 1 382 duration = random.randrange(self.min_phone_call_duration, 383 self.max_phone_call_duration) 384 result = True 385 test_name = "%s_No_%s_phone_call" % (self.test_name, the_number) 386 log_msg = "[Test Case] %s" % test_name 387 self.log.info("%s for %s seconds begin", log_msg, duration) 388 begin_time = get_device_epoch_time(ads[0]) 389 for ad in self.android_devices: 390 if self.user_params.get("turn_on_tcpdump", False): 391 start_adb_tcpdump(ad, interface="any", mask="all") 392 if not getattr(ad, "droid", None): 393 ad.droid, ad.ed = ad.get_droid() 394 ad.ed.start() 395 else: 396 try: 397 if not ad.droid.is_live: 398 ad.droid, ad.ed = ad.get_droid() 399 ad.ed.start() 400 else: 401 ad.ed.clear_all_events() 402 except Exception: 403 ad.log.info("Create new sl4a session for phone call") 404 ad.droid, ad.ed = ad.get_droid() 405 ad.ed.start() 406 ad.droid.logI("[BEGIN]%s" % log_msg) 407 if self.sdm_log: 408 for ad in ads: 409 ad.adb.shell("i2cset -fy 3 64 6 1 b", ignore_status=True) 410 ad.adb.shell("i2cset -fy 3 65 6 1 b", ignore_status=True) 411 start_sdm_loggers(self.log, self.android_devices) 412 else: 413 start_qxdm_loggers(self.log, self.android_devices) 414 if self.cbrs_esim: 415 self._cbrs_data_check_test(begin_time, expected_cbrs=True, 416 test_time="before") 417 failure_reasons = set() 418 self.dut_incall = True 419 if self.single_phone_test: 420 call_setup_result = initiate_call( 421 self.log, 422 self.dut, 423 self.call_server_number, 424 incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND 425 ) and wait_for_in_call_active(self.dut, 60, 3) 426 else: 427 call_setup_result = call_setup_teardown( 428 self.log, 429 ads[0], 430 ads[1], 431 ad_hangup=None, 432 verify_caller_func=call_verification_func, 433 verify_callee_func=call_verification_func, 434 wait_time_in_call=0, 435 incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND, 436 slot_id_callee=slot_id_callee) 437 if not call_setup_result: 438 get_telephony_signal_strength(ads[0]) 439 if not self.single_phone_test: 440 get_telephony_signal_strength(ads[1]) 441 call_logs = ads[0].search_logcat( 442 "ActivityManager: START u0 {act=android.intent.action.CALL", 443 begin_time) 444 messaging_logs = ads[0].search_logcat( 445 "com.google.android.apps.messaging/.ui.conversation.ConversationActivity", 446 begin_time) 447 if call_logs and messaging_logs: 448 if (messaging_logs[-1]["datetime_obj"] - 449 call_logs[-1]["datetime_obj"]).seconds < 5: 450 ads[0].log.info( 451 "Call setup failure due to simultaneous activities") 452 self.result_info[ 453 "Call Setup Failure With Simultaneous Activity"] += 1 454 return True 455 self.log.error("%s: Setup Call failed.", log_msg) 456 failure_reasons.add("Setup") 457 result = False 458 else: 459 elapsed_time = 0 460 check_interval = 5 461 if self.sdm_log: 462 for ad in ads: 463 ad.adb.shell("i2cset -fy 3 64 6 1 b", ignore_status=True) 464 ad.adb.shell("i2cset -fy 3 65 6 1 b", ignore_status=True) 465 if self.cbrs_esim: 466 time.sleep(5) 467 self._cbrs_data_check_test(begin_time, expected_cbrs=False, 468 test_time="during") 469 while (elapsed_time < duration): 470 check_interval = min(check_interval, duration - elapsed_time) 471 time.sleep(check_interval) 472 elapsed_time += check_interval 473 time_message = "at <%s>/<%s> second." % (elapsed_time, 474 duration) 475 for ad in ads: 476 get_telephony_signal_strength(ad) 477 if not call_verification_func(self.log, ad): 478 ad.log.warning("Call is NOT in correct %s state at %s", 479 call_verification_func.__name__, 480 time_message) 481 if call_verification_func.__name__ == "is_phone_in_call_iwlan": 482 if is_phone_in_call(self.log, ad): 483 if getattr(ad, "data_rat_state_error_count", 484 0) < 1: 485 setattr(ad, "data_rat_state_error_count", 486 1) 487 continue 488 failure_reasons.add("Maintenance") 489 last_call_drop_reason(ad, begin_time) 490 hangup_call(self.log, ads[0]) 491 result = False 492 else: 493 ad.log.info("Call is in correct %s state at %s", 494 call_verification_func.__name__, 495 time_message) 496 if not result: 497 break 498 if not hangup_call(self.log, ads[0]): 499 failure_reasons.add("Teardown") 500 result = False 501 for ad in ads: 502 if not wait_for_call_id_clearing(ad, 503 []) or ad.droid.telecomIsInCall(): 504 ad.log.error("Fail to hang up call") 505 failure_reasons.add("Teardown") 506 result = False 507 self.result_info["Call Total"] += 1 508 for ad in self.android_devices: 509 try: 510 ad.droid.logI("[END]%s" % log_msg) 511 except: 512 pass 513 self.log.info("%s end", log_msg) 514 self.dut_incall = False 515 if self.cbrs_esim: 516 time.sleep(30) 517 self._cbrs_data_check_test(begin_time, expected_cbrs=True, 518 test_time="after") 519 if not result: 520 self.log.info("%s failed", log_msg) 521 if self.gps_log_file: 522 gps_info = job.run( 523 "tail %s" % self.gps_log_file, ignore_status=True) 524 if gps_info.stdout: 525 gps_log_path = os.path.join(self.log_path, test_name) 526 os.makedirs(gps_log_path, exist_ok=True) 527 job.run( 528 "tail %s > %s" % 529 (self.gps_log_file, 530 os.path.join(gps_log_path, "gps_logs.txt")), 531 ignore_status=True) 532 self.log.info("gps log:\n%s", gps_info.stdout) 533 else: 534 self.log.warning("Fail to get gps log %s", 535 self.user_params["gps_log_file"]) 536 for reason in failure_reasons: 537 self.result_info["Call %s Failure" % reason] += 1 538 for ad in ads: 539 log_path = os.path.join(self.log_path, test_name, 540 "%s_binder_logs" % ad.serial) 541 os.makedirs(log_path, exist_ok=True) 542 ad.pull_files(BINDER_LOGS, log_path) 543 try: 544 self._take_bug_report(test_name, begin_time) 545 except Exception as e: 546 self.log.exception(e) 547 for ad in ads: 548 if ad.droid.telecomIsInCall(): 549 hangup_call_by_adb(ad) 550 else: 551 self.log.info("%s test succeed", log_msg) 552 self.result_info["Call Success"] += 1 553 if self.result_info["Call Total"] % 50 == 0: 554 for ad in ads: 555 synchronize_device_time(ad) 556 force_connectivity_metrics_upload(ad) 557 if self.get_binder_logs: 558 log_path = os.path.join(self.log_path, test_name, 559 "%s_binder_logs" % ad.serial) 560 os.makedirs(log_path, exist_ok=True) 561 ad.pull_files(BINDER_LOGS, log_path) 562 return result 563 564 def _prefnetwork_mode_change(self, sub_id): 565 # ModePref change to non-LTE 566 begin_time = get_device_epoch_time(self.dut) 567 if self.sdm_log: 568 start_sdm_loggers(self.log, self.android_devices) 569 else: 570 start_qxdm_loggers(self.log, self.android_devices) 571 self.result_info["Network Change Request Total"] += 1 572 test_name = "%s_network_change_iter_%s" % ( 573 self.test_name, self.result_info["Network Change Request Total"]) 574 log_msg = "[Test Case] %s" % test_name 575 self.log.info("%s begin", log_msg) 576 self.dut.droid.logI("[BEGIN]%s" % log_msg) 577 network_preference_list = [ 578 NETWORK_MODE_TDSCDMA_GSM_WCDMA, NETWORK_MODE_WCDMA_ONLY, 579 NETWORK_MODE_GLOBAL, NETWORK_MODE_CDMA, NETWORK_MODE_GSM_ONLY 580 ] 581 network_preference = random.choice(network_preference_list) 582 set_preferred_network_mode_pref(self.log, self.dut, sub_id, 583 network_preference) 584 time.sleep(WAIT_TIME_AFTER_MODE_CHANGE) 585 self.dut.log.info("Current Voice RAT is %s", 586 get_current_voice_rat(self.log, self.dut)) 587 588 # ModePref change back to with LTE 589 if not phone_setup_volte(self.log, self.dut): 590 self.dut.log.error("Phone failed to enable VoLTE.") 591 self.result_info["VoLTE Setup Failure"] += 1 592 self.dut.droid.logI("%s end" % log_msg) 593 self.dut.log.info("[END]%s", log_msg) 594 try: 595 self._ad_take_extra_logs(self.dut, test_name, begin_time) 596 self._ad_take_bugreport(self.dut, test_name, begin_time) 597 except Exception as e: 598 self.log.exception(e) 599 return False 600 else: 601 self.result_info["VoLTE Setup Success"] += 1 602 return True 603 604 def _mobile_data_toggling(self, setup="volte"): 605 # ModePref change to non-LTE 606 begin_time = get_device_epoch_time(self.dut) 607 if self.sdm_log: 608 start_sdm_loggers(self.log, self.android_devices) 609 else: 610 start_qxdm_loggers(self.log, self.android_devices) 611 result = True 612 self.result_info["Data Toggling Request Total"] += 1 613 test_name = "%s_data_toggling_iter_%s" % ( 614 self.test_name, self.result_info["Data Toggling Request Total"]) 615 log_msg = "[Test Case] %s" % test_name 616 self.log.info("%s begin", log_msg) 617 self.dut.droid.logI("[BEGIN]%s" % log_msg) 618 self.dut.adb.shell("svc data disable") 619 time.sleep(WAIT_TIME_AFTER_MODE_CHANGE) 620 self.dut.adb.shell("svc data enable") 621 if not self._check_data(): 622 result = False 623 elif setup == "volte" and not phone_idle_volte(self.log, self.dut): 624 result = False 625 self.dut.droid.logI("%s end" % log_msg) 626 self.dut.log.info("[END]%s", log_msg) 627 if not result: 628 self.result_info["Data Toggling Failure"] += 1 629 try: 630 self._ad_take_extra_logs(self.dut, test_name, begin_time) 631 self._ad_take_bugreport(self.dut, test_name, begin_time) 632 except Exception as e: 633 self.log.exception(e) 634 return False 635 else: 636 self.result_info["Data Toggling Success"] += 1 637 return True 638 639 def _get_result_message(self): 640 msg_list = [ 641 "%s: %s" % (count, self.result_info[count]) 642 for count in sorted(self.result_info.keys()) 643 ] 644 return ", ".join(msg_list) 645 646 def _write_perf_json(self): 647 json_str = json.dumps(self.perf_data, indent=4, sort_keys=True) 648 with open(self.perf_file, 'w') as f: 649 f.write(json_str) 650 651 def _init_perf_json(self): 652 self.perf_file = os.path.join(self.log_path, "%s_perf_data_%s.json" % 653 (self.test_name, self.begin_time)) 654 self.perf_data = self.dut.build_info.copy() 655 self.perf_data["build_fingerprint"] = self.dut.adb.getprop( 656 "ro.build.fingerprint") 657 self.perf_data["model"] = self.dut.model 658 self.perf_data["carrier"] = self.dut.adb.getprop( 659 "gsm.sim.operator.alpha") 660 self._write_perf_json() 661 662 def _update_perf_json(self): 663 for result_key, result_value in self.result_info.items(): 664 self.perf_data[result_key] = result_value 665 self._write_perf_json() 666 667 def crash_check_test(self): 668 failure = 0 669 while time.time() < self.finishing_time: 670 try: 671 self.log.info(dict(self.result_info)) 672 self._update_perf_json() 673 begin_time = get_device_epoch_time(self.dut) 674 run_time_in_seconds = (begin_time - self.begin_time) / 1000 675 test_name = "%s_crash_%s_seconds_after_start" % ( 676 self.test_name, run_time_in_seconds) 677 time.sleep(self.crash_check_interval) 678 for ad in self.android_devices: 679 crash_report = ad.check_crash_report( 680 test_name, begin_time, log_crash_report=True) 681 if crash_report: 682 ad.log.error("Find new crash reports %s", crash_report) 683 failure += 1 684 self.result_info["Crashes"] += len(crash_report) 685 for crash in crash_report: 686 if "ramdump_modem" in crash: 687 self.result_info["Crashes-Modem"] += 1 688 try: 689 ad.take_bug_report(test_name, begin_time) 690 except Exception as e: 691 self.log.exception(e) 692 except Exception as e: 693 self.log.error("Exception error %s", str(e)) 694 self.result_info["Exception Errors"] += 1 695 self.log.info("Crashes found: %s", failure) 696 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 697 self.log.error("Too many exception errors, quit test") 698 return False 699 if failure: 700 return False 701 else: 702 return True 703 704 def _cbrs_data_check_test(self, begin_time, expected_cbrs=True, 705 test_time="before"): 706 cbrs_fail_count = 0 707 the_number = self.result_info["CBRS Total"] + 1 708 test_name = "%s_cbrs_%s_call_No_%s" % (self.test_name, 709 test_time, the_number) 710 for ad in self.android_devices: 711 current_state = is_current_data_on_cbrs(ad, ad.cbrs) 712 if current_state == expected_cbrs: 713 self.result_info["CBRS-Check-Pass"] += 1 714 else: 715 self.result_info["CBRS-Check-Fail"] += 1 716 cbrs_fail_count += 1 717 try: 718 self._ad_take_extra_logs(ad, test_name, begin_time) 719 self._ad_take_bugreport(ad, test_name, begin_time) 720 except Exception as e: 721 self.log.warning(e) 722 if cbrs_fail_count > 0: 723 ad.log.error("Found %d checks failed, expected cbrs %s", 724 cbrs_fail_count, expected_cbrs) 725 cbrs_fail_count += 1 726 self.result_info["CBRS Total"] += 1 727 return True 728 729 def call_test(self, call_verification_func=None): 730 while time.time() < self.finishing_time: 731 time.sleep( 732 random.randrange(self.min_sleep_time, self.max_sleep_time)) 733 try: 734 self._make_phone_call(call_verification_func) 735 except Exception as e: 736 self.log.exception("Exception error %s", str(e)) 737 self.result_info["Exception Errors"] += 1 738 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 739 self.log.error("Too many exception errors, quit test") 740 return False 741 self.log.info("%s", dict(self.result_info)) 742 if any([ 743 self.result_info["Call Setup Failure"], 744 self.result_info["Call Maintenance Failure"], 745 self.result_info["Call Teardown Failure"] 746 ]): 747 return False 748 else: 749 return True 750 751 def message_test(self, max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE): 752 while time.time() < self.finishing_time: 753 try: 754 self._send_message(max_wait_time=max_wait_time) 755 except Exception as e: 756 self.log.exception("Exception error %s", str(e)) 757 self.result_info["Exception Errors"] += 1 758 self.log.info(dict(self.result_info)) 759 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 760 self.log.error("Too many exception errors, quit test") 761 return False 762 time.sleep( 763 random.randrange(self.min_sleep_time, self.max_sleep_time)) 764 if self.result_info["SMS Failure"] or ( 765 self.result_info["MMS Failure"] / self.result_info["MMS Total"] 766 > 0.3): 767 return False 768 else: 769 return True 770 771 def _data_download(self, file_names=["5MB", "10MB", "20MB", "50MB"]): 772 begin_time = get_current_epoch_time() 773 slot_id = random.randint(0,1) 774 if self.dsds_esim: 775 sub_id = get_subid_from_slot_index(self.log, self.dut, slot_id) 776 self.dut.log.info("Data - slot_Id %d", slot_id) 777 set_subid_for_data(self.dut, sub_id) 778 self.dut.droid.telephonyToggleDataConnection(True) 779 if self.sdm_log: 780 start_sdm_loggers(self.log, self.android_devices) 781 else: 782 start_qxdm_loggers(self.log, self.android_devices) 783 self.dut.log.info(dict(self.result_info)) 784 selection = random.randrange(0, len(file_names)) 785 file_name = file_names[selection] 786 self.result_info["Internet Connection Check Total"] += 1 787 788 rat = self._get_network_rat(slot_id) 789 if not self.internet_connection_check_method(self.log, self.dut): 790 self.dut.log.info("Network in RAT %s", rat) 791 if self.dut_incall and not is_rat_svd_capable(rat.upper()): 792 self.result_info[ 793 "Expected Incall Internet Connection Check Failure"] += 1 794 return True 795 else: 796 self.result_info["Internet Connection Check Failure"] += 1 797 test_name = "%s_internet_connection_No_%s_failure" % ( 798 self.test_name, 799 self.result_info["Internet Connection Check Failure"]) 800 try: 801 self._ad_take_extra_logs(self.dut, test_name, begin_time) 802 self._ad_take_bugreport(self.dut, test_name, begin_time) 803 except Exception as e: 804 self.log.exception(e) 805 return False 806 else: 807 self.result_info["Internet Connection Check Success"] += 1 808 809 self.result_info["File Download Total"] += 1 810 if not active_file_download_test( 811 self.log, self.dut, file_name, 812 method=self.file_download_method): 813 self.result_info["File Download Failure"] += 1 814 if self.result_info["File Download Failure"] == 1: 815 try: 816 self._ad_take_extra_logs( 817 self.dut, "%s_file_download_failure" % self.test_name, 818 begin_time) 819 self._ad_take_bugreport( 820 self.dut, "%s_file_download_failure" % self.test_name, 821 begin_time) 822 except Exception as e: 823 self.log.exception(e) 824 return False 825 else: 826 self.result_info["File Download Success"] += 1 827 return True 828 829 def data_test(self): 830 while time.time() < self.finishing_time: 831 try: 832 self._data_download() 833 except Exception as e: 834 self.log.error("Exception error %s", str(e)) 835 self.result_info["Exception Errors"] += 1 836 self.log.info("%s", dict(self.result_info)) 837 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 838 self.log.error("Too many exception errors, quit test") 839 return False 840 time.sleep( 841 random.randrange(self.min_sleep_time, self.max_sleep_time)) 842 if self.result_info["Internet Connection Check Failure"]: 843 return False 844 else: 845 return True 846 847 def _check_data(self): 848 self.result_info["Data Connection Check Total"] += 1 849 if not wait_for_data_connection(self.log, self.dut, True): 850 self.result_info["Data Connection Setup Failure"] += 1 851 return False 852 if not self.internet_connection_check_method(self.log, self.dut): 853 rat = self.dut.adb.getprop("gsm.network.type") 854 self.dut.log.info("Network in RAT %s", rat) 855 self.result_info["Internet Connection Check Failure"] += 1 856 return False 857 return True 858 859 def _data_call_test(self, sub_id, generation): 860 self.dut.log.info(dict(self.result_info)) 861 begin_time = get_device_epoch_time(self.dut) 862 if self.sdm_log: 863 start_sdm_loggers(self.log, self.android_devices) 864 else: 865 start_qxdm_loggers(self.log, self.android_devices) 866 self.result_info["Network Change Request Total"] += 1 867 test_name = "%s_network_change_test_iter_%s" % ( 868 self.test_name, self.result_info["Network Change Request Total"]) 869 log_msg = "[Test Case] %s" % test_name 870 self.log.info("%s begin", log_msg) 871 self.dut.droid.logI("[BEGIN]%s" % log_msg) 872 if not ensure_network_generation_for_subscription( 873 self.log, self.dut, sub_id, 874 generation) or not self._check_data(): 875 self.result_info["Network Change Failure"] += 1 876 self.dut.droid.logI("%s end" % log_msg) 877 self.dut.log.info("[END]%s", log_msg) 878 try: 879 self._ad_take_extra_logs(self.dut, test_name, begin_time) 880 self._ad_take_bugreport(self.dut, test_name, begin_time) 881 except Exception as e: 882 self.log.warning(e) 883 return False 884 if not self._mobile_data_toggling(setup=None): 885 return False 886 return True 887 888 def data_call_stress_test(self): 889 result = True 890 sub_id = self.dut.droid.subscriptionGetDefaultSubId() 891 while time.time() < self.finishing_time: 892 for generation in (GEN_4G, GEN_3G): 893 try: 894 if not self._data_call_test(sub_id, generation): 895 result = False 896 except Exception as e: 897 self.log.error("Exception error %s", str(e)) 898 self.result_info["Exception Errors"] += 1 899 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 900 self.log.error("Too many exception errors, quit test") 901 return False 902 return result 903 904 def check_incall_data(self): 905 if verify_internet_connection_by_ping(self.log, self.dut): 906 self.internet_connection_check_method = verify_internet_connection_by_ping 907 elif verify_http_connection(self.log, self.dut): 908 self.internet_connection_check_method = verify_http_connection 909 else: 910 self.dut.log.error("Data test failed") 911 raise signals.TestFailure("Data check failed") 912 if self.single_phone_test: 913 if not initiate_call( 914 self.log, self.dut, 915 self.call_server_number) and wait_for_in_call_active( 916 self.dut, 60, 3): 917 self._take_bug_report(self.test_name, self.begin_time) 918 raise signals.TestFailure("Unable to make phone call") 919 else: 920 if not call_setup_teardown( 921 self.log, self.dut, self.android_devices[1], 922 ad_hangup=None): 923 self._take_bug_report(self.test_name, self.begin_time) 924 raise signals.TestFailure("Unable to make phone call") 925 voice_rat = self.dut.droid.telephonyGetCurrentVoiceNetworkType() 926 data_rat = self.dut.droid.telephonyGetCurrentDataNetworkType() 927 self.dut.log.info("Voice in RAT %s, Data in RAT %s", voice_rat, 928 data_rat) 929 try: 930 if "wfc" in self.test_name or is_rat_svd_capable( 931 voice_rat.upper()) and is_rat_svd_capable( 932 data_rat.upper()): 933 self.dut.log.info("Capable for simultaneous voice and data") 934 935 if not self.internet_connection_check_method( 936 self.log, self.dut): 937 self.dut.log.error("Incall data check failed") 938 raise signals.TestFailure("Incall data check failed") 939 else: 940 return True 941 else: 942 self.dut.log.info( 943 "Not capable for simultaneous voice and data") 944 return False 945 hangup_call(self.log, self.dut) 946 finally: 947 for ad in self.android_devices: 948 if ad.droid.telecomIsInCall(): 949 hangup_call(self.log, ad) 950 951 def parallel_tests(self, setup_func=None, call_verification_func=None): 952 self.log.info(self._get_result_message()) 953 if setup_func and not setup_func(): 954 msg = "%s setup %s failed" % (self.test_name, setup_func.__name__) 955 self.log.error(msg) 956 self._take_bug_report("%s%s" % (self.test_name, 957 setup_func.__name__), 958 self.begin_time) 959 return False 960 if not call_verification_func: 961 call_verification_func = is_phone_in_call 962 self.finishing_time = time.time() + self.max_run_time 963 # CBRS setup 964 if self.cbrs_esim: 965 cbrs_sub_count = 0 966 for ad in self.android_devices: 967 if not getattr(ad, 'cbrs', {}): 968 setattr(ad, 'cbrs', None) 969 for i in range(0, 2): 970 sub_id = get_subid_from_slot_index(ad.log, ad, i) 971 operator = get_operatorname_from_slot_index(ad, i) 972 carrier_id = get_carrierid_from_slot_index(ad, i) 973 ad.log.info("Slot %d - Sub %s - %s - %d", i, sub_id, operator, carrier_id) 974 if carrier_id == 2340: 975 ad.cbrs = sub_id 976 cbrs_sub_count += 1 977 if cbrs_sub_count != 2: 978 self.log.error("Expecting - 2 CBRS subs, found - %d", cbrs_sub_count) 979 raise signals.TestAbortClass("Cannot find all expected CBRS subs") 980 # DSDS setup 981 if self.dsds_esim: 982 for ad in self.android_devices: 983 for i in range(0, 2): 984 sub_id = get_subid_from_slot_index(ad.log, ad, i) 985 set_slways_allow_mms_data(ad, sub_id) 986 operator = get_operatorname_from_slot_index(ad, i) 987 ad.log.info("Slot %d - Sub %s - %s", i, sub_id, operator) 988 # Actual test trigger 989 if not self.dsds_esim and self.check_incall_data(): 990 self.log.info( 991 "==== Start parallel voice/message/data stress test ====") 992 self.perf_data["testing method"] = "parallel" 993 results = run_multithread_func( 994 self.log, [(self.call_test, [call_verification_func]), 995 (self.message_test, []), (self.data_test, []), 996 (self.crash_check_test, [])]) 997 else: 998 self.log.info( 999 "==== Start sequential voice/message/data stress test ====") 1000 self.perf_data["testing method"] = "sequential" 1001 results = run_multithread_func( 1002 self.log, [(self.sequential_tests, [call_verification_func]), 1003 (self.crash_check_test, [])]) 1004 result_message = self._get_result_message() 1005 self.log.info(result_message) 1006 self._update_perf_json() 1007 self.result_detail = result_message 1008 return all(results) 1009 1010 def sequential_tests(self, call_verification_func): 1011 funcs = [(self._make_phone_call, [call_verification_func]), 1012 (self._send_message, []), (self._data_download, [["5MB"]])] 1013 while time.time() < self.finishing_time: 1014 selection = random.randrange(0, 3) 1015 try: 1016 funcs[selection][0](*funcs[selection][1]) 1017 except Exception as e: 1018 self.log.error("Exception error %s", str(e)) 1019 self.result_info["Exception Errors"] += 1 1020 self.log.info("%s", dict(self.result_info)) 1021 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 1022 self.log.error("Too many exception errors, quit test") 1023 return False 1024 time.sleep( 1025 random.randrange(self.min_sleep_time, self.max_sleep_time)) 1026 if any([ 1027 self.result_info["Call Setup Failure"], 1028 self.result_info["Call Maintenance Failure"], 1029 self.result_info["Call Teardown Failure"], 1030 self.result_info["SMS Failure"], 1031 self.result_info["MMS Failure"], 1032 self.result_info["Internet Connection Check Failure"] 1033 ]): 1034 return False 1035 return True 1036 1037 def volte_modechange_volte_test(self): 1038 sub_id = self.dut.droid.subscriptionGetDefaultSubId() 1039 result = True 1040 while time.time() < self.finishing_time: 1041 try: 1042 if self._prefnetwork_mode_change(sub_id): 1043 run_multithread_func( 1044 self.log, 1045 [(self._data_download, [["5MB"]]), 1046 (self._make_phone_call, [is_phone_in_call_volte]), 1047 (self._send_message, [])]) 1048 else: 1049 result = False 1050 if self._mobile_data_toggling(): 1051 run_multithread_func( 1052 self.log, 1053 [(self._data_download, [["5MB"]]), 1054 (self._make_phone_call, [is_phone_in_call_volte]), 1055 (self._send_message, [])]) 1056 else: 1057 result = False 1058 except Exception as e: 1059 self.log.error("Exception error %s", str(e)) 1060 self.result_info["Exception Errors"] += 1 1061 self.log.info(dict(self.result_info)) 1062 if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE: 1063 self.log.error("Too many exception errors, quit test") 1064 return False 1065 return result 1066 1067 def parallel_with_network_change_tests(self, setup_func=None): 1068 if setup_func and not setup_func(): 1069 self.log.error("Test setup %s failed", setup_func.__name__) 1070 return False 1071 self.finishing_time = time.time() + self.max_run_time 1072 results = run_multithread_func(self.log, 1073 [(self.volte_modechange_volte_test, []), 1074 (self.crash_check_test, [])]) 1075 result_message = self._get_result_message() 1076 self.log.info(result_message) 1077 self._update_perf_json() 1078 self.result_detail = result_message 1079 return all(results) 1080 1081 def connect_to_wifi(self): 1082 for ad in self.android_devices: 1083 if not ensure_wifi_connected( 1084 self.log, 1085 ad, 1086 self.wifi_network_ssid, 1087 self.wifi_network_pass, 1088 retries=3): 1089 ad.log.error("Bringing up Wifi connection fails.") 1090 return False 1091 ad.log.info("Phone WIFI is connected successfully.") 1092 return True 1093 1094 """ Tests Begin """ 1095 1096 @test_tracker_info(uuid="d035e5b9-476a-4e3d-b4e9-6fd86c51a68d") 1097 @TelephonyBaseTest.tel_test_wrap 1098 def test_default_parallel_stress(self): 1099 """ Default state stress test""" 1100 return self.parallel_tests() 1101 1102 @test_tracker_info(uuid="798a3c34-db75-4bcf-b8ef-e1116414a7fe") 1103 @TelephonyBaseTest.tel_test_wrap 1104 def test_default_parallel_stress_with_wifi(self): 1105 """ Default state stress test with Wifi enabled.""" 1106 if self.connect_to_wifi(): 1107 return self.parallel_tests() 1108 1109 @test_tracker_info(uuid="c21e1f17-3282-4f0b-b527-19f048798098") 1110 @TelephonyBaseTest.tel_test_wrap 1111 def test_lte_volte_parallel_stress(self): 1112 """ VoLTE on stress test""" 1113 return self.parallel_tests( 1114 setup_func=self._setup_lte_volte_enabled, 1115 call_verification_func=is_phone_in_call_volte) 1116 1117 @test_tracker_info(uuid="a317c23a-41e0-4ef8-af67-661451cfefcf") 1118 @TelephonyBaseTest.tel_test_wrap 1119 def test_csfb_parallel_stress(self): 1120 """ LTE non-VoLTE stress test""" 1121 return self.parallel_tests( 1122 setup_func=self._setup_lte_volte_disabled, 1123 call_verification_func=is_phone_in_call_csfb) 1124 1125 @test_tracker_info(uuid="fdb791bf-c414-4333-9fa3-cc18c9b3b234") 1126 @TelephonyBaseTest.tel_test_wrap 1127 def test_wfc_parallel_stress(self): 1128 """ Wifi calling APM mode off stress test""" 1129 if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: 1130 raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") 1131 return self.parallel_tests( 1132 setup_func=self._setup_wfc, 1133 call_verification_func=is_phone_in_call_iwlan) 1134 1135 @test_tracker_info(uuid="e334c1b3-4378-49bb-bf57-1573fa1b23fa") 1136 @TelephonyBaseTest.tel_test_wrap 1137 def test_wfc_apm_parallel_stress(self): 1138 """ Wifi calling in APM mode on stress test""" 1139 return self.parallel_tests( 1140 setup_func=self._setup_wfc_apm, 1141 call_verification_func=is_phone_in_call_iwlan) 1142 1143 @test_tracker_info(uuid="4566eef6-55de-4ac8-87ee-58f2ef41a3e8") 1144 @TelephonyBaseTest.tel_test_wrap 1145 def test_3g_parallel_stress(self): 1146 """ 3G stress test""" 1147 return self.parallel_tests( 1148 setup_func=self._setup_3g, 1149 call_verification_func=is_phone_in_call_3g) 1150 1151 @test_tracker_info(uuid="f34f1a31-3948-4675-8698-372a83b8088d") 1152 @TelephonyBaseTest.tel_test_wrap 1153 def test_2g_parallel_stress(self): 1154 """ 2G call stress test""" 1155 return self.parallel_tests( 1156 setup_func=self._setup_2g, 1157 call_verification_func=is_phone_in_call_2g) 1158 1159 @test_tracker_info(uuid="af580fca-fea6-4ca5-b981-b8c710302d37") 1160 @TelephonyBaseTest.tel_test_wrap 1161 def test_volte_modeprefchange_parallel_stress(self): 1162 """ VoLTE Mode Pref call stress test""" 1163 return self.parallel_with_network_change_tests( 1164 setup_func=self._setup_lte_volte_enabled) 1165 1166 @test_tracker_info(uuid="10e34247-5fd3-4f87-81bf-3c17a6b71ab2") 1167 @TelephonyBaseTest.tel_test_wrap 1168 def test_data_call_stress(self): 1169 """ Default state stress test""" 1170 self.finishing_time = time.time() + self.max_run_time 1171 results = run_multithread_func(self.log, 1172 [(self.data_call_stress_test, []), 1173 (self.crash_check_test, [])]) 1174 result_message = self._get_result_message() 1175 self.log.info(result_message) 1176 self._update_perf_json() 1177 self.result_detail = result_message 1178 return all(results) 1179 1180 """ Tests End """ 1181