| #!/usr/bin/env python3.4 |
| # |
| # Copyright 2016 - The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import math |
| import os |
| from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest |
| from acts.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED |
| from acts.test_utils.tel.tel_test_utils import call_setup_teardown |
| from acts.test_utils.tel.tel_test_utils import ensure_phones_default_state |
| from acts.test_utils.tel.tel_test_utils import ensure_phones_idle |
| from acts.test_utils.tel.tel_test_utils import ensure_wifi_connected |
| from acts.test_utils.tel.tel_test_utils import hangup_call |
| from acts.test_utils.tel.tel_test_utils import is_wfc_enabled |
| from acts.test_utils.tel.tel_test_utils import set_phone_screen_on |
| from acts.test_utils.tel.tel_test_utils import set_wfc_mode |
| from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode |
| from acts.test_utils.tel.tel_test_utils import verify_incall_state |
| from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_3g |
| from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_2g |
| from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan |
| from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_volte |
| from acts.test_utils.tel.tel_voice_utils import phone_idle_2g |
| from acts.test_utils.tel.tel_voice_utils import phone_idle_3g |
| from acts.test_utils.tel.tel_voice_utils import phone_idle_iwlan |
| from acts.test_utils.tel.tel_voice_utils import phone_idle_volte |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_csfb |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_iwlan |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_3g |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_2g |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_volte |
| from acts.utils import create_dir |
| from acts.utils import disable_doze |
| from acts.utils import get_current_human_time |
| from acts.utils import set_adaptive_brightness |
| from acts.utils import set_ambient_display |
| from acts.utils import set_auto_rotate |
| from acts.utils import set_location_service |
| from acts.utils import set_mobile_data_always_on |
| |
| # Monsoon output Voltage in V |
| MONSOON_OUTPUT_VOLTAGE = 4.2 |
| # Monsoon output max current in A |
| MONSOON_MAX_CURRENT = 7.8 |
| |
| # Default power test pass criteria |
| DEFAULT_POWER_PASS_CRITERIA = 999 |
| |
| # Sampling rate in Hz |
| ACTIVE_CALL_TEST_SAMPLING_RATE = 100 |
| # Sample duration in seconds |
| ACTIVE_CALL_TEST_SAMPLE_TIME = 300 |
| # Offset time in seconds |
| ACTIVE_CALL_TEST_OFFSET_TIME = 180 |
| |
| # Sampling rate in Hz |
| IDLE_TEST_SAMPLING_RATE = 100 |
| # Sample duration in seconds |
| IDLE_TEST_SAMPLE_TIME = 2400 |
| # Offset time in seconds |
| IDLE_TEST_OFFSET_TIME = 360 |
| |
| # Constant for RAT |
| RAT_LTE = 'lte' |
| RAT_3G = '3g' |
| RAT_2G = '2g' |
| # Constant for WIFI |
| WIFI_5G = '5g' |
| WIFI_2G = '2g' |
| |
| # For wakeup ping test, the frequency to wakeup. In unit of second. |
| WAKEUP_PING_TEST_WAKEUP_FREQ = 60 |
| |
| WAKEUP_PING_TEST_NUMBER_OF_ALARM = math.ceil( |
| (IDLE_TEST_SAMPLE_TIME * 60 + IDLE_TEST_OFFSET_TIME) / |
| WAKEUP_PING_TEST_WAKEUP_FREQ) |
| |
| |
| class TelPowerTest(TelephonyBaseTest): |
| def __init__(self, controllers): |
| TelephonyBaseTest.__init__(self, controllers) |
| self.tests = ( |
| # Note: For all these power tests, please do environment calibration |
| # and baseline for pass criteria. |
| # All pass criteria information should be included in test config file. |
| # The test result will be meaning less if pass criteria is not correct. |
| "test_power_active_call_3g", |
| "test_power_active_call_volte", |
| "test_power_active_call_wfc_2g_apm", |
| "test_power_active_call_wfc_2g_lte_volte_on", |
| "test_power_active_call_wfc_5g_apm", |
| "test_power_active_call_wfc_5g_lte_volte_on", |
| "test_power_idle_baseline", |
| "test_power_idle_baseline_wifi_connected", |
| "test_power_idle_wfc_2g_apm", |
| "test_power_idle_wfc_2g_lte", |
| "test_power_idle_lte_volte_enabled", |
| "test_power_idle_lte_volte_disabled", |
| "test_power_idle_3g", |
| "test_power_idle_lte_volte_enabled_wakeup_ping", |
| "test_power_idle_lte_volte_disabled_wakeup_ping", |
| "test_power_idle_3g_wakeup_ping", |
| |
| # Mobile Data Always On |
| "test_power_mobile_data_always_on_lte", |
| "test_power_mobile_data_always_on_wcdma", |
| "test_power_mobile_data_always_on_gsm", |
| "test_power_mobile_data_always_on_1x", |
| "test_power_mobile_data_always_on_lte_wifi_on", |
| "test_power_mobile_data_always_on_wcdma_wifi_on", |
| "test_power_mobile_data_always_on_gsm_wifi_on", |
| "test_power_mobile_data_always_on_1x_wifi_on") |
| |
| def setup_class(self): |
| super().setup_class() |
| self.mon = self.monsoons[0] |
| self.mon.set_voltage(MONSOON_OUTPUT_VOLTAGE) |
| self.mon.set_max_current(MONSOON_MAX_CURRENT) |
| # Monsoon phone |
| self.mon.dut = self.ad = self.android_devices[0] |
| self.ad.reboot() |
| set_adaptive_brightness(self.ad, False) |
| set_ambient_display(self.ad, False) |
| set_auto_rotate(self.ad, False) |
| set_location_service(self.ad, False) |
| # This is not needed for AOSP build |
| disable_doze(self.ad) |
| set_phone_screen_on(self.log, self.ad, 15) |
| |
| self.wifi_network_ssid_2g = self.user_params["wifi_network_ssid_2g"] |
| self.wifi_network_pass_2g = self.user_params["wifi_network_pass_2g"] |
| self.wifi_network_ssid_5g = self.user_params["wifi_network_ssid_5g"] |
| self.wifi_network_pass_5g = self.user_params["wifi_network_pass_5g"] |
| |
| self.monsoon_log_path = os.path.join(self.log_path, "MonsoonLog") |
| create_dir(self.monsoon_log_path) |
| return True |
| |
| def _save_logs_for_power_test(self, monsoon_result, bug_report): |
| if monsoon_result and "monsoon_log_for_power_test" in self.user_params: |
| monsoon_result.save_to_text_file( |
| [monsoon_result], |
| os.path.join(self.monsoon_log_path, self.test_id)) |
| if bug_report and "bug_report_for_power_test" in self.user_params: |
| self.android_devices[0].take_bug_report(self.test_name, |
| self.begin_time) |
| |
| def _setup_apm(self): |
| if not toggle_airplane_mode(self.log, self.ad, True): |
| self.log.error("Phone failed to turn on airplane mode.") |
| return False |
| else: |
| self.log.info("Airplane mode is enabled successfully.") |
| return True |
| |
| def _setup_wifi(self, wifi): |
| if wifi == WIFI_5G: |
| network_ssid = self.wifi_network_ssid_5g |
| network_pass = self.wifi_network_pass_5g |
| else: |
| network_ssid = self.wifi_network_ssid_2g |
| network_pass = self.wifi_network_pass_2g |
| if not ensure_wifi_connected( |
| self.log, self.ad, network_ssid, network_pass, retry=3): |
| self.log.error("Wifi %s connection fails." % wifi) |
| return False |
| self.log.info("WIFI %s is connected successfully." % wifi) |
| return True |
| |
| def _setup_wfc(self): |
| if not set_wfc_mode(self.log, self.ad, WFC_MODE_WIFI_PREFERRED): |
| self.log.error("Phone failed to enable Wifi-Calling.") |
| return False |
| self.log.info("Phone is set in Wifi-Calling successfully.") |
| if not phone_idle_iwlan(self.log, self.ad): |
| self.log.error("DUT not in WFC enabled state.") |
| return False |
| return True |
| |
| def _setup_lte_volte_enabled(self): |
| if not phone_setup_volte(self.log, self.ad): |
| self.log.error("Phone failed to enable VoLTE.") |
| return False |
| self.log.info("VOLTE is enabled successfully.") |
| return True |
| |
| def _setup_lte_volte_disabled(self): |
| if not phone_setup_csfb(self.log, self.ad): |
| self.log.error("Phone failed to setup CSFB.") |
| return False |
| self.log.info("VOLTE is disabled successfully.") |
| return True |
| |
| def _setup_3g(self): |
| if not phone_setup_voice_3g(self.log, self.ad): |
| self.log.error("Phone failed to setup 3g.") |
| return False |
| self.log.info("RAT 3G is enabled successfully.") |
| return True |
| |
| def _setup_2g(self): |
| if not phone_setup_voice_2g(self.log, self.ad): |
| self.log.error("Phone failed to setup 2g.") |
| return False |
| self.log.info("RAT 2G is enabled successfully.") |
| return True |
| |
| def _setup_rat(self, rat, volte): |
| if rat == RAT_3G: |
| return self._setup_3g() |
| elif rat == RAT_2G: |
| return self._setup_2g() |
| elif rat == RAT_LTE and volte: |
| return self._setup_lte_volte_enabled() |
| elif rat == RAT_LTE and not volte: |
| return self._setup_lte_volte_disabled() |
| |
| def _start_alarm(self): |
| # TODO: This one works with a temporary SL4A API to start alarm. |
| # https://googleplex-android-review.git.corp.google.com/#/c/1562684/ |
| # simulate normal user behavior -- wake up every 1 minutes and do ping |
| # (transmit data) |
| try: |
| alarm_id = self.ad.droid.telephonyStartRecurringAlarm( |
| WAKEUP_PING_TEST_NUMBER_OF_ALARM, |
| 1000 * WAKEUP_PING_TEST_WAKEUP_FREQ, "PING_GOOGLE", None) |
| except: |
| self.log.error("Failed to setup periodic ping.") |
| return False |
| if alarm_id is None: |
| self.log.error("Start alarm for periodic ping failed.") |
| return False |
| self.log.info("Set up periodic ping successfully.") |
| return True |
| |
| def _setup_phone_active_call(self): |
| if not call_setup_teardown( |
| self.log, self.ad, self.android_devices[1], ad_hangup=None): |
| self.log.error("Setup Call failed.") |
| return False |
| self.log.info("Setup active call successfully.") |
| return True |
| |
| def _test_setup(self, |
| apm=False, |
| rat=None, |
| volte=False, |
| wifi=None, |
| wfc=False, |
| mobile_data_always_on=False, |
| periodic_ping=False, |
| active_call=False): |
| if not ensure_phones_default_state(self.log, self.android_devices): |
| self.log.error("Fail to set phones in default state") |
| return False |
| else: |
| self.log.info("Set phones in default state successfully") |
| if apm and not self._setup_apm(): return False |
| if rat and not self._setup_rat(rat, volte): return False |
| if wifi and not self._setup_wifi(wifi): return False |
| if wfc and not self._setup_wfc(): return False |
| if mobile_data_always_on: set_mobile_data_always_on(self.ad, True) |
| if periodic_ping and not self._start_alarm(): return False |
| if active_call and not self._setup_phone_active_call(): return False |
| self.ad.droid.goToSleepNow() |
| return True |
| |
| def _power_test(self, phone_check_func_after_power_test=None, **kwargs): |
| # Test passing criteria can be defined in test config file with the |
| # maximum mA allowed for the test case in "pass_criteria"->test_name |
| # field. By default it will set to 999. |
| pass_criteria = self._get_pass_criteria(self.test_name) |
| bug_report = True |
| active_call = kwargs.get('active_call') |
| average_current = 0 |
| result = None |
| self.log.info("Test %s: %s" % (self.test_name, kwargs)) |
| if active_call: |
| sample_rate = ACTIVE_CALL_TEST_SAMPLING_RATE |
| sample_time = ACTIVE_CALL_TEST_SAMPLE_TIME |
| offset_time = ACTIVE_CALL_TEST_OFFSET_TIME |
| else: |
| sample_rate = IDLE_TEST_SAMPLING_RATE |
| sample_time = IDLE_TEST_SAMPLE_TIME |
| offset_time = IDLE_TEST_OFFSET_TIME |
| try: |
| if not self._test_setup(**kwargs): |
| self.log.error("DUT Failed to Set Up Properly.") |
| return False |
| |
| if ((phone_check_func_after_power_test is not None) and |
| (not phone_check_func_after_power_test( |
| self.log, self.android_devices[0]))): |
| self.log.error( |
| "Phone is not in correct status before power test.") |
| return False |
| |
| result = self.mon.measure_power(sample_rate, sample_time, |
| self.test_id, offset_time) |
| average_current = result.average_current |
| if ((phone_check_func_after_power_test is not None) and |
| (not phone_check_func_after_power_test( |
| self.log, self.android_devices[0]))): |
| self.log.error( |
| "Phone is not in correct status after power test.") |
| return False |
| if active_call: |
| if not verify_incall_state(self.log, [ |
| self.android_devices[0], self.android_devices[1] |
| ], True): |
| self.log.error("Call drop during power test.") |
| return False |
| else: |
| hangup_call(self.log, self.android_devices[1]) |
| if (average_current <= pass_criteria): |
| bug_report = False |
| return True |
| finally: |
| self._save_logs_for_power_test(result, bug_report) |
| self.log.info("{} Result: {} mA, pass criteria: {} mA".format( |
| self.test_id, average_current, pass_criteria)) |
| |
| def _get_pass_criteria(self, test_name): |
| """Get the test passing criteria. |
| Test passing criteria can be defined in test config file with the |
| maximum mA allowed for the test case in "pass_criteria"->test_name |
| field. By default it will set to 999. |
| """ |
| try: |
| pass_criteria = int(self.user_params["pass_criteria"][test_name]) |
| except KeyError: |
| pass_criteria = DEFAULT_POWER_PASS_CRITERIA |
| return pass_criteria |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_volte(self): |
| """Power measurement test for active VoLTE call. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in VoLTE call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_volte) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_3g(self): |
| """Power measurement test for active CS(3G) call. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in CS(3G) call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_3g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_2g(self): |
| """Power measurement test for active CS(2G) call. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in CS(2G) call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_2g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_wifi2g_apm(self): |
| """Power measurement test for active WiFi call. |
| |
| Steps: |
| 1. DUT idle, in Airplane mode, connect to 2G WiFi, |
| WiFi Calling enabled (WiFi-preferred mode). |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in WFC call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| apm=True, |
| wifi=WIFI_2G, |
| wfc=True, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_wifi2g_lte_volte_enabled(self): |
| """Power measurement test for active WiFi call. |
| |
| Steps: |
| 1. DUT idle, LTE cellular data network, VoLTE is On, connect to 2G WiFi, |
| WiFi Calling enabled (WiFi-preferred). |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in WFC call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| wifi=WIFI_2G, |
| wfc=True, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_wifi5g_apm(self): |
| """Power measurement test for active WiFi call. |
| |
| Steps: |
| 1. DUT idle, in Airplane mode, connect to 5G WiFi, |
| WiFi Calling enabled (WiFi-preferred mode). |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in WFC call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| apm=True, |
| wifi=WIFI_5G, |
| wfc=True, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_wifi5g_lte_volte_enabled(self): |
| """Power measurement test for active WiFi call. |
| |
| Steps: |
| 1. DUT idle, LTE cellular data network, VoLTE is On, connect to 5G WiFi, |
| WiFi Calling enabled (WiFi-preferred). |
| 2. Make a phone Call from DUT to PhoneB. Answer on PhoneB. |
| Make sure DUT is in WFC call. |
| 3. Turn off screen and wait for 3 minutes. |
| Then measure power consumption for 5 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| wifi=WIFI_5G, |
| wfc=True, |
| active_call=True, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_baseline(self): |
| """Power measurement test for phone idle baseline. |
| |
| Steps: |
| 1. DUT idle, in Airplane mode. WiFi disabled, WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test(apm=True) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_baseline_wifi2g_connected(self): |
| """Power measurement test for phone idle baseline (WiFi connected). |
| |
| Steps: |
| 1. DUT idle, in Airplane mode. WiFi connected to 2.4G WiFi, |
| WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test(apm=True, wifi=WIFI_2G) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_wfc_wifi2g_apm(self): |
| """Power measurement test for phone idle WiFi Calling Airplane Mode. |
| |
| Steps: |
| 1. DUT idle, in Airplane mode. Connected to 2G WiFi, |
| WiFi Calling enabled (WiFi preferred). |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| apm=True, |
| wifi=WIFI_2G, |
| wfc=True, |
| phone_check_func_after_power_test=phone_idle_iwlan) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_wfc_wifi2g_lte_volte_enabled(self): |
| """Power measurement test for phone idle WiFi Calling LTE VoLTE enabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. Connected to 2G WiFi, |
| WiFi Calling enabled (WiFi preferred). |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| wifi=WIFI_2G, |
| wfc=True, |
| phone_check_func_after_power_test=phone_idle_iwlan) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled(self): |
| """Power measurement test for phone idle LTE VoLTE enabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| phone_check_func_after_power_test=phone_idle_volte) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled_wifi2g(self): |
| """Power measurement test for phone idle LTE VoLTE enabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi enabled, |
| WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| wifi=WIFI_2G, |
| phone_check_func_after_power_test=phone_idle_volte) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_disabled(self): |
| """Power measurement test for phone idle LTE VoLTE disabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE disabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test(rat=RAT_LTE) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, phone_check_func_after_power_test=phone_idle_3g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g_wifi2g(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi enabled, WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| wifi=WIFI_2G, |
| phone_check_func_after_power_test=phone_idle_3g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_2g(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, phone_check_func_after_power_test=phone_idle_2g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_2g_wifi2g(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, |
| wifi=WIFI_2G, |
| phone_check_func_after_power_test=phone_idle_2g) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled_wakeup_ping(self): |
| """Power measurement test for phone LTE VoLTE enabled Wakeup Ping every |
| 1 minute. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_iwlan) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_disabled_wakeup_ping(self): |
| """Power measurement test for phone LTE VoLTE disabled Wakeup Ping every |
| 1 minute. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE disabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test(rat=RAT_LTE, periodic_ping=True) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g_wakeup_ping(self): |
| """Power measurement test for phone 3G Wakeup Ping every 1 minute. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_3g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled_mobile_data_always_on(self): |
| """Power measurement test for phone idle LTE VoLTE enabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| mobile_data_always_on=True, |
| phone_check_func_after_power_test=phone_idle_volte) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled_wifi2g_mobile_data_always_on(self): |
| """Power measurement test for phone idle LTE VoLTE enabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi enabled, |
| WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| wifi=WIFI_2G, |
| mobile_data_always_on=True, |
| phone_check_func_after_power_test=phone_idle_volte) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_disabled_mobile_data_always_on(self): |
| """Power measurement test for phone idle LTE VoLTE disabled. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE disabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test(rat=RAT_LTE, mobile_data_always_on=True) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g_mobile_data_always_on(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| mobile_data_always_on=True, |
| phone_check_func_after_power_test=phone_idle_3g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g_wifi2g_mobile_data_always_on(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi enabled, WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| wifi=WIFI_2G, |
| mobile_data_always_on=True, |
| phone_check_func_after_power_test=phone_idle_3g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_2g_mobile_data_always_on(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, |
| mobile_data_always_on=True, |
| phone_check_func_after_power_test=phone_idle_2g) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_2g_wifi2g_mobile_data_always_on(self): |
| """Power measurement test for phone idle 3G. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. WiFi enabled, WiFi Calling disabled. |
| 2. Turn on mobile data always on |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, |
| wifi=WIFI_2G, |
| mobile_data_always_on=True, |
| phone_check_func_after_power_test=phone_idle_2g) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled_wakeup_ping_mobile_data_always_on( |
| self): |
| """Power measurement test for phone LTE VoLTE enabled Wakeup Ping every |
| 1 minute. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| mobile_data_always_on=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_volte) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_enabled_wifi2g_wakeup_ping_mobile_data_always_on( |
| self): |
| """Power measurement test for phone LTE VoLTE enabled Wakeup Ping every |
| 1 minute. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE enabled. WiFi enabled, |
| WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, |
| volte=True, |
| wifi=WIFI_2G, |
| mobile_data_always_on=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_volte) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_lte_volte_disabled_wakeup_ping_mobile_data_always_on( |
| self): |
| """Power measurement test for phone LTE VoLTE disabled Wakeup Ping every |
| 1 minute. |
| |
| Steps: |
| 1. DUT idle, in LTE mode, VoLTE disabled. WiFi disabled, |
| WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_LTE, mobile_data_always_on=True, periodic_ping=True) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g_wakeup_ping_mobile_data_always_on(self): |
| """Power measurement test for phone 3G Wakeup Ping every 1 minute. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| mobile_data_always_on=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_3g) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_3g_wifi2g_wakeup_ping_mobile_data_always_on(self): |
| """Power measurement test for phone 3G Wakeup Ping every 1 minute. |
| |
| Steps: |
| 1. DUT idle, in 3G mode. WiFi enabled, WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_3G, |
| wifi=WIFI_2G, |
| mobile_data_always_on=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_3g) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_2g_wakeup_ping_mobile_data_always_on(self): |
| """Power measurement test for phone 3G Wakeup Ping every 1 minute. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. WiFi disabled, WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, |
| mobile_data_always_on=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_2g) |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_2g_wifi2g_wakeup_ping_mobile_data_always_on(self): |
| """Power measurement test for phone 3G Wakeup Ping every 1 minute. |
| |
| Steps: |
| 1. DUT idle, in 2G mode. WiFi enabled, WiFi Calling disabled. |
| 2. Start script to wake up AP every 1 minute, after wakeup, |
| DUT send http Request to Google.com then go to sleep. |
| 3. Turn off screen and wait for 6 minutes. Then measure power |
| consumption for 40 minutes and get average. |
| |
| Expected Results: |
| Average power consumption should be within pre-defined limit. |
| |
| Returns: |
| True if Pass, False if Fail. |
| |
| Note: Please calibrate your test environment and baseline pass criteria. |
| Pass criteria info should be in test config file. |
| """ |
| return self._power_test( |
| rat=RAT_2G, |
| wifi=WIFI_2G, |
| mobile_data_always_on=True, |
| periodic_ping=True, |
| phone_check_func_after_power_test=phone_idle_2g) |
| |
