werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/tools/test/connectivity/acts_tests/tests/google/wifi/WifiSoftApTest.py

1265 lines
56 KiB
Python
Raw Normal View History

Initial commit: AOSP 14 with modifications for Unplugged OS
2025-10-06 13:59:42 +00:00
#!/usr/bin/env python3.4
#
# Copyright 2016 - The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import time
from acts import asserts
from acts import utils
from acts.keys import Config
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.tel import tel_test_utils as tel_utils
from acts_contrib.test_utils.wifi import wifi_constants
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
WifiEnums = wutils.WifiEnums
WIFI_CONFIG_APBAND_2G = WifiEnums.WIFI_CONFIG_APBAND_2G
WIFI_CONFIG_APBAND_5G = WifiEnums.WIFI_CONFIG_APBAND_5G
WIFI_CONFIG_APBAND_AUTO = WifiEnums.WIFI_CONFIG_APBAND_AUTO
WPA3_SAE_TRANSITION_SOFTAP = WifiEnums.SoftApSecurityType.WPA3_SAE_TRANSITION
WPA3_SAE_SOFTAP = WifiEnums.SoftApSecurityType.WPA3_SAE
WAIT_AFTER_REBOOT = 10
class WifiSoftApTest(WifiBaseTest):
def setup_class(self):
"""It will setup the required dependencies from config file and configure
the devices for softap mode testing.
Returns:
True if successfully configured the requirements for testing.
"""
super().setup_class()
self.dut = self.android_devices[0]
self.dut_client = self.android_devices[1]
req_params = ["dbs_supported_models", "sta_concurrency_supported_models",
"wifi6_models"]
opt_param = ["reference_networks"]
self.unpack_userparams(
req_param_names=req_params, opt_param_names=opt_param)
if "AccessPoint" in self.user_params:
self.legacy_configure_ap_and_start()
elif "OpenWrtAP" in self.user_params:
self.configure_openwrt_ap_and_start(wpa_network=True)
self.wifi_network = self.reference_networks[0]["2g"]
# Do a simple version of init - mainly just sync the time and enable
# verbose logging. This test will fail if the DUT has a sim and cell
# data is disabled. We would also like to test with phones in less
# constrained states (or add variations where we specifically
# constrain).
utils.require_sl4a((self.dut, self.dut_client))
utils.sync_device_time(self.dut)
utils.sync_device_time(self.dut_client)
# Enable verbose logging on the duts
self.dut.droid.wifiEnableVerboseLogging(1)
asserts.assert_equal(self.dut.droid.wifiGetVerboseLoggingLevel(), 1,
"Failed to enable WiFi verbose logging on the softap dut.")
self.dut_client.droid.wifiEnableVerboseLogging(1)
asserts.assert_equal(self.dut_client.droid.wifiGetVerboseLoggingLevel(), 1,
"Failed to enable WiFi verbose logging on the client dut.")
wutils.wifi_toggle_state(self.dut, True)
wutils.wifi_toggle_state(self.dut_client, True)
self.AP_IFACE = 'wlan0'
if self.dut.model in self.dbs_supported_models:
self.AP_IFACE = 'wlan1'
if self.dut.model in self.sta_concurrency_supported_models:
self.AP_IFACE = 'wlan2'
if len(self.android_devices) > 2:
utils.sync_device_time(self.android_devices[2])
self.android_devices[2].droid.wifiEnableVerboseLogging(1)
asserts.assert_equal(self.android_devices[2].droid.wifiGetVerboseLoggingLevel(), 1,
"Failed to enable WiFi verbose logging on the client dut.")
self.dut_client_2 = self.android_devices[2]
self.country_code = wutils.WifiEnums.CountryCode.US
if hasattr(self, "country_code_file"):
if isinstance(self.country_code_file, list):
self.country_code_file = self.country_code_file[0]
if not os.path.isfile(self.country_code_file):
self.country_code_file = os.path.join(
self.user_params[Config.key_config_path.value],
self.country_code_file)
self.country_code = utils.load_config(
self.country_code_file)["country"]
def teardown_class(self):
if self.dut.droid.wifiIsApEnabled():
wutils.stop_wifi_tethering(self.dut)
wutils.reset_wifi(self.dut)
wutils.reset_wifi(self.dut_client)
if "AccessPoint" in self.user_params:
del self.user_params["reference_networks"]
del self.user_params["open_network"]
def setup_test(self):
super().setup_test()
for ad in self.android_devices:
wutils.wifi_toggle_state(ad, True)
if "chan_13" in self.test_name and "OpenWrtAP" in self.user_params:
self.access_points[0].close()
self.configure_openwrt_ap_and_start(wpa_network=True,
channel_2g=13)
self.wifi_network = self.reference_networks[0]["2g"]
for ad in self.android_devices:
wutils.set_wifi_country_code(
ad, wutils.WifiEnums.CountryCode.AUSTRALIA)
def teardown_test(self):
super().teardown_test()
self.dut.log.debug("Toggling Airplane mode OFF.")
asserts.assert_true(utils.force_airplane_mode(self.dut, False),
"Can not turn off airplane mode: %s" % self.dut.serial)
if self.dut.droid.wifiIsApEnabled():
wutils.stop_wifi_tethering(self.dut)
if "chan_13" in self.test_name and "OpenWrtAP" in self.user_params:
self.access_points[0].close()
self.configure_openwrt_ap_and_start(wpa_network=True)
self.wifi_network = self.reference_networks[0]["2g"]
for ad in self.android_devices:
wutils.set_wifi_country_code(ad, self.country_code)
""" Helper Functions """
def create_softap_config(self):
"""Create a softap config with ssid and password."""
ap_ssid = "softap_" + utils.rand_ascii_str(8)
ap_password = utils.rand_ascii_str(8)
self.dut.log.info("softap setup: %s %s", ap_ssid, ap_password)
config = {wutils.WifiEnums.SSID_KEY: ap_ssid}
config[wutils.WifiEnums.PWD_KEY] = ap_password
return config
def confirm_softap_in_scan_results(self, ap_ssid):
"""Confirm the ap started by wifi tethering is seen in scan results.
Args:
ap_ssid: SSID of the ap we are looking for.
"""
wutils.start_wifi_connection_scan_and_ensure_network_found(
self.dut_client, ap_ssid);
def confirm_softap_not_in_scan_results(self, ap_ssid):
"""Confirm the ap started by wifi tethering is not seen in scan results.
Args:
ap_ssid: SSID of the ap we are looking for.
"""
wutils.start_wifi_connection_scan_and_ensure_network_not_found(
self.dut_client, ap_ssid);
def check_cell_data_and_enable(self):
"""Make sure that cell data is enabled if there is a sim present.
If a sim is active, cell data needs to be enabled to allow provisioning
checks through (when applicable). This is done to relax hardware
requirements on DUTs - without this check, running this set of tests
after other wifi tests may cause failures.
"""
# We do have a sim. Make sure data is enabled so we can tether.
if not self.dut.droid.telephonyIsDataEnabled():
self.dut.log.info("need to enable data")
self.dut.droid.telephonyToggleDataConnection(True)
asserts.assert_true(self.dut.droid.telephonyIsDataEnabled(),
"Failed to enable cell data for softap dut.")
def validate_full_tether_startup(self, band=None, hidden=None,
test_ping=False, test_clients=None,
security=None):
"""Test full startup of wifi tethering
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
initial_wifi_state = self.dut.droid.wifiCheckState()
initial_cell_state = tel_utils.is_sim_ready(self.log, self.dut)
self.dut.log.info("current state: %s", initial_wifi_state)
self.dut.log.info("is sim ready? %s", initial_cell_state)
if initial_cell_state:
self.check_cell_data_and_enable()
config = self.create_softap_config()
wutils.start_wifi_tethering(self.dut,
config[wutils.WifiEnums.SSID_KEY],
config[wutils.WifiEnums.PWD_KEY],
band,
hidden,
security)
if hidden:
# First ensure it's not seen in scan results.
self.confirm_softap_not_in_scan_results(
config[wutils.WifiEnums.SSID_KEY])
# If the network is hidden, it should be saved on the client to be
# seen in scan results.
config[wutils.WifiEnums.HIDDEN_KEY] = True
ret = self.dut_client.droid.wifiAddNetwork(config)
asserts.assert_true(ret != -1, "Add network %r failed" % config)
self.dut_client.droid.wifiEnableNetwork(ret, 0)
self.confirm_softap_in_scan_results(config[wutils.WifiEnums.SSID_KEY])
if test_ping:
self.validate_ping_between_softap_and_client(config)
if test_clients:
if len(self.android_devices) > 2:
self.validate_ping_between_two_clients(config)
wutils.stop_wifi_tethering(self.dut)
asserts.assert_false(self.dut.droid.wifiIsApEnabled(),
"SoftAp is still reported as running")
if initial_wifi_state:
wutils.wait_for_wifi_state(self.dut, True)
elif self.dut.droid.wifiCheckState():
asserts.fail("Wifi was disabled before softap and now it is enabled")
def validate_ping_between_softap_and_client(self, config):
"""Test ping between softap and its client.
Connect one android device to the wifi hotspot.
Verify they can ping each other.
Args:
config: wifi network config with SSID, password
"""
wutils.wifi_connect(self.dut_client, config, check_connectivity=False)
dut_ip = self.dut.droid.connectivityGetIPv4Addresses(self.AP_IFACE)[0]
dut_client_ip = self.dut_client.droid.connectivityGetIPv4Addresses('wlan0')[0]
wutils.verify_11ax_softap(self.dut, self.dut_client, self.wifi6_models)
self.dut.log.info("Try to ping %s" % dut_client_ip)
asserts.assert_true(
utils.adb_shell_ping(self.dut, count=10, dest_ip=dut_client_ip, timeout=20),
"%s ping %s failed" % (self.dut.serial, dut_client_ip))
self.dut_client.log.info("Try to ping %s" % dut_ip)
asserts.assert_true(
utils.adb_shell_ping(self.dut_client, count=10, dest_ip=dut_ip, timeout=20),
"%s ping %s failed" % (self.dut_client.serial, dut_ip))
wutils.stop_wifi_tethering(self.dut)
def validate_ping_between_two_clients(self, config):
"""Test ping between softap's clients.
Connect two android device to the wifi hotspot.
Verify the clients can ping each other.
Args:
config: wifi network config with SSID, password
"""
# Connect DUT to Network
ad1 = self.dut_client
ad2 = self.android_devices[2]
wutils.wifi_connect(ad1, config, check_connectivity=False)
wutils.wifi_connect(ad2, config, check_connectivity=False)
ad1_ip = ad1.droid.connectivityGetIPv4Addresses('wlan0')[0]
ad2_ip = ad2.droid.connectivityGetIPv4Addresses('wlan0')[0]
# Ping each other
ad1.log.info("Try to ping %s" % ad2_ip)
asserts.assert_true(
utils.adb_shell_ping(ad1, count=10, dest_ip=ad2_ip, timeout=20),
"%s ping %s failed" % (ad1.serial, ad2_ip))
ad2.log.info("Try to ping %s" % ad1_ip)
asserts.assert_true(
utils.adb_shell_ping(ad2, count=10, dest_ip=ad1_ip, timeout=20),
"%s ping %s failed" % (ad2.serial, ad1_ip))
def validate_softap_after_reboot(self, band, security, hidden=False):
config = self.create_softap_config()
softap_config = config.copy()
softap_config[WifiEnums.AP_BAND_KEY] = band
softap_config[WifiEnums.SECURITY] = security
if hidden:
softap_config[WifiEnums.HIDDEN_KEY] = hidden
asserts.assert_true(
self.dut.droid.wifiSetWifiApConfiguration(softap_config),
"Failed to update WifiAp Configuration")
self.dut.reboot()
time.sleep(WAIT_AFTER_REBOOT)
wutils.start_wifi_tethering_saved_config(self.dut)
wutils.connect_to_wifi_network(self.dut_client, config, hidden=hidden)
""" Tests Begin """
@test_tracker_info(uuid="495f1252-e440-461c-87a7-2c45f369e129")
def test_check_wifi_tethering_supported(self):
"""Test check for wifi tethering support.
1. Call method to check if wifi hotspot is supported
"""
# TODO(silberst): wifiIsPortableHotspotSupported() is currently failing.
# Remove the extra check and logging when b/30800811 is resolved
hotspot_supported = self.dut.droid.wifiIsPortableHotspotSupported()
tethering_supported = self.dut.droid.connectivityIsTetheringSupported()
self.log.info(
"IsPortableHotspotSupported: %s, IsTetheringSupported %s." % (
hotspot_supported, tethering_supported))
asserts.assert_true(hotspot_supported,
"DUT should support wifi tethering but is reporting false.")
asserts.assert_true(tethering_supported,
"DUT should also support wifi tethering when called from ConnectivityManager")
@test_tracker_info(uuid="09c19c35-c708-48a5-939b-ac2bbb403d54")
def test_full_tether_startup(self):
"""Test full startup of wifi tethering in default band.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup()
@test_tracker_info(uuid="6437727d-7db1-4f69-963e-f26a7797e47f")
def test_full_tether_startup_2G(self):
"""Test full startup of wifi tethering in 2G band.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_2G)
@test_tracker_info(uuid="970272fa-1302-429b-b261-51efb4dad779")
def test_full_tether_startup_5G(self):
"""Test full startup of wifi tethering in 5G band.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_5G)
@test_tracker_info(uuid="f76ed37a-519a-48b4-b260-ee3fc5a9cae0")
def test_full_tether_startup_auto(self):
"""Test full startup of wifi tethering in auto-band.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_AUTO)
@test_tracker_info(uuid="d26ee4df-5dcb-4191-829f-05a10b1218a7")
def test_full_tether_startup_2G_hidden(self):
"""Test full startup of wifi tethering in 2G band using hidden AP.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_2G, True)
@test_tracker_info(uuid="229cd585-a789-4c9a-8948-89fa72de9dd5")
def test_full_tether_startup_5G_hidden(self):
"""Test full startup of wifi tethering in 5G band using hidden AP.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_5G, True)
@test_tracker_info(uuid="d546a143-6047-4ffd-b3c6-5ec81a38001f")
def test_full_tether_startup_auto_hidden(self):
"""Test full startup of wifi tethering in auto-band using hidden AP.
1. Report current state.
2. Switch to AP mode.
3. verify SoftAP active.
4. Shutdown wifi tethering.
5. verify back to previous mode.
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_AUTO, True)
@test_tracker_info(uuid="25996696-e9c8-4cd3-816a-44536166e69f")
def test_full_tether_startup_wpa3(self):
"""Test full startup of softap in default band and wpa3 security.
Steps:
1. Configure softap in default band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="65ecdd4b-857e-4bda-87e7-3db578cee7aa")
def test_full_tether_startup_2G_wpa3(self):
"""Test full startup of softap in 2G band and wpa3 security.
Steps:
1. Configure softap in 2G band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_2G, security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="dbc788dc-bf11-48aa-b88f-c2ee767cd13d")
def test_full_tether_startup_5G_wpa3(self):
"""Test full startup of softap in 5G band and wpa3 security.
Steps:
1. Configure softap in 5G band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_5G, security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="1192c522-824a-4a79-a6cd-bd63b7d19e82")
def test_full_tether_startup_auto_wpa3(self):
"""Test full startup of softap in auto band and wpa3 security.
Steps:
1. Configure softap in auto band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_AUTO, security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="120d2dcb-ded6-40d3-854c-366c200c8deb")
def test_full_tether_startup_hidden_wpa3(self):
"""Test full startup of hidden softap in default band and wpa3 security.
Steps:
1. Configure hidden softap in default band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(security=WPA3_SAE_SOFTAP, hidden=True)
@test_tracker_info(uuid="82fc2329-480b-4cab-bf9d-e1c397673e4a")
def test_full_tether_startup_2G_hidden_wpa3(self):
"""Test full startup of hidden softap in 2G band and wpa3 security.
Steps:
1. Configure hidden softap in 2G band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_2G, True, security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="0da2958e-de0b-4567-aff1-d4ba5439eb4e")
def test_full_tether_startup_5G_hidden_wpa3(self):
"""Test full startup of hidden softap in 5G band and wpa3 security.
Steps:
1. Configure hidden softap in 5G band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_5G, True, security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="1412f928-e89b-4e84-8ad0-1b14e936b239")
def test_full_tether_startup_auto_hidden_wpa3(self):
"""Test full startup of hidden softap in auto band and wpa3 security.
Steps:
1. Configure hidden softap in auto band and wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_AUTO, True, security=WPA3_SAE_SOFTAP)
@test_tracker_info(uuid="e1433f7e-57f6-4475-822c-754d77817bbc")
def test_full_tether_startup_wpa2_wpa3(self):
"""Test full startup of softap in default band and wpa2/wpa3 security.
Steps:
1. Configure softap in default band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_full_tether_startup(security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="8f55209f-0b9a-4600-a416-84d075c349af")
def test_full_tether_startup_2G_wpa2_wpa3(self):
"""Test full startup of softap in 2G band and wpa2/wpa3 security.
Steps:
1. Configure softap in default band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_2G, security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="3d54b7c5-cc34-473f-b484-fc3bf1773a90")
def test_full_tether_startup_5G_wpa2_wpa3(self):
"""Test full startup of softap in 5G band and wpa2/wpa3 security.
Steps:
1. Configure softap in default band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_5G, security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="f07bedd2-d768-497d-8922-2e5fe1cd9365")
def test_full_tether_startup_auto_wpa2_wpa3(self):
"""Test full startup of softap in auto band and wpa2/wpa3 security.
Steps:
1. Configure softap in default band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_AUTO, security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="9a54f97f-eaca-4a64-ad20-f9e52f8b16a1")
def test_full_tether_startup_2G_hidden_wpa2_wpa3(self):
"""Test full startup of hidden softap in 2G band and wpa2/wpa3.
Steps:
1. Configure hidden softap in 2G band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_2G, True, security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="1baef45f-c6c9-46bc-8227-1aacf410e60d")
def test_full_tether_startup_5G_hidden_wpa2_wpa3(self):
"""Test full startup of hidden softap in 5G band and wpa2/wpa3 security.
Steps:
1. Configure hidden softap in 5G band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_5G, True, security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="1976ac84-f967-4961-bdb9-4fcfe297fe22")
def test_full_tether_startup_auto_hidden_wpa2_wpa3(self):
"""Test full startup of hidden softap in auto band and wpa2/wpa3.
Steps:
1. Configure hidden softap in auto band and wpa2/wpa3 security.
2. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_full_tether_startup(
WIFI_CONFIG_APBAND_AUTO, True, security=WPA3_SAE_TRANSITION_SOFTAP)
@test_tracker_info(uuid="dd4c79dc-169f-4d8f-a700-95ba2923af35")
def test_softap_wpa3_2g_after_reboot(self):
"""Test full startup of softap in 2G band, wpa3 security after reboot.
Steps:
1. Save softap in 2G band and wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_2G, WPA3_SAE_SOFTAP, False)
@test_tracker_info(uuid="02f080d8-91e7-4363-a291-da3c87e74758")
def test_softap_wpa3_5g_after_reboot(self):
"""Test full startup of softap in 5G band, wpa3 security after reboot.
Steps:
1. Save softap in 5G band and wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_5G, WPA3_SAE_SOFTAP, False)
@test_tracker_info(uuid="2224f94e-88e8-4ebf-bbab-f78ab24cefda")
def test_softap_wpa2_wpa3_2g_after_reboot(self):
"""Test softap in 2G band, wpa2/wpa3 security after reboot.
Steps:
1. Save softap in 2G band and wpa2/wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_2G, WPA3_SAE_TRANSITION_SOFTAP, False)
@test_tracker_info(uuid="320643e2-9e13-4c8c-a2cb-1903b6bd3741")
def test_softap_wpa2_wpa3_5g_after_reboot(self):
"""Test softap in 5G band, wpa2/wpa3 security after reboot.
Steps:
1. Save softap in 5G band and wpa2/wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_5G, WPA3_SAE_TRANSITION_SOFTAP, False)
@test_tracker_info(uuid="52005efc-45a2-41df-acd1-5fd551e88a3c")
def test_softap_wpa3_2g_hidden_after_reboot(self):
"""Test hidden softap in 2G band, wpa3 security after reboot.
Steps:
1. Save hidden softap in 2G band and wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_2G, WPA3_SAE_SOFTAP, True)
@test_tracker_info(uuid="78e07c03-f628-482d-b78b-84bdfba0bfaf")
def test_softap_wpa3_5g_hidden_after_reboot(self):
"""Test hidden softap in 5G band, wpa3 security after reboot.
Steps:
1. Save hidden softap in 5G band and wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_5G, WPA3_SAE_SOFTAP, True)
@test_tracker_info(uuid="749ba522-dd1f-459a-81bd-957943201c32")
def test_softap_wpa2_wpa3_2g_hidden_after_reboot(self):
"""Test hidden softap in 2G band, wpa2/wpa3 security after reboot.
Steps:
1. Save hidden softap in 2G band and wpa2/wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_2G, WPA3_SAE_TRANSITION_SOFTAP, True)
@test_tracker_info(uuid="638f1456-8556-448d-8cad-63e6b72337ca")
def test_softap_wpa2_wpa3_5g_hidden_after_reboot(self):
"""Test hidden softap in 5G band, wpa2/wpa3 security after reboot.
Steps:
1. Save hidden softap in 5G band and wpa2/wpa3 security.
2. Reboot device and start softap.
3. Verify dut client connects to the softap.
"""
asserts.skip_if(self.dut.model not in self.sta_concurrency_supported_models,
"DUT does not support WPA2/WPA3 softAp")
self.validate_softap_after_reboot(
WIFI_CONFIG_APBAND_5G, WPA3_SAE_TRANSITION_SOFTAP, True)
@test_tracker_info(uuid="b2f75330-bf33-4cdd-851a-de390f891ef7")
def test_tether_startup_while_connected_to_a_network(self):
"""Test full startup of wifi tethering in auto-band while the device
is connected to a network.
1. Connect to an open network.
2. Turn on AP mode (in auto band).
3. Verify SoftAP active.
4. Make a client connect to the AP.
5. Shutdown wifi tethering.
6. Ensure that the client disconnected.
"""
wutils.wifi_toggle_state(self.dut, True)
wutils.wifi_connect(self.dut, self.wifi_network)
config = self.create_softap_config()
wutils.start_wifi_tethering(self.dut,
config[wutils.WifiEnums.SSID_KEY],
config[wutils.WifiEnums.PWD_KEY],
WIFI_CONFIG_APBAND_AUTO)
asserts.assert_true(self.dut.droid.wifiIsApEnabled(),
"SoftAp is not reported as running")
# local hotspot may not have internet connectivity
self.confirm_softap_in_scan_results(config[wutils.WifiEnums.SSID_KEY])
wutils.wifi_connect(self.dut_client, config, check_connectivity=False)
wutils.verify_11ax_softap(self.dut, self.dut_client, self.wifi6_models)
wutils.stop_wifi_tethering(self.dut)
wutils.wait_for_disconnect(self.dut_client)
@test_tracker_info(uuid="f2cf56ad-b8b9-43b6-ab15-a47b1d96b92e")
def test_full_tether_startup_2G_with_airplane_mode_on(self):
"""Test full startup of wifi tethering in 2G band with
airplane mode on.
1. Turn on airplane mode.
2. Report current state.
3. Switch to AP mode.
4. verify SoftAP active.
5. Shutdown wifi tethering.
6. verify back to previous mode.
7. Turn off airplane mode.
"""
self.dut.log.debug("Toggling Airplane mode ON.")
asserts.assert_true(utils.force_airplane_mode(self.dut, True),
"Can not turn on airplane mode: %s" % self.dut.serial)
wutils.wifi_toggle_state(self.dut, True)
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_2G)
@test_tracker_info(uuid="883dd5b1-50c6-4958-a50f-bb4bea77ccaf")
def test_full_tether_startup_2G_one_client_ping_softap(self):
"""(AP) 1 Device can connect to 2G hotspot
Steps:
1. Turn on DUT's 2G softap
2. Client connects to the softap
3. Client and DUT ping each other
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_2G, test_ping=True)
@test_tracker_info(uuid="6604e848-99d6-422c-9fdc-2882642438b6")
def test_full_tether_startup_5G_one_client_ping_softap(self):
"""(AP) 1 Device can connect to 5G hotspot
Steps:
1. Turn on DUT's 5G softap
2. Client connects to the softap
3. Client and DUT ping each other
"""
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_5G, test_ping=True)
@test_tracker_info(uuid="17725ecd-f900-4cf7-8b2d-d7515b0a595c")
def test_softap_2G_two_clients_ping_each_other(self):
"""Test for 2G hotspot with 2 clients
1. Turn on 2G hotspot
2. Two clients connect to the hotspot
3. Two clients ping each other
"""
asserts.skip_if(len(self.android_devices) < 3,
"No extra android devices. Skip test")
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_2G, test_clients=True)
@test_tracker_info(uuid="98c09888-1021-4f79-9065-b3cf9b132146")
def test_softap_5G_two_clients_ping_each_other(self):
"""Test for 5G hotspot with 2 clients
1. Turn on 5G hotspot
2. Two clients connect to the hotspot
3. Two clients ping each other
"""
asserts.skip_if(len(self.android_devices) < 3,
"No extra android devices. Skip test")
self.validate_full_tether_startup(WIFI_CONFIG_APBAND_5G, test_clients=True)
@test_tracker_info(uuid="b991129e-030a-4998-9b08-0687270bec24")
def test_number_of_softap_clients(self):
"""Test for number of softap clients to be updated correctly
1. Turn of hotspot
2. Register softap callback
3. Let client connect to the hotspot
4. Register second softap callback
5. Force client connect/disconnect to hotspot
6. Unregister second softap callback
7. Force second client connect to hotspot (if supported)
8. Turn off hotspot
9. Verify second softap callback doesn't respond after unregister
"""
config = wutils.start_softap_and_verify(self, WIFI_CONFIG_APBAND_AUTO)
# Register callback after softap enabled to avoid unnecessary callback
# impact the test
callbackId = self.dut.droid.registerSoftApCallback()
# Verify clients will update immediately after register callback
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId, 0)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_ENABLED_STATE)
# Force DUTs connect to Network
wutils.wifi_connect(self.dut_client, config,
check_connectivity=False)
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId, 1)
# Register another callback to verify multi callback clients case
callbackId_2 = self.dut.droid.registerSoftApCallback()
# Verify clients will update immediately after register callback
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId_2, 1)
wutils.wait_for_expected_softap_state(self.dut, callbackId_2,
wifi_constants.WIFI_AP_ENABLED_STATE)
# Client Off/On Wifi to verify number of softap clients will be updated
wutils.toggle_wifi_and_wait_for_reconnection(self.dut_client, config)
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId_2, 0)
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 1)
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId_2, 1)
# Unregister callbackId_2 to verify multi callback clients case
self.dut.droid.unregisterSoftApCallback(callbackId_2)
if len(self.android_devices) > 2:
wutils.wifi_connect(self.android_devices[2], config,
check_connectivity=False)
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId, 2)
# Turn off softap when clients connected
wutils.stop_wifi_tethering(self.dut)
wutils.wait_for_disconnect(self.dut_client)
if len(self.android_devices) > 2:
wutils.wait_for_disconnect(self.android_devices[2])
# Verify client number change back to 0 after softap stop if client
# doesn't disconnect before softap stop
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_DISABLING_STATE)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_DISABLED_STATE)
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId, 0)
# Unregister callback
self.dut.droid.unregisterSoftApCallback(callbackId)
# Check no any callbackId_2 event after unregister
asserts.assert_equal(
wutils.get_current_number_of_softap_clients(
self.dut, callbackId_2), None)
@test_tracker_info(uuid="35bc4ba1-bade-42ee-a563-0c73afb2402a")
def test_softap_auto_shut_off(self):
"""Test for softap auto shut off
1. Turn off hotspot
2. Register softap callback
3. Let client connect to the hotspot
4. Start wait [wifi_constants.DEFAULT_SOFTAP_TIMEOUT_S] seconds
5. Check hotspot doesn't shut off
6. Let client disconnect to the hotspot
7. Start wait [wifi_constants.DEFAULT_SOFTAP_TIMEOUT_S] seconds
8. Check hotspot auto shut off
"""
config = wutils.start_softap_and_verify(self, WIFI_CONFIG_APBAND_AUTO)
# Register callback after softap enabled to avoid unnecessary callback
# impact the test
callbackId = self.dut.droid.registerSoftApCallback()
# Verify clients will update immediately after register callback
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_ENABLED_STATE)
# Force DUTs connect to Network
wutils.wifi_connect(self.dut_client, config, check_connectivity=False)
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId, 1)
self.dut.log.info("Start waiting %s seconds with 1 clients ",
wifi_constants.DEFAULT_SOFTAP_TIMEOUT_S*1.1)
time.sleep(wifi_constants.DEFAULT_SOFTAP_TIMEOUT_S*1.1)
# When client connected, softap should keep as enabled
asserts.assert_true(self.dut.droid.wifiIsApEnabled(),
"SoftAp is not reported as running")
wutils.wifi_toggle_state(self.dut_client, False)
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
self.dut.log.info("Start waiting %s seconds with 0 client",
wifi_constants.DEFAULT_SOFTAP_TIMEOUT_S*1.1)
time.sleep(wifi_constants.DEFAULT_SOFTAP_TIMEOUT_S*1.1)
# Softap should stop since no client connected
# doesn't disconnect before softap stop
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_DISABLING_STATE)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_DISABLED_STATE)
asserts.assert_false(self.dut.droid.wifiIsApEnabled(),
"SoftAp is not reported as running")
self.dut.droid.unregisterSoftApCallback(callbackId)
@test_tracker_info(uuid="3a10c7fd-cd8d-4d46-9d12-88a68640e060")
def test_softap_auto_shut_off_with_customized_timeout(self):
"""Test for softap auto shut off
1. Turn on hotspot
2. Register softap callback
3. Backup original shutdown timeout value
4. Set up test_shutdown_timeout_value
5. Let client connect to the hotspot
6. Start wait test_shutdown_timeout_value * 1.1 seconds
7. Check hotspot doesn't shut off
8. Let client disconnect to the hotspot
9. Start wait test_shutdown_timeout_value seconds
10. Check hotspot auto shut off
"""
# Backup config
original_softap_config = self.dut.droid.wifiGetApConfiguration()
# This config only included SSID and Password which used for connection
# only.
config = wutils.start_softap_and_verify(self, WIFI_CONFIG_APBAND_AUTO)
# Get current configuration to use for update configuration
current_softap_config = self.dut.droid.wifiGetApConfiguration()
# Register callback after softap enabled to avoid unnecessary callback
# impact the test
callbackId = self.dut.droid.registerSoftApCallback()
# Verify clients will update immediately after register callback
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_ENABLED_STATE)
# Setup shutdown timeout value
test_shutdown_timeout_value_s = 10
wutils.save_wifi_soft_ap_config(self.dut, current_softap_config,
shutdown_timeout_millis=test_shutdown_timeout_value_s * 1000)
# Force DUTs connect to Network
wutils.wifi_connect(self.dut_client, config, check_connectivity=False)
wutils.wait_for_expected_number_of_softap_clients(
self.dut, callbackId, 1)
self.dut.log.info("Start waiting %s seconds with 1 clients ",
test_shutdown_timeout_value_s * 1.1)
time.sleep(test_shutdown_timeout_value_s * 1.1)
# When client connected, softap should keep as enabled
asserts.assert_true(self.dut.droid.wifiIsApEnabled(),
"SoftAp is not reported as running")
wutils.wifi_toggle_state(self.dut_client, False)
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
self.dut.log.info("Start waiting %s seconds with 0 client",
test_shutdown_timeout_value_s * 1.1)
time.sleep(test_shutdown_timeout_value_s * 1.1)
# Softap should stop since no client connected
# doesn't disconnect before softap stop
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_DISABLING_STATE)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_DISABLED_STATE)
asserts.assert_false(self.dut.droid.wifiIsApEnabled(),
"SoftAp is not reported as running")
self.dut.droid.unregisterSoftApCallback(callbackId)
# Restore config
wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)
@test_tracker_info(uuid="a9444699-f0d3-4ac3-922b-05e9d4f67968")
def test_softap_configuration_update(self):
"""Test for softap configuration update
1. Get current softap configuration
2. Update to Open Security configuration
3. Update to WPA2_PSK configuration
4. Update to Multi-Channels, Mac Randomization off,
bridged_shutdown off, 11ax off configuration which are introduced in S.
5. Restore the configuration
"""
# Backup config
original_softap_config = self.dut.droid.wifiGetApConfiguration()
wutils.save_wifi_soft_ap_config(self.dut, {"SSID":"ACTS_TEST"},
band=WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, hidden=False,
security=WifiEnums.SoftApSecurityType.OPEN, password="",
channel=11, max_clients=0, shutdown_timeout_enable=False,
shutdown_timeout_millis=0, client_control_enable=True,
allowedList=[], blockedList=[])
wutils.save_wifi_soft_ap_config(self.dut, {"SSID":"ACTS_TEST"},
band=WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G, hidden=True,
security=WifiEnums.SoftApSecurityType.WPA2, password="12345678",
channel=0, max_clients=1, shutdown_timeout_enable=True,
shutdown_timeout_millis=10000, client_control_enable=False,
allowedList=["aa:bb:cc:dd:ee:ff"], blockedList=["11:22:33:44:55:66"])
if self.dut.droid.isSdkAtLeastS():
wutils.save_wifi_soft_ap_config(self.dut, {"SSID":"ACTS_TEST"},
channel_frequencys=[2412,5745],
mac_randomization_setting = wifi_constants.SOFTAP_RANDOMIZATION_NONE,
bridged_opportunistic_shutdown_enabled=False,
ieee80211ax_enabled=False)
# Restore config
wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)
@test_tracker_info(uuid="8a5d81fa-649c-4679-a823-5cef50828a94")
def test_softap_client_control(self):
"""Test Client Control feature
1. Check SoftApCapability to make sure feature is supported
2. Backup config
3. Setup configuration which used to start softap
4. Register callback after softap enabled
5. Trigger client connect to softap
6. Verify blocking event
7. Add client into allowed list
8. Verify client connected
9. Restore Config
"""
# Register callback to check capability first
callbackId = self.dut.droid.registerSoftApCallback()
# Check capability first to make sure DUT support this test.
capabilityEventStr = wifi_constants.SOFTAP_CALLBACK_EVENT + str(
callbackId) + wifi_constants.SOFTAP_CAPABILITY_CHANGED
capability = self.dut.ed.pop_event(capabilityEventStr, 10)
asserts.skip_if(not capability['data'][wifi_constants
.SOFTAP_CAPABILITY_FEATURE_CLIENT_CONTROL],
"Client control isn't supported, ignore test")
# Unregister callback before start test to avoid
# unnecessary callback impact the test
self.dut.droid.unregisterSoftApCallback(callbackId)
# start the test
# Backup config
original_softap_config = self.dut.droid.wifiGetApConfiguration()
# Setup configuration which used to start softap
wutils.save_wifi_soft_ap_config(self.dut, {"SSID":"ACTS_TEST"},
band=WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G, hidden=False,
security=WifiEnums.SoftApSecurityType.WPA2, password="12345678",
client_control_enable=True)
wutils.start_wifi_tethering_saved_config(self.dut)
current_softap_config = self.dut.droid.wifiGetApConfiguration()
# Register callback after softap enabled to avoid unnecessary callback
# impact the test
callbackId = self.dut.droid.registerSoftApCallback()
# Verify clients will update immediately after register callback
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_ENABLED_STATE)
# Trigger client connection
self.dut_client.droid.wifiConnectByConfig(current_softap_config)
eventStr = wifi_constants.SOFTAP_CALLBACK_EVENT + str(
callbackId) + wifi_constants.SOFTAP_BLOCKING_CLIENT_CONNECTING
blockedClient = self.dut.ed.pop_event(eventStr, 10)
asserts.assert_equal(blockedClient['data'][wifi_constants.
SOFTAP_BLOCKING_CLIENT_REASON_KEY],
wifi_constants.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER,
"Blocked reason code doesn't match")
# Update configuration, add client into allowed list
wutils.save_wifi_soft_ap_config(self.dut, current_softap_config,
allowedList=[blockedClient['data'][wifi_constants.
SOFTAP_BLOCKING_CLIENT_WIFICLIENT_KEY]])
# Wait configuration updated
time.sleep(3)
# Trigger connection again
self.dut_client.droid.wifiConnectByConfig(current_softap_config)
# Verify client connected
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 1)
# Restore config
wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)
# Unregister callback
self.dut.droid.unregisterSoftApCallback(callbackId)
@test_tracker_info(uuid="d0b61b58-fa2b-4ced-bc52-3366cb826e79")
def test_softap_max_client_setting(self):
"""Test Client Control feature
1. Check device number and capability to make sure feature is supported
2. Backup config
3. Setup configuration which used to start softap
4. Register callback after softap enabled
5. Trigger client connect to softap
6. Verify blocking event
7. Extend max client setting
8. Verify client connected
9. Restore Config
"""
asserts.skip_if(len(self.android_devices) < 3,
"Device less than 3, skip the test.")
# Register callback to check capability first
callbackId = self.dut.droid.registerSoftApCallback()
# Check capability first to make sure DUT support this test.
capabilityEventStr = wifi_constants.SOFTAP_CALLBACK_EVENT + str(
callbackId) + wifi_constants.SOFTAP_CAPABILITY_CHANGED
capability = self.dut.ed.pop_event(capabilityEventStr, 10)
asserts.skip_if(not capability['data'][wifi_constants
.SOFTAP_CAPABILITY_FEATURE_CLIENT_CONTROL],
"Client control isn't supported, ignore test")
# Unregister callback before start test to avoid
# unnecessary callback impact the test
self.dut.droid.unregisterSoftApCallback(callbackId)
# Backup config
original_softap_config = self.dut.droid.wifiGetApConfiguration()
# Setup configuration which used to start softap
wutils.save_wifi_soft_ap_config(self.dut, {"SSID":"ACTS_TEST"},
band=WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G, hidden=False,
security=WifiEnums.SoftApSecurityType.WPA2, password="12345678",
max_clients=1)
wutils.start_wifi_tethering_saved_config(self.dut)
current_softap_config = self.dut.droid.wifiGetApConfiguration()
# Register callback again after softap enabled to avoid
# unnecessary callback impact the test
callbackId = self.dut.droid.registerSoftApCallback()
# Verify clients will update immediately after register calliback
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 0)
wutils.wait_for_expected_softap_state(self.dut, callbackId,
wifi_constants.WIFI_AP_ENABLED_STATE)
# Trigger client connection
self.dut_client.droid.wifiConnectByConfig(current_softap_config)
self.dut_client_2.droid.wifiConnectByConfig(current_softap_config)
# Wait client connect
time.sleep(3)
# Verify one client connected and one blocked due to max client
eventStr = wifi_constants.SOFTAP_CALLBACK_EVENT + str(
callbackId) + wifi_constants.SOFTAP_BLOCKING_CLIENT_CONNECTING
blockedClient = self.dut.ed.pop_event(eventStr, 10)
asserts.assert_equal(blockedClient['data'][wifi_constants.
SOFTAP_BLOCKING_CLIENT_REASON_KEY],
wifi_constants.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS,
"Blocked reason code doesn't match")
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 1)
# Update configuration, extend client to 2
wutils.save_wifi_soft_ap_config(self.dut, current_softap_config,
max_clients=2)
# Wait configuration updated
time.sleep(3)
# Trigger connection again
self.dut_client_2.droid.wifiConnectByConfig(current_softap_config)
# Wait client connect
time.sleep(3)
# Verify client connected
wutils.wait_for_expected_number_of_softap_clients(self.dut,
callbackId, 2)
# Restore config
wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)
# Unregister callback
self.dut.droid.unregisterSoftApCallback(callbackId)
@test_tracker_info(uuid="07b4e5b3-48ce-49b9-a83e-3e288bb88e91")
def test_softap_5g_preferred_country_code_de(self):
"""Verify softap works when set to 5G preferred band
with country code 'DE'.
Steps:
1. Set country code to Germany
2. Save a softap configuration set to 5G preferred band.
3. Start softap and verify it works
4. Verify a client device can connect to it.
"""
wutils.set_wifi_country_code(
self.dut, wutils.WifiEnums.CountryCode.GERMANY)
sap_config = self.create_softap_config()
wifi_network = sap_config.copy()
sap_config[
WifiEnums.AP_BAND_KEY] = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G
sap_config[WifiEnums.SECURITY] = WifiEnums.SoftApSecurityType.WPA2
asserts.assert_true(
self.dut.droid.wifiSetWifiApConfiguration(sap_config),
"Failed to set WifiAp Configuration")
wutils.start_wifi_tethering_saved_config(self.dut)
softap_conf = self.dut.droid.wifiGetApConfiguration()
self.log.info("softap conf: %s" % softap_conf)
sap_band = softap_conf[WifiEnums.AP_BAND_KEY]
asserts.assert_true(
sap_band == WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G,
"Soft AP didn't start in 5G preferred band")
wutils.connect_to_wifi_network(self.dut_client, wifi_network)
wutils.verify_11ax_softap(self.dut, self.dut_client, self.wifi6_models)
@test_tracker_info(uuid="dbcd653c-ec65-400f-a6ce-77bb13add473")
def test_softp_2g_channel_when_connected_to_chan_13(self):
"""Verify softAp 2G channel when connected to network on channel 13.
Steps:
1. Configure AP in channel 13 on 2G band and connect DUT to it.
2. Start softAp on DUT on 2G band.
3. Verify softAp is started on channel 13.
"""
asserts.skip_if("OpenWrtAP" not in self.user_params,
"Need openwrt AP to configure channel 13.")
wutils.connect_to_wifi_network(self.dut, self.wifi_network)
sap_config = self.create_softap_config()
sap_config[WifiEnums.AP_BAND_KEY] = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G
asserts.assert_true(
self.dut.droid.wifiSetWifiApConfiguration(sap_config),
"Failed to set WifiAp Configuration")
wutils.start_wifi_tethering_saved_config(self.dut)
softap_conf = self.dut.droid.wifiGetApConfiguration()
self.log.info("softap conf: %s" % softap_conf)
wutils.connect_to_wifi_network(self.dut_client, sap_config)
softap_channel = self.dut_client.droid.wifiGetConnectionInfo(
)
conn_info = self.dut_client.droid.wifiGetConnectionInfo()
self.log.info("Wifi connection info on dut_client: %s" % conn_info)
softap_channel = wutils.WifiEnums.freq_to_channel[conn_info["frequency"]]
asserts.assert_true(softap_channel == 13,
"Dut client did not connect to softAp on channel 13")
""" Tests End """
if __name__ == "__main__":
pass
Reference in New Issue Copy Permalink