| #!/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_phone_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 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_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_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_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_csfb |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_iwlan |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_volte |
| from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_general |
| 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 |
| |
| # 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] |
| 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, test_name, monsoon_result): |
| current_time = get_current_human_time() |
| file_name = "{}_{}".format(test_name, current_time) |
| if "monsoon_log_for_power_test" in self.user_params: |
| monsoon_result.save_to_text_file( |
| [monsoon_result], |
| os.path.join(self.monsoon_log_path, file_name)) |
| if "bug_report_for_power_test" in self.user_params: |
| self.android_devices[0].take_bug_report(test_name, current_time) |
| |
| def _test_power_active_call(self, |
| test_name, |
| test_setup_func, |
| pass_criteria=DEFAULT_POWER_PASS_CRITERIA, |
| phone_check_func_after_power_test=None, |
| *args, |
| **kwargs): |
| average_current = 0 |
| try: |
| ensure_phone_default_state(self.log, self.android_devices[0]) |
| ensure_phone_default_state(self.log, self.android_devices[1]) |
| if not phone_setup_voice_general(self.log, |
| self.android_devices[1]): |
| self.log.error("PhoneB Failed to Set Up Properly.") |
| return False |
| if not test_setup_func(self.android_devices[0], *args, **kwargs): |
| self.log.error("DUT Failed to Set Up Properly.") |
| return False |
| result = self.mon.measure_power( |
| ACTIVE_CALL_TEST_SAMPLING_RATE, ACTIVE_CALL_TEST_SAMPLE_TIME, |
| test_name, ACTIVE_CALL_TEST_OFFSET_TIME) |
| self._save_logs_for_power_test(test_name, result) |
| average_current = result.average_current |
| 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 |
| 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 |
| return (average_current <= pass_criteria) |
| finally: |
| hangup_call(self.log, self.android_devices[1]) |
| self.log.info("Result: {} mA, pass criteria: {} mA".format( |
| average_current, pass_criteria)) |
| |
| def _test_power_idle(self, |
| test_name, |
| test_setup_func, |
| pass_criteria=DEFAULT_POWER_PASS_CRITERIA, |
| phone_check_func_after_power_test=None, |
| *args, |
| **kwargs): |
| average_current = 0 |
| try: |
| ensure_phone_default_state(self.log, self.android_devices[0]) |
| if not test_setup_func(self.android_devices[0], *args, **kwargs): |
| self.log.error("DUT Failed to Set Up Properly.") |
| return False |
| result = self.mon.measure_power(IDLE_TEST_SAMPLING_RATE, |
| IDLE_TEST_SAMPLE_TIME, test_name, |
| IDLE_TEST_OFFSET_TIME) |
| self._save_logs_for_power_test(test_name, result) |
| 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 |
| return (average_current <= pass_criteria) |
| finally: |
| self.log.info("Result: {} mA, pass criteria: {} mA".format( |
| average_current, pass_criteria)) |
| |
| def _start_alarm(self): |
| alarm_id = self.ad.droid.phoneStartRecurringAlarm( |
| WAKEUP_PING_TEST_NUMBER_OF_ALARM, |
| 1000 * WAKEUP_PING_TEST_WAKEUP_FREQ, "PING_GOOGLE", None) |
| if alarm_id is None: |
| self.log.error("Start alarm failed.") |
| return False |
| return True |
| |
| def _setup_phone_idle_and_wakeup_ping(self, ad, phone_setup_func): |
| if not phone_setup_func(self.log, ad): |
| self.log.error("Phone failed to setup {}.".format( |
| phone_setup_func.__name__)) |
| return False |
| if not self._start_alarm(): |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| def _setup_phone_mobile_data_always_on(self, |
| ad, |
| phone_setup_func, |
| connect_wifi, |
| wifi_ssid=None, |
| wifi_password=None, |
| mobile_data_always_on=True): |
| set_mobile_data_always_on(ad, mobile_data_always_on) |
| if not phone_setup_func(self.log, ad): |
| self.log.error("Phone failed to setup {}.".format( |
| phone_setup_func.__name__)) |
| return False |
| if (connect_wifi and not ensure_wifi_connected(self.log, ad, wifi_ssid, |
| wifi_password)): |
| self.log.error("WiFi connect failed") |
| return False |
| # simulate normal user behavior -- wake up every 1 minutes and do ping |
| # (transmit data) |
| if not self._start_alarm(): |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| def _setup_phone_active_call(self, ad, phone_setup_func, |
| phone_idle_check_func, |
| phone_in_call_check_func): |
| if not phone_setup_func(self.log, ad): |
| self.log.error("DUT Failed to Set Up Properly: {}".format( |
| phone_setup_func.__name__)) |
| return False |
| ensure_phones_idle(self.log, [ad, self.android_devices[1]]) |
| if not phone_idle_check_func(self.log, ad): |
| self.log.error("DUT not in correct idle state: {}".format( |
| phone_idle_check_func.__name__)) |
| return False |
| if not call_setup_teardown( |
| self.log, |
| ad, |
| self.android_devices[1], |
| ad_hangup=None, |
| verify_caller_func=phone_in_call_check_func): |
| self.log.error("Setup Call failed.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| def _setup_phone_active_call_wfc(self, |
| ad, |
| ssid, |
| password, |
| airplane_mode, |
| wfc_mode, |
| setup_volte=False): |
| if setup_volte and (not phone_setup_volte(self.log, ad)): |
| self.log.error("Phone failed to setup VoLTE.") |
| return False |
| if not phone_setup_iwlan(self.log, ad, airplane_mode, wfc_mode, ssid, |
| password): |
| self.log.error("DUT Failed to Set Up WiFi Calling") |
| return False |
| ensure_phones_idle(self.log, [ad, self.android_devices[1]]) |
| if not phone_idle_iwlan(self.log, ad): |
| self.log.error("DUT not in WFC enabled state.") |
| return False |
| if not call_setup_teardown( |
| self.log, |
| ad, |
| self.android_devices[1], |
| ad_hangup=None, |
| verify_caller_func=is_phone_in_call_iwlan): |
| self.log.error("Setup Call failed.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| @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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params["pass_criteria_call_3g"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| return self._test_power_active_call( |
| "test_power_active_call_3g", |
| self._setup_phone_active_call, |
| PASS_CRITERIA, |
| phone_check_func_after_power_test=is_phone_in_call_3g, |
| phone_setup_func=phone_setup_voice_3g, |
| phone_idle_check_func=phone_idle_3g, |
| phone_in_call_check_func=is_phone_in_call_3g) |
| |
| @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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params["pass_criteria_call_volte"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| return self._test_power_active_call( |
| "test_power_active_call_volte", |
| self._setup_phone_active_call, |
| PASS_CRITERIA, |
| phone_check_func_after_power_test=is_phone_in_call_volte, |
| phone_setup_func=phone_setup_volte, |
| phone_idle_check_func=phone_idle_volte, |
| phone_in_call_check_func=is_phone_in_call_volte) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_2g_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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_call_wfc_2g_apm"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| return self._test_power_active_call( |
| "test_power_active_call_wfc_2g_apm", |
| self._setup_phone_active_call_wfc, |
| PASS_CRITERIA, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan, |
| ssid=self.wifi_network_ssid_2g, |
| password=self.wifi_network_pass_2g, |
| airplane_mode=True, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED, |
| setup_volte=False) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_2g_lte_volte_on(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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_call_wfc_2g_lte_volte_on"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| return self._test_power_active_call( |
| "test_power_active_call_wfc_2g_lte_volte_on", |
| self._setup_phone_active_call_wfc, |
| PASS_CRITERIA, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan, |
| ssid=self.wifi_network_ssid_2g, |
| password=self.wifi_network_pass_2g, |
| airplane_mode=False, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED, |
| setup_volte=True) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_5g_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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_call_wfc_5g_apm"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| return self._test_power_active_call( |
| "test_power_active_call_wfc_5g_apm", |
| self._setup_phone_active_call_wfc, |
| PASS_CRITERIA, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan, |
| ssid=self.wifi_network_ssid_5g, |
| password=self.wifi_network_pass_5g, |
| airplane_mode=True, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED, |
| setup_volte=False) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_active_call_wfc_5g_lte_volte_on(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. |
| """ |
| |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_call_wfc_5g_lte_volte_on"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| return self._test_power_active_call( |
| "test_power_active_call_wfc_5g_lte_volte_on", |
| self._setup_phone_active_call_wfc, |
| PASS_CRITERIA, |
| phone_check_func_after_power_test=is_phone_in_call_iwlan, |
| ssid=self.wifi_network_ssid_5g, |
| password=self.wifi_network_pass_5g, |
| airplane_mode=False, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED, |
| setup_volte=True) |
| |
| @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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params["pass_criteria_idle_baseline"] |
| ["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_baseline(ad): |
| if not toggle_airplane_mode(self.log, ad, True): |
| self.log.error("Phone failed to turn on airplane mode.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_baseline", |
| _idle_baseline, PASS_CRITERIA) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_baseline_wifi_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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_baseline_wifi_connected"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_baseline_wifi_connected(ad): |
| if not toggle_airplane_mode(self.log, ad, True): |
| self.log.error("Phone failed to turn on airplane mode.") |
| return False |
| if not ensure_wifi_connected(self.log, ad, |
| self.wifi_network_ssid_2g, |
| self.wifi_network_pass_2g): |
| self.log.error("WiFi connect failed") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_baseline_wifi_connected", |
| _idle_baseline_wifi_connected, |
| PASS_CRITERIA) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_wfc_2g_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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_wfc_2g_apm"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_wfc_2g_apm(ad): |
| if not phone_setup_iwlan( |
| self.log, ad, True, WFC_MODE_WIFI_PREFERRED, |
| self.wifi_network_ssid_2g, self.wifi_network_pass_2g): |
| self.log.error("Phone failed to setup WFC.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_wfc_2g_apm", |
| _idle_wfc_2g_apm, PASS_CRITERIA, |
| is_wfc_enabled) |
| |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_idle_wfc_2g_lte(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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_wfc_2g_lte"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_wfc_2g_lte(ad): |
| if not phone_setup_volte(self.log, ad): |
| self.log.error("Phone failed to setup VoLTE.") |
| return False |
| if not phone_setup_iwlan( |
| self.log, ad, False, WFC_MODE_WIFI_PREFERRED, |
| self.wifi_network_ssid_2g, self.wifi_network_pass_2g): |
| self.log.error("Phone failed to setup WFC.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_wfc_2g_lte", |
| _idle_wfc_2g_lte, PASS_CRITERIA, |
| is_wfc_enabled) |
| |
| @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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_lte_volte_enabled"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_lte_volte_enabled(ad): |
| if not phone_setup_volte(self.log, ad): |
| self.log.error("Phone failed to setup VoLTE.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_lte_volte_enabled", |
| _idle_lte_volte_enabled, PASS_CRITERIA) |
| |
| @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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_lte_volte_disabled"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_lte_volte_disabled(ad): |
| if not phone_setup_csfb(self.log, ad): |
| self.log.error("Phone failed to setup CSFB.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_lte_volte_disabled", |
| _idle_lte_volte_disabled, PASS_CRITERIA) |
| |
| @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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params["pass_criteria_idle_3g"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| |
| def _idle_3g(ad): |
| if not phone_setup_voice_3g(self.log, ad): |
| self.log.error("Phone failed to setup 3g.") |
| return False |
| ad.droid.goToSleepNow() |
| return True |
| |
| return self._test_power_idle("test_power_idle_3g", _idle_3g, |
| PASS_CRITERIA) |
| |
| # 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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_lte_volte_enabled_wakeup_ping"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| # TODO: b/26338146 need a SL4A API to clear all existing alarms. |
| |
| result = self._test_power_idle( |
| "test_power_idle_lte_volte_enabled_wakeup_ping", |
| self._setup_phone_idle_and_wakeup_ping, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_volte) |
| return result |
| |
| # 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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_lte_volte_disabled_wakeup_ping"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| # TODO: b/26338146 need a SL4A API to clear all existing alarms. |
| |
| result = self._test_power_idle( |
| "test_power_idle_lte_volte_disabled_wakeup_ping", |
| self._setup_phone_idle_and_wakeup_ping, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_csfb) |
| return result |
| |
| # 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. |
| """ |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_idle_3g_wakeup_ping"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| # TODO: b/26338146 need a SL4A API to clear all existing alarms. |
| |
| result = self._test_power_idle( |
| "test_power_idle_3g_wakeup_ping", |
| self._setup_phone_idle_and_wakeup_ping, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_3g) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_lte(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_lte"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_lte", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_csfb, |
| connect_wifi=False) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_wcdma(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_wcdma"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_wcdma", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_3g, |
| connect_wifi=False) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_1xevdo(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_1xevdo"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_1xevdo", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_3g, |
| connect_wifi=False) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_gsm(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_gsm"]["pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_gsm", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_2g, |
| connect_wifi=False) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_lte_wifi_on(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_lte_wifi_on"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_lte_wifi_on", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_csfb, |
| connect_wifi=True, |
| wifi_ssid=self.wifi_network_ssid_2g, |
| wifi_password=self.wifi_network_pass_2g) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_wcdma_wifi_on(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_wcdma_wifi_on"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_wcdma_wifi_on", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_3g, |
| connect_wifi=True, |
| wifi_ssid=self.wifi_network_ssid_2g, |
| wifi_password=self.wifi_network_pass_2g) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_1xevdo_wifi_on(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_1xevdo_wifi_on"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_1xevdo_wifi_on", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_3g, |
| connect_wifi=True, |
| wifi_ssid=self.wifi_network_ssid_2g, |
| wifi_password=self.wifi_network_pass_2g) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
| |
| # TODO: This one is not working right now. Requires SL4A API to start alarm. |
| @TelephonyBaseTest.tel_test_wrap |
| def test_power_mobile_data_always_on_gsm_wifi_on(self): |
| try: |
| PASS_CRITERIA = int(self.user_params[ |
| "pass_criteria_mobile_data_always_on_gsm_wifi_on"][ |
| "pass_criteria"]) |
| except KeyError: |
| PASS_CRITERIA = DEFAULT_POWER_PASS_CRITERIA |
| result = self._test_power_idle( |
| "test_power_mobile_data_always_on_gsm_wifi_on", |
| self._setup_phone_mobile_data_always_on, |
| PASS_CRITERIA, |
| phone_setup_func=phone_setup_voice_2g, |
| connect_wifi=True, |
| wifi_ssid=self.wifi_network_ssid_2g, |
| wifi_password=self.wifi_network_pass_2g) |
| set_mobile_data_always_on(self.ad, False) |
| return result |
