• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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