#!/usr/bin/env python3 # # Copyright 2021 - 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 logging import time from acts import asserts from acts import signals from acts.test_decorators import test_tracker_info import acts_contrib.test_utils.wifi.wifi_test_utils as wutils from acts_contrib.test_utils.wifi import wifi_constants from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest from acts.controllers.ap_lib.hostapd_constants import BAND_2G from acts.controllers.ap_lib.hostapd_constants import BAND_5G from acts.controllers.ap_lib import hostapd_constants WifiEnums = wutils.WifiEnums # Each wait time add 5 seconds as buffer. BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS = 5 BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES = 305 BRIDGED_AP_SHUTDOWN_INTERVAL_5_SECONDS = 5 SOFT_AP_SHUTDOWN_INTERVAL_10_MINUTES = 605 INTERVAL_9_MINUTES = 545 INTERVAL_2_MINUTES = 125 INTERVAL_1_MINUTES = 65 class WifiBridgedApTest(WifiBaseTest): """WiFi BridgedAp test class. Test Bed Requirement: * Android device x 1 with BridgedAp supported. * Android devices x2 as clients, at least Android 10. * OpenWrt AP x 1. * Google Wi-Fi x 2 as packet captures. """ def setup_class(self): super().setup_class() if len(self.android_devices) == 3: self.dut = self.android_devices[0] self.client1 = self.android_devices[1] self.client2 = self.android_devices[2] else: raise signals.TestAbortClass("WifiBridgedApTest requires 3 DUTs") if not self.dut.droid.wifiIsBridgedApConcurrencySupported(): raise signals.TestAbortClass("Legacy phone is not supported") req_params = ["dbs_supported_models"] opt_param = [] self.unpack_userparams( req_param_names=req_params, opt_param_names=opt_param) def setup_test(self): super().setup_test() for ad in self.android_devices: wutils.reset_wifi(ad) wutils.wifi_toggle_state(self.dut, False) wutils.wifi_toggle_state(self.client1, True) wutils.wifi_toggle_state(self.client2, True) def teardown_test(self): super().teardown_test() # Reset unplugged status self.dut.adb.shell("cmd battery reset") if self.dut.droid.wifiIsApEnabled(): wutils.stop_wifi_tethering(self.dut) for ad in self.android_devices: wutils.reset_wifi(ad) wutils.set_wifi_country_code( ad, wutils.WifiEnums.CountryCode.US) # Stop packet captures. if hasattr(self, "sniffer_procs"): for i in range(len(self.sniffer_procs)): try: wutils.stop_pcap( self.packet_capture[i], self.sniffer_procs[i], False) logging.info("packet_capture[{}] is STOPPED".format(i)) except: logging.info("packet_capture[{}] is NOT STOPPED".format(i)) def teardown_class(self): super().teardown_class() for ad in self.android_devices: wutils.reset_wifi(ad) if "AccessPoint" in self.user_params: del self.user_params["reference_networks"] del self.user_params["open_network"] def set_country_code_and_verify(self, ad, country_code): wutils.set_wifi_country_code(ad, country_code) # Wi-Fi ON and OFF to make sure country code take effect. wutils.wifi_toggle_state(ad, True) wutils.wifi_toggle_state(ad, False) country = ad.droid.wifiGetCountryCode() asserts.assert_true(country == country_code, "country code {} is not set".format(country_code)) ad.log.info("Country code set to : {}".format(country)) def verify_clients_support_wpa3_sae(self, *args): """Check if clients support WPA3 SAE. Args: args: arbitrary number of clients. e.g., self.dut1, self.dut2, ... """ duts = args for dut in duts: asserts.skip_if(not dut.droid.wifiIsWpa3SaeSupported(), "All DUTs support WPA3 SAE is required") def verify_band_of_bridged_ap_instance(self, ad, infos, bands): """Check bands enabled as expected. This function won't be called directly. Args: infos: SoftAp info list. bands: A list of bands. e,g,. [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G] """ self.dut.log.info("Length of infos: {}, Length of bands: {}" .format(len(infos), len(bands))) asserts.assert_true(len(infos) == len(bands), "There should be {} BridgedAp instance, " "instead of {}".format(len(bands), len(infos))) if len(bands) == 1 and (bands[0] == WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G): asserts.assert_true(infos[0][wifi_constants. SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.softap_band_frequencies[bands[0]], "This should be a {} instance".format(bands[0])) if len(bands) == 2 and (bands[0] == WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G): asserts.assert_true((infos[0][wifi_constants. SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.ALL_2G_FREQUENCIES and infos[1][wifi_constants. SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.ALL_5G_FREQUENCIES) or (infos[0][wifi_constants. SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.ALL_5G_FREQUENCIES and infos[1][wifi_constants. SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.ALL_2G_FREQUENCIES), "There should only be 2G and 5G instances") def verify_softap_freq_equals_to_ap_freq(self, ad, infos): """Verify if instance frequency equal to AP frequency. This function won't be called directly. Args: infos: SoftAp info list. """ wlan0_freq = wutils.get_wlan0_link(ad)["freq"] softap_freqs = [] for i in range(len(infos)): softap_freqs.append(infos[i][WifiEnums.frequency_key]) ad.log.info("softap_freqs : {}".format(softap_freqs)) asserts.assert_true(int(wlan0_freq) in softap_freqs, "AP freq != SoftAp freq") ad.log.info("softap freq == AP freq") def verify_number_band_freq_of_bridged_ap(self, ad, bands, freq_equal=False): """Verify every aspect of info list from BridgedAp. Args: bands: A list of bands, e,g,. [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G] freq_equal: True if need to check SoftAp freq equals to STA freq. Returns: infos: A List of SoftAp info, e.g., [{'autoShutdownTimeoutMillis': 600000, 'bandwidth': 4, 'bssid': '12:dd:0b:b9:4b:cc', 'frequency': 5180, 'wifiStandard': 6}, {'autoShutdownTimeoutMillis': 600000, 'bandwidth': 2, 'bssid': '12:22:f4:b9:4b:cc', 'frequency': 2462, 'wifiStandard': 4}] """ callbackId = ad.droid.registerSoftApCallback() infos = wutils.get_current_softap_infos(ad, callbackId, True) self.verify_band_of_bridged_ap_instance(ad, infos, bands) if freq_equal: self.verify_softap_freq_equals_to_ap_freq(ad, infos) ad.droid.unregisterSoftApCallback(callbackId) return infos def verify_expected_number_of_softap_clients(self, ad, number): """Verify the number of softap clients. Args: number: expect number of client connect to SoftAp. """ callbackId = self.dut.droid.registerSoftApCallback() wutils.wait_for_expected_number_of_softap_clients(self.dut, callbackId, number) ad.log.info("{} clients connect to soft ap".format(number)) self.dut.droid.unregisterSoftApCallback(callbackId) def wait_interval(self, interval): """print different messages with different intervals. Args: interval: different interval for different situation. """ if interval == BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS: logging.info("Wait {} seconds for BridgedAp launch" .format(interval)) time.sleep(interval) elif interval == BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES: logging.info("Wait {} minutes for BridgedAp shutdown" .format(interval/60)) time.sleep(interval) elif interval == SOFT_AP_SHUTDOWN_INTERVAL_10_MINUTES: logging.info("Wait {} minutes for SoftAp shutdown" .format(interval/60)) time.sleep(interval) elif interval == INTERVAL_9_MINUTES: logging.info("Wait {} minutes".format(interval/60)) time.sleep(interval) elif interval == INTERVAL_2_MINUTES: logging.info("Wait {} minutes".format(interval/60)) time.sleep(interval) elif interval == INTERVAL_1_MINUTES: logging.info("Wait {} minutes".format(interval/60)) time.sleep(interval) def generate_softap_config(self, security): """Return a soft ap config Args: security: String; represent certain security. e.g., "WPA3_SAE" """ config = wutils.create_softap_config() config[WifiEnums.SECURITY] = security return config def enable_bridged_ap(self, ad, security, bands, **kwargs): """Enable BridgedAp. Args: security: String; represent certain security. e.g., "WPA3_SAE" bands: specifies the band list for the soft ap. """ self.config = self.generate_softap_config(security) wutils.save_wifi_soft_ap_config( ad, self.config, bands=bands, **kwargs) wutils.start_wifi_tethering_saved_config(self.dut) # Wait 5 seconds for BridgedAp launch. self.wait_interval(BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS) def sniffing_bridgedap_channels(self, infos): """Sniff BridgedAp channels. Args: infos: A List of SoftAp info. e.g., [{'autoShutdownTimeoutMillis': 600000, 'bandwidth': 4, 'bssid': '12:dd:0b:b9:4b:cc', 'frequency': 5180, 'wifiStandard': 6}, {'autoShutdownTimeoutMillis': 600000, 'bandwidth': 2, 'bssid': '12:22:f4:b9:4b:cc', 'frequency': 2462, 'wifiStandard': 4}] """ if hasattr(self, "packet_capture") and len(self.packet_capture) == 2: # Create sniffer_config. self.sniffer_config = {} for i in range(len(infos)): if (infos[i][WifiEnums.frequency_key] in WifiEnums.ALL_5G_FREQUENCIES): self.sniffer_config[BAND_5G] = WifiEnums.freq_to_channel[ int(infos[i][WifiEnums.frequency_key])] if (infos[i][WifiEnums.frequency_key] in WifiEnums.ALL_2G_FREQUENCIES): self.sniffer_config[BAND_2G] = WifiEnums.freq_to_channel[ int(infos[i][WifiEnums.frequency_key])] logging.info("sniffer_config : {}".format(self.sniffer_config)) # Enable sniffers. self.sniffer_procs = [] for i in range(len(self.sniffer_config)): self.packet_capture[i].log.info( "Enable packet_capture[{}]".format(i)) result = self.packet_capture[i].configure_monitor_mode( list(self.sniffer_config.keys())[i], list(self.sniffer_config.values())[i]) if not result: logging.error("Failed to enable packet_capture" "on {}".format(self.packet_capture[i])) self.pcap_procs = wutils.start_pcap( self.packet_capture[i], list(self.sniffer_config.keys())[i], self.test_name) self.sniffer_procs.append(self.pcap_procs) logging.info("sniffer_procs: {}".format(self.sniffer_procs)) else: logging.warning("Packet_capture not enabled, " "because two packet_capture hardware required") def sniffing_ap_channels(self, channel1, channel2): """Sniff on two Wi-Fi channels. Args: channel1: Integer; a Wi-Fi channel, e.g., 6. channel2: Integer; a Wi-Fi channel, e,g,. 36. """ if not channel1: channel1 = hostapd_constants.AP_DEFAULT_CHANNEL_2G if not channel2: channel2 = hostapd_constants.AP_DEFAULT_CHANNEL_5G if hasattr(self, "packet_capture") and len(self.packet_capture) == 2: # Create sniffer_config. self.sniffer_config = {} if channel1 in WifiEnums.channel_2G_to_freq: self.sniffer_config[BAND_2G] = channel1 if channel1 in WifiEnums.channel_5G_to_freq: self.sniffer_config[BAND_5G] = channel1 if channel2 in WifiEnums.channel_2G_to_freq: self.sniffer_config[BAND_2G] = channel2 if channel2 in WifiEnums.channel_5G_to_freq: self.sniffer_config[BAND_5G] = channel2 logging.info("sniffer_config : {}".format(self.sniffer_config)) # Enable sniffers. self.sniffer_procs = [] for i in range(len(self.sniffer_config)): self.packet_capture[i].log.info( "Enable packet_capture[{}]".format(i)) result = self.packet_capture[i].configure_monitor_mode( list(self.sniffer_config.keys())[i], list(self.sniffer_config.values())[i]) if not result: logging.error("Failed to enable packet_capture" "on {}".format(self.packet_capture[i])) self.pcap_procs = wutils.start_pcap( self.packet_capture[i], list(self.sniffer_config.keys())[i], self.test_name) self.sniffer_procs.append(self.pcap_procs) logging.info("sniffer_procs: {}".format(self.sniffer_procs)) else: logging.debug("Packet_capture not enabled, " "because two packet_capture hardware required") def start_ap(self, channel_2g, channel_5g): """Enable OpenWrt AP with specific 2G/5G channels Args: channel_2g: Integer; a 2G channel, e.g., 6. channel_5g: Integer; a 5G channel, e,g,. 36 """ if not channel_2g: channel_2g = hostapd_constants.AP_DEFAULT_CHANNEL_2G if not channel_5g: channel_5g = hostapd_constants.AP_DEFAULT_CHANNEL_5G # Enable OpenWrt AP. if "OpenWrtAP" in self.user_params: self.configure_openwrt_ap_and_start(wpa_network=True, channel_2g=channel_2g, channel_5g=channel_5g) def two_clients_connect_to_wifi_network(self, dut1, dut2, config): """Connect two clients to different BridgedAp instances. This function will be called only when BridgedAp ON. Args: config: Wi-Fi config, e.g., {"SSID": "xxx", "password": "xxx"} Steps: Backup config. Register SoftAp Callback. Get SoftAp Infos. Get BSSIDs from Infos. Connect two clients to different BridgedAp instances. Restore config. """ # Make sure 2 instances enabled, and get BSSIDs from BridgedAp Infos. callbackId = self.dut.droid.registerSoftApCallback() infos = wutils.get_current_softap_infos(self.dut, callbackId, True) self.dut.droid.unregisterSoftApCallback(callbackId) if len(infos) == 0: raise signals.TestFailure("No BridgedAp instance") elif len(infos) == 1: raise signals.TestFailure( "Only one BridgedAp instance, should be two") else: bssid_5g = infos[0][wifi_constants.SOFTAP_INFO_BSSID_CALLBACK_KEY] bssid_2g = infos[1][wifi_constants.SOFTAP_INFO_BSSID_CALLBACK_KEY] # Two configs for BridgedAp 2G and 5G instances. config_5g = config.copy() config_2g = config.copy() config_5g[WifiEnums.BSSID_KEY] = bssid_5g config_2g[WifiEnums.BSSID_KEY] = bssid_2g # Connect two clients to BridgedAp. wutils.connect_to_wifi_network(dut1, config_5g, check_connectivity=False) wutils.connect_to_wifi_network(dut2, config_2g, check_connectivity=False) # Verify if Clients connect to the expected BridgedAp instances. client1_bssid = wutils.get_wlan0_link( self.client1)[wifi_constants.SOFTAP_INFO_BSSID_CALLBACK_KEY] client2_bssid = wutils.get_wlan0_link( self.client2)[wifi_constants.SOFTAP_INFO_BSSID_CALLBACK_KEY] asserts.assert_true(client1_bssid == bssid_5g, "Client1 does not connect to the 5G instance") asserts.assert_true(client2_bssid == bssid_2g, "Client2 does not connect to the 2G instance") def client_connects_to_a_bridgeap(self, ad, band): """One client connects to a BridgeAp instance Args: band: String; '2g' or '5g'. """ callbackId = self.dut.droid.registerSoftApCallback() infos = wutils.get_current_softap_infos(self.dut, callbackId, True) self.dut.droid.unregisterSoftApCallback(callbackId) # Make one client connects to 2G instance if band == '2g'. if band == BAND_2G: if (infos[0][wifi_constants.SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.ALL_2G_FREQUENCIES): bssid_2g = (infos[0][wifi_constants. SOFTAP_INFO_BSSID_CALLBACK_KEY]) else: bssid_2g = (infos[1][wifi_constants. SOFTAP_INFO_BSSID_CALLBACK_KEY]) config_2g = self.config.copy() config_2g[WifiEnums.BSSID_KEY] = bssid_2g wutils.connect_to_wifi_network(ad, config_2g, check_connectivity=False) # Make one client connects to 5G instance if band == '5g'. elif band == BAND_5G: if (infos[0][wifi_constants.SOFTAP_INFO_FREQUENCY_CALLBACK_KEY] in WifiEnums.ALL_5G_FREQUENCIES): bssid_5g = (infos[0][wifi_constants. SOFTAP_INFO_BSSID_CALLBACK_KEY]) else: bssid_5g = (infos[1][wifi_constants. SOFTAP_INFO_BSSID_CALLBACK_KEY]) config_5g = self.config.copy() config_5g[WifiEnums.BSSID_KEY] = bssid_5g wutils.connect_to_wifi_network(ad, config_5g, check_connectivity=False) # Tests @test_tracker_info(uuid="6f776b4a-b080-4b52-a330-52aa641b18f2") def test_two_clients_ping_bridged_ap_5g_2g_wpa3_country_us(self): """Test clients on different instances can ping each other. Steps: Backup config. Make sure clients support WPA3 SAE. Make sure DUT is able to enable BridgedAp. Enable BridgedAp with bridged configuration. RegisterSoftApCallback. Check the bridged AP enabled succeed. start sniffer and sniffing on BridgedAp channels. Force client#1 connect to 5G. Force client#2 connect to 2.4G. Trigger client#1 and client#2 each other. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure clients support WPA3 SAE. self.verify_clients_support_wpa3_sae(self.client1, self.client2) # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) self.two_clients_connect_to_wifi_network(self.client1, self.client2, self.config) # Trigger client#1 and client#2 ping each other. wutils.validate_ping_between_two_clients(self.client1, self.client2) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="8685a6cb-f7be-4384-b25b-23cecb4cb6dc") def test_two_clients_ping_bridged_ap_5g_2g_wpa3_sae_transition_country_us(self): """Test clients on different instances can ping each other. Steps: Refer to test_two_clients_ping_bridged_ap_5g_2g_wpa3_country_us, but this case enable WPA3/WPA2-Personal SoftAp security type. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure clients support WPA3 SAE. self.verify_clients_support_wpa3_sae(self.client1, self.client2) # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE_TRANSITION, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) self.two_clients_connect_to_wifi_network(self.client1, self.client2, self.config) # Trigger client#1 and client#2 ping each other. wutils.validate_ping_between_two_clients(self.client1, self.client2) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="b217d4de-cd09-4a8f-b27d-302ae5b86c7e") def test_two_clients_ping_bridged_ap_5g_2g_wpa2_country_us(self): """Test clients on different instances can ping each other. Steps: Refer to test_two_clients_ping_bridged_ap_5g_2g_wpa3_country_us, but this case enable WPA2-Personal SoftAp security type. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA2, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) self.two_clients_connect_to_wifi_network(self.client1, self.client2, self.config) # Trigger client#1 and client#2 ping each other. wutils.validate_ping_between_two_clients(self.client1, self.client2) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="ef98a5ea-c7d5-4cc4-a2f8-e5fd44648788") def test_two_clients_ping_bridged_ap_5g_2g_no_security_country_us(self): """Test clients on different instances can ping each other. Steps: Refer to test_two_clients_ping_bridged_ap_5g_2g_wpa3_country_us, but this case enable OPEN SoftAp security type. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.OPEN, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) self.two_clients_connect_to_wifi_network(self.client1, self.client2, self.config) # Trigger client#1 and client#2 ping each other. wutils.validate_ping_between_two_clients(self.client1, self.client2) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="0325ee58-ed8e-489e-9dee-55740406f896") def test_bridged_ap_5g_2g_and_sta_5g_dfs(self): """Test if auto fallback to one single 2G AP mode when BridgedAP enabled and STA connect to a 5G DFS channel. Steps: Backup config. DUT enable BridgedAp. start sniffer and sniffing on AP channels. DUT connect to a 5G DFS channel Wi-Fi network. Verify 5G instance is shutdown. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_ap_channels(channel1=None, channel2=132) self.start_ap(channel_2g=None, channel_5g=132) wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0][BAND_5G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="9a5d4ca9-67fc-412c-8114-01c43c34a76d") def test_bridged_ap_5g_2g_and_sta_5g_non_dfs(self): """Test 5G scc when BridgedAp enabled and 5G STA. Steps: Backup config. DUT enable BridgedAp. start sniffer and sniffing on AP channels. DUT connect to a 5G non-DFS channel Wi-Fi network. Verify STA frequency equals to 5G BridgedAp frequency. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_ap_channels(channel1=None, channel2=36) self.start_ap(channel_2g=None, channel_5g=36) wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0][BAND_5G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], True) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="e26e8a72-3e21-47b3-8fd8-4c4db5fb2573") def test_bridged_ap_5g_2g_and_sta_2g(self): """ Test 2G SCC when BridgedAp enable and 2G STA. Steps: Backup config. DUT enable BridgedAp. start sniffer and sniffing on AP channels. STA connect to a 2G Wi-Fi network. Verify STA frequency equals to 2G BridgedAp frequency. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_ap_channels(channel1=6, channel2=None) self.start_ap(channel_2g=6, channel_5g=None) wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0][BAND_2G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], True) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="b25f710a-2e53-456e-8280-dcdd37badd6c") def test_sta_5g_dfs_and_bridged_ap_5g_2g(self): """Test auto fallback to Single AP mode when STA connect to a DFS channel. Steps: Backup config. start sniffer and sniffing on AP channels. Enable a Wi-Fi network. DUT connect to a 5G DFS channel Wi-Fi network. DUT enable BridgedAp. Verify 5G instance is shutdown and only 2G instance enabled. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) self.sniffing_ap_channels(channel1=None, channel2=132) self.start_ap(channel_2g=None, channel_5g=132) wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0][BAND_5G]) # Enable BridgedAp self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) # # Verify only 2G instance enabled. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="6acaed3f-616f-4a03-a329-702e6cc537bd") def test_sta_5g_non_dfs_and_bridged_ap_5g_2g(self): """Test 5G scc when 5G STA and BridgedAp enabled. Steps: Backup config. start sniffer and sniffing on AP channels. Enable a Wi-Fi network. DUT connect to a 5G non-DFS channel Wi-Fi network. DUT enable BridgedAp. Verify STA frequency equals to 5G BridgedAp frequency. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) self.sniffing_ap_channels(channel1=None, channel2=36) self.start_ap(channel_2g=None, channel_5g=36) wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0][BAND_5G]) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) # Verify STA frequency equals to 5G BridgedAp frequency. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], True) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="e24e7f2d-f1d5-4dc7-aa6a-487677864d1d") def test_sta_2g_and_bridged_ap_5g_2g(self): """ Test 2G SCC when 2G STA and BridgedAp enable. Steps: Backup config. start sniffer and sniffing on AP channels. Enable a Wi-Fi network. DUT connect to a 2G Wi-Fi network. DUT enable BridgedAp. Verify STA frequency equals to 2G BridgedAp frequency. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) self.sniffing_ap_channels(channel1=6, channel2=None) self.start_ap(channel_2g=6, channel_5g=None) wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.wpa_networks[0][BAND_2G]) # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], True) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="927d564d-2ac4-4e6f-bb36-270efd519e0b") def test_bridged_ap_5g_2g_shutdown_5g_2g_no_client(self): """Test the BridgeAp shutdown mechanism with no client connect to it. Steps: Backup config. DUT turns ON BridgedAp. Verify no client connect to the BridgedAp. Wait for 5 minutes. Verify that 5G BridgedAp instance is shutdown. Maks sure there is still no client connect to the BridgedAp. Wait for 5 minutes. Verify that 2G BridgedAp instance is shutdown. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) # No client connection, wait 5 minutes, verify 5G is shutdown. self.verify_expected_number_of_softap_clients(self.dut, 0) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # No client connection, wait 5 minutes, verify 2G is shutdown. self.verify_expected_number_of_softap_clients(self.dut, 0) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) self.verify_number_band_freq_of_bridged_ap(self.dut, [], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="4c5b210c-412f-40e4-84b6-2a12dbffa017") def test_bridged_ap_5g_2g_shutdown_5g_auto_shutdown_2g(self): """Test the BridgeAp shutdown mechanism with no client connect to it. Steps: Backup config. DUT turns ON BridgedAp. start sniffer and sniffing on BridgedAp channels. Verify no client connect to the BridgedAp. Wait for 5 minutes. Verify that 5G BridgedAp instance is shutdown. A client connect to the 2G BridgedAp. The client disconnect from 2G BridgedAp. Wait for 10 minutes. Verify 2G BridgedAp is shutdown, no BridgedAp instance enabled. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) # Verify no connection to BridgedAp, wait for 5 mins, 5G shutdown. self.verify_expected_number_of_softap_clients(self.dut, 0) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # A client connect to 2G BridgedAp instance. callbackId = self.dut.droid.registerSoftApCallback() infos = wutils.get_current_softap_infos(self.dut, callbackId, True) self.dut.droid.unregisterSoftApCallback(callbackId) bssid_2g = infos[0][wifi_constants.SOFTAP_INFO_BSSID_CALLBACK_KEY] config_2g = self.config.copy() config_2g[WifiEnums.BSSID_KEY] = bssid_2g wutils.connect_to_wifi_network(self.client1, config_2g, check_connectivity=False) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_SECONDS) # Client disconnect From 2G BridgedAp instance. is_disconnect = self.client1.droid.wifiDisconnect() self.client1.log.info("Disconnected from SoftAp") if not is_disconnect: raise signals.TestFailure("Wi-Fi is not disconnected as expect") wutils.reset_wifi(self.client1) # Verify 2G instance is still enabled. self.wait_interval(INTERVAL_9_MINUTES) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # Verify all BridgedAp instances are shutdown after 10 minutes. self.wait_interval(INTERVAL_1_MINUTES) self.verify_number_band_freq_of_bridged_ap(self.dut, [], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="2b1b4579-d610-4983-83f4-5fc34b3cdd6b") def test_bridged_ap_5g_2g_shutdown_5g_auto_shutdown_2g_after_10_mins(self): """Test the BridgeAp shutdown mechanism with no client connect to it. Steps: Backup config. DUT turns ON BridgedAp. start sniffer and sniffing on BridgedAp channels. Verify no client connect to the BridgedAp. Wait for 5 minutes. Verify that 5G BridgedAp instance is shutdown. A client connect to the 2G BridgedAp at 7th minutes. The client disconnect from 2G BridgedAp at 9th minutes. Wait for 10 minutes. Verify 2G BridgedAp is shutdown, no BridgedAp instance enabled. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G], bridged_opportunistic_shutdown_enabled=True, shutdown_timeout_enable=True) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) self.verify_expected_number_of_softap_clients(self.dut, 0) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # Client connects to 2G instance at 7th mins. self.wait_interval(INTERVAL_2_MINUTES) callbackId = self.dut.droid.registerSoftApCallback() infos = wutils.get_current_softap_infos(self.dut, callbackId, True) self.dut.droid.unregisterSoftApCallback(callbackId) bssid_2g = infos[0][wifi_constants.SOFTAP_INFO_BSSID_CALLBACK_KEY] config_2g = self.config.copy() config_2g[WifiEnums.BSSID_KEY] = bssid_2g wutils.connect_to_wifi_network(self.client1, config_2g, check_connectivity=False) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_SECONDS) # Client disconnect From 2G BridgedAp instance at 9th mins. self.wait_interval(INTERVAL_2_MINUTES) is_disconnect = self.client1.droid.wifiDisconnect() self.client1.log.info("Disconnected from SoftAp") if not is_disconnect: raise signals.TestFailure("Wi-Fi is not disconnected as expect") wutils.reset_wifi(self.client1) # Make sure 2G instance is still enabled. self.wait_interval(INTERVAL_9_MINUTES) self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) self.wait_interval(INTERVAL_1_MINUTES) self.verify_number_band_freq_of_bridged_ap(self.dut, [], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="1785a487-dd95-4c17-852d-3c9b7b7dd4c3") def test_bridged_ap_5g_2g_fallback_2g_country_jp(self): """Test BridgedAp fallback to Single AP mode with JP country code. Steps: Backup config. Set DUT country code to "JP". DUT turns ON BridgedAp. Verify only 2G BridgedAp instance is enabled. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Set country code to JP and enable BridgedAp self.set_country_code_and_verify(self.dut, WifiEnums.CountryCode.JAPAN) # Enable BridgedAp self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) # Verify only 2G BridgedAp instance enabled. infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) self.sniffing_bridgedap_channels(infos) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="b5c7c6df-b181-4bba-a7b3-48fad0d7fa98") def test_bridged_ap_5g_2g_shutdown_2g_after_5_minutes(self): """Test the BridgeAp shutdown mechanism. Steps: Backup config. DUT turns ON BridgedAp. start sniffer and sniffing on BridgedAp channels. A Client connect to BridgeAp 5G instance. Wait for 5 minutes. Verify 2G instance is shutdown and only 5G instance exists. Stop sniffers. Restore config.""" # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) # Client connects to the 5G BridgedAp instance. self.client_connects_to_a_bridgeap(self.client1, BAND_5G) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) # Verify there is only one client connects to the BridgedAp. self.verify_expected_number_of_softap_clients(self.dut, 1) # Verify the BridgedAp instance is 5G. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="683b2c7f-7f24-4324-be09-0b6554d5d7a8") def test_bridged_ap_5g_2g_shutdown_5g_after_5_minutes(self): """Test the BridgeAp shutdown mechanism. Steps: Backup config. DUT turns ON BridgedAp. start sniffer and sniffing on BridgedAp channels. A Client connect to BridgeAp 2G instance. Wait for 5 minutes. Verify 5G instance is shutdown and only 2G instance exists. Stop sniffers. Restore config.""" # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) # Client connects to the 2G BridgedAp instance. self.client_connects_to_a_bridgeap(self.client1, BAND_2G) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) # Verify there is only one client connects to the BridgedAp. self.verify_expected_number_of_softap_clients(self.dut, 1) # Verify the BridgedAp instance is 2G. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="6de46e5b-04c3-4fba-a21d-e914a3e34e24") def test_bridged_ap_5g_2g_no_shutdown_after_5_minutes(self): """Test clients on different instances can ping each other. Steps: Backup config. Make sure clients support WPA3 SAE. Make sure DUT is able to enable BridgedAp. Enable BridgedAp with bridged configuration. RegisterSoftApCallback. Check the bridged AP enabled succeed. start sniffer and sniffing on BridgedAp channels. Client#1 connect to 5G instance. Client#2 connect to 2G instance. Wait for 5 minutes. Verify both 2G/5G BridgedAp instances are exist. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure clients support WPA3 SAE. self.verify_clients_support_wpa3_sae(self.client1, self.client2) # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp and verify both 2G,5G instances have been enabled. self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) infos = self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) self.sniffing_bridgedap_channels(infos) self.two_clients_connect_to_wifi_network(self.client1, self.client2, self.config) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) # Verify there are two clients connect to the BridgedAp. self.verify_expected_number_of_softap_clients(self.dut, 2) # Verify both 2G/5G BridgedAp instances are exist. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="f8742dfb-5232-4fe8-b568-3a99a9356d59") def test_bridged_ap_5g_2g_extend_compatibility_on_no_shutdown_5g(self): """Test BridgedAp mechanism when "Extend compatibility is ON. Steps: Backup config. Make sure clients support WPA3 SAE. Make sure DUT is able to enable BridgedAp. Enable BridgedAp with Extend compatibility is ON. RegisterSoftApCallback. Check the bridged AP enabled succeed. start sniffer and sniffing on BridgedAp channels. Client#1 connect to 2G. Verify both 2G/5G instances are exist. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure clients support WPA3 SAE. self.verify_clients_support_wpa3_sae(self.client1, self.client2) # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp with "Extend compatibility set to ON". self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G], bridged_opportunistic_shutdown_enabled=False) # Client connects to the 2G BridgedAp instance and wait 5 minutes. self.client_connects_to_a_bridgeap(self.client1, BAND_2G) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) # Verify both 2G/5G BridgedAp instances exist. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config) @test_tracker_info(uuid="050f8dd8-ed38-4f7a-87a9-9dbdade58cc7") def test_bridged_ap_5g_2g_extend_compatibility_on_no_shutdown_2g(self): """Test BridgedAp mechanism when "Extend compatibility is ON. Steps: Backup config. Make sure clients support WPA3 SAE. Make sure DUT is able to enable BridgedAp. Enable BridgedAp with Extend compatibility is ON. RegisterSoftApCallback. Check the bridged AP enabled succeed. start sniffer and sniffing on BridgedAp channels. Client#1 connect to 5G. Verify both 2G/5G instances are exist. Stop sniffers. Restore config. """ # Backup config original_softap_config = self.dut.droid.wifiGetApConfiguration() # Make sure clients support WPA3 SAE. self.verify_clients_support_wpa3_sae(self.client1, self.client2) # Make sure DUT is able to enable BridgedAp. is_supported = wutils.check_available_channels_in_bands_2_5( self.dut, wutils.WifiEnums.CountryCode.US) asserts.skip_if(not is_supported, "BridgedAp is not supported in {}" .format(wutils.WifiEnums.CountryCode.US)) # Simulate the unplugged scenario self.dut.adb.shell("cmd battery unplug") # Enable BridgedAp with "Extend compatibility set to ON". self.enable_bridged_ap(self.dut, WifiEnums.SoftApSecurityType.WPA3_SAE, bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G], bridged_opportunistic_shutdown_enabled=False) # Client connects to the 5G BridgedAp instance and wait 5 minutes. self.client_connects_to_a_bridgeap(self.client1, BAND_5G) self.wait_interval(BRIDGED_AP_SHUTDOWN_INTERVAL_5_MINUTES) # Verify both 2G/5G BridgedAp instances exist. self.verify_number_band_freq_of_bridged_ap( self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False) # Restore config wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)