Home | History | Annotate | Download | only in live
      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 Mobility Stress Test
     18 """
     19 
     20 import collections
     21 import random
     22 import time
     23 from acts.asserts import fail
     24 from acts.test_decorators import test_tracker_info
     25 from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
     26 from acts.test_utils.tel.tel_atten_utils import set_rssi
     27 from acts.test_utils.tel.tel_defines import CELL_WEAK_RSSI_VALUE
     28 from acts.test_utils.tel.tel_defines import CELL_STRONG_RSSI_VALUE
     29 from acts.test_utils.tel.tel_defines import MAX_RSSI_RESERVED_VALUE
     30 from acts.test_utils.tel.tel_defines import MIN_RSSI_RESERVED_VALUE
     31 from acts.test_utils.tel.tel_defines import WFC_MODE_CELLULAR_PREFERRED
     32 from acts.test_utils.tel.tel_defines import WFC_MODE_DISABLED
     33 from acts.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED
     34 from acts.test_utils.tel.tel_defines import WFC_MODE_CELLULAR_PREFERRED
     35 from acts.test_utils.tel.tel_defines import WIFI_WEAK_RSSI_VALUE
     36 from acts.test_utils.tel.tel_test_utils import active_file_download_test
     37 from acts.test_utils.tel.tel_test_utils import call_setup_teardown
     38 from acts.test_utils.tel.tel_test_utils import ensure_phone_default_state
     39 from acts.test_utils.tel.tel_test_utils import ensure_phone_subscription
     40 from acts.test_utils.tel.tel_test_utils import ensure_phones_idle
     41 from acts.test_utils.tel.tel_test_utils import ensure_wifi_connected
     42 from acts.test_utils.tel.tel_test_utils import hangup_call
     43 from acts.test_utils.tel.tel_test_utils import is_voice_attached
     44 from acts.test_utils.tel.tel_test_utils import run_multithread_func
     45 from acts.test_utils.tel.tel_test_utils import set_wfc_mode
     46 from acts.test_utils.tel.tel_test_utils import sms_send_receive_verify
     47 from acts.test_utils.tel.tel_test_utils import mms_send_receive_verify
     48 from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_3g
     49 from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_2g
     50 from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_csfb
     51 from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan
     52 from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_volte
     53 from acts.test_utils.tel.tel_voice_utils import phone_setup_csfb
     54 from acts.test_utils.tel.tel_voice_utils import phone_setup_iwlan
     55 from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_3g
     56 from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_2g
     57 from acts.test_utils.tel.tel_voice_utils import phone_setup_volte
     58 from acts.test_utils.tel.tel_voice_utils import get_current_voice_rat
     59 from acts.utils import rand_ascii_str
     60 from TelWifiVoiceTest import TelWifiVoiceTest
     61 from TelWifiVoiceTest import ATTEN_NAME_FOR_WIFI_2G
     62 from TelWifiVoiceTest import ATTEN_NAME_FOR_WIFI_5G
     63 from TelWifiVoiceTest import ATTEN_NAME_FOR_CELL_3G
     64 from TelWifiVoiceTest import ATTEN_NAME_FOR_CELL_4G
     65 
     66 
     67 class TelLiveMobilityStressTest(TelWifiVoiceTest):
     68     def setup_class(self):
     69         super().setup_class()
     70         #super(TelWifiVoiceTest, self).setup_class()
     71         self.user_params["telephony_auto_rerun"] = False
     72         self.max_phone_call_duration = int(
     73             self.user_params.get("max_phone_call_duration", 600))
     74         self.max_sleep_time = int(self.user_params.get("max_sleep_time", 120))
     75         self.max_run_time = int(self.user_params.get("max_run_time", 7200))
     76         self.max_sms_length = int(self.user_params.get("max_sms_length", 1000))
     77         self.max_mms_length = int(self.user_params.get("max_mms_length", 160))
     78         self.crash_check_interval = int(
     79             self.user_params.get("crash_check_interval", 300))
     80         self.signal_change_interval = int(
     81             self.user_params.get("signal_change_interval", 10))
     82         self.signal_change_step = int(
     83             self.user_params.get("signal_change_step", 5))
     84         self.dut = self.android_devices[0]
     85         self.helper = self.android_devices[1]
     86 
     87         return True
     88 
     89     def _setup_volte_wfc_wifi_preferred(self):
     90         return self._wfc_phone_setup(
     91             False, WFC_MODE_WIFI_PREFERRED, volte_mode=True)
     92 
     93     def _setup_volte_wfc_cell_preferred(self):
     94         return self._wfc_phone_setup(
     95             False, WFC_MODE_CELLULAR_PREFERRED, volte_mode=True)
     96 
     97     def _setup_csfb_wfc_wifi_preferred(self):
     98         return self._wfc_phone_setup(
     99             False, WFC_MODE_WIFI_PREFERRED, volte_mode=False)
    100 
    101     def _setup_csfb_wfc_cell_preferred(self):
    102         return self._wfc_phone_setup(
    103             False, WFC_MODE_CELLULAR_PREFERRED, volte_mode=False)
    104 
    105     def _setup_volte_wfc_disabled(self):
    106         return self._wfc_phone_setup(False, WFC_MODE_DISABLED, volte_mode=True)
    107 
    108     def _setup_csfb_wfc_disabled(self):
    109         return self._wfc_phone_setup(
    110             False, WFC_MODE_DISABLED, volte_mode=False)
    111 
    112     def _send_message(self, ads):
    113         selection = random.randrange(0, 2)
    114         message_type_map = {0: "SMS", 1: "MMS"}
    115         max_length_map = {0: self.max_sms_length, 1: self.max_mms_length}
    116         length = random.randrange(0, max_length_map[selection] + 1)
    117         text = rand_ascii_str(length)
    118         message_content_map = {0: [text], 1: [("Mms Message", text, None)]}
    119         message_func_map = {
    120             0: sms_send_receive_verify,
    121             1: mms_send_receive_verify
    122         }
    123         if not message_func_map[selection](self.log, ads[0], ads[1],
    124                                            message_content_map[selection]):
    125             self.log.error("%s of length %s from %s to %s fails",
    126                            message_type_map[selection], length, ads[0].serial,
    127                            ads[1].serial)
    128             self.result_info["%s failure" % message_type_map[selection]] += 1
    129             return False
    130         else:
    131             self.log.info("%s of length %s from %s to %s succeed",
    132                           message_type_map[selection], length, ads[0].serial,
    133                           ads[1].serial)
    134             return True
    135 
    136     def _make_phone_call(self, ads):
    137         if not call_setup_teardown(
    138                 self.log,
    139                 ads[0],
    140                 ads[1],
    141                 ad_hangup=ads[random.randrange(0, 2)],
    142                 verify_caller_func=is_voice_attached,
    143                 verify_callee_func=is_voice_attached,
    144                 wait_time_in_call=random.randrange(
    145                     30, self.max_phone_call_duration)):
    146             ads[0].log.error("Setup phone Call failed.")
    147             return False
    148         ads[0].log.info("Setup call successfully.")
    149         return True
    150 
    151     def crash_check_test(self):
    152         failure = 0
    153         while time.time() < self.finishing_time:
    154             new_crash = self.dut.check_crash_report()
    155             crash_diff = set(new_crash).difference(set(self.dut.crash_report))
    156             self.dut.crash_report = new_crash
    157             if crash_diff:
    158                 self.dut.log.error("Find new crash reports %s",
    159                                    list(crash_diff))
    160                 self.dut.pull_files(list(crash_diff))
    161                 failure += 1
    162                 self.result_info["Crashes"] += 1
    163                 self._take_bug_report("%s_crash_found" % self.test_name,
    164                                       time.strftime("%m-%d-%Y-%H-%M-%S"))
    165             self.dut.droid.goToSleepNow()
    166             time.sleep(self.crash_check_interval)
    167         return failure
    168 
    169     def environment_change_4g_wifi(self):
    170         #block cell 3G, WIFI 2G
    171         set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
    172                  MIN_RSSI_RESERVED_VALUE)
    173         set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
    174                  MIN_RSSI_RESERVED_VALUE)
    175         while time.time() < self.finishing_time:
    176             #set strong wifi 5G and LTE
    177             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
    178                      MAX_RSSI_RESERVED_VALUE)
    179             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
    180                      MAX_RSSI_RESERVED_VALUE)
    181             #gratually decrease wifi 5g
    182             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
    183                      self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE,
    184                      self.signal_change_step, self.signal_change_interval)
    185             #gratually increase wifi 5g
    186             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
    187                      MIN_RSSI_RESERVED_VALUE, MAX_RSSI_RESERVED_VALUE,
    188                      self.signal_change_step, self.signal_change_interval)
    189 
    190             #gratually decrease cell 4G
    191             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
    192                      self.cell_rssi_with_no_atten, CELL_WEAK_RSSI_VALUE,
    193                      self.signal_change_step, self.signal_change_interval)
    194             #gradtually increase cell 4G
    195             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
    196                      MIN_RSSI_RESERVED_VALUE, MAX_RSSI_RESERVED_VALUE,
    197                      self.signal_change_step, self.signal_change_interval)
    198         return 0
    199 
    200     def environment_change_4g_3g(self):
    201         #block wifi 2G and 5G
    202         set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
    203                  MIN_RSSI_RESERVED_VALUE)
    204         set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
    205                  MIN_RSSI_RESERVED_VALUE)
    206         while time.time() < self.finishing_time:
    207             #set strong cell 4G and 3G
    208             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
    209                      MAX_RSSI_RESERVED_VALUE)
    210             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
    211                      MAX_RSSI_RESERVED_VALUE)
    212             #gratually decrease cell 4G
    213             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
    214                      self.cell_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE,
    215                      self.signal_change_step, self.signal_change_interval)
    216             #gradtually increase cell 4G
    217             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
    218                      MIN_RSSI_RESERVED_VALUE, MAX_RSSI_RESERVED_VALUE,
    219                      self.signal_change_step, self.signal_change_interval)
    220             #gratually decrease cell 3G
    221             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G],
    222                      self.cell_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE,
    223                      self.signal_change_step, self.signal_change_interval)
    224             #gradtually increase cell 3G
    225             set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G],
    226                      MIN_RSSI_RESERVED_VALUE, MAX_RSSI_RESERVED_VALUE,
    227                      self.signal_change_step, self.signal_change_interval)
    228 
    229         return 0
    230 
    231     def call_test(self):
    232         failure = 0
    233         total_count = 0
    234         while time.time() < self.finishing_time:
    235             ads = [self.dut, self.helper]
    236             random.shuffle(ads)
    237             total_count += 1
    238             # Current Voice RAT
    239             self.dut.log.info("Current Voice RAT is %s",
    240                               get_current_voice_rat(self.log, self.dut))
    241             self.helper.log.info("Current Voice RAT is %s",
    242                               get_current_voice_rat(self.log, self.helper))
    243             if not self._make_phone_call(ads):
    244                 failure += 1
    245                 self.log.error("New call test failure: %s/%s", failure,
    246                                total_count)
    247                 self.result_info["Call failure"] += 1
    248                 self._take_bug_report("%s_call_failure" % self.test_name,
    249                                       time.strftime("%m-%d-%Y-%H-%M-%S"))
    250             self.dut.droid.goToSleepNow()
    251             time.sleep(random.randrange(0, self.max_sleep_time))
    252         return failure
    253 
    254     def message_test(self):
    255         failure = 0
    256         total_count = 0
    257         while time.time() < self.finishing_time:
    258             ads = [self.dut, self.helper]
    259             random.shuffle(ads)
    260             total_count += 1
    261             if not self._send_message(ads):
    262                 failure += 1
    263                 self.log.error("New messaging test failure: %s/%s", failure,
    264                                total_count)
    265                 #self._take_bug_report("%s_messaging_failure" % self.test_name,
    266                 #                      time.strftime("%m-%d-%Y-%H-%M-%S"))
    267             self.dut.droid.goToSleepNow()
    268             time.sleep(random.randrange(0, self.max_sleep_time))
    269         return failure
    270 
    271     def data_test(self):
    272         failure = 0
    273         #file_names = ["5MB", "10MB", "20MB", "50MB", "200MB", "512MB", "1GB"]
    274         #wifi download is very slow in lab, limit the file size upto 200MB
    275         file_names = ["5MB", "10MB", "20MB", "50MB", "200MB"]
    276         while time.time() < self.finishing_time:
    277             self.dut.log.info(dict(self.result_info))
    278             self.result_info["Total file download"] += 1
    279             selection = random.randrange(0, 5)
    280             file_name = file_names[selection]
    281             if not active_file_download_test(self.log, self.dut, file_name):
    282                 self.result_info["%s file download failure" % file_name] += 1
    283                 #self._take_bug_report("%s_download_failure" % self.test_name,
    284                 #                      time.strftime("%m-%d-%Y-%H-%M-%S"))
    285                 failure += 1
    286                 self.dut.droid.goToSleepNow()
    287                 time.sleep(random.randrange(0, self.max_sleep_time))
    288         return failure
    289 
    290     def parallel_tests(self, change_env_func, setup_func=None):
    291         if setup_func and not setup_func():
    292             self.log.error("Test setup %s failed", setup_func.__name__)
    293             return False
    294         self.result_info = collections.defaultdict(int)
    295         self.finishing_time = time.time() + self.max_run_time
    296         results = run_multithread_func(self.log, [(self.call_test, []), (
    297             self.message_test, []), (self.data_test, []), (
    298                 change_env_func, []), (self.crash_check_test, [])])
    299         self.log.info(dict(self.result_info))
    300         if results[0]:
    301             fail(str(dict(self.result_info)))
    302         else:
    303             return True
    304 
    305     """ Tests Begin """
    306 
    307     @test_tracker_info(uuid="6fcba97c-3572-47d7-bcac-9608f1aa5304")
    308     @TelephonyBaseTest.tel_test_wrap
    309     def test_volte_wfc_wifi_preferred_parallel_stress(self):
    310         return self.parallel_tests(
    311             self.environment_change_4g_wifi,
    312             setup_func=self._setup_volte_wfc_wifi_preferred)
    313 
    314     @test_tracker_info(uuid="df78a9a8-2a14-40bf-a7aa-719502f975be")
    315     @TelephonyBaseTest.tel_test_wrap
    316     def test_volte_wfc_cell_preferred_parallel_stress(self):
    317         return self.parallel_tests(
    318             self.environment_change_4g_wifi,
    319             setup_func=self._setup_volte_wfc_cell_preferred)
    320 
    321     @test_tracker_info(uuid="4cb47315-c420-44c2-ac47-a8bdca6d0e25")
    322     @TelephonyBaseTest.tel_test_wrap
    323     def test_csfb_wfc_wifi_preferred_parallel_stress(self):
    324         return self.parallel_tests(
    325             self.environment_change_4g_wifi,
    326             setup_func=self._setup_csfb_wfc_wifi_preferred)
    327 
    328     @test_tracker_info(uuid="92821ef7-542a-4139-b3b0-22278e2b06c4")
    329     @TelephonyBaseTest.tel_test_wrap
    330     def test_csfb_wfc_cell_preferred_parallel_stress(self):
    331         return self.parallel_tests(
    332             self.self.environment_change_4g_wifi,
    333             setup_func=self._setup_csfb_wfc_cell_preferred)
    334 
    335     @test_tracker_info(uuid="dd23923e-ebbc-461e-950a-0657e845eacf")
    336     @TelephonyBaseTest.tel_test_wrap
    337     def test_4g_volte_3g_parallel_stress(self):
    338         return self.parallel_tests(
    339             self.environment_change_4g_3g,
    340             setup_func=self._setup_volte_wfc_disabled)
    341 
    342     @test_tracker_info(uuid="faef9384-a5b0-4640-8cfa-f9f34ce6d977")
    343     @TelephonyBaseTest.tel_test_wrap
    344     def test_4g_csfb_3g_parallel_stress(self):
    345         return self.parallel_tests(
    346             self.environment_change_4g_3g,
    347             setup_func=self._setup_csfb_wfc_disabled)
    348 
    349     """ Tests End """
    350