Fix the typo in setup_class.
am: aec1f27860
Change-Id: If35c6624a1455e95551c6a9cbca1a9671de15d0a
diff --git a/acts/framework/acts/controllers/android_device.py b/acts/framework/acts/controllers/android_device.py
index 4b2b431..4110a51 100644
--- a/acts/framework/acts/controllers/android_device.py
+++ b/acts/framework/acts/controllers/android_device.py
@@ -446,6 +446,26 @@
return info
@property
+ def build_info(self):
+ """Get the build info of this Android device, including build id and
+ build type.
+
+ This is not available if the device is in bootloader mode.
+
+ Returns:
+ A dict with the build info of this Android device, or None if the
+ device is in bootloader mode.
+ """
+ if self.is_bootloader:
+ return
+ info = {}
+ info["build_id"] = self.adb.shell("getprop ro.build.id").decode(
+ "utf-8").strip()
+ info["build_type"] = self.adb.shell("getprop ro.build.type").decode(
+ "utf-8").strip()
+ return info
+
+ @property
def is_bootloader(self):
"""True if the device is in bootloader mode.
"""
diff --git a/acts/framework/acts/records.py b/acts/framework/acts/records.py
index 94a3471..6cdf037 100644
--- a/acts/framework/acts/records.py
+++ b/acts/framework/acts/records.py
@@ -245,6 +245,16 @@
setattr(sum_result, name, l_value)
return sum_result
+ def add_controller_info(self, name, info):
+ try:
+ json.dumps(info)
+ except TypeError:
+ logging.warning(("Controller info for %s is not JSON serializable!"
+ " Coercing it to string.") % name)
+ self.controller_info[name] = str(info)
+ return
+ self.controller_info[name] = info
+
def add_record(self, record):
"""Adds a test record to test result.
@@ -341,6 +351,7 @@
A dictionary with the stats of this test result.
"""
d = {}
+ d["ControllerInfo"] = self.controller_info
d["Requested"] = len(self.requested)
d["Executed"] = len(self.executed)
d["Passed"] = len(self.passed)
diff --git a/acts/framework/acts/test_runner.py b/acts/framework/acts/test_runner.py
index f27ef2b..79e2451 100644
--- a/acts/framework/acts/test_runner.py
+++ b/acts/framework/acts/test_runner.py
@@ -302,7 +302,7 @@
attr))
if not getattr(module, attr):
raise signals.ControllerError(
- ("Controller interface %s in %s cannot be null.") % (
+ "Controller interface %s in %s cannot be null." % (
attr, module.__name__))
def register_controller(self, module, required=True):
@@ -410,7 +410,7 @@
# Implementation of "get_info" is optional for a controller module.
if hasattr(module, "get_info"):
controller_info = module.get_info(objects)
- logging.debug("Controller %s: %s", module_config_name,
+ self.log.info("Controller %s: %s", module_config_name,
controller_info)
self.results.add_controller_info(module_config_name,
controller_info)
diff --git a/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py b/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
index 40e967e..84449bf 100644
--- a/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
+++ b/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
@@ -199,6 +199,18 @@
for ad in self.android_devices:
setup_droid_properties(self.log, ad, sim_conf_file)
+ # Setup VoWiFi MDN for Verizon. b/33187374
+ build_id = ad.build_info["build_id"]
+ if "vzw" in [sub["operator"] for sub in ad.cfg[
+ "subscription"].values()] and ad.model in (
+ "marlin", "sailfish") and (build_id.startswith(
+ "N2") or build_id.startswith("OR")):
+ ad.log.info("setup VoWiFi MDN for MR2 or OC branch per b/33187374")
+ ad.adb.shell("setprop dbg.vzw.force_wfc_nv_enabled true")
+ ad.adb.shell("am start --ei EXTRA_LAUNCH_CARRIER_APP 0 -n "
+ "\"com.google.android.wfcactivation/"
+ ".VzwEmergencyAddressActivity\"")
+
# Ensure that a test class starts from a consistent state that
# improves chances of valid network selection and facilitates
# logging.
diff --git a/acts/tests/google/bt/BtBasicFunctionalityTest.py b/acts/tests/google/bt/BtBasicFunctionalityTest.py
index ab41358..7d89867 100644
--- a/acts/tests/google/bt/BtBasicFunctionalityTest.py
+++ b/acts/tests/google/bt/BtBasicFunctionalityTest.py
@@ -25,7 +25,6 @@
from acts.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest
from acts.test_utils.bt.BtEnum import BluetoothScanModeType
from acts.test_utils.bt.bt_test_utils import check_device_supported_profiles
-from acts.test_utils.bt.bt_test_utils import log_energy_info
from acts.test_utils.bt.bt_test_utils import reset_bluetooth
from acts.test_utils.bt.bt_test_utils import set_device_name
from acts.test_utils.bt.bt_test_utils import set_bt_scan_mode
@@ -46,13 +45,11 @@
return setup_multiple_devices_for_bt_test(self.android_devices)
def setup_test(self):
- self.log.debug(log_energy_info(self.android_devices, "Start"))
for a in self.android_devices:
a.ed.clear_all_events()
return True
def teardown_test(self):
- self.log.debug(log_energy_info(self.android_devices, "End"))
return True
def on_fail(self, test_name, begin_time):
diff --git a/acts/tests/google/tel/live/TelLiveDataTest.py b/acts/tests/google/tel/live/TelLiveDataTest.py
index 2cef056..0bebcd2 100644
--- a/acts/tests/google/tel/live/TelLiveDataTest.py
+++ b/acts/tests/google/tel/live/TelLiveDataTest.py
@@ -100,58 +100,14 @@
class TelLiveDataTest(TelephonyBaseTest):
def __init__(self, controllers):
TelephonyBaseTest.__init__(self, controllers)
- self.tests = ("test_airplane_mode",
- "test_4g",
- "test_3g",
- "test_2g",
- "test_lte_wifi_switching",
- "test_wcdma_wifi_switching",
- "test_gsm_wifi_switching",
- "test_wifi_connect_disconnect",
- "test_lte_multi_bearer",
- "test_wcdma_multi_bearer",
- "test_2g_wifi_not_associated",
- "test_3g_wifi_not_associated",
- "test_4g_wifi_not_associated",
- # WiFi Tethering tests
- "test_tethering_entitlement_check",
- "test_tethering_2g_to_2gwifi",
- "test_tethering_2g_to_5gwifi",
- "test_tethering_3g_to_5gwifi",
- "test_tethering_3g_to_2gwifi",
- "test_tethering_4g_to_5gwifi",
- "test_tethering_4g_to_2gwifi",
- "test_tethering_4g_to_2gwifi_2clients",
- "test_toggle_apm_during_active_wifi_tethering",
- "test_toggle_data_during_active_wifi_tethering",
- "test_disable_wifi_tethering_resume_connected_wifi",
- "test_tethering_wifi_ssid_quotes",
- "test_tethering_wifi_no_password",
- "test_tethering_wifi_password_escaping_characters",
- "test_tethering_wifi_ssid",
- "test_tethering_wifi_password",
- "test_tethering_wifi_volte_call",
- "test_tethering_wifi_csfb_call",
- "test_tethering_wifi_3g_call",
- "test_tethering_wifi_reboot",
- "test_connect_wifi_start_tethering_wifi_reboot",
- "test_connect_wifi_reboot_start_tethering_wifi",
- "test_tethering_wifi_screen_off_enable_doze_mode",
-
- # stress tests
- "test_4g_stress",
- "test_3g_stress",
- "test_lte_multi_bearer_stress",
- "test_wcdma_multi_bearer_stress",
- "test_tethering_4g_to_2gwifi_stress", )
self.stress_test_number = self.get_stress_test_number()
- self.wifi_network_ssid = self.user_params["wifi_network_ssid"]
-
- try:
- self.wifi_network_pass = self.user_params["wifi_network_pass"]
- except KeyError:
- self.wifi_network_pass = None
+ self.wifi_network_ssid = self.user_params.get(
+ "wifi_network_ssid") or self.user_params.get(
+ "wifi_network_ssid_2g")
+ self.wifi_network_pass = self.user_params.get(
+ "wifi_network_pass") or self.user_params.get(
+ "wifi_network_pass_2g")
@TelephonyBaseTest.tel_test_wrap
def test_airplane_mode(self):
diff --git a/acts/tests/google/tel/live/TelLiveRebootStressTest.py b/acts/tests/google/tel/live/TelLiveRebootStressTest.py
index e0dcfd9..8c7462d 100644
--- a/acts/tests/google/tel/live/TelLiveRebootStressTest.py
+++ b/acts/tests/google/tel/live/TelLiveRebootStressTest.py
@@ -17,6 +17,7 @@
Test Script for Telephony Pre Check In Sanity
"""
+import collections
import time
from acts.controllers.sl4a_types import Sl4aNetworkInfo
from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
@@ -85,114 +86,135 @@
self.dut_model = get_model_name(self.dut)
self.dut_operator = get_operator_name(self.log, self.dut)
- def _check_provisioning(self, ad):
+ def _check_provisioning(self):
if (CAPABILITY_OMADM in device_capabilities[self.dut_model] and
CAPABILITY_OMADM in operator_capabilities[self.dut_operator]):
self.log.info("Check Provisioning bit")
- if not ad.droid.imsIsVolteProvisionedOnDevice():
+ if not self.dut.droid.imsIsVolteProvisionedOnDevice():
self.log.error("{}: VoLTE Not Provisioned on the Platform".
- format(ad.serial))
+ format(self.dut.serial))
return False
return True
- def _clear_provisioning(self, ad):
+ def _check_provision(self):
+ elapsed_time = 0
+ while (elapsed_time < MAX_WAIT_TIME_PROVISIONING):
+ if self._check_provisioning(self.dut):
+ return True
+ else:
+ time.sleep(CHECK_INTERVAL)
+ elapsed_time += CHECK_INTERVAL
+ self.log.error("Provisioning fail.")
+ return False
+
+ def _clear_provisioning(self):
if (CAPABILITY_OMADM in device_capabilities[self.dut_model] and
CAPABILITY_OMADM in operator_capabilities[self.dut_operator]):
self.log.info("Clear Provisioning bit")
- ad.droid.imsSetVolteProvisioning(False)
+ self.dut.droid.imsSetVolteProvisioning(False)
return True
- def _check_lte_data(self, ad):
+ def _check_call_setup_teardown(self):
+ if not call_setup_teardown(self.log, self.dut, self.ad_reference):
+ self.log.error("Phone Call Failed.")
+ return False
+ return True
+
+ def _check_lte_data(self):
self.log.info("Check LTE data.")
- if not phone_setup_csfb(self.log, ad):
+ if not phone_setup_csfb(self.log, self.dut):
self.log.error("Failed to setup LTE data.")
return False
- if not verify_http_connection(self.log, ad):
+ if not verify_http_connection(self.log, self.dut):
self.log.error("Data not available on cell.")
return False
return True
- def _check_volte(self, ad, ad_reference):
+ def _check_volte(self):
if (CAPABILITY_VOLTE in device_capabilities[self.dut_model] and
CAPABILITY_VOLTE in operator_capabilities[self.dut_operator]):
self.log.info("Check VoLTE")
- if not phone_setup_volte(self.log, ad):
+ if not phone_setup_volte(self.log, self.dut):
self.log.error("Failed to setup VoLTE.")
return False
- if not call_setup_teardown(self.log, ad, ad_reference, ad,
- is_phone_in_call_volte):
+ if not call_setup_teardown(self.log, self.dut, self.ad_reference,
+ self.dut, is_phone_in_call_volte):
self.log.error("VoLTE Call Failed.")
return False
- if not sms_send_receive_verify(self.log, ad, ad_reference,
+ if not sms_send_receive_verify(self.log, self.dut,
+ self.ad_reference,
[rand_ascii_str(50)]):
self.log.error("SMS failed")
return False
return True
- def _check_wfc(self, ad, ad_reference):
+ def _check_wfc(self):
if (CAPABILITY_WFC in device_capabilities[self.dut_model] and
CAPABILITY_WFC in operator_capabilities[self.dut_operator]):
self.log.info("Check WFC")
if not phone_setup_iwlan(
- self.log, ad, True, WFC_MODE_WIFI_PREFERRED,
+ self.log, self.dut, True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass):
self.log.error("Failed to setup WFC.")
return False
- if not call_setup_teardown(self.log, ad, ad_reference, ad,
- is_phone_in_call_iwlan):
+ if not call_setup_teardown(self.log, self.dut, self.ad_reference,
+ self.dut, is_phone_in_call_iwlan):
self.log.error("WFC Call Failed.")
return False
- if not sms_send_receive_verify(self.log, ad, ad_reference,
+ if not sms_send_receive_verify(self.log, self.dut,
+ self.ad_reference,
[rand_ascii_str(50)]):
self.log.error("SMS failed")
return False
return True
- def _check_3g(self, ad, ad_reference):
+ def _check_3g(self):
self.log.info("Check 3G data and CS call")
- if not phone_setup_voice_3g(self.log, ad):
+ if not phone_setup_voice_3g(self.log, self.dut):
self.log.error("Failed to setup 3G")
return False
- if not verify_http_connection(self.log, ad):
+ if not verify_http_connection(self.log, self.dut):
self.log.error("Data not available on cell.")
return False
- if not call_setup_teardown(self.log, ad, ad_reference, ad,
- is_phone_in_call_3g):
+ if not call_setup_teardown(self.log, self.dut, self.ad_reference,
+ self.dut, is_phone_in_call_3g):
self.log.error("WFC Call Failed.")
return False
- if not sms_send_receive_verify(self.log, ad, ad_reference,
+ if not sms_send_receive_verify(self.log, self.dut, self.ad_reference,
[rand_ascii_str(50)]):
self.log.error("SMS failed")
return False
return True
- def _check_tethering(self, ad, ad_reference):
+ def _check_tethering(self):
self.log.info("Check tethering")
- if not ad.droid.carrierConfigIsTetheringModeAllowed(
+ if not self.dut.droid.carrierConfigIsTetheringModeAllowed(
TETHERING_MODE_WIFI,
MAX_WAIT_TIME_TETHERING_ENTITLEMENT_CHECK):
self.log.error("Tethering Entitlement check failed.")
return False
if not wifi_tethering_setup_teardown(
- self.log, ad, [ad_reference], check_interval=5,
+ self.log,
+ self.dut, [self.ad_reference],
+ check_interval=5,
check_iteration=1):
self.log.error("Tethering Failed.")
return False
return True
- def _check_data_roaming_status(self, ad):
- if not ad.droid.telephonyIsDataEnabled():
+ def _check_data_roaming_status(self):
+ if not self.dut.droid.telephonyIsDataEnabled():
self.log.info("Enabling Cellular Data")
telephonyToggleDataConnection(True)
else:
self.log.info("Cell Data is Enabled")
self.log.info("Waiting for cellular data to be connected")
- if not wait_for_cell_data_connection(self.log, ad, state=True):
+ if not wait_for_cell_data_connection(self.log, self.dut, state=True):
self.log.error("Failed to enable cell data")
return False
self.log.info("Cellular data connected, checking NetworkInfos")
- roaming_state = ad.droid.telephonyCheckNetworkRoaming()
- for network_info in ad.droid.connectivityNetworkGetAllInfo():
+ roaming_state = self.dut.droid.telephonyCheckNetworkRoaming()
+ for network_info in self.dut.droid.connectivityNetworkGetAllInfo():
sl4a_network_info = Sl4aNetworkInfo.from_dict(network_info)
if sl4a_network_info.isRoaming:
self.log.warning("We don't expect to be roaming")
@@ -204,6 +226,80 @@
return False
return True
+ def _reboot_stress_test(self, **kwargs):
+ """Reboot Reliability Test
+
+ Arguments:
+ check_provision: whether to check provisioning after reboot.
+ check_call_setup_teardown: whether to check setup and teardown a call.
+ check_lte_data: whether to check the LTE data.
+ check_volte: whether to check Voice over LTE.
+ check_wfc: whether to check Wifi Calling.
+ check_3g: whether to check 3G.
+ check_tethering: whether to check Tethering.
+ check_data_roaming: whether to check Data Roaming.
+ clear_provision: whether to clear provisioning before reboot.
+
+ Expected Results:
+ No crash happens in stress test.
+
+ Returns:
+ True is pass, False if fail.
+ """
+ CHECK_INTERVAL = 10
+
+ toggle_airplane_mode(self.log, self.dut, False)
+ phone_setup_voice_general(self.log, self.ad_reference)
+ fail_count = collections.defaultdict(int)
+ test_result = True
+ test_method_mapping = {
+ "check_provision": self._check_provision,
+ "check_call_setup_teardown": self._check_call_setup_teardown,
+ "check_lte_data": self._check_lte_data,
+ "check_volte": self._check_volte,
+ "check_wfc": self._check_wfc,
+ "check_3g": self._check_3g,
+ "check_tethering": self._check_tethering,
+ "check_data_roaming": self._check_data_roaming_status,
+ "clear_provision": self._clear_provisioning
+ }
+ for kwarg in kwargs:
+ if kwarg not in test_method_mapping:
+ self.log.error("method %s is not supported" % method)
+
+ required_methods = []
+ for method in ("check_provistion", "check_call_setup_teardown",
+ "check_lte_data", "check_volte", "check_wfc",
+ "check_3g", "check_tethering", "check_data_roaming",
+ "clear_provion"):
+ if method in kwargs: required_methods.append(method)
+
+ for i in range(1, self.stress_test_number + 1):
+ self.log.info("Reboot Stress Test {} Iteration: <{}> / <{}>".format(
+ self.test_name, i, self.stress_test_number))
+
+ self.log.info("{} reboot!".format(self.dut.serial))
+ self.dut.reboot()
+ self.log.info("{} wait {}s for radio up.".format(
+ self.dut.serial, WAIT_TIME_AFTER_REBOOT))
+ time.sleep(WAIT_TIME_AFTER_REBOOT)
+ iteration_result = "pass"
+ for check in required_methods:
+ if not test_method_mapping[check]():
+ fail_count[check] += 1
+ iteration_result = "fail"
+ self.log.info("Reboot Stress Test {} Iteration: <{}> / <{}> {}".format(
+ self.test_name, i, self.stress_test_number, iteration_result))
+
+ # TODO: Check if crash happens.
+
+ for failure, count in fail_count.items():
+ if count:
+ self.log.error("{} {} failures in {} iterations".format(
+ count, failure, self.stress_test_number))
+ test_result = False
+ return test_result
+
""" Tests Begin """
@TelephonyBaseTest.tel_test_wrap
@@ -233,62 +329,16 @@
Returns:
True is pass, False if fail.
"""
- CHECK_INTERVAL = 10
-
- toggle_airplane_mode(self.log, self.dut, False)
- phone_setup_voice_general(self.log, self.ad_reference)
-
- for i in range(1, self.stress_test_number + 1):
- self.log.info("Reboot Stress Test Iteration: <{}> / <{}>".format(
- i, self.stress_test_number))
-
- self.log.info("{} reboot!".format(self.dut.serial))
- self.dut.reboot()
- self.log.info("{} wait {}s for radio up.".format(
- self.dut.serial, WAIT_TIME_AFTER_REBOOT))
- time.sleep(WAIT_TIME_AFTER_REBOOT)
-
- elapsed_time = 0
- provisioned = False
- while (elapsed_time < MAX_WAIT_TIME_PROVISIONING):
- if self._check_provisioning(self.dut):
- provisioned = True
- break
- else:
- time.sleep(CHECK_INTERVAL)
- elapsed_time += CHECK_INTERVAL
- if not provisioned:
- self.log.error("Provisioning fail.")
- return False
-
- if not self._check_lte_data(self.dut):
- self.log.error("LTE Data fail.")
- return False
-
- if not self._check_volte(self.dut, self.ad_reference):
- self.log.error("VoLTE fail.")
- return False
-
- if not self._check_wfc(self.dut, self.ad_reference):
- self.log.error("WFC fail.")
- return False
-
- if not self._check_3g(self.dut, self.ad_reference):
- self.log.error("3G fail.")
- return False
-
- if not self._check_tethering(self.dut, self.ad_reference):
- self.log.error("Tethering fail.")
- return False
-
- self._clear_provisioning(self.dut)
-
- # TODO: Check if crash happens.
-
- self.log.info("Iteration: <{}> / <{}> Pass".format(
- i, self.stress_test_number))
-
- return True
+ return self._reboot_stress_test(
+ check_provision=True,
+ check_call_setup_teardown=True,
+ check_lte_data=True,
+ check_volte=True,
+ check_wfc=True,
+ check_3g=True,
+ check_tethering=True,
+ check_data_roaming=False,
+ clear_provision=True)
@TelephonyBaseTest.tel_test_wrap
def test_reboot_stress_without_clear_provisioning(self):
@@ -316,53 +366,38 @@
Returns:
True is pass, False if fail.
"""
-
- toggle_airplane_mode(self.log, self.dut, False)
- phone_setup_voice_general(self.log, self.ad_reference)
-
- for i in range(1, self.stress_test_number + 1):
- self.log.info("Reboot Stress Test Iteration: <{}> / <{}>".format(
- i, self.stress_test_number))
-
- self.log.info("{} reboot!".format(self.dut.serial))
- self.dut.reboot()
- self.log.info("{} wait {}s for radio up.".format(
- self.dut.serial, WAIT_TIME_AFTER_REBOOT))
- time.sleep(WAIT_TIME_AFTER_REBOOT)
-
- if not self._check_provisioning(self.dut):
- self.log.error("Provisioning fail.")
- return False
-
- if not self._check_lte_data(self.dut):
- self.log.error("LTE Data fail.")
- return False
-
- if not self._check_volte(self.dut, self.ad_reference):
- self.log.error("VoLTE fail.")
- return False
-
- if not self._check_wfc(self.dut, self.ad_reference):
- self.log.error("WFC fail.")
- return False
-
- if not self._check_3g(self.dut, self.ad_reference):
- self.log.error("3G fail.")
- return False
-
- if not self._check_tethering(self.dut, self.ad_reference):
- self.log.error("Tethering fail.")
- return False
-
- # TODO: Check if crash happens.
-
- self.log.info("Iteration: <{}> / <{}> Pass".format(
- i, self.stress_test_number))
-
- return True
+ return self._reboot_stress_test(
+ check_provision=True,
+ check_call_setup_teardown=True,
+ check_lte_data=True,
+ check_volte=True,
+ check_wfc=True,
+ check_3g=True,
+ check_tethering=True,
+ check_data_roaming=False,
+ clear_provision=False)
@TelephonyBaseTest.tel_test_wrap
- def test_data_roaming_stress(self):
+ def test_reboot_stress_check_phone_call_only(self):
+ """Reboot Reliability Test
+
+ Steps:
+ 1. Reboot DUT.
+ 2. Check phone call .
+ 3. Check crashes.
+ 4. Repeat Step 1~9 for N times. (before reboot, clear Provisioning
+ bit if provisioning is supported)
+
+ Expected Results:
+ No crash happens in stress test.
+
+ Returns:
+ True is pass, False if fail.
+ """
+ return self._stress_test(check_provision=True, check_call_setup_teardown=True)
+
+ @TelephonyBaseTest.tel_test_wrap
+ def test_reboot_stress_data_roaming(self):
"""Reboot Reliability Test
Steps:
@@ -378,24 +413,8 @@
Returns:
True is pass, False if fail.
"""
- for i in range(1, self.stress_test_number + 1):
- self.log.info("Reboot Stress Test Iteration: <{}> / <{}>".format(
- i, self.stress_test_number))
-
- self.log.info("{} reboot!".format(self.dut.serial))
- self.dut.reboot()
- self.log.info("{} wait {}s for radio up.".format(
- self.dut.serial, WAIT_TIME_AFTER_REBOOT))
- time.sleep(WAIT_TIME_AFTER_REBOOT)
-
- if not self._check_data_roaming_status(self.dut):
- self.log.error("Something wrong with the data connection!")
- return False
-
- self.log.info("Iteration: <{}> / <{}> Pass".format(
- i, self.stress_test_number))
-
- return True
+ return self._reboot_stress_test(check_data_roaming=True)
""" Tests End """
+
diff --git a/acts/tests/google/tel/live/TelPowerTest.py b/acts/tests/google/tel/live/TelPowerTest.py
index ffd9d23..e5543f1 100644
--- a/acts/tests/google/tel/live/TelPowerTest.py
+++ b/acts/tests/google/tel/live/TelPowerTest.py
@@ -19,26 +19,28 @@
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_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_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_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.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
@@ -70,6 +72,14 @@
# 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
@@ -89,6 +99,7 @@
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)
@@ -106,213 +117,201 @@
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:
+ 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, file_name))
- if "bug_report_for_power_test" in self.user_params:
- self.android_devices[0].take_bug_report(test_name, current_time)
+ 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 _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.")
+ 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_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__))
+ 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
- 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.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
- 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.
+ 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
- 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.
+ 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
- Expected Results:
- Average power consumption should be within pre-defined limit.
+ 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
- Returns:
- True if Pass, False if Fail.
+ 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
- Note: Please calibrate your test environment and baseline pass criteria.
- Pass criteria info should be in test config file.
+ 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_call_3g"][
- "pass_criteria"])
+ pass_criteria = int(self.user_params["pass_criteria"][test_name])
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)
+ pass_criteria = DEFAULT_POWER_PASS_CRITERIA
+ return pass_criteria
@TelephonyBaseTest.tel_test_wrap
def test_power_active_call_volte(self):
@@ -334,23 +333,64 @@
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)
+ 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_wfc_2g_apm(self):
+ 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:
@@ -370,25 +410,15 @@
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)
+ 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_2g_lte_volte_on(self):
+ def test_power_active_call_wfc_wifi2g_lte_volte_enabled(self):
"""Power measurement test for active WiFi call.
Steps:
@@ -408,25 +438,16 @@
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)
+ 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_5g_apm(self):
+ def test_power_active_call_wfc_wifi5g_apm(self):
"""Power measurement test for active WiFi call.
Steps:
@@ -446,25 +467,15 @@
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)
+ 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_5g_lte_volte_on(self):
+ def test_power_active_call_wfc_wifi5g_lte_volte_enabled(self):
"""Power measurement test for active WiFi call.
Steps:
@@ -484,23 +495,13 @@
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)
+ 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):
@@ -520,24 +521,10 @@
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)
+ return self._power_test(apm=True)
@TelephonyBaseTest.tel_test_wrap
- def test_power_idle_baseline_wifi_connected(self):
+ def test_power_idle_baseline_wifi2g_connected(self):
"""Power measurement test for phone idle baseline (WiFi connected).
Steps:
@@ -555,30 +542,10 @@
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)
+ return self._power_test(apm=True, wifi=WIFI_2G)
@TelephonyBaseTest.tel_test_wrap
- def test_power_idle_wfc_2g_apm(self):
+ def test_power_idle_wfc_wifi2g_apm(self):
"""Power measurement test for phone idle WiFi Calling Airplane Mode.
Steps:
@@ -596,27 +563,14 @@
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)
+ 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_2g_lte(self):
+ def test_power_idle_wfc_wifi2g_lte_volte_enabled(self):
"""Power measurement test for phone idle WiFi Calling LTE VoLTE enabled.
Steps:
@@ -634,27 +588,12 @@
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)
+ 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):
@@ -675,21 +614,35 @@
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
+ return self._power_test(
+ rat=RAT_LTE,
+ volte=True,
+ phone_check_func_after_power_test=phone_idle_volte)
- 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
+ @TelephonyBaseTest.tel_test_wrap
+ def test_power_idle_lte_volte_enabled_wifi2g(self):
+ """Power measurement test for phone idle LTE VoLTE enabled.
- return self._test_power_idle("test_power_idle_lte_volte_enabled",
- _idle_lte_volte_enabled, PASS_CRITERIA)
+ 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):
@@ -710,21 +663,7 @@
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)
+ return self._power_test(rat=RAT_LTE)
@TelephonyBaseTest.tel_test_wrap
def test_power_idle_3g(self):
@@ -744,21 +683,75 @@
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
+ return self._power_test(
+ rat=RAT_3G, phone_check_func_after_power_test=phone_idle_3g)
- 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
+ @TelephonyBaseTest.tel_test_wrap
+ def test_power_idle_3g_wifi2g(self):
+ """Power measurement test for phone idle 3G.
- return self._test_power_idle("test_power_idle_3g", _idle_3g,
- PASS_CRITERIA)
+ 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
@@ -783,20 +776,11 @@
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
+ 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
@@ -821,20 +805,7 @@
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
+ 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
@@ -857,164 +828,381 @@
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.
+ return self._power_test(
+ rat=RAT_3G,
+ periodic_ping=True,
+ phone_check_func_after_power_test=phone_idle_3g)
- 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
+ @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_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
+ 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_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
+ 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_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
+ 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_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
+ 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_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
+ 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_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
+ 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_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
+ def test_power_idle_2g_wifi2g_wakeup_ping_mobile_data_always_on(self):
+ """Power measurement test for phone 3G Wakeup Ping every 1 minute.
- # 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
+ 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)
+