420 lines
15 KiB
Python
420 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Copyright 2019 - 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 re
|
|
import time
|
|
from queue import Empty
|
|
|
|
from acts import utils
|
|
from acts import base_test
|
|
from acts.libs.proc import job
|
|
from acts import signals
|
|
from acts.test_decorators import test_tracker_info
|
|
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
|
|
from acts_contrib.test_utils.tel import tel_test_utils as tutils
|
|
from acts_contrib.test_utils.tel import tel_defines
|
|
from acts_contrib.test_utils.tel.anritsu_utils import wait_for_sms_sent_success
|
|
from acts_contrib.test_utils.tel.tel_defines import EventMmsSentSuccess
|
|
from acts_contrib.test_utils.tel.tel_bootloader_utils import fastboot_wipe
|
|
|
|
# Time it takes for the usb tethering IP to
|
|
# show up in ifconfig and function waiting.
|
|
DEFAULT_SETTLE_TIME = 5
|
|
WifiEnums = wutils.WifiEnums
|
|
USB_CHARGE_MODE = 'svc usb setFunctions'
|
|
USB_TETHERING_MODE = 'svc usb setFunctions rndis'
|
|
USB_MTP_MODE = 'svc usb setFunctions mtp'
|
|
DEVICE_IP_ADDRESS = 'ip address'
|
|
|
|
|
|
class UsbTetheringFunctionsTest(base_test.BaseTestClass):
|
|
"""Tests for usb tethering throughput test.
|
|
|
|
Test Bed Requirement:
|
|
* One Android device.
|
|
* Wi-Fi networks visible to the device.
|
|
* Sim card with data call.
|
|
"""
|
|
|
|
def setup_class(self):
|
|
self.dut = self.android_devices[0]
|
|
req_params = ['wifi_network', 'receiver_number', 'ping_count']
|
|
self.unpack_userparams(req_param_names=req_params)
|
|
|
|
self.ssid_map = {}
|
|
for network in self.wifi_network:
|
|
SSID = network['SSID'].replace('-', '_')
|
|
self.ssid_map[SSID] = network
|
|
self.dut.droid.setMobileDataEnabled()
|
|
if not tutils.verify_internet_connection(
|
|
self.dut.log, self.dut, retries=3):
|
|
tutils.abort_all_tests(self.dut.log, 'Internet connection Failed.')
|
|
|
|
def setup_test(self):
|
|
self.dut.droid.wakeLockAcquireBright()
|
|
self.dut.droid.wakeUpNow()
|
|
self.dut.unlock_screen()
|
|
|
|
def teardown_test(self):
|
|
wutils.wifi_toggle_state(self.dut, False)
|
|
self.dut.droid.wakeLockRelease()
|
|
self.dut.droid.goToSleepNow()
|
|
self.dut.droid.setMobileDataEnabled()
|
|
self.dut.droid.connectivityStopTethering(tel_defines.TETHERING_WIFI)
|
|
self.dut.stop_services()
|
|
# Set usb function back to charge mode.
|
|
self.dut.adb.shell(USB_CHARGE_MODE)
|
|
self.dut.adb.wait_for_device()
|
|
self.dut.start_services()
|
|
|
|
def teardown_class(self):
|
|
wutils.reset_wifi(self.dut)
|
|
|
|
def on_fail(self, test_name, begin_time):
|
|
self.dut.take_bug_report(test_name, begin_time)
|
|
self.dut.cat_adb_log(test_name, begin_time)
|
|
|
|
def enable_usb_tethering(self, attempts=3):
|
|
"""Stop SL4A service and enable usb tethering.
|
|
|
|
Logic steps are
|
|
1. Stop SL4A service.
|
|
2. Enable usb tethering.
|
|
3. Restart SL4A service.
|
|
4. Check usb tethering enabled.
|
|
5. Attempt if fail to enable usb tethering.
|
|
|
|
Args:
|
|
attempts: number of times for enable usb tethering.
|
|
|
|
Raises:
|
|
TestFailure when unable to find rndis string.
|
|
"""
|
|
for i in range(attempts):
|
|
self.dut.stop_services()
|
|
self.dut.adb.shell(USB_TETHERING_MODE, ignore_status=True)
|
|
self.dut.adb.wait_for_device()
|
|
self.dut.start_services()
|
|
if 'rndis' in self.dut.adb.shell(DEVICE_IP_ADDRESS):
|
|
self.log.info('Usb tethering is enabled.')
|
|
return
|
|
else:
|
|
self.log.info('Enable usb tethering - attempt %d' % (i + 1))
|
|
raise signals.TestFailure('Unable to enable USB tethering.')
|
|
|
|
def connect_to_wifi_network(self, network):
|
|
"""Connection logic for wifi network.
|
|
|
|
Args:
|
|
network: Dictionary with network info.
|
|
"""
|
|
SSID = network[WifiEnums.SSID_KEY]
|
|
self.dut.ed.clear_all_events()
|
|
wutils.start_wifi_connection_scan(self.dut)
|
|
scan_results = self.dut.droid.wifiGetScanResults()
|
|
wutils.assert_network_in_list({WifiEnums.SSID_KEY: SSID}, scan_results)
|
|
wutils.wifi_connect(self.dut, network, num_of_tries=3)
|
|
|
|
def enable_wifi_hotspot(self):
|
|
"""Enable wifi hotspot."""
|
|
sap_config = wutils.create_softap_config()
|
|
wutils.start_wifi_tethering(self.dut,
|
|
sap_config[wutils.WifiEnums.SSID_KEY],
|
|
sap_config[wutils.WifiEnums.PWD_KEY],
|
|
wutils.WifiEnums.WIFI_CONFIG_APBAND_2G)
|
|
|
|
def get_rndis_interface(self):
|
|
"""Check rndis interface after usb tethering enable.
|
|
|
|
Returns:
|
|
Usb tethering interface from Android device.
|
|
|
|
Raises:
|
|
TestFailure when unable to find correct usb tethering interface.
|
|
"""
|
|
time.sleep(DEFAULT_SETTLE_TIME)
|
|
check_usb_tethering = job.run('ifconfig').stdout
|
|
# A regex that stores the tethering interface in group 1.
|
|
tethered_interface_regex = r'^(enp.*?):.*?broadcast 192.168.42.255'
|
|
match = re.search(tethered_interface_regex, check_usb_tethering,
|
|
re.DOTALL + re.MULTILINE)
|
|
if match:
|
|
return match.group(1)
|
|
else:
|
|
raise signals.TestFailure(
|
|
'Unable to find tethering interface. The device may not be tethered.'
|
|
)
|
|
|
|
def can_ping(self, ip, extra_params='', count=10):
|
|
"""Run ping test and check and check ping lost rate.
|
|
|
|
Args:
|
|
ip: ip address for ping.
|
|
extra_params: params for ping test.
|
|
count: default ping count.
|
|
|
|
Returns:
|
|
True: If no packet loss.
|
|
False: Otherwise.
|
|
"""
|
|
out = job.run(
|
|
'ping -c {} {} {}'.format(count, extra_params, ip),
|
|
ignore_status=True).stdout
|
|
self.log.info(out)
|
|
return '0%' in out.split(' ')
|
|
|
|
def can_ping_through_usb_interface(self):
|
|
"""Run ping test and check result after usb tethering enabled.
|
|
|
|
Raises:
|
|
TestFailure when unable to ping through usb tethering interface.
|
|
"""
|
|
ip = '8.8.8.8'
|
|
interface = self.get_rndis_interface()
|
|
if not self.can_ping(
|
|
ip, '-I {}'.format(interface), count=self.ping_count):
|
|
raise signals.TestFailure(
|
|
'Fail to ping through usb tethering interface.')
|
|
|
|
def enable_usb_mtp(self):
|
|
"""Enable usb mtp mode.
|
|
|
|
Raises:
|
|
TestFailure when unable to set mtp mode.
|
|
"""
|
|
try:
|
|
self.dut.stop_services()
|
|
self.dut.adb.shell(USB_MTP_MODE, ignore_status=True)
|
|
self.dut.adb.wait_for_device()
|
|
self.dut.start_services()
|
|
except:
|
|
raise signals.TestFailure('Device can not enable mtp mode.')
|
|
|
|
def check_sms_send_status(self, message='usb_sms_test'):
|
|
"""Send a SMS and check send status.
|
|
|
|
Args:
|
|
message: SMS string.
|
|
|
|
Raises:
|
|
Exception when unable to send SMS.
|
|
"""
|
|
self.dut.droid.smsSendTextMessage(self.receiver_number, message, False)
|
|
self.log.info('Waiting for SMS sent event')
|
|
test_status = wait_for_sms_sent_success(self.log, self.dut)
|
|
if not test_status:
|
|
raise Exception('Failed to send SMS')
|
|
|
|
def check_mms_send_status(self,
|
|
subject='usb_subject',
|
|
message='usb_mms_test'):
|
|
"""Send a MMS and check send status.
|
|
|
|
Args:
|
|
subject: MMS subject.
|
|
message: MMS string.
|
|
|
|
Raises:
|
|
Exception when unable to send MMS.
|
|
"""
|
|
# Permission require for send MMS.
|
|
self.dut.adb.shell('su root setenforce 0')
|
|
self.dut.droid.smsSendMultimediaMessage(self.receiver_number, subject,
|
|
message)
|
|
self.log.info('Waiting for MMS sent event')
|
|
test_status = self.wait_for_mms_sent_success()
|
|
if not test_status:
|
|
raise Exception('Failed to send MMS')
|
|
|
|
def wait_for_mms_sent_success(self, time_to_wait=60):
|
|
"""Check MMS send status.
|
|
|
|
Args:
|
|
time_to_wait: Time out for check MMS.
|
|
|
|
Returns:
|
|
status = MMS send status.
|
|
"""
|
|
mms_sent_event = EventMmsSentSuccess
|
|
try:
|
|
event = self.dut.ed.pop_event(mms_sent_event, time_to_wait)
|
|
self.log.info(event)
|
|
except Empty:
|
|
self.log.error('Timeout: Expected event is not received.')
|
|
return False
|
|
return True
|
|
|
|
@test_tracker_info(uuid="7c2ae85e-32a2-416e-a65e-c15a15e76f86")
|
|
def test_usb_tethering_wifi_only(self):
|
|
"""Enable usb tethering with wifi only then executing ping test.
|
|
|
|
Steps:
|
|
1. Stop SL4A services.
|
|
2. Enable usb tethering.
|
|
3. Restart SL4A services.
|
|
4. Mobile data disable and wifi enable.
|
|
5. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
self.log.info('Disable mobile data.')
|
|
self.dut.droid.setMobileDataEnabled(False)
|
|
self.log.info('Enable wifi.')
|
|
wutils.wifi_toggle_state(self.dut, True)
|
|
self.connect_to_wifi_network(
|
|
self.ssid_map[self.wifi_network[0]['SSID']])
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="8910b07b-0beb-4d9d-b901-c4195b4e0930")
|
|
def test_usb_tethering_data_only(self):
|
|
"""Enable usb tethering with data only then executing ping test.
|
|
|
|
Steps:
|
|
1. Stop SL4A services.
|
|
2. Enable usb tethering.
|
|
3. Restart SL4A services.
|
|
4. Wifi disable and mobile data enable.
|
|
5. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
wutils.wifi_toggle_state(self.dut, False)
|
|
self.dut.droid.setMobileDataEnabled()
|
|
time.sleep(DEFAULT_SETTLE_TIME)
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="f971806e-e003-430a-bc80-321f128d31cb")
|
|
def test_usb_tethering_after_airplane_mode(self):
|
|
"""Enable usb tethering after airplane mode then executing ping test.
|
|
|
|
Steps:
|
|
1. Stop SL4A services.
|
|
2. Enable usb tethering.
|
|
3. Restart SL4A services.
|
|
4. Wifi disable and mobile data enable.
|
|
5. Enable/disable airplane mode.
|
|
6. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
wutils.wifi_toggle_state(self.dut, False)
|
|
self.log.info('Enable airplane mode.')
|
|
utils.force_airplane_mode(self.dut, True)
|
|
self.log.info('Disable airplane mode.')
|
|
utils.force_airplane_mode(self.dut, False)
|
|
time.sleep(DEFAULT_SETTLE_TIME)
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="db1c561d-67bd-47d7-b65e-d882f0e2641e")
|
|
def test_usb_tethering_coexist_wifi_hotspot(self):
|
|
"""Enable usb tethering with hotspot then executing ping test.
|
|
|
|
Steps:
|
|
1. Enable hotspot
|
|
2. Stop SL4A services.
|
|
3. Enable usb tethering.
|
|
4. Restart SL4A services.
|
|
5. Run ping test through tethering interface during hotspot enable.
|
|
6. Run ping test through tethering interface during hotspot disable.
|
|
"""
|
|
self.log.info('Enable wifi hotspot.')
|
|
self.enable_wifi_hotspot()
|
|
self.enable_usb_tethering()
|
|
self.log.info('Ping test with hotspot enable.')
|
|
self.can_ping_through_usb_interface()
|
|
self.log.info('Disable wifi hotspot.')
|
|
self.dut.droid.connectivityStopTethering(tel_defines.TETHERING_WIFI)
|
|
self.log.info('Ping test with hotspot disable.')
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="7018abdb-049e-41aa-a4f9-e11012369d9b")
|
|
def test_usb_tethering_after_mtp(self):
|
|
"""Enable usb tethering after mtp enable then executing ping test.
|
|
|
|
Steps:
|
|
1. Stop SL4A services.
|
|
2. Enable usb tethering.
|
|
3. Restart SL4A services.
|
|
4. Enable usb mtp mode.
|
|
5. Enable usb tethering and mtp will disable.
|
|
6. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
self.log.info('Enable usb mtp mode.')
|
|
self.enable_usb_mtp()
|
|
# Turn on mtp mode for 5 sec.
|
|
time.sleep(DEFAULT_SETTLE_TIME)
|
|
self.enable_usb_tethering()
|
|
self.log.info('Usb tethering enable, usb mtp mode disabled.')
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="f1ba2cbc-1cb2-4b8a-92eb-9b366c3f4c37")
|
|
def test_usb_tethering_after_sms_mms(self):
|
|
"""Enable usb tethering after send sms and mms then executing ping test.
|
|
|
|
Steps:
|
|
1. Stop SL4A services.
|
|
2. Enable usb tethering.
|
|
3. Restart SL4A services.
|
|
4. Send a sms and mms.
|
|
5. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
self.log.info('Start send SMS and check status.')
|
|
self.check_sms_send_status()
|
|
time.sleep(DEFAULT_SETTLE_TIME)
|
|
self.log.info('Start send MMS and check status.')
|
|
self.check_mms_send_status()
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="e6586b30-4886-4c3e-8225-633aa9333968")
|
|
def test_usb_tethering_after_reboot(self):
|
|
"""Enable usb tethering after reboot then executing ping test.
|
|
|
|
Steps:
|
|
1. Reboot device.
|
|
2. Stop SL4A services.
|
|
3. Enable usb tethering.
|
|
4. Restart SL4A services.
|
|
5. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
self.log.info('Reboot device.')
|
|
self.dut.reboot()
|
|
self.dut.droid.setMobileDataEnabled()
|
|
self.log.info('Start usb tethering and ping test.')
|
|
self.enable_usb_tethering()
|
|
self.can_ping_through_usb_interface()
|
|
|
|
@test_tracker_info(uuid="40093ab8-6db4-4af4-97ae-9467bf33bf23")
|
|
def test_usb_tethering_after_wipe(self):
|
|
"""Enable usb tethering after wipe.
|
|
|
|
Steps:
|
|
1. Enable usb tethering.
|
|
2. Wipe device.
|
|
3. Wake up device and unlock screen.
|
|
4. Enable usb tethering.
|
|
5. Run ping test through usb tethering interface.
|
|
"""
|
|
self.enable_usb_tethering()
|
|
fastboot_wipe(self.dut)
|
|
time.sleep(DEFAULT_SETTLE_TIME)
|
|
# Skip setup wizard after wipe.
|
|
self.dut.adb.shell(
|
|
'am start -a com.android.setupwizard.EXIT', ignore_status=True)
|
|
self.dut.droid.setMobileDataEnabled()
|
|
self.dut.droid.wakeUpNow()
|
|
self.dut.unlock_screen()
|
|
self.enable_usb_tethering()
|
|
self.can_ping_through_usb_interface() |