445 lines
18 KiB
Python
Executable File
445 lines
18 KiB
Python
Executable File
# !/usr/bin/env python3.4
|
|
#
|
|
# Copyright 2017 - 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
|
|
from acts import asserts
|
|
from acts.controllers.android_device import SL4A_APK_NAME
|
|
from acts.libs.ota import ota_updater
|
|
import acts.signals as signals
|
|
from acts.test_decorators import test_tracker_info
|
|
from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_CONFIG_APBAND_5G
|
|
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
|
|
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
|
|
import acts.utils as utils
|
|
|
|
WifiEnums = wutils.WifiEnums
|
|
SSID = WifiEnums.SSID_KEY
|
|
PWD = WifiEnums.PWD_KEY
|
|
NETID = WifiEnums.NETID_KEY
|
|
# Default timeout used for reboot, toggle WiFi and Airplane mode,
|
|
# for the system to settle down after the operation.
|
|
DEFAULT_TIMEOUT = 10
|
|
BAND_2GHZ = 0
|
|
BAND_5GHZ = 1
|
|
|
|
|
|
class WifiAutoUpdateTest(WifiBaseTest):
|
|
"""Tests for APIs in Android's WifiManager class.
|
|
|
|
Test Bed Requirement:
|
|
* One Android device
|
|
* Several Wi-Fi networks visible to the device, including an open Wi-Fi
|
|
network.
|
|
"""
|
|
|
|
def __init__(self, controllers):
|
|
WifiBaseTest.__init__(self, controllers)
|
|
self.tests = (
|
|
"test_check_wifi_state_after_au",
|
|
"test_verify_networks_after_au",
|
|
"test_configstore_after_au",
|
|
"test_mac_randomization_after_au",
|
|
"test_wifi_hotspot_5g_psk_after_au",
|
|
"test_all_networks_connectable_after_au",
|
|
"test_connect_to_network_suggestion_after_au",
|
|
"test_check_wifi_toggling_after_au",
|
|
"test_connection_to_new_networks",
|
|
"test_reset_wifi_after_au")
|
|
|
|
def setup_class(self):
|
|
super(WifiAutoUpdateTest, self).setup_class()
|
|
ota_updater.initialize(self.user_params, self.android_devices)
|
|
self.dut = self.android_devices[0]
|
|
self.dut_client = self.android_devices[1]
|
|
wutils.wifi_test_device_init(self.dut)
|
|
wutils.wifi_toggle_state(self.dut, True)
|
|
|
|
# configure APs
|
|
opt_param = ["reference_networks"]
|
|
self.unpack_userparams(opt_param_names=opt_param)
|
|
if "AccessPoint" in self.user_params:
|
|
self.legacy_configure_ap_and_start(wpa_network=True,
|
|
wep_network=True)
|
|
elif "OpenWrtAP" in self.user_params:
|
|
self.configure_openwrt_ap_and_start(wpa_network=True,
|
|
wep_network=True,
|
|
ap_count=2)
|
|
self.wpapsk_2g = self.reference_networks[0]["2g"]
|
|
self.wpapsk_5g = self.reference_networks[0]["5g"]
|
|
self.wep_2g = self.wep_networks[0]["2g"]
|
|
self.wep_5g = self.wep_networks[0]["5g"]
|
|
|
|
# saved & connected networks, network suggestions
|
|
# and new networks
|
|
self.saved_networks = [self.wep_2g]
|
|
self.network_suggestions = [self.wpapsk_5g]
|
|
self.connected_networks = [self.wpapsk_2g, self.wep_5g]
|
|
self.new_networks = [self.reference_networks[1]["2g"],
|
|
self.wep_networks[1]["5g"]]
|
|
|
|
# add pre ota upgrade configuration
|
|
self.wifi_config_list = []
|
|
self.pre_default_mac = {}
|
|
self.pre_random_mac = {}
|
|
self.pst_default_mac = {}
|
|
self.pst_random_mac = {}
|
|
self.add_pre_update_configuration()
|
|
|
|
# Run OTA below, if ota fails then abort all tests.
|
|
try:
|
|
ota_updater.update(self.dut)
|
|
except Exception as e:
|
|
raise signals.TestAbortClass(
|
|
"Failed up apply OTA update. Aborting tests: %s" % e)
|
|
|
|
def setup_test(self):
|
|
super().setup_test()
|
|
self.dut.droid.wakeLockAcquireBright()
|
|
self.dut.droid.wakeUpNow()
|
|
|
|
def teardown_test(self):
|
|
super().teardown_test()
|
|
self.dut.droid.wakeLockRelease()
|
|
self.dut.droid.goToSleepNow()
|
|
|
|
def teardown_class(self):
|
|
if "AccessPoint" in self.user_params:
|
|
del self.user_params["reference_networks"]
|
|
|
|
### Helper Methods
|
|
|
|
def add_pre_update_configuration(self):
|
|
self.add_network_suggestions(self.network_suggestions)
|
|
self.add_network_and_enable(self.saved_networks[0])
|
|
self.add_wifi_hotspot()
|
|
self.connect_to_multiple_networks(self.connected_networks)
|
|
|
|
def add_wifi_hotspot(self):
|
|
self.wifi_hotspot = {"SSID": "hotspot_%s" % utils.rand_ascii_str(6),
|
|
"password": "pass_%s" % utils.rand_ascii_str(6)}
|
|
band = WIFI_CONFIG_APBAND_5G
|
|
if self.dut.build_info["build_id"].startswith("R"):
|
|
band = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G
|
|
self.wifi_hotspot[WifiEnums.AP_BAND_KEY] = band
|
|
asserts.assert_true(
|
|
self.dut.droid.wifiSetWifiApConfiguration(self.wifi_hotspot),
|
|
"Failed to set WifiAp Configuration")
|
|
wifi_ap = self.dut.droid.wifiGetApConfiguration()
|
|
asserts.assert_true(
|
|
wifi_ap[WifiEnums.SSID_KEY] == self.wifi_hotspot[WifiEnums.SSID_KEY],
|
|
"Hotspot SSID doesn't match with expected SSID")
|
|
return
|
|
if self.dut.build_info["build_id"].startswith("Q"):
|
|
band = WifiEnums.WIFI_CONFIG_APBAND_5G_OLD
|
|
self.wifi_hotspot[WifiEnums.AP_BAND_KEY] = band
|
|
asserts.assert_true(
|
|
self.dut.droid.wifiSetWifiApConfiguration(self.wifi_hotspot),
|
|
"Failed to set WifiAp Configuration")
|
|
wifi_ap = self.dut.droid.wifiGetApConfiguration()
|
|
asserts.assert_true(
|
|
wifi_ap[WifiEnums.SSID_KEY] == self.wifi_hotspot[WifiEnums.SSID_KEY],
|
|
"Hotspot SSID doesn't match with expected SSID")
|
|
return
|
|
wutils.save_wifi_soft_ap_config(self.dut, self.wifi_hotspot, band)
|
|
|
|
def verify_wifi_hotspot(self):
|
|
"""Verify wifi tethering."""
|
|
wutils.start_wifi_tethering_saved_config(self.dut)
|
|
wutils.connect_to_wifi_network(self.dut_client,
|
|
self.wifi_hotspot,
|
|
check_connectivity=False)
|
|
wutils.stop_wifi_tethering(self.dut)
|
|
|
|
def connect_to_multiple_networks(self, networks):
|
|
"""Connect to a list of wifi networks.
|
|
|
|
Args:
|
|
networks : list of wifi networks.
|
|
"""
|
|
self.log.info("Connect to multiple wifi networks")
|
|
for network in networks:
|
|
ssid = network[SSID]
|
|
wutils.start_wifi_connection_scan_and_ensure_network_found(
|
|
self.dut, ssid)
|
|
wutils.wifi_connect(self.dut, network, num_of_tries=6)
|
|
self.wifi_config_list.append(network)
|
|
self.pre_default_mac[network[SSID]] = self.get_sta_mac_address()
|
|
self.pre_random_mac[network[SSID]] = \
|
|
self.dut.droid.wifigetRandomizedMacAddress(network)
|
|
|
|
def get_sta_mac_address(self):
|
|
"""Gets the current MAC address being used for client mode."""
|
|
out = self.dut.adb.shell("ifconfig wlan0")
|
|
res = re.match(".* HWaddr (\S+).*", out, re.S)
|
|
return res.group(1)
|
|
|
|
def add_network_suggestions(self, network_suggestions):
|
|
"""Add wifi network suggestions to DUT.
|
|
|
|
Args:
|
|
network_suggestions : suggestions to add.
|
|
"""
|
|
self.dut.log.info("Adding network suggestions")
|
|
asserts.assert_true(
|
|
self.dut.droid.wifiAddNetworkSuggestions(network_suggestions),
|
|
"Failed to add suggestions")
|
|
|
|
# Enable suggestions by the app.
|
|
self.dut.log.debug("Enabling suggestions from test")
|
|
self.dut.adb.shell(
|
|
"cmd wifi network-suggestions-set-user-approved %s yes" % \
|
|
SL4A_APK_NAME)
|
|
|
|
def remove_suggestions_and_ensure_no_connection(self,
|
|
network_suggestions,
|
|
expected_ssid):
|
|
"""Remove network suggestions.
|
|
|
|
Args:
|
|
network_suggestions : suggestions to remove.
|
|
expected_ssid : SSID to verify that DUT is not connected.
|
|
"""
|
|
# remove network suggestion and verify disconnect
|
|
self.dut.log.info("Removing network suggestions")
|
|
asserts.assert_true(
|
|
self.dut.droid.wifiRemoveNetworkSuggestions(network_suggestions),
|
|
"Failed to remove suggestions")
|
|
|
|
wutils.wait_for_disconnect(self.dut)
|
|
self.dut.ed.clear_all_events()
|
|
|
|
# Now ensure that we didn't connect back.
|
|
asserts.assert_false(
|
|
wutils.wait_for_connect(self.dut,
|
|
expected_ssid,
|
|
assert_on_fail=False),
|
|
"Device should not connect back")
|
|
|
|
def add_network_and_enable(self, network):
|
|
"""Add a network and enable it.
|
|
|
|
Args:
|
|
network : Network details for the network to be added.
|
|
"""
|
|
self.log.info("Add a wifi network and enable it")
|
|
ret = self.dut.droid.wifiAddNetwork(network)
|
|
asserts.assert_true(ret != -1, "Add network %r failed" % network)
|
|
self.wifi_config_list.append({SSID: network[SSID], NETID: ret})
|
|
self.dut.droid.wifiEnableNetwork(ret, 0)
|
|
|
|
def check_networks_after_autoupdate(self, networks):
|
|
"""Verify that all previously configured networks are persistent.
|
|
|
|
Args:
|
|
networks: List of network dicts.
|
|
"""
|
|
network_info = self.dut.droid.wifiGetConfiguredNetworks()
|
|
"""
|
|
b/189285598, the network id of a network might be changed after \
|
|
reboot because the network sequence is not stable on \
|
|
backup/restore. This test should find the correct network against
|
|
the desired SSID before connecting to the network after reboot.
|
|
Start from Android S.
|
|
"""
|
|
network_info_ssid = list()
|
|
for i in network_info:
|
|
network_info_ssid.append(i['SSID'])
|
|
network_info_ssid_list = set(network_info_ssid)
|
|
networks_ssid= list()
|
|
for i in networks:
|
|
networks_ssid.append(i['SSID'])
|
|
networks_ssid_list = set(networks_ssid)
|
|
if len(network_info_ssid_list) != len(networks_ssid_list):
|
|
msg = (
|
|
"Number of configured networks before and after Auto-update "
|
|
"don't match. \nBefore reboot = %s \n After reboot = %s" %
|
|
(networks, network_info))
|
|
raise signals.TestFailure(msg)
|
|
|
|
# For each network, check if it exists in configured list after Auto-
|
|
# update.
|
|
for network in networks:
|
|
exists = wutils.match_networks({SSID: network[SSID]}, network_info)
|
|
if not exists:
|
|
raise signals.TestFailure("%s network is not present in the"
|
|
" configured list after Auto-update" %
|
|
network[SSID])
|
|
|
|
# Get the new network id for each network after reboot.
|
|
network[NETID] = exists[0]["networkId"]
|
|
|
|
def get_enabled_network(self, network1, network2):
|
|
"""Check network status and return currently unconnected network.
|
|
|
|
Args:
|
|
network1: dict representing a network.
|
|
network2: dict representing a network.
|
|
|
|
Returns:
|
|
Network dict of the unconnected network.
|
|
"""
|
|
wifi_info = self.dut.droid.wifiGetConnectionInfo()
|
|
enabled = network1
|
|
if wifi_info[SSID] == network1[SSID]:
|
|
enabled = network2
|
|
return enabled
|
|
|
|
### Tests
|
|
|
|
@test_tracker_info(uuid="9ff1f01e-e5ff-408b-9a95-29e87a2df2d8")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_check_wifi_state_after_au(self):
|
|
"""Check if the state of WiFi is enabled after Auto-update."""
|
|
if not self.dut.droid.wifiCheckState():
|
|
raise signals.TestFailure("WiFi is disabled after Auto-update!!!")
|
|
|
|
@test_tracker_info(uuid="e3ebdbba-71dd-4281-aef8-5b3d42b88770")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_verify_networks_after_au(self):
|
|
"""Check if the previously added networks are intact.
|
|
|
|
Steps:
|
|
Number of networs should be the same and match each network.
|
|
|
|
"""
|
|
self.check_networks_after_autoupdate(self.wifi_config_list)
|
|
|
|
@test_tracker_info(uuid="799e83c2-305d-4510-921e-dac3c0dbb6c5")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_configstore_after_au(self):
|
|
"""Verify DUT automatically connects to wifi networks after ota.
|
|
|
|
Steps:
|
|
1. Connect to two wifi networks pre ota.
|
|
2. Verify DUT automatically connects to 1 after ota.
|
|
3. Re-connect to the other wifi network.
|
|
"""
|
|
wifi_info = self.dut.droid.wifiGetConnectionInfo()
|
|
self.pst_default_mac[wifi_info[SSID]] = self.get_sta_mac_address()
|
|
self.pst_random_mac[wifi_info[SSID]] = \
|
|
self.dut.droid.wifigetRandomizedMacAddress(wifi_info)
|
|
reconnect_to = self.get_enabled_network(self.wifi_config_list[1],
|
|
self.wifi_config_list[2])
|
|
wutils.start_wifi_connection_scan_and_ensure_network_found(
|
|
self.dut, reconnect_to[SSID])
|
|
wutils.wifi_connect_by_id(self.dut, reconnect_to[NETID])
|
|
connect_data = self.dut.droid.wifiGetConnectionInfo()
|
|
connect_ssid = connect_data[SSID]
|
|
self.log.info("Expected SSID = %s" % reconnect_to[SSID])
|
|
self.log.info("Connected SSID = %s" % connect_ssid)
|
|
if connect_ssid != reconnect_to[SSID]:
|
|
raise signals.TestFailure(
|
|
"Device failed to reconnect to the correct"
|
|
" network after reboot.")
|
|
self.pst_default_mac[wifi_info[SSID]] = self.get_sta_mac_address()
|
|
self.pst_random_mac[wifi_info[SSID]] = \
|
|
self.dut.droid.wifigetRandomizedMacAddress(wifi_info)
|
|
|
|
for network in self.connected_networks:
|
|
wutils.wifi_forget_network(self.dut, network[SSID])
|
|
|
|
@test_tracker_info(uuid="e26d0ed9-9457-4a95-a962-4d43b0032bac")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_mac_randomization_after_au(self):
|
|
"""Verify randomized MAC addrs are persistent after ota.
|
|
|
|
Steps:
|
|
1. Reconnect to the wifi networks configured pre ota.
|
|
2. Get the randomized MAC addrs.
|
|
"""
|
|
for ssid, mac in self.pst_random_mac.items():
|
|
asserts.assert_true(
|
|
self.pre_random_mac[ssid] == mac,
|
|
"MAC addr of %s is %s after ota. Expected %s" %
|
|
(ssid, mac, self.pre_random_mac[ssid]))
|
|
|
|
@test_tracker_info(uuid="f68a65e6-97b7-4746-bad8-4c206551d87e")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_wifi_hotspot_5g_psk_after_au(self):
|
|
"""Verify hotspot after ota upgrade.
|
|
|
|
Steps:
|
|
1. Start wifi hotspot on the saved config.
|
|
2. Verify DUT client connects to it.
|
|
"""
|
|
self.verify_wifi_hotspot()
|
|
|
|
@test_tracker_info(uuid="21f91372-88a6-44b9-a4e8-d4664823dffb")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_connect_to_network_suggestion_after_au(self):
|
|
"""Verify connection to network suggestion after ota.
|
|
|
|
Steps:
|
|
1. DUT has network suggestion added before OTA.
|
|
2. Wait for the device to connect to it.
|
|
3. Remove the suggestions and ensure the device does not
|
|
connect back.
|
|
"""
|
|
wutils.reset_wifi(self.dut)
|
|
wutils.start_wifi_connection_scan_and_return_status(self.dut)
|
|
wutils.wait_for_connect(self.dut, self.network_suggestions[0][SSID])
|
|
self.remove_suggestions_and_ensure_no_connection(
|
|
self.network_suggestions, self.network_suggestions[0][SSID])
|
|
|
|
@test_tracker_info(uuid="b8e47a4f-62fe-4a0e-b999-27ae1ebf4d19")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_connection_to_new_networks(self):
|
|
"""Check if we can connect to new networks after Auto-update.
|
|
|
|
Steps:
|
|
1. Connect to a PSK network.
|
|
2. Connect to an open network.
|
|
3. Forget ntworks added in 1 & 2.
|
|
TODO: (@bmahadev) Add WEP network once it's ready.
|
|
"""
|
|
for network in self.new_networks:
|
|
wutils.connect_to_wifi_network(self.dut, network)
|
|
for network in self.new_networks:
|
|
wutils.wifi_forget_network(self.dut, network[SSID])
|
|
|
|
@test_tracker_info(uuid="1d8309e4-d5a2-4f48-ba3b-895a58c9bf3a")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_all_networks_connectable_after_au(self):
|
|
"""Check if previously added networks are connectable.
|
|
|
|
Steps:
|
|
1. Connect to previously added PSK network using network id.
|
|
2. Connect to previously added open network using network id.
|
|
TODO: (@bmahadev) Add WEP network once it's ready.
|
|
"""
|
|
network = self.wifi_config_list[0]
|
|
if not wutils.connect_to_wifi_network_with_id(self.dut,
|
|
network[NETID],
|
|
network[SSID]):
|
|
raise signals.TestFailure("Failed to connect to %s after OTA" %
|
|
network[SSID])
|
|
wutils.wifi_forget_network(self.dut, network[SSID])
|
|
|
|
@test_tracker_info(uuid="05671859-38b1-4dbf-930c-18048971d075")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_check_wifi_toggling_after_au(self):
|
|
"""Check if WiFi can be toggled ON/OFF after auto-update."""
|
|
self.log.debug("Going from on to off.")
|
|
wutils.wifi_toggle_state(self.dut, False)
|
|
self.log.debug("Going from off to on.")
|
|
wutils.wifi_toggle_state(self.dut, True)
|
|
|
|
@test_tracker_info(uuid="440edf32-4b00-42b0-9811-9f2bc4a83efb")
|
|
@WifiBaseTest.wifi_test_wrap
|
|
def test_reset_wifi_after_au(self):
|
|
""""Check if WiFi can be reset after auto-update."""
|
|
wutils.reset_wifi(self.dut)
|