#!/usr/bin/env python3 # # Copyright 2020 - 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 time import random import re import logging import acts_contrib.test_utils.wifi.wifi_test_utils as wutils import acts_contrib.test_utils.tel.tel_test_utils as tel_utils import acts.utils as utils from acts import asserts from acts.test_decorators import test_tracker_info from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest from acts import signals from acts.controllers import packet_capture from acts.controllers.ap_lib.hostapd_constants import BAND_2G from acts.controllers.ap_lib.hostapd_constants import BAND_5G WifiEnums = wutils.WifiEnums class WifiChannelSwitchStressTest(WifiBaseTest): def setup_class(self): super().setup_class() self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] utils.require_sl4a((self.dut, self.dut_client)) if hasattr(self, 'packet_capture'): self.packet_capture = self.packet_capture[0] req_params = ["dbs_supported_models"] opt_param = ["stress_count", "cs_count"] self.unpack_userparams( req_param_names=req_params, opt_param_names=opt_param) self.AP_IFACE = 'wlan0' if self.dut.model in self.dbs_supported_models: self.AP_IFACE = 'wlan1' for ad in self.android_devices: wutils.wifi_test_device_init(ad) utils.sync_device_time(ad) wutils.set_wifi_country_code(ad, WifiEnums.CountryCode.US) def setup_test(self): super().setup_test() for ad in self.android_devices: ad.droid.wakeLockAcquireBright() ad.droid.wakeUpNow() try: if self.dut.droid.wifiIsApEnabled(): wutils.stop_wifi_tethering(self.dut) except signals.TestFailure: pass wutils.wifi_toggle_state(self.dut_client, True) init_sim_state = tel_utils.is_sim_ready(self.log, self.dut) if init_sim_state: self.check_cell_data_and_enable() self.config = wutils.create_softap_config() self.channel_list_2g = self.generate_random_list( WifiEnums.ALL_2G_FREQUENCIES) self.channel_list_5g = self.generate_random_list( WifiEnums.NONE_DFS_5G_FREQUENCIES) def teardown_test(self): super().teardown_test() for ad in self.android_devices: ad.droid.wakeLockRelease() ad.droid.goToSleepNow() wutils.reset_wifi(ad) try: wutils.stop_wifi_tethering(self.dut) except signals.TestFailure: pass def on_fail(self, test_name, begin_time): try: wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) except signals.TestFailure: pass super().on_fail(test_name, begin_time) def check_cell_data_and_enable(self): """Make sure that cell data is enabled if there is a sim present. If a sim is active, cell data needs to be enabled to allow provisioning checks through (when applicable). This is done to relax hardware requirements on DUTs - without this check, running this set of tests after other wifi tests may cause failures. """ if not self.dut.droid.telephonyIsDataEnabled(): self.dut.log.info("need to enable data") self.dut.droid.telephonyToggleDataConnection(True) asserts.assert_true(self.dut.droid.telephonyIsDataEnabled(), "Failed to enable cell data for dut.") def get_wlan0_link(self, dut): """ get wlan0 interface status""" get_wlan0 = 'wpa_cli -iwlan0 -g@android:wpa_wlan0 IFNAME=wlan0 status' out = dut.adb.shell(get_wlan0) out = dict(re.findall(r'(\S+)=(".*?"|\S+)', out)) asserts.assert_true("ssid" in out, "Client doesn't connect to any network") return out def get_wlan1_status(self, dut): """ get wlan1 interface status""" get_wlan1 = 'hostapd_cli status' out_wlan1 = dut.adb.shell(get_wlan1) out_wlan1 = dict(re.findall(r'(\S+)=(".*?"|\S+)', out_wlan1)) return out_wlan1 def generate_random_list(self, lst): """Generate a list where the previous and subsequent items do not repeat""" channel_list = [] num = random.choice(lst) channel_list.append(num) for i in range(1, self.stress_count): num = random.choice(lst) while num == channel_list[-1]: num = random.choice(lst) channel_list.append(num) return channel_list def conf_packet_capture(self, band, channel): """Configure packet capture on necessary channels.""" freq_to_chan = wutils.WifiEnums.freq_to_channel[int(channel)] logging.info("Capturing packets from " "frequency:{}, Channel:{}".format(channel, freq_to_chan)) result = self.packet_capture.configure_monitor_mode(band, freq_to_chan) if not result: logging.error("Failed to configure channel " "for {} band".format(band)) self.pcap_procs = wutils.start_pcap( self.packet_capture, band, self.test_name) time.sleep(5) @test_tracker_info(uuid="b1a8b00e-eca8-4eba-99e9-c7a3beb2a009") def test_softap_channel_switch_stress_2g(self): """ 1. Disable DUT's Wi-Fi 2. Enable CLIENT's Wi-Fi 3. Check DUT's sim is ready or not 4. Enable DUT's mobile data 5. Bring up DUT's softap in 2g 6. CLIENT connect to DUT 7. DUT switch to different 2g channel 8. Verify CLIENT follow the change 9, Repeat step 7 and 8 """ wutils.start_wifi_tethering(self.dut, self.config[wutils.WifiEnums.SSID_KEY], self.config[wutils.WifiEnums.PWD_KEY], WifiEnums.WIFI_CONFIG_APBAND_2G) wutils.connect_to_wifi_network(self.dut_client, self.config) time.sleep(10) for count in range(len(self.channel_list_2g)): self.dut.log.info("2g channel switch iteration : {}".format(count+1)) channel_2g = str(self.channel_list_2g[count]) # Configure sniffer before set SoftAP channel if hasattr(self, 'packet_capture'): self.conf_packet_capture(BAND_2G, channel_2g) # Set SoftAP channel wutils.set_softap_channel(self.dut, self.AP_IFACE, self.cs_count, channel_2g) time.sleep(10) softap_frequency = int(self.get_wlan1_status(self.dut)['freq']) self.dut.log.info('softap frequency : {}'.format(softap_frequency)) client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"]) self.dut_client.log.info( "client frequency : {}".format(client_frequency)) asserts.assert_true( softap_frequency == client_frequency, "hotspot frequency != client frequency") if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) @test_tracker_info(uuid="3411cb7c-2609-433a-97b6-202a096dc71b") def test_softap_channel_switch_stress_5g(self): """ 1. Disable DUT's Wi-Fi 2. Enable CLIENT's Wi-Fi 3. Check DUT's sim is ready or not 4. Enable DUT's mobile data 5. Bring up DUT's softap in 5g 6. CLIENT connect to DUT 7. DUT switch to different 5g channel 8. Verify CLIENT follow the change 9, Repeat step 7 and 8 """ wutils.start_wifi_tethering(self.dut, self.config[wutils.WifiEnums.SSID_KEY], self.config[wutils.WifiEnums.PWD_KEY], WifiEnums.WIFI_CONFIG_APBAND_5G) wutils.connect_to_wifi_network(self.dut_client, self.config) time.sleep(10) for count in range(len(self.channel_list_5g)): self.dut.log.info("5g channel switch iteration : {}".format(count+1)) channel_5g = str(self.channel_list_5g[count]) # Configure sniffer before set SoftAP channel if hasattr(self, 'packet_capture'): self.conf_packet_capture(BAND_5G, channel_5g) # Set SoftAP channel wutils.set_softap_channel(self.dut, self.AP_IFACE, self.cs_count, channel_5g) time.sleep(10) softap_frequency = int(self.get_wlan1_status(self.dut)['freq']) self.dut.log.info('softap frequency : {}'.format(softap_frequency)) client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"]) self.dut_client.log.info( "client frequency : {}".format(client_frequency)) asserts.assert_true( softap_frequency == client_frequency, "hotspot frequency != client frequency") if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) @test_tracker_info(uuid="0f279058-119f-49fc-b8d6-fb2991cc35aa") def test_softap_channel_switch_stress_2g_5g(self): """ 1. Disable DUT's Wi-Fi 2. Enable CLIENT's Wi-Fi 3. Check DUT's sim is ready or not 4. Enable DUT's mobile data 5. Bring up DUT's softap in 2g 6. CLIENT connect to DUT 7. DUT switch to different 2g channel 8. Verify CLIENT follow the change 9. DUT switch to 5g channel 10. Verify CLIENT follow the change 11. Repeat step 7 to 10 """ for count in range(self.stress_count): self.log.info("2g 5g channel switch iteration : {}".format(count+1)) wutils.start_wifi_tethering(self.dut, self.config[wutils.WifiEnums.SSID_KEY], self.config[wutils.WifiEnums.PWD_KEY], WifiEnums.WIFI_CONFIG_APBAND_2G) wutils.connect_to_wifi_network(self.dut_client, self.config) self.log.info("wait 10 secs for client reconnect to dut") time.sleep(10) channel_2g = self.channel_list_2g[count] if hasattr(self, 'packet_capture'): self.conf_packet_capture(BAND_2G, channel_2g) wutils.set_softap_channel(self.dut, self.AP_IFACE, self.cs_count, channel_2g) time.sleep(10) softap_frequency = int(self.get_wlan1_status(self.dut)['freq']) self.dut.log.info('softap frequency : {}'.format(softap_frequency)) client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"]) self.dut_client.log.info( "client frequency : {}".format(client_frequency)) asserts.assert_true( softap_frequency == client_frequency, "hotspot frequency != client frequency") wutils.stop_wifi_tethering(self.dut) if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) self.dut.log.info('switch to SoftAP 5g') # switch to SoftAp 5g wutils.start_wifi_tethering(self.dut, self.config[wutils.WifiEnums.SSID_KEY], self.config[wutils.WifiEnums.PWD_KEY], WifiEnums.WIFI_CONFIG_APBAND_5G) wutils.connect_to_wifi_network(self.dut_client, self.config) self.log.info("wait 10 secs for client reconnect to dut") time.sleep(10) channel_5g = self.channel_list_5g[count] if hasattr(self, 'packet_capture'): self.conf_packet_capture(BAND_5G, channel_5g) wutils.set_softap_channel(self.dut, self.AP_IFACE, self.cs_count, channel_5g) time.sleep(10) softap_frequency = int(self.get_wlan1_status(self.dut)['freq']) self.dut.log.info('softap frequency : {}'.format(softap_frequency)) client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"]) self.dut_client.log.info( "client frequency : {}".format(client_frequency)) asserts.assert_true( softap_frequency == client_frequency, "hotspot frequency != client frequency") wutils.stop_wifi_tethering(self.dut) if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)