605 lines
27 KiB
Python
605 lines
27 KiB
Python
#
|
|
# Copyright 2022 - 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 threading
|
|
import time
|
|
|
|
from acts import asserts
|
|
from acts import base_test
|
|
from acts import utils
|
|
from acts.controllers import adb
|
|
from acts.controllers.adb_lib.error import AdbError
|
|
from acts.controllers.ap_lib import hostapd_constants
|
|
from acts.test_decorators import test_tracker_info
|
|
from acts_contrib.test_utils.net import connectivity_const as cconst
|
|
from acts_contrib.test_utils.net import connectivity_test_utils as cutils
|
|
from acts_contrib.test_utils.net import net_test_utils as nutils
|
|
from acts_contrib.test_utils.net.net_test_utils import start_tcpdump
|
|
from acts_contrib.test_utils.net.net_test_utils import stop_tcpdump
|
|
from acts_contrib.test_utils.tel import tel_test_utils as ttutils
|
|
from acts_contrib.test_utils.tel.tel_test_utils import get_operator_name
|
|
from acts_contrib.test_utils.tel.tel_data_utils import http_file_download_by_chrome
|
|
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
|
|
import queue
|
|
from queue import Empty
|
|
|
|
|
|
conn_test_class = "com.android.tests.connectivity.uid.ConnectivityTestActivity"
|
|
android_os_class = "com.quicinc.cne.CNEService.CNEServiceApp"
|
|
instr_cmd = ("am instrument -w -e command grant-all "
|
|
"com.android.permissionutils/.PermissionInstrumentation")
|
|
|
|
HOUR_IN_MILLIS = 1000 * 60 * 60
|
|
BYTE_TO_MB_ANDROID = 1000.0 * 1000.0
|
|
BYTE_TO_MB = 1024.0 * 1024.0
|
|
DOWNLOAD_PATH = "/sdcard/download/"
|
|
DATA_USG_ERR = 2.2
|
|
DATA_ERR = 0.2
|
|
TIMEOUT = 2 * 60
|
|
INC_DATA = 10
|
|
AP_PASSPHRASE_LENGTH_2G = hostapd_constants.AP_PASSPHRASE_LENGTH_2G
|
|
AP_SSID_LENGTH_2G = hostapd_constants.AP_SSID_LENGTH_2G
|
|
RETRY_SLEEP = 3
|
|
WIFI_SLEEP = 180
|
|
|
|
|
|
class DataUsageTest(base_test.BaseTestClass):
|
|
"""Data usage tests.
|
|
|
|
Requirements:
|
|
Two Pixel devices - one device with TMO and other with VZW SIM
|
|
WiFi network - Wifi network to test wifi data usage
|
|
"""
|
|
|
|
def __init__(self, controllers):
|
|
base_test.BaseTestClass.__init__(self, controllers)
|
|
|
|
def setup_class(self):
|
|
"""Setup devices for tests and unpack params."""
|
|
|
|
# unpack user params
|
|
req_params = ("wifi_network",
|
|
"file_size",
|
|
"download_file_ipv4",
|
|
"download_file_ipv6",
|
|
"dbs_supported_models")
|
|
self.unpack_userparams(req_params)
|
|
self.file_path = DOWNLOAD_PATH + self.download_file_ipv4.split("/")[-1]
|
|
self.file_size = float(self.file_size)
|
|
|
|
for ad in self.android_devices:
|
|
self.log.info("Operator on %s is %s" % \
|
|
(ad.serial, get_operator_name(self.log, ad)))
|
|
ad.reboot()
|
|
nutils.verify_lte_data_and_tethering_supported(ad)
|
|
nutils.set_chrome_browser_permissions(ad)
|
|
cutils.set_private_dns(ad, cconst.PRIVATE_DNS_MODE_OFF)
|
|
try:
|
|
ad.adb.shell(instr_cmd)
|
|
except AdbError:
|
|
self.log.warn("cmd %s failed on %s" % (instr_cmd, ad.serial))
|
|
self.tcpdumps = []
|
|
self.hs_enabled = []
|
|
|
|
def setup_test(self):
|
|
for ad in self.android_devices:
|
|
self.tcpdumps.append(start_tcpdump(ad, self.test_name))
|
|
ad.droid.wakeLockAcquireBright()
|
|
ad.droid.wakeUpNow()
|
|
|
|
def teardown_test(self):
|
|
for ad in self.hs_enabled:
|
|
try:
|
|
wutils.stop_wifi_tethering(ad)
|
|
except Exception as e:
|
|
self.log.warn("Failed to stop wifi tethering: %s" % e)
|
|
self.hs_enabled = []
|
|
for i in range(len(self.android_devices)):
|
|
ad = self.android_devices[i]
|
|
stop_tcpdump(ad, self.tcpdumps[i], self.test_name)
|
|
wutils.reset_wifi(ad)
|
|
sub_id = str(ad.droid.telephonyGetSubscriberId())
|
|
ad.droid.connectivityFactoryResetNetworkPolicies(sub_id)
|
|
ad.droid.telephonyToggleDataConnection(True)
|
|
ad.droid.wakeLockRelease()
|
|
ad.droid.goToSleepNow()
|
|
self.tcpdumps = []
|
|
|
|
def teardown_class(self):
|
|
for ad in self.android_devices:
|
|
cutils.set_private_dns(ad, cconst.PRIVATE_DNS_MODE_OPPORTUNISTIC)
|
|
|
|
def on_fail(self, test_name, begin_time):
|
|
for ad in self.android_devices:
|
|
ad.take_bug_report(test_name, begin_time)
|
|
|
|
### Helper functions
|
|
|
|
def _download_data_through_app(self, ad, file_link):
|
|
"""Download data through app on DUT.
|
|
|
|
Args:
|
|
ad: DUT to download the file on
|
|
file_link: http link of the file to download
|
|
|
|
Returns:
|
|
True if file download is successful, False if not
|
|
"""
|
|
intent = ad.droid.createIntentForClassName(conn_test_class)
|
|
json_obj = {"url": file_link}
|
|
ad.droid.launchForResultWithIntent(intent, json_obj)
|
|
download_status = False
|
|
end_time = time.time() + TIMEOUT
|
|
while time.time() < end_time:
|
|
download_status = ttutils._check_file_existence(
|
|
ad, self.file_path, self.file_size * BYTE_TO_MB)
|
|
if download_status:
|
|
self.log.info("Delete file: %s", self.file_path)
|
|
ad.adb.shell("rm %s" % self.file_path, ignore_status=True)
|
|
break
|
|
time.sleep(RETRY_SLEEP*2) # wait to check if download is complete
|
|
return download_status
|
|
|
|
def _get_total_data_usage_for_device(self, ad, conn_type):
|
|
"""Get total data usage in MB for device.
|
|
|
|
Args:
|
|
ad: android device object
|
|
conn_type: MOBILE/WIFI data usage
|
|
|
|
Returns:
|
|
Data usage in MB
|
|
"""
|
|
sub_id = str(ad.droid.telephonyGetSubscriberId())
|
|
end_time = int(time.time() * 1000) + 2 * HOUR_IN_MILLIS
|
|
data_usage = ad.droid.connectivityQuerySummaryForDevice(
|
|
conn_type, sub_id, 0, end_time)
|
|
data_usage /= BYTE_TO_MB_ANDROID
|
|
self.log.info("Total data usage is: %s" % data_usage)
|
|
return data_usage
|
|
|
|
def _get_data_usage_for_uid_rx(self, ad, conn_type, uid):
|
|
"""Get data usage for UID in Rx Bytes.
|
|
|
|
Args:
|
|
ad: DUT to get data usage from
|
|
conn_type: MOBILE/WIFI data usage
|
|
uid: UID of the app
|
|
|
|
Returns:
|
|
Data usage in MB
|
|
"""
|
|
subscriber_id = ad.droid.telephonyGetSubscriberId()
|
|
end_time = int(time.time() * 1000) + 2 * HOUR_IN_MILLIS
|
|
data_usage = ad.droid.connectivityQueryDetailsForUidRxBytes(
|
|
conn_type, subscriber_id, 0, end_time, uid)
|
|
return data_usage/BYTE_TO_MB_ANDROID
|
|
|
|
def _get_data_usage_for_device_rx(self, ad, conn_type):
|
|
"""Get total data usage in rx bytes for device.
|
|
|
|
Args:
|
|
ad: DUT to get data usage from
|
|
conn_type: MOBILE/WIFI data usage
|
|
|
|
Returns:
|
|
Data usage in MB
|
|
"""
|
|
subscriber_id = ad.droid.telephonyGetSubscriberId()
|
|
end_time = int(time.time() * 1000) + 2 * HOUR_IN_MILLIS
|
|
data_usage = ad.droid.connectivityQuerySummaryForDeviceRxBytes(
|
|
conn_type, subscriber_id, 0, end_time)
|
|
return data_usage/BYTE_TO_MB_ANDROID
|
|
|
|
def _get_data_usage(self, ad, conn_type):
|
|
"""Get data usage.
|
|
|
|
Args:
|
|
ad: DUT to get data usage from
|
|
conn_type: MOBILE/WIFI data usage
|
|
|
|
Returns:
|
|
Tuple of Android Os app, Conn UID app, Total data usages
|
|
"""
|
|
android_os_uid = ad.droid.getUidForPackage(android_os_class)
|
|
conn_test_uid = ad.droid.getUidForPackage(conn_test_class)
|
|
aos = self._get_data_usage_for_uid_rx(ad, conn_type, android_os_uid)
|
|
app = self._get_data_usage_for_uid_rx(ad, conn_type, conn_test_uid)
|
|
tot = self._get_data_usage_for_device_rx(ad, conn_type)
|
|
self.log.info("Android Os data usage: %s" % aos)
|
|
self.log.info("Conn UID Test data usage: %s" % app)
|
|
self.log.info("Total data usage: %s" % tot)
|
|
return (aos, app, tot)
|
|
|
|
def _listen_for_network_callback(self, ad, event, q):
|
|
"""Verify network callback for data usage.
|
|
|
|
Args:
|
|
ad: DUT to get the network callback for
|
|
event: Network callback event
|
|
q: queue object
|
|
|
|
Returns:
|
|
True: if the expected network callback found, False if not
|
|
"""
|
|
key = ad.droid.connectivityRegisterDefaultNetworkCallback()
|
|
ad.droid.connectivityNetworkCallbackStartListeningForEvent(key, event)
|
|
|
|
curr_time = time.time()
|
|
status = False
|
|
while time.time() < curr_time + TIMEOUT:
|
|
try:
|
|
nc_event = ad.ed.pop_event("NetworkCallback")
|
|
self.log.info("Received: %s" %
|
|
nc_event["data"]["networkCallbackEvent"])
|
|
if nc_event["data"]["networkCallbackEvent"] == event:
|
|
status = True
|
|
break
|
|
except Empty:
|
|
pass
|
|
|
|
ad.droid.connectivityNetworkCallbackStopListeningForEvent(key, event)
|
|
ad.droid.connectivityUnregisterNetworkCallback(key)
|
|
q.put(status)
|
|
|
|
def _test_data_usage_downlink(self,
|
|
dut_a,
|
|
dut_b,
|
|
file_link,
|
|
data_usage,
|
|
tethering=False,
|
|
connect_wifi=False,
|
|
app_inc=True):
|
|
"""Verify data usage.
|
|
|
|
Steps:
|
|
1. Get the current data usage of ConnUIDTest and Android OS apps
|
|
2. DUT is on LTE data (on wifi if connect_wifi is True)
|
|
3. Download file of size xMB through ConnUIDTest app
|
|
4. Verify that data usage of Android OS app did not change
|
|
5. Verify that data usage of ConnUIDTest app increased by ~xMB
|
|
6. Verify that data usage of device also increased by ~xMB
|
|
|
|
Args:
|
|
dut_a: DUT on which data usage need to be verified
|
|
dut_b: DUT on which data is downloaded
|
|
file_link: Link used to download data
|
|
data_usage: specifies if MOBILE or WIFI data is calculated
|
|
tethering: if True, enable hotspot on dut_a and connect dut_b to it
|
|
connect_wifi: if True, connect dut_a to a wifi network
|
|
app_inc: if True, verify app data usage on dut_a is increased
|
|
"""
|
|
if connect_wifi:
|
|
dut_a.droid.telephonyToggleDataConnection(False)
|
|
wutils.start_wifi_connection_scan_and_ensure_network_found(
|
|
dut_a, self.wifi_network["SSID"])
|
|
wutils.wifi_connect(dut_a, self.wifi_network)
|
|
# sleep for some time after connecting to wifi. some apps use wifi
|
|
# data when connected initially. waiting after connecting to wifi
|
|
# ensures correct wifi data usage calculation
|
|
time.sleep(WIFI_SLEEP)
|
|
|
|
if tethering:
|
|
ssid = "hs_%s" % utils.rand_ascii_str(AP_SSID_LENGTH_2G)
|
|
pwd = utils.rand_ascii_str(AP_PASSPHRASE_LENGTH_2G)
|
|
network = {wutils.WifiEnums.SSID_KEY: ssid,
|
|
wutils.WifiEnums.PWD_KEY: pwd}
|
|
dut_b.droid.telephonyToggleDataConnection(False)
|
|
wutils.start_wifi_tethering(dut_a,
|
|
network[wutils.WifiEnums.SSID_KEY],
|
|
network[wutils.WifiEnums.PWD_KEY])
|
|
self.hs_enabled.append(dut_a)
|
|
wutils.start_wifi_connection_scan_and_ensure_network_found(
|
|
dut_b, network[wutils.WifiEnums.SSID_KEY])
|
|
wutils.wifi_connect(dut_b, network)
|
|
# sleep for some time after connecting to wifi. though wifi hotspot
|
|
# is metered, some apps would still use wifi data when connected
|
|
# initially. this ensures correct wifi data usage calculation
|
|
time.sleep(WIFI_SLEEP)
|
|
|
|
# get pre data usage
|
|
(aos_pre, app_pre, total_pre) = self._get_data_usage(dut_a, data_usage)
|
|
|
|
# download file through app
|
|
status = self._download_data_through_app(dut_b, file_link)
|
|
asserts.assert_true(status, "Failed to download file: %s" % file_link)
|
|
|
|
# get new data usage
|
|
aos_exp = DATA_ERR
|
|
app_exp = self.file_size + DATA_USG_ERR
|
|
file_size = self.file_size
|
|
if not app_inc:
|
|
app_exp = DATA_ERR
|
|
file_size = 0
|
|
total_exp = self.file_size + DATA_USG_ERR
|
|
|
|
# somtimes data usage is not increased immediately.
|
|
# re-tries until the data usage is closed to expected value.
|
|
curr_time = time.time()
|
|
while time.time() < curr_time + TIMEOUT:
|
|
(aos_pst, app_pst, total_pst) = self._get_data_usage(dut_a,
|
|
data_usage)
|
|
if total_pst - total_pre >= self.file_size and \
|
|
app_pst - app_pre >= file_size:
|
|
# wait for some time to verify that data doesn't increase
|
|
time.sleep(RETRY_SLEEP*2)
|
|
break
|
|
time.sleep(RETRY_SLEEP) # wait before retry
|
|
(aos_pst, app_pst, total_pst) = self._get_data_usage(dut_a, data_usage)
|
|
|
|
# verify data usage
|
|
aos_diff = aos_pst - aos_pre
|
|
app_diff = app_pst - app_pre
|
|
total_diff = total_pst - total_pre
|
|
self.log.info("Usage of Android OS increased: %sMB, expected: %sMB" % \
|
|
(aos_diff, aos_exp))
|
|
self.log.info("Usage of ConnUID app increased: %sMB, expected: %sMB" % \
|
|
(app_diff, app_exp))
|
|
self.log.info("Usage on the device increased: %sMB, expected: %sMB" % \
|
|
(total_diff, total_exp))
|
|
|
|
asserts.assert_true(
|
|
(aos_diff < aos_exp) and (file_size <= app_diff < app_exp) and \
|
|
(self.file_size <= total_diff < total_exp),
|
|
"Incorrect data usage count")
|
|
|
|
def _test_data_usage_limit_downlink(self,
|
|
dut_a,
|
|
dut_b,
|
|
file_link,
|
|
data_usage,
|
|
tethering=False):
|
|
"""Verify data usage limit reached.
|
|
|
|
Steps:
|
|
1. Set the data usage limit to current data usage + 10MB
|
|
2. If tested for tethered device, start wifi hotspot and
|
|
connect DUT to it.
|
|
3. If tested for tethered device, download 20MB data from
|
|
tethered device else download on the same DUT
|
|
4. Verify file download stops and data limit reached
|
|
|
|
Args:
|
|
dut_a: DUT on which data usage limit needs to be verified
|
|
dut_b: DUT on which data needs to be downloaded
|
|
file_link: specifies if the link is IPv4 or IPv6
|
|
data_usage: specifies if MOBILE or WIFI data usage
|
|
tethering: if wifi hotspot should be enabled on dut_a
|
|
"""
|
|
sub_id = str(dut_a.droid.telephonyGetSubscriberId())
|
|
|
|
# enable hotspot and connect dut_b to it.
|
|
if tethering:
|
|
ssid = "hs_%s" % utils.rand_ascii_str(AP_SSID_LENGTH_2G)
|
|
pwd = utils.rand_ascii_str(AP_PASSPHRASE_LENGTH_2G)
|
|
network = {wutils.WifiEnums.SSID_KEY: ssid,
|
|
wutils.WifiEnums.PWD_KEY: pwd}
|
|
dut_b.droid.telephonyToggleDataConnection(False)
|
|
wutils.start_wifi_tethering(dut_a,
|
|
network[wutils.WifiEnums.SSID_KEY],
|
|
network[wutils.WifiEnums.PWD_KEY])
|
|
self.hs_enabled.append(dut_a)
|
|
wutils.start_wifi_connection_scan_and_ensure_network_found(
|
|
dut_b, network[wutils.WifiEnums.SSID_KEY])
|
|
wutils.wifi_connect(dut_b, network)
|
|
|
|
# get pre mobile data usage
|
|
total_pre = self._get_total_data_usage_for_device(dut_a, data_usage)
|
|
|
|
# set data usage limit to current usage limit + 10MB
|
|
self.log.info("Set data usage limit to %sMB" % (total_pre + INC_DATA))
|
|
dut_a.droid.connectivitySetDataUsageLimit(
|
|
sub_id, int((total_pre + INC_DATA) * BYTE_TO_MB_ANDROID))
|
|
|
|
# download file on dut_b and look for BlockedStatusChanged callback
|
|
q = queue.Queue()
|
|
t = threading.Thread(target=self._listen_for_network_callback,
|
|
args=(dut_a, "BlockedStatusChanged", q))
|
|
t.daemon = True
|
|
t.start()
|
|
status = http_file_download_by_chrome(
|
|
dut_b, file_link, self.file_size, True, TIMEOUT)
|
|
t.join()
|
|
cb_res = q.get()
|
|
|
|
# verify file download fails and expected callback is recevied
|
|
asserts.assert_true(cb_res,
|
|
"Failed to verify blocked status network callback")
|
|
asserts.assert_true(not status,
|
|
"File download successful. Expected to fail")
|
|
|
|
### Test Cases
|
|
|
|
@test_tracker_info(uuid="b2d9b36c-3a1c-47ca-a9c1-755450abb20c")
|
|
def test_mobile_data_usage_downlink_ipv4_tmo(self):
|
|
"""Verify mobile data usage over IPv4 and TMO carrier."""
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[0],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="fbbb58ed-d573-4bbd-bd5d-0bc540507896")
|
|
def test_mobile_data_usage_downlink_ipv6_tmo(self):
|
|
"""Verify mobile data usage over IPv6 and TMO carrier."""
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[0],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="6562d626-2271-4d93-96c0-f33138635330")
|
|
def test_mobile_data_usage_downlink_ipv4_vzw(self):
|
|
"""Verify mobile data usage over IPv4 and VZW carrier."""
|
|
self._test_data_usage_downlink(self.android_devices[1],
|
|
self.android_devices[1],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="2edf94cf-d937-459a-a7e4-2c679803c4d3")
|
|
def test_mobile_data_usage_downlink_ipv6_vzw(self):
|
|
"""Verify mobile data usage over IPv6 and VZW carrier."""
|
|
self._test_data_usage_downlink(self.android_devices[1],
|
|
self.android_devices[1],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="fe1390e5-635c-49a9-b050-032e66f52f40")
|
|
def test_wifi_tethering_mobile_data_usage_downlink_ipv4_tmo(self):
|
|
"""Verify mobile data usage with tethered device over IPv4 and TMO."""
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[1],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE,
|
|
True,
|
|
False,
|
|
False)
|
|
|
|
@test_tracker_info(uuid="d7fde6b2-6672-484a-a2fd-47858f5a163f")
|
|
def test_wifi_tethering_mobile_data_usage_downlink_ipv6_tmo(self):
|
|
"""Verify mobile data usage with tethered device over IPv6 and TMO."""
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[1],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE,
|
|
True,
|
|
False,
|
|
False)
|
|
|
|
@test_tracker_info(uuid="6285ef69-37a8-4069-8cb2-21dc266a57c3")
|
|
def test_wifi_tethering_mobile_data_usage_downlink_ipv4_vzw(self):
|
|
"""Verify mobile data usage with tethered device over IPv4 and VZW."""
|
|
self._test_data_usage_downlink(self.android_devices[1],
|
|
self.android_devices[0],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE,
|
|
True,
|
|
False,
|
|
False)
|
|
|
|
@test_tracker_info(uuid="565fc7e3-d7cf-43cc-8982-4f17999cf579")
|
|
def test_wifi_tethering_mobile_data_usage_downlink_ipv6_vzw(self):
|
|
"""Verify mobile data usage with tethered device over IPv6 and VZW."""
|
|
self._test_data_usage_downlink(self.android_devices[1],
|
|
self.android_devices[0],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE,
|
|
True,
|
|
False,
|
|
False)
|
|
|
|
@test_tracker_info(uuid="72ddb42a-5942-4a6a-8b20-2181c41b2765")
|
|
def test_wifi_data_usage_downlink_ipv4(self):
|
|
"""Verify wifi data usage over IPv4."""
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[0],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_WIFI,
|
|
False,
|
|
True,
|
|
True)
|
|
|
|
@test_tracker_info(uuid="76b316f5-2946-4757-b5d6-62a8b1fd627e")
|
|
def test_wifi_data_usage_downlink_ipv6(self):
|
|
"""Verify wifi data usage over IPv6."""
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[0],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_WIFI,
|
|
False,
|
|
True,
|
|
True)
|
|
|
|
@test_tracker_info(uuid="4be5f2d4-9bc6-4190-813e-044f00d94aa6")
|
|
def test_wifi_tethering_wifi_data_usage_downlink_ipv4(self):
|
|
"""Verify wifi data usage with tethered device over IPv4."""
|
|
asserts.skip_if(
|
|
self.android_devices[0].model not in self.dbs_supported_models,
|
|
"Device %s does not support dual interfaces." %
|
|
self.android_devices[0].model)
|
|
self._test_data_usage_downlink(self.android_devices[0],
|
|
self.android_devices[1],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_WIFI,
|
|
True,
|
|
True,
|
|
False)
|
|
|
|
@test_tracker_info(uuid="ac4750fd-20d9-451d-a85b-79fdbaa7da97")
|
|
def test_data_usage_limit_downlink_ipv4_tmo(self):
|
|
"""Verify data limit for TMO with IPv4 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[0],
|
|
self.android_devices[0],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="6598732e-f4d3-40c7-a73b-e89bb3d196c5")
|
|
def test_data_usage_limit_downlink_ipv6_tmo(self):
|
|
"""Verify data limit for TMO with IPv6 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[0],
|
|
self.android_devices[0],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="d1ef0405-cf58-4141-94c7-cfa0c9d14438")
|
|
def test_data_usage_limit_downlink_ipv4_vzw(self):
|
|
"""Verify data limit for VZW with IPv4 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[1],
|
|
self.android_devices[1],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="18d169d9-fc4f-4782-8f5f-fc96b8976d03")
|
|
def test_data_usage_limit_downlink_ipv6_vzw(self):
|
|
"""Verify data limit for VZW with IPv6 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[1],
|
|
self.android_devices[1],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE)
|
|
|
|
@test_tracker_info(uuid="7c9ab330-9645-4030-bb1e-dcce126944a2")
|
|
def test_wifi_tethering_data_usage_limit_downlink_ipv4_tmo(self):
|
|
"""Verify data limit for TMO from tethered device with IPv4 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[0],
|
|
self.android_devices[1],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE,
|
|
True)
|
|
|
|
@test_tracker_info(uuid="1cafdaf7-a41e-4d19-b08a-ae094d796426")
|
|
def test_wifi_tethering_data_usage_limit_downlink_ipv6_tmo(self):
|
|
"""Verify data limit for TMO from tethered device with IPv6 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[0],
|
|
self.android_devices[1],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE,
|
|
True)
|
|
|
|
@test_tracker_info(uuid="bd5a8f93-4e2f-474d-a01d-4bb5117d5350")
|
|
def test_wifi_tethering_data_usage_limit_downlink_ipv4_vzw(self):
|
|
"""Verify data limit for VZW from tethered device with IPv4 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[1],
|
|
self.android_devices[0],
|
|
self.download_file_ipv4,
|
|
cconst.TYPE_MOBILE,
|
|
True)
|
|
|
|
@test_tracker_info(uuid="ec082fe5-6af1-425e-ace6-4726930bf62f")
|
|
def test_wifi_tethering_data_usage_limit_downlink_ipv6_vzw(self):
|
|
"""Verify data limit for VZW from tethered device with IPv6 link."""
|
|
self._test_data_usage_limit_downlink(self.android_devices[1],
|
|
self.android_devices[0],
|
|
self.download_file_ipv6,
|
|
cconst.TYPE_MOBILE,
|
|
True)
|