| #!/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 itertools |
| import json |
| import pprint |
| import queue |
| import time |
| |
| import acts.base_test |
| import acts.signals as signals |
| import acts_contrib.test_utils.wifi.wifi_test_utils as wutils |
| import acts.utils |
| |
| from acts import asserts |
| from acts.test_decorators import test_tracker_info |
| from acts_contrib.test_utils.bt.bt_test_utils import enable_bluetooth |
| from acts_contrib.test_utils.bt.bt_test_utils import disable_bluetooth |
| from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest |
| from acts_contrib.test_utils.wifi.wifi_constants import\ |
| COEX_BAND, COEX_CHANNEL, COEX_POWER_CAP_DBM, KEY_COEX_UNSAFE_CHANNELS, KEY_COEX_RESTRICTIONS |
| |
| WifiEnums = wutils.WifiEnums |
| # 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 WifiManagerTest(WifiBaseTest): |
| """Tests for APIs in Android's WifiManager class. |
| |
| Test Bed Requirement: |
| * Two Android device |
| * Several Wi-Fi networks visible to the device, including an open Wi-Fi |
| network. |
| """ |
| |
| def __init__(self, configs): |
| super().__init__(configs) |
| self.enable_packet_log = True |
| |
| def setup_class(self): |
| super().setup_class() |
| |
| self.dut = self.android_devices[0] |
| wutils.wifi_test_device_init(self.dut) |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| self.dut_client = None |
| if len(self.android_devices) > 1: |
| self.dut_client = self.android_devices[1] |
| wutils.wifi_test_device_init(self.dut_client) |
| wutils.wifi_toggle_state(self.dut_client, True) |
| |
| req_params = [] |
| opt_param = [ |
| "open_network", "reference_networks", "iperf_server_address", |
| "wpa_networks", "wep_networks", "iperf_server_port", |
| "coex_unsafe_channels", "coex_restrictions", "wifi6_models" |
| ] |
| 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(wpa_network=True, wep_network=True) |
| elif "OpenWrtAP" in self.user_params: |
| self.configure_openwrt_ap_and_start(open_network=True, |
| wpa_network=True, |
| wep_network=True) |
| |
| asserts.assert_true( |
| len(self.reference_networks) > 0, |
| "Need at least one reference network with psk.") |
| self.wpapsk_2g = self.reference_networks[0]["2g"] |
| self.wpapsk_5g = self.reference_networks[0]["5g"] |
| self.open_network_2g = self.open_network[0]["2g"] |
| self.open_network_5g = self.open_network[0]["5g"] |
| |
| def setup_test(self): |
| super().setup_test() |
| for ad in self.android_devices: |
| ad.droid.wakeLockAcquireBright() |
| ad.droid.wakeUpNow() |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| def teardown_test(self): |
| super().teardown_test() |
| for ad in self.android_devices: |
| ad.droid.wakeLockRelease() |
| ad.droid.goToSleepNow() |
| self.turn_location_off_and_scan_toggle_off() |
| if self.dut.droid.wifiIsApEnabled(): |
| wutils.stop_wifi_tethering(self.dut) |
| for ad in self.android_devices: |
| wutils.reset_wifi(ad) |
| self.log.debug("Toggling Airplane mode OFF") |
| asserts.assert_true( |
| acts.utils.force_airplane_mode(self.dut, False), |
| "Can not turn airplane mode off: %s" % self.dut.serial) |
| |
| def teardown_class(self): |
| if "AccessPoint" in self.user_params: |
| del self.user_params["reference_networks"] |
| del self.user_params["open_network"] |
| |
| """Helper Functions""" |
| |
| def connect_to_wifi_network(self, params): |
| """Connection logic for open and psk wifi networks. |
| |
| Args: |
| params: A tuple of network info and AndroidDevice object. |
| """ |
| network, ad = params |
| droid = ad.droid |
| ed = ad.ed |
| SSID = network[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| ad, SSID); |
| wutils.wifi_connect(ad, network, num_of_tries=3) |
| |
| def get_connection_data(self, dut, network): |
| """Get network id and ssid info from connection data. |
| |
| Args: |
| dut: The Android device object under test. |
| network: dict representing the network to connect to. |
| |
| Returns: |
| A convenience dict with the connected network's ID and SSID. |
| |
| """ |
| params = (network, dut) |
| self.connect_to_wifi_network(params) |
| connect_data = dut.droid.wifiGetConnectionInfo() |
| ssid_id_dict = dict() |
| ssid_id_dict[WifiEnums.NETID_KEY] = connect_data[WifiEnums.NETID_KEY] |
| ssid_id_dict[WifiEnums.SSID_KEY] = connect_data[WifiEnums.SSID_KEY] |
| return ssid_id_dict |
| |
| def connect_multiple_networks(self, dut): |
| """Connect to one 2.4GHz and one 5Ghz network. |
| |
| Args: |
| dut: The Android device object under test. |
| |
| Returns: |
| A list with the connection details for the 2GHz and 5GHz networks. |
| |
| """ |
| network_list = list() |
| connect_2g_data = self.get_connection_data(dut, self.wpapsk_2g) |
| network_list.append(connect_2g_data) |
| connect_5g_data = self.get_connection_data(dut, self.wpapsk_5g) |
| network_list.append(connect_5g_data) |
| return network_list |
| |
| 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. |
| |
| Return: |
| Network dict of the unconnected network. |
| |
| """ |
| wifi_info = self.dut.droid.wifiGetConnectionInfo() |
| enabled = network1 |
| if wifi_info[WifiEnums.SSID_KEY] == network1[WifiEnums.SSID_KEY]: |
| enabled = network2 |
| return enabled |
| |
| def check_configstore_networks(self, networks): |
| """Verify that all previously configured networks are presistent after |
| reboot. |
| |
| Args: |
| networks: List of network dicts. |
| |
| Return: |
| None. Raises TestFailure. |
| |
| """ |
| network_info = self.dut.droid.wifiGetConfiguredNetworks() |
| if len(network_info) != len(networks): |
| msg = ( |
| "Length of configured networks before and after reboot don't" |
| " match. \nBefore reboot = %s \n After reboot = %s" % |
| (networks, network_info)) |
| raise signals.TestFailure(msg) |
| current_count = 0 |
| # For each network, check if it exists in configured list after reboot |
| for network in networks: |
| exists = wutils.match_networks({ |
| WifiEnums.SSID_KEY: network[WifiEnums.SSID_KEY] |
| }, network_info) |
| if not len(exists): |
| raise signals.TestFailure("%s network is not present in the" |
| " configured list after reboot" % |
| network[WifiEnums.SSID_KEY]) |
| # Get the new network id for each network after reboot. |
| network[WifiEnums.NETID_KEY] = exists[0]['networkId'] |
| if exists[0]['status'] == 'CURRENT': |
| current_count += 1 |
| # At any given point, there can only be one currently active |
| # network, defined with 'status':'CURRENT' |
| if current_count > 1: |
| raise signals.TestFailure("More than one network showing" |
| "as 'CURRENT' after reboot") |
| |
| def connect_to_wifi_network_with_id(self, network_id, network_ssid): |
| """Connect to the given network using network id and verify SSID. |
| |
| Args: |
| network_id: int Network Id of the network. |
| network_ssid: string SSID of the network. |
| |
| Returns: True if connect using network id was successful; |
| False otherwise. |
| |
| """ |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, network_ssid); |
| wutils.wifi_connect_by_id(self.dut, network_id) |
| connect_data = self.dut.droid.wifiGetConnectionInfo() |
| connect_ssid = connect_data[WifiEnums.SSID_KEY] |
| self.log.debug("Expected SSID = %s Connected SSID = %s" % |
| (network_ssid, connect_ssid)) |
| if connect_ssid != network_ssid: |
| return False |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| return True |
| |
| def run_iperf_client(self, params): |
| """Run iperf traffic after connection. |
| |
| Args: |
| params: A tuple of network info and AndroidDevice object. |
| """ |
| if "iperf_server_address" in self.user_params: |
| wait_time = 5 |
| network, ad = params |
| SSID = network[WifiEnums.SSID_KEY] |
| self.log.info("Starting iperf traffic through {}".format(SSID)) |
| time.sleep(wait_time) |
| port_arg = "-p {}".format(self.iperf_server_port) |
| success, data = ad.run_iperf_client(self.iperf_server_address, |
| port_arg) |
| self.log.debug(pprint.pformat(data)) |
| asserts.assert_true(success, "Error occurred in iPerf traffic.") |
| |
| def connect_to_wifi_network_toggle_wifi_and_run_iperf(self, params): |
| """ Connect to the provided network and then toggle wifi mode and wait |
| for reconnection to the provided network. |
| |
| Logic steps are |
| 1. Connect to the network. |
| 2. Turn wifi off. |
| 3. Turn wifi on. |
| 4. Wait for connection to the network. |
| 5. Run iperf traffic. |
| |
| Args: |
| params: A tuple of network info and AndroidDevice object. |
| """ |
| network, ad = params |
| self.connect_to_wifi_network(params) |
| wutils.toggle_wifi_and_wait_for_reconnection( |
| ad, network, num_of_tries=5) |
| self.run_iperf_client(params) |
| |
| def run_iperf(self, iperf_args): |
| if "iperf_server_address" not in self.user_params: |
| self.log.error(("Missing iperf_server_address. " |
| "Provide one in config.")) |
| else: |
| iperf_addr = self.user_params["iperf_server_address"] |
| self.log.info("Running iperf client.") |
| result, data = self.dut.run_iperf_client(iperf_addr, iperf_args) |
| self.log.debug(data) |
| |
| def run_iperf_rx_tx(self, time, omit=10): |
| args = "-p {} -t {} -O 10".format(self.iperf_server_port, time, omit) |
| self.log.info("Running iperf client {}".format(args)) |
| self.run_iperf(args) |
| args = "-p {} -t {} -O 10 -R".format(self.iperf_server_port, time, |
| omit) |
| self.log.info("Running iperf client {}".format(args)) |
| self.run_iperf(args) |
| |
| def get_energy_info(self): |
| """ Steps: |
| 1. Check that the WiFi energy info reporting support on this device |
| is as expected (support or not). |
| 2. If the device does not support energy info reporting as |
| expected, skip the test. |
| 3. Call API to get WiFi energy info. |
| 4. Verify the values of "ControllerEnergyUsed" and |
| "ControllerIdleTimeMillis" in energy info don't decrease. |
| 5. Repeat from Step 3 for 10 times. |
| """ |
| # Check if dut supports energy info reporting. |
| actual_support = self.dut.droid.wifiIsEnhancedPowerReportingSupported() |
| model = self.dut.model |
| if not actual_support: |
| asserts.skip( |
| ("Device %s does not support energy info reporting as " |
| "expected.") % model) |
| # Verify reported values don't decrease. |
| self.log.info(("Device %s supports energy info reporting, verify that " |
| "the reported values don't decrease.") % model) |
| energy = 0 |
| idle_time = 0 |
| for i in range(10): |
| info = self.dut.droid.wifiGetControllerActivityEnergyInfo() |
| self.log.debug("Iteration %d, got energy info: %s" % (i, info)) |
| new_energy = info["ControllerEnergyUsed"] |
| new_idle_time = info["ControllerIdleTimeMillis"] |
| asserts.assert_true(new_energy >= energy, |
| "Energy value decreased: previous %d, now %d" % |
| (energy, new_energy)) |
| energy = new_energy |
| asserts.assert_true(new_idle_time >= idle_time, |
| "Idle time decreased: previous %d, now %d" % ( |
| idle_time, new_idle_time)) |
| idle_time = new_idle_time |
| wutils.start_wifi_connection_scan(self.dut) |
| |
| def turn_location_on_and_scan_toggle_on(self): |
| """ Turns on wifi location scans. |
| """ |
| acts.utils.set_location_service(self.dut, True) |
| self.dut.droid.wifiScannerToggleAlwaysAvailable(True) |
| msg = "Failed to turn on location service's scan." |
| asserts.assert_true(self.dut.droid.wifiScannerIsAlwaysAvailable(), msg) |
| |
| def turn_location_off_and_scan_toggle_off(self): |
| """ Turns off wifi location scans. |
| """ |
| acts.utils.set_location_service(self.dut, False) |
| self.dut.droid.wifiScannerToggleAlwaysAvailable(False) |
| msg = "Failed to turn off location service's scan." |
| asserts.assert_true(not self.dut.droid.wifiScannerIsAlwaysAvailable(), msg) |
| |
| def turn_location_on_and_scan_toggle_off(self): |
| """ Turns off wifi location scans, but keeps location on. |
| """ |
| acts.utils.set_location_service(self.dut, True) |
| self.dut.droid.wifiScannerToggleAlwaysAvailable(False) |
| msg = "Failed to turn off location service's scan." |
| asserts.assert_true(not self.dut.droid.wifiScannerIsAlwaysAvailable(), msg) |
| |
| def helper_reconnect_toggle_wifi(self): |
| """Connect to multiple networks, turn off/on wifi, then reconnect to |
| a previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn WiFi OFF/ON. |
| 4. Reconnect to the non-current network. |
| |
| """ |
| connect_2g_data = self.get_connection_data(self.dut, self.wpapsk_2g) |
| connect_5g_data = self.get_connection_data(self.dut, self.wpapsk_5g) |
| wutils.toggle_wifi_off_and_on(self.dut) |
| reconnect_to = self.get_enabled_network(connect_2g_data, |
| connect_5g_data) |
| reconnect = self.connect_to_wifi_network_with_id( |
| reconnect_to[WifiEnums.NETID_KEY], |
| reconnect_to[WifiEnums.SSID_KEY]) |
| if not reconnect: |
| raise signals.TestFailure("Device did not connect to the correct" |
| " network after toggling WiFi.") |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| def helper_reconnect_toggle_airplane(self): |
| """Connect to multiple networks, turn on/off Airplane moce, then |
| reconnect a previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn ON/OFF Airplane mode. |
| 4. Reconnect to the non-current network. |
| |
| """ |
| connect_2g_data = self.get_connection_data(self.dut, self.wpapsk_2g) |
| connect_5g_data = self.get_connection_data(self.dut, self.wpapsk_5g) |
| wutils.toggle_airplane_mode_on_and_off(self.dut) |
| reconnect_to = self.get_enabled_network(connect_2g_data, |
| connect_5g_data) |
| reconnect = self.connect_to_wifi_network_with_id( |
| reconnect_to[WifiEnums.NETID_KEY], |
| reconnect_to[WifiEnums.SSID_KEY]) |
| if not reconnect: |
| raise signals.TestFailure("Device did not connect to the correct" |
| " network after toggling Airplane mode.") |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| def helper_reboot_configstore_reconnect(self, lock_screen=False): |
| """Connect to multiple networks, reboot then reconnect to previously |
| connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Reboot device. |
| 4. Verify all networks are persistent after reboot. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| network_list = self.connect_multiple_networks(self.dut) |
| network_list = self.dut.droid.wifiGetConfiguredNetworks() |
| self.dut.reboot() |
| time.sleep(DEFAULT_TIMEOUT) |
| self.check_configstore_networks(network_list) |
| |
| reconnect_to = self.get_enabled_network(network_list[BAND_2GHZ], |
| network_list[BAND_5GHZ]) |
| |
| if lock_screen: |
| self.dut.droid.wakeLockRelease() |
| self.dut.droid.goToSleepNow() |
| reconnect = self.connect_to_wifi_network_with_id( |
| reconnect_to[WifiEnums.NETID_KEY], |
| reconnect_to[WifiEnums.SSID_KEY]) |
| if not reconnect: |
| raise signals.TestFailure( |
| "Device failed to reconnect to the correct" |
| " network after reboot.") |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| def helper_toggle_wifi_reboot_configstore_reconnect(self): |
| """Connect to multiple networks, disable WiFi, reboot, then |
| reconnect to previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn WiFi OFF. |
| 4. Reboot device. |
| 5. Turn WiFi ON. |
| 4. Verify all networks are persistent after reboot. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| network_list = self.connect_multiple_networks(self.dut) |
| self.log.debug("Toggling wifi OFF") |
| wutils.wifi_toggle_state(self.dut, False) |
| time.sleep(DEFAULT_TIMEOUT) |
| network_list = self.dut.droid.wifiGetConfiguredNetworks() |
| self.dut.reboot() |
| time.sleep(DEFAULT_TIMEOUT) |
| self.log.debug("Toggling wifi ON") |
| wutils.wifi_toggle_state(self.dut, True) |
| time.sleep(DEFAULT_TIMEOUT) |
| self.check_configstore_networks(network_list) |
| reconnect_to = self.get_enabled_network(network_list[BAND_2GHZ], |
| network_list[BAND_5GHZ]) |
| reconnect = self.connect_to_wifi_network_with_id( |
| reconnect_to[WifiEnums.NETID_KEY], |
| reconnect_to[WifiEnums.SSID_KEY]) |
| if not reconnect: |
| msg = ("Device failed to reconnect to the correct network after" |
| " toggling WiFi and rebooting.") |
| raise signals.TestFailure(msg) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| def helper_toggle_airplane_reboot_configstore_reconnect(self): |
| """Connect to multiple networks, enable Airplane mode, reboot, then |
| reconnect to previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Toggle Airplane mode ON. |
| 4. Reboot device. |
| 5. Toggle Airplane mode OFF. |
| 4. Verify all networks are persistent after reboot. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| network_list = self.connect_multiple_networks(self.dut) |
| self.log.debug("Toggling Airplane mode ON") |
| asserts.assert_true( |
| acts.utils.force_airplane_mode(self.dut, True), |
| "Can not turn on airplane mode on: %s" % self.dut.serial) |
| time.sleep(DEFAULT_TIMEOUT) |
| network_list = self.dut.droid.wifiGetConfiguredNetworks() |
| self.dut.reboot() |
| time.sleep(DEFAULT_TIMEOUT) |
| self.log.debug("Toggling Airplane mode OFF") |
| asserts.assert_true( |
| acts.utils.force_airplane_mode(self.dut, False), |
| "Can not turn on airplane mode on: %s" % self.dut.serial) |
| time.sleep(DEFAULT_TIMEOUT) |
| self.check_configstore_networks(network_list) |
| reconnect_to = self.get_enabled_network(network_list[BAND_2GHZ], |
| network_list[BAND_5GHZ]) |
| reconnect = self.connect_to_wifi_network_with_id( |
| reconnect_to[WifiEnums.NETID_KEY], |
| reconnect_to[WifiEnums.SSID_KEY]) |
| if not reconnect: |
| msg = ("Device failed to reconnect to the correct network after" |
| " toggling Airplane mode and rebooting.") |
| raise signals.TestFailure(msg) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| def verify_traffic_between_devices(self,dest_device,src_device,num_of_tries=2): |
| """Test the clients and DUT can ping each other. |
| |
| Args: |
| num_of_tries: the retry times of ping test. |
| dest_device:Test device. |
| src_device:Second DUT access same AP |
| """ |
| dest_device = dest_device.droid.connectivityGetIPv4Addresses('wlan0')[0] |
| for _ in range(num_of_tries): |
| if acts.utils.adb_shell_ping(src_device, count=10, dest_ip=dest_device, timeout=20): |
| break |
| else: |
| asserts.fail("Ping to %s from %s failed" % (src_device.serial, dest_device)) |
| |
| def ping_public_gateway_ip(self): |
| """Ping 8.8.8.8""" |
| try: |
| ping_result = self.dut.adb.shell('ping -w 5 8.8.8.8') |
| if '0%' in ping_result: |
| self.dut.log.info('Ping success') |
| return True |
| except: |
| self.dut.log.error('Faild to ping public gateway 8.8.8.8') |
| return False |
| |
| """Tests""" |
| |
| @test_tracker_info(uuid="525fc5e3-afba-4bfd-9a02-5834119e3c66") |
| def test_toggle_wifi_state_and_get_startupTime(self): |
| """Test toggling wifi""" |
| self.log.debug("Going from on to off.") |
| wutils.wifi_toggle_state(self.dut, False) |
| self.log.debug("Going from off to on.") |
| startTime = time.time() |
| wutils.wifi_toggle_state(self.dut, True) |
| startup_time = time.time() - startTime |
| self.log.debug("WiFi was enabled on the device in %s s." % startup_time) |
| |
| @test_tracker_info(uuid="e9d11563-2bbe-4c96-87eb-ec919b51435b") |
| def test_toggle_with_screen(self): |
| """Test toggling wifi with screen on/off""" |
| wait_time = 5 |
| self.log.debug("Screen from off to on.") |
| self.dut.droid.wakeLockAcquireBright() |
| self.dut.droid.wakeUpNow() |
| time.sleep(wait_time) |
| self.log.debug("Going from on to off.") |
| try: |
| wutils.wifi_toggle_state(self.dut, False) |
| time.sleep(wait_time) |
| self.log.debug("Going from off to on.") |
| wutils.wifi_toggle_state(self.dut, True) |
| finally: |
| self.dut.droid.wakeLockRelease() |
| time.sleep(wait_time) |
| self.dut.droid.goToSleepNow() |
| |
| @test_tracker_info(uuid="71556e06-7fb1-4e2b-9338-b01f1f8e286e") |
| def test_scan(self): |
| """Test wifi connection scan can start and find expected networks.""" |
| ssid = self.open_network_2g[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| ssid = self.open_network_5g[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| |
| @test_tracker_info(uuid="3ea09efb-6921-429e-afb1-705ef5a09afa") |
| def test_scan_with_wifi_off_and_location_scan_on(self): |
| """Put wifi in scan only mode""" |
| self.turn_location_on_and_scan_toggle_on() |
| wutils.wifi_toggle_state(self.dut, False) |
| |
| """Test wifi connection scan can start and find expected networks.""" |
| ssid = self.open_network_2g[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| ssid = self.open_network_5g[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| |
| @test_tracker_info(uuid="558652de-c802-405f-b9dc-b7fcc9237673") |
| def test_scan_after_reboot_with_wifi_off_and_location_scan_on(self): |
| """Put wifi in scan only mode""" |
| self.turn_location_on_and_scan_toggle_on() |
| wutils.wifi_toggle_state(self.dut, False) |
| |
| # Reboot the device. |
| self.dut.reboot() |
| time.sleep(DEFAULT_TIMEOUT) |
| |
| """Test wifi connection scan can start and find expected networks.""" |
| ssid = self.open_network_2g[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| ssid = self.open_network_5g[WifiEnums.SSID_KEY] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| |
| @test_tracker_info(uuid="770caebe-bcb1-43ac-95b6-5dd52dd90e80") |
| def test_scan_with_wifi_off_and_location_scan_off(self): |
| """Turn off wifi and location scan""" |
| self.turn_location_on_and_scan_toggle_off() |
| wutils.wifi_toggle_state(self.dut, False) |
| |
| """Test wifi connection scan should fail.""" |
| self.dut.droid.wifiStartScan() |
| try: |
| self.dut.ed.pop_event("WifiManagerScanResultsAvailable", 60) |
| except queue.Empty: |
| self.log.debug("Wifi scan results not received.") |
| else: |
| asserts.fail("Wi-Fi scan results received") |
| |
| @test_tracker_info(uuid="a4ad9930-a8fa-4868-81ed-a79c7483e502") |
| def test_add_network(self): |
| """Test wifi connection scan.""" |
| ssid = self.open_network_2g[WifiEnums.SSID_KEY] |
| nId = self.dut.droid.wifiAddNetwork(self.open_network_2g) |
| asserts.assert_true(nId > -1, "Failed to add network.") |
| configured_networks = self.dut.droid.wifiGetConfiguredNetworks() |
| self.log.debug( |
| ("Configured networks after adding: %s" % configured_networks)) |
| wutils.assert_network_in_list({ |
| WifiEnums.SSID_KEY: ssid |
| }, configured_networks) |
| |
| @test_tracker_info(uuid="aca85551-10ba-4007-90d9-08bcdeb16a60") |
| def test_forget_network(self): |
| ssid = self.open_network_2g[WifiEnums.SSID_KEY] |
| nId = self.dut.droid.wifiAddNetwork(self.open_network_2g) |
| asserts.assert_true(nId > -1, "Failed to add network.") |
| configured_networks = self.dut.droid.wifiGetConfiguredNetworks() |
| self.log.debug( |
| ("Configured networks after adding: %s" % configured_networks)) |
| wutils.assert_network_in_list({ |
| WifiEnums.SSID_KEY: ssid |
| }, configured_networks) |
| wutils.wifi_forget_network(self.dut, ssid) |
| configured_networks = self.dut.droid.wifiGetConfiguredNetworks() |
| for nw in configured_networks: |
| asserts.assert_true( |
| nw[WifiEnums.BSSID_KEY] != ssid, |
| "Found forgotten network %s in configured networks." % ssid) |
| |
| @test_tracker_info(uuid="3cff17f6-b684-4a95-a438-8272c2ad441d") |
| def test_reconnect_to_previously_connected(self): |
| """Connect to multiple networks and reconnect to the previous network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Reconnect to the 2GHz network using its network id. |
| 4. Reconnect to the 5GHz network using its network id. |
| |
| """ |
| connect_2g_data = self.get_connection_data(self.dut, self.wpapsk_2g) |
| connect_5g_data = self.get_connection_data(self.dut, self.wpapsk_5g) |
| reconnect_2g = self.connect_to_wifi_network_with_id( |
| connect_2g_data[WifiEnums.NETID_KEY], |
| connect_2g_data[WifiEnums.SSID_KEY]) |
| if not reconnect_2g: |
| raise signals.TestFailure("Device did not connect to the correct" |
| " 2GHz network.") |
| reconnect_5g = self.connect_to_wifi_network_with_id( |
| connect_5g_data[WifiEnums.NETID_KEY], |
| connect_5g_data[WifiEnums.SSID_KEY]) |
| if not reconnect_5g: |
| raise signals.TestFailure("Device did not connect to the correct" |
| " 5GHz network.") |
| |
| @test_tracker_info(uuid="334175c3-d26a-4c87-a8ab-8eb220b2d80f") |
| def test_reconnect_toggle_wifi(self): |
| """Connect to multiple networks, turn off/on wifi, then reconnect to |
| a previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn WiFi OFF/ON. |
| 4. Reconnect to the non-current network. |
| |
| """ |
| self.helper_reconnect_toggle_wifi() |
| |
| @test_tracker_info(uuid="bd2cec9e-7f17-44ef-8a0c-4da92a9b55ae") |
| def test_reconnect_toggle_wifi_with_location_scan_on(self): |
| """Connect to multiple networks, turn off/on wifi, then reconnect to |
| a previously connected network. |
| |
| Steps: |
| 1. Turn on location scans. |
| 2. Connect to a 2GHz network. |
| 3. Connect to a 5GHz network. |
| 4. Turn WiFi OFF/ON. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| self.turn_location_on_and_scan_toggle_on() |
| self.helper_reconnect_toggle_wifi() |
| |
| @test_tracker_info(uuid="8e6e6c21-fefb-4fe8-9fb1-f09b1182b76d") |
| def test_reconnect_toggle_airplane(self): |
| """Connect to multiple networks, turn on/off Airplane moce, then |
| reconnect a previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn ON/OFF Airplane mode. |
| 4. Reconnect to the non-current network. |
| |
| """ |
| self.helper_reconnect_toggle_airplane() |
| |
| @test_tracker_info(uuid="28562f13-8a0a-492e-932c-e587560db5f2") |
| def test_reconnect_toggle_airplane_with_location_scan_on(self): |
| """Connect to multiple networks, turn on/off Airplane moce, then |
| reconnect a previously connected network. |
| |
| Steps: |
| 1. Turn on location scans. |
| 2. Connect to a 2GHz network. |
| 3. Connect to a 5GHz network. |
| 4. Turn ON/OFF Airplane mode. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| self.turn_location_on_and_scan_toggle_on() |
| self.helper_reconnect_toggle_airplane() |
| |
| @test_tracker_info(uuid="52b89a47-f260-4343-922d-fbeb4d8d2b63") |
| def test_reconnect_toggle_wifi_on_with_airplane_on(self): |
| """Connect to multiple networks, turn on airplane mode, turn on wifi, |
| then reconnect a previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn ON Airplane mode. |
| 4. Turn ON WiFi. |
| 5. Reconnect to the a previously connected network. |
| """ |
| connect_2g_data = self.get_connection_data(self.dut, self.wpapsk_2g) |
| connect_5g_data = self.get_connection_data(self.dut, self.wpapsk_5g) |
| self.log.debug("Toggling Airplane mode ON") |
| asserts.assert_true( |
| acts.utils.force_airplane_mode(self.dut, True), |
| "Can not turn on airplane mode on: %s" % self.dut.serial) |
| self.log.debug("Toggling wifi ON") |
| wutils.wifi_toggle_state(self.dut, True) |
| time.sleep(DEFAULT_TIMEOUT) |
| reconnect_to = self.get_enabled_network(connect_2g_data, |
| connect_5g_data) |
| reconnect = self.connect_to_wifi_network_with_id( |
| reconnect_to[WifiEnums.NETID_KEY], |
| reconnect_to[WifiEnums.SSID_KEY]) |
| if not reconnect: |
| raise signals.TestFailure("Device did not connect to the correct" |
| " network after toggling WiFi.") |
| |
| @test_tracker_info(uuid="2dddc734-e9f6-4d30-9c2d-4368e721a350") |
| def test_verify_airplane_mode_on_with_wifi_disabled(self): |
| """Connect to multiple networks, turn on airplane mode, turn off Wi-Fi, |
| then make sure there is no internet. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn ON Airplane mode. |
| 4. Turn OFF WiFi. |
| 5. Ping to make sure there is no internet |
| """ |
| connect_2g_data = self.get_connection_data(self.dut, self.wpapsk_2g) |
| connect_5g_data = self.get_connection_data(self.dut, self.wpapsk_5g) |
| self.log.debug("Toggling Airplane mode ON") |
| asserts.assert_true( |
| acts.utils.force_airplane_mode(self.dut, True), |
| "Can not turn on airplane mode on: %s" % self.dut.serial) |
| self.log.debug("Toggling Wi-Fi OFF") |
| wutils.wifi_toggle_state(self.dut, False) |
| time.sleep(DEFAULT_TIMEOUT) |
| if self.ping_public_gateway_ip(): |
| raise signals.TestFailure("Device has internet after" |
| " toggling WiFi off.") |
| |
| @test_tracker_info(uuid="3d041c12-05e2-46a7-ab9b-e3f60cc735db") |
| def test_reboot_configstore_reconnect(self): |
| """Connect to multiple networks, reboot then reconnect to previously |
| connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Reboot device. |
| 4. Verify all networks are persistent after reboot. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| self.helper_reboot_configstore_reconnect() |
| |
| @test_tracker_info(uuid="a70d5853-67b5-4d48-bdf7-08ee51fafd21") |
| def test_reboot_configstore_reconnect_with_location_scan_on(self): |
| """Connect to multiple networks, reboot then reconnect to previously |
| connected network. |
| |
| Steps: |
| 1. Turn on location scans. |
| 2. Connect to a 2GHz network. |
| 3. Connect to a 5GHz network. |
| 4. Reboot device. |
| 5. Verify all networks are persistent after reboot. |
| 6. Reconnect to the non-current network. |
| |
| """ |
| self.turn_location_on_and_scan_toggle_on() |
| self.helper_reboot_configstore_reconnect() |
| |
| @test_tracker_info(uuid="26d94dfa-1349-4c8b-aea0-475eb73bb521") |
| def test_toggle_wifi_reboot_configstore_reconnect(self): |
| """Connect to multiple networks, disable WiFi, reboot, then |
| reconnect to previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Turn WiFi OFF. |
| 4. Reboot device. |
| 5. Turn WiFi ON. |
| 4. Verify all networks are persistent after reboot. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| self.helper_toggle_wifi_reboot_configstore_reconnect() |
| |
| @test_tracker_info(uuid="7c004a3b-c1c6-4371-9124-0f34650be915") |
| def test_toggle_wifi_reboot_configstore_reconnect_with_location_scan_on(self): |
| """Connect to multiple networks, disable WiFi, reboot, then |
| reconnect to previously connected network. |
| |
| Steps: |
| 1. Turn on location scans. |
| 2. Connect to a 2GHz network. |
| 3. Connect to a 5GHz network. |
| 4. Turn WiFi OFF. |
| 5. Reboot device. |
| 6. Turn WiFi ON. |
| 7. Verify all networks are persistent after reboot. |
| 8. Reconnect to the non-current network. |
| |
| """ |
| self.turn_location_on_and_scan_toggle_on() |
| self.helper_toggle_wifi_reboot_configstore_reconnect() |
| |
| @test_tracker_info(uuid="4fce017b-b443-40dc-a598-51d59d3bb38f") |
| def test_toggle_airplane_reboot_configstore_reconnect(self): |
| """Connect to multiple networks, enable Airplane mode, reboot, then |
| reconnect to previously connected network. |
| |
| Steps: |
| 1. Connect to a 2GHz network. |
| 2. Connect to a 5GHz network. |
| 3. Toggle Airplane mode ON. |
| 4. Reboot device. |
| 5. Toggle Airplane mode OFF. |
| 4. Verify all networks are persistent after reboot. |
| 5. Reconnect to the non-current network. |
| |
| """ |
| self.helper_toggle_airplane_reboot_configstore_reconnect() |
| |
| @test_tracker_info(uuid="7f0810f9-2338-4158-95f5-057f5a1905b6") |
| def test_toggle_airplane_reboot_configstore_reconnect_with_location_scan_on(self): |
| """Connect to multiple networks, enable Airplane mode, reboot, then |
| reconnect to previously connected network. |
| |
| Steps: |
| 1. Turn on location scans. |
| 2. Connect to a 2GHz network. |
| 3. Connect to a 5GHz network. |
| 4. Toggle Airplane mode ON. |
| 5. Reboot device. |
| 6. Toggle Airplane mode OFF. |
| 7. Verify all networks are persistent after reboot. |
| 8. Reconnect to the non-current network. |
| |
| """ |
| self.turn_location_on_and_scan_toggle_on() |
| self.helper_toggle_airplane_reboot_configstore_reconnect() |
| |
| @test_tracker_info(uuid="342c13cb-6508-4942-bee3-07c5d20d92a5") |
| def test_reboot_configstore_reconnect_with_screen_lock(self): |
| """Verify device can re-connect to configured networks after reboot. |
| |
| Steps: |
| 1. Connect to 2G and 5G networks. |
| 2. Reboot device |
| 3. Verify device connects to 1 network automatically. |
| 4. Lock screen and verify device can connect to the other network. |
| """ |
| self.helper_reboot_configstore_reconnect(lock_screen=True) |
| |
| @test_tracker_info(uuid="7e6050d9-79b1-4726-80cf-686bb99b8945") |
| def test_connect_to_5g_after_reboot_without_unlock(self): |
| """Connect to 5g network afer reboot without unlock. |
| |
| Steps: |
| 1. Reboot device and lock screen |
| 2. Connect to 5G network and verify it works. |
| """ |
| self.dut.reboot() |
| time.sleep(DEFAULT_TIMEOUT) |
| self.dut.droid.wakeLockRelease() |
| self.dut.droid.goToSleepNow() |
| wutils.connect_to_wifi_network(self.dut, self.wpapsk_5g) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| @test_tracker_info(uuid="81eb7527-4c92-4422-897a-6b5f6445e84a") |
| def test_config_store_with_wpapsk_2g(self): |
| self.connect_to_wifi_network_toggle_wifi_and_run_iperf( |
| (self.wpapsk_2g, self.dut)) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| @test_tracker_info(uuid="8457903d-cb7e-4c89-bcea-7f59585ea6e0") |
| def test_config_store_with_wpapsk_5g(self): |
| self.connect_to_wifi_network_toggle_wifi_and_run_iperf( |
| (self.wpapsk_5g, self.dut)) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| @test_tracker_info(uuid="b9fbc13a-47b4-4f64-bd2c-e5a3cb24ab2f") |
| def test_tdls_supported(self): |
| model = self.dut.model |
| self.log.debug("Model is %s" % model) |
| if not model.startswith("volantis"): |
| asserts.assert_true(self.dut.droid.wifiIsTdlsSupported(), ( |
| "TDLS should be supported on %s, but device is " |
| "reporting not supported.") % model) |
| else: |
| asserts.assert_false(self.dut.droid.wifiIsTdlsSupported(), ( |
| "TDLS should not be supported on %s, but device " |
| "is reporting supported.") % model) |
| |
| @test_tracker_info(uuid="50637d40-ea59-4f4b-9fc1-e6641d64074c") |
| def test_energy_info(self): |
| """Verify the WiFi energy info reporting feature """ |
| self.get_energy_info() |
| |
| @test_tracker_info(uuid="1f1cf549-53eb-4f36-9f33-ce06c9158efc") |
| def test_energy_info_connected(self): |
| """Verify the WiFi energy info reporting feature when connected. |
| |
| Connect to a wifi network, then the same as test_energy_info. |
| """ |
| wutils.wifi_connect(self.dut, self.open_network_2g) |
| self.get_energy_info() |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| @test_tracker_info(uuid="2622c253-defc-4a35-93a6-ca9d29a8238c") |
| def test_connect_to_wep_2g(self): |
| """Verify DUT can connect to 2GHz WEP network |
| |
| Steps: |
| 1. Ensure the 2GHz WEP network is visible in scan result. |
| 2. Connect to the network and validate internet connection. |
| """ |
| wutils.connect_to_wifi_network(self.dut, self.wep_networks[0]["2g"]) |
| |
| @test_tracker_info(uuid="1f2d17a2-e92d-43af-966b-3421c0db8620") |
| def test_connect_to_wep_5g(self): |
| """Verify DUT can connect to 5GHz WEP network |
| |
| Steps: |
| 1. Ensure the 5GHz WEP network is visible in scan result. |
| 2. Connect to the network and validate internet connection. |
| """ |
| wutils.connect_to_wifi_network(self.dut, self.wep_networks[0]["5g"]) |
| |
| @test_tracker_info(uuid="4a957952-289d-4657-9882-e1475274a7ff") |
| def test_connect_to_wpa_2g(self): |
| """Verify DUT can connect to 2GHz WPA-PSK network |
| |
| Steps: |
| 1. Ensure the 2GHz WPA-PSK network is visible in scan result. |
| 2. Connect to the network and validate internet connection. |
| """ |
| wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0]["2g"]) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| @test_tracker_info(uuid="612c3c31-a4c5-4014-9a2d-3f4bcc20c0d7") |
| def test_connect_to_wpa_5g(self): |
| """Verify DUT can connect to 5GHz WPA-PSK network |
| |
| Steps: |
| 1. Ensure the 5GHz WPA-PSK network is visible in scan result. |
| 2. Connect to the network and validate internet connection. |
| """ |
| wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0]["5g"]) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| @test_tracker_info(uuid="2a617fb4-1d8e-44e9-a500-a5456e1df83f") |
| def test_connect_to_2g_can_be_pinged(self): |
| """Verify DUT can be pinged by another device when it connects to 2GHz AP |
| |
| Steps: |
| 1. Ensure the 2GHz WPA-PSK network is visible in scan result. |
| 2. Connect to the network and validate internet connection. |
| 3. Check DUT can be pinged by another device |
| """ |
| wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0]["2g"]) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| wutils.connect_to_wifi_network(self.dut_client, self.wpa_networks[0]["2g"]) |
| wutils.verify_11ax_wifi_connection( |
| self.dut_client, self.wifi6_models, "wifi6_ap" in self.user_params) |
| self.verify_traffic_between_devices(self.dut,self.dut_client) |
| |
| @test_tracker_info(uuid="94bdd657-649b-4a2c-89c3-3ec6ba18e08e") |
| def test_connect_to_5g_can_be_pinged(self): |
| """Verify DUT can be pinged by another device when it connects to 5GHz AP |
| |
| Steps: |
| 1. Ensure the 5GHz WPA-PSK network is visible in scan result. |
| 2. Connect to the network and validate internet connection. |
| 3. Check DUT can be pinged by another device |
| """ |
| wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0]["5g"]) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| wutils.connect_to_wifi_network(self.dut_client, self.wpa_networks[0]["5g"]) |
| wutils.verify_11ax_wifi_connection( |
| self.dut_client, self.wifi6_models, "wifi6_ap" in self.user_params) |
| self.verify_traffic_between_devices(self.dut,self.dut_client) |
| |
| @test_tracker_info(uuid="d87359aa-c4da-4554-b5de-8e3fa852a6b0") |
| def test_sta_turn_off_screen_can_be_pinged(self): |
| """Verify DUT can be pinged by another device after idle for a while |
| |
| Steps: |
| 1. Ensure the 2GHz WPA-PSK network is visible in scan result. |
| 2. DUT and DUT_Client connect to the network and validate internet connection. |
| 3. Let DUT sleep for 5 minutes |
| 4. Check DUT can be pinged by DUT_Client |
| """ |
| asserts.skip_if(len(self.android_devices) < 3, "Need 3 devices") |
| self.dut_client_a = self.android_devices[1] |
| self.dut_client_b = self.android_devices[2] |
| |
| # enable hotspot on dut and connect client devices to it |
| ap_ssid = "softap_" + acts.utils.rand_ascii_str(8) |
| ap_password = acts.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 |
| wutils.start_wifi_tethering( |
| self.dut, |
| config[wutils.WifiEnums.SSID_KEY], |
| config[wutils.WifiEnums.PWD_KEY], |
| wutils.WifiEnums.WIFI_CONFIG_APBAND_AUTO) |
| |
| # DUT connect to AP |
| wutils.connect_to_wifi_network( |
| self.dut_client_a, config, check_connectivity=False) |
| wutils.connect_to_wifi_network( |
| self.dut_client_b, config, check_connectivity=False) |
| # Check DUT and DUT_Client can ping each other successfully |
| self.verify_traffic_between_devices(self.dut_client_a, |
| self.dut_client_b) |
| self.verify_traffic_between_devices(self.dut_client_a, |
| self.dut_client_b) |
| |
| # DUT turn off screen and go sleep for 5 mins |
| self.dut.droid.wakeLockRelease() |
| self.dut.droid.goToSleepNow() |
| # TODO(hsiuchangchen): find a way to check system already suspended |
| # instead of waiting 5 mins |
| self.log.info("Sleep for 5 minutes") |
| time.sleep(300) |
| # Verify DUT_Client can ping DUT when DUT sleeps |
| self.verify_traffic_between_devices(self.dut_client_a, |
| self.dut_client_b) |
| self.dut.droid.wakeLockAcquireBright() |
| self.dut.droid.wakeUpNow() |
| |
| @test_tracker_info(uuid="25e8dd62-ae9f-46f7-96aa-030fee95dfda") |
| def test_wifi_saved_network_reset(self): |
| """Verify DUT can reset Wi-Fi saved network list after add a network. |
| |
| Steps: |
| 1. Connect to a 2GHz network |
| 2. Reset the Wi-Fi saved network |
| 3. Verify the saved network has been clear |
| """ |
| ssid = self.open_network_2g[WifiEnums.SSID_KEY] |
| nId = self.dut.droid.wifiAddNetwork(self.open_network_2g) |
| asserts.assert_true(nId > -1, "Failed to add network.") |
| configured_networks = self.dut.droid.wifiGetConfiguredNetworks() |
| self.log.debug( |
| ("Configured networks after adding: %s" % configured_networks)) |
| wutils.assert_network_in_list({ |
| WifiEnums.SSID_KEY: ssid |
| }, configured_networks) |
| self.dut.droid.wifiFactoryReset() |
| configured_networks = self.dut.droid.wifiGetConfiguredNetworks() |
| for nw in configured_networks: |
| asserts.assert_true( |
| nw[WifiEnums.BSSID_KEY] != ssid, |
| "Found saved network %s in configured networks." % ssid) |
| |
| @test_tracker_info(uuid="402cfaa8-297f-4865-9e27-6bab6adca756") |
| def test_reboot_wifi_and_bluetooth_on(self): |
| """Toggle WiFi and bluetooth ON then reboot """ |
| wutils.wifi_toggle_state(self.dut, True) |
| enable_bluetooth(self.dut.droid, self.dut.ed) |
| |
| self.dut.reboot() |
| time.sleep(DEFAULT_TIMEOUT) |
| |
| asserts.assert_true(self.dut.droid.bluetoothCheckState(), |
| "bluetooth state changed after reboot") |
| asserts.assert_true(self.dut.droid.wifiCheckState(), |
| "wifi state changed after reboot") |
| |
| disable_bluetooth(self.dut.droid) |
| |
| @test_tracker_info(uuid="d0e14a2d-a28f-4551-8988-1e15d9d8bb1a") |
| def test_scan_result_api(self): |
| """Register scan result callback, start scan and wait for event""" |
| self.dut.ed.clear_all_events() |
| self.dut.droid.wifiStartScanWithListener() |
| try: |
| events = self.dut.ed.pop_events( |
| "WifiManagerScanResultsCallbackOnSuccess", 60) |
| except queue.Empty: |
| asserts.fail( |
| "Wi-Fi scan results did not become available within 60s.") |
| |
| @test_tracker_info(uuid="03cfbc86-7fcc-48d8-ab0f-1f6f3523e596") |
| def test_enable_disable_auto_join_saved_network(self): |
| """ |
| Add a saved network, simulate user change the auto join to false, ensure the device doesn't |
| auto connect to this network |
| |
| Steps: |
| 1. Create a saved network. |
| 2. Add this saved network, and ensure we connect to this network |
| 3. Simulate user change the auto join to false. |
| 4. Toggle the Wifi off and on |
| 4. Ensure device doesn't connect to his network |
| """ |
| network = self.open_network_5g |
| wutils.connect_to_wifi_network(self.dut, network) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| info = self.dut.droid.wifiGetConnectionInfo() |
| network_id = info[WifiEnums.NETID_KEY] |
| self.dut.log.info("Disable auto join on network") |
| self.dut.droid.wifiEnableAutojoin(network_id, False) |
| wutils.wifi_toggle_state(self.dut, False) |
| wutils.wifi_toggle_state(self.dut, True) |
| asserts.assert_false( |
| wutils.wait_for_connect(self.dut, network[WifiEnums.SSID_KEY], |
| assert_on_fail=False), "Device should not connect.") |
| self.dut.droid.wifiEnableAutojoin(network_id, True) |
| wutils.wait_for_connect(self.dut, network[WifiEnums.SSID_KEY], assert_on_fail=False) |
| wutils.verify_11ax_wifi_connection( |
| self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) |
| |
| def coex_unsafe_channel_key(self, unsafe_channel): |
| if COEX_POWER_CAP_DBM in unsafe_channel: |
| return (unsafe_channel[COEX_BAND], unsafe_channel[COEX_CHANNEL], |
| unsafe_channel[COEX_POWER_CAP_DBM]) |
| return (unsafe_channel[COEX_BAND], unsafe_channel[COEX_CHANNEL]) |
| |
| @test_tracker_info(uuid="78558b30-3792-4a1f-bb56-34bbbbce6ac8") |
| def test_set_get_coex_unsafe_channels(self): |
| """ |
| Set the unsafe channels to avoid for coex, then retrieve the active values and compare to |
| values set. If the default algorithm is enabled, then ensure that the active values are |
| unchanged. |
| |
| Steps: |
| 1. Register a coex callback and listen for the update event to get the current coex values. |
| 2. Create list of coex unsafe channels and restrictions |
| |
| coex_unsafe_channels format: |
| [ |
| { |
| "band": <"24_GHZ" or "5_GHZ"> |
| "channel" : <Channel number> |
| (Optional) "powerCapDbm" : <Power Cap in Dbm> |
| } |
| ... |
| ] |
| |
| coex_restrictions format: |
| [ |
| (Optional) "WIFI_DIRECT", |
| (Optional) "SOFTAP", |
| (Optional) "WIFI_AWARE" |
| ] |
| 3. Set these values as the active values and listen for the update event. |
| 4. If the default algorithm is enabled, expect to not get the update event. If it is |
| disabled, compare the updated values and see if they are the same as the provided values. |
| 5. Restore the previous values if the test values were set. |
| """ |
| asserts.skip_if(not self.dut.droid.isSdkAtLeastS(), |
| "Require SDK at least S to use wifi coex apis.") |
| self.dut.ed.clear_all_events() |
| |
| # Register a coex callback to start receiving coex events |
| self.dut.droid.wifiRegisterCoexCallback() |
| try: |
| # Wait for the immediate callback from registering and store the current values |
| event = self.dut.ed.pop_event("WifiManagerCoexCallback#onCoexUnsafeChannelsChanged", 5) |
| except queue.Empty: |
| asserts.fail("Coex callback event not received after registering.") |
| prev_unsafe_channels = sorted(json.loads(event["data"][KEY_COEX_UNSAFE_CHANNELS]), |
| key=self.coex_unsafe_channel_key) |
| prev_restrictions = sorted(json.loads(event["data"][KEY_COEX_RESTRICTIONS])) |
| |
| # Set new values for coex unsafe channels |
| test_unsafe_channels = sorted(self.coex_unsafe_channels, |
| key=self.coex_unsafe_channel_key) |
| test_restrictions = sorted(self.coex_restrictions) |
| self.dut.droid.wifiSetCoexUnsafeChannels(test_unsafe_channels, test_restrictions) |
| try: |
| # Wait for the callback from setting the coex unsafe channels |
| event = self.dut.ed.pop_event("WifiManagerCoexCallback#onCoexUnsafeChannelsChanged", 5) |
| # Callback received. This should be expected only if default algo is disabled. |
| asserts.assert_false(self.dut.droid.wifiIsDefaultCoexAlgorithmEnabled(), |
| "Default algo was enabled but Coex callback received after" |
| " setCoexUnsafeChannels") |
| curr_unsafe_channels = sorted(json.loads(event["data"][KEY_COEX_UNSAFE_CHANNELS]), |
| key=self.coex_unsafe_channel_key) |
| curr_restrictions = sorted(json.loads(event["data"][KEY_COEX_RESTRICTIONS])) |
| # Compare the current values with the set values |
| asserts.assert_true(curr_unsafe_channels == test_unsafe_channels, |
| "default coex algorithm disabled but current unsafe channels " |
| + str(curr_unsafe_channels) |
| + " do not match the set values " + str(test_unsafe_channels)) |
| asserts.assert_true(curr_restrictions == test_restrictions, |
| "default coex algorithm disabled but current restrictions " |
| + str(curr_restrictions) |
| + " do not match the set values " + str(test_restrictions)) |
| # Restore the previous values |
| self.dut.droid.wifiSetCoexUnsafeChannels(prev_unsafe_channels, prev_restrictions) |
| except queue.Empty: |
| # Callback not received. This should be expected only if the default algo is enabled. |
| asserts.assert_true(self.dut.droid.wifiIsDefaultCoexAlgorithmEnabled(), |
| "Default algo was disabled but Coex callback not received after" |
| " setCoexUnsafeChannels") |
| |
| self.dut.droid.wifiUnregisterCoexCallback() |
