diff options
| -rw-r--r-- | acts_tests/tests/google/wifi/WifiCellCoexChannelAvoidTest.py | 274 |
1 files changed, 274 insertions, 0 deletions
diff --git a/acts_tests/tests/google/wifi/WifiCellCoexChannelAvoidTest.py b/acts_tests/tests/google/wifi/WifiCellCoexChannelAvoidTest.py new file mode 100644 index 000000000..6d47ddf6a --- /dev/null +++ b/acts_tests/tests/google/wifi/WifiCellCoexChannelAvoidTest.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3.4 +# +# Copyright 2016 - The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import time +import re +import json +import logging +import pprint + +from acts import asserts +from acts import utils +from acts.keys import Config +from acts.test_decorators import test_tracker_info +from acts_contrib.test_utils.wifi import wifi_constants +from acts_contrib.test_utils.wifi import wifi_test_utils as wutils +from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest +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 +WIFI_CONFIG_APBAND_2G = WifiEnums.WIFI_CONFIG_APBAND_2G +WIFI_CONFIG_APBAND_5G = WifiEnums.WIFI_CONFIG_APBAND_5G +WIFI_CONFIG_APBAND_AUTO = WifiEnums.WIFI_CONFIG_APBAND_AUTO +WPA3_SAE_TRANSITION_SOFTAP = WifiEnums.SoftApSecurityType.WPA3_SAE_TRANSITION +WPA3_SAE_SOFTAP = WifiEnums.SoftApSecurityType.WPA3_SAE +WAIT_AFTER_REBOOT = 10 + +BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS = 5 + + +class WifiCellCoexChannelAvoidTest(WifiBaseTest): + + def __init__(self, configs): + super().__init__(configs) + self.generate_test_list() + + def generate_test_list(self): + """Generates a test list sorted with coex_unsafe_list_sap list. + Test with a sorted list can reduce lots of time + on switch radio and band start up. + """ + sorted_list = sorted( + self.user_params["coex_unsafe_list_sap"], key=lambda radio: radio["band"]) + for test_item in sorted_list: + self.init_test_case(self.coex_unsafechannel_avoidance, test_item) + pprint.pprint("self.tests = {}".format(self.tests)) + + def init_test_case(self, coex_unsafechannel_avoidance, test_item): + """Generates a single test case from the given data. + + Args: + coex_unsafechannel_avoidance: The base test case function to run. + test_item: test case required info include ["uuid","coex_unsafe_case"] + """ + test_name = test_item["coex_unsafe_case"] + test_tracker_uuid = test_item["uuid"] + if not test_name.startswith("test_"): + test_name = "test_{}".format(test_name) + test_case = test_tracker_info(uuid=test_tracker_uuid)( + lambda: coex_unsafechannel_avoidance(test_item)) + setattr(self, test_name, test_case) + self.tests.append(test_name) + + def setup_class(self): + """It will setup the required dependencies from config file and configure + the devices for softap mode testing. + + Returns: + True if successfully configured the requirements for testing. + """ + super().setup_class() + self.dut = self.android_devices[0] + self.dut_client = self.android_devices[1] + req_params = ["dbs_supported_models", "sta_concurrency_supported_models", + "wifi6_models","coex_unsafe_list_sap"] + opt_param = ["reference_networks"] + self.unpack_userparams( + req_param_names=req_params, opt_param_names=opt_param) + if "AccessPoint" in self.user_params: + self.legacy_configure_ap_and_start() + elif "OpenWrtAP" in self.user_params: + self.configure_openwrt_ap_and_start(wpa_network=True) + self.wifi_network = self.reference_networks[0]["2g"] + # Do a simple version of init - mainly just sync the time and enable + # verbose logging. This test will fail if the DUT has a sim and cell + # data is disabled. We would also like to test with phones in less + # constrained states (or add variations where we specifically + # constrain). + utils.require_sl4a((self.dut, self.dut_client)) + utils.sync_device_time(self.dut) + utils.sync_device_time(self.dut_client) + # Enable verbose logging on the duts + self.dut.droid.wifiEnableVerboseLogging(1) + asserts.assert_equal(self.dut.droid.wifiGetVerboseLoggingLevel(), 1, + "Failed to enable WiFi verbose logging on the softap dut.") + self.dut_client.droid.wifiEnableVerboseLogging(1) + asserts.assert_equal(self.dut_client.droid.wifiGetVerboseLoggingLevel(), 1, + "Failed to enable WiFi verbose logging on the client dut.") + wutils.wifi_toggle_state(self.dut, True) + wutils.wifi_toggle_state(self.dut_client, True) + self.AP_IFACE = 'wlan0' + if self.dut.model in self.dbs_supported_models: + self.AP_IFACE = 'wlan1' + if self.dut.model in self.sta_concurrency_supported_models: + self.AP_IFACE = 'wlan2' + if len(self.android_devices) > 2: + utils.sync_device_time(self.android_devices[2]) + self.android_devices[2].droid.wifiEnableVerboseLogging(1) + asserts.assert_equal(self.android_devices[2].droid.wifiGetVerboseLoggingLevel(), 1, + "Failed to enable WiFi verbose logging on the client dut.") + self.dut_client_2 = self.android_devices[2] + + def teardown_class(self): + super().teardown_class() + for ad in self.android_devices: + wutils.wifi_toggle_state(ad, True) + wutils.reset_wifi(ad) + time.sleep(WAIT_AFTER_REBOOT) + if self.dut.droid.wifiIsApEnabled(): + wutils.stop_wifi_tethering(self.dut) + if "AccessPoint" in self.user_params: + del self.user_params["reference_networks"] + del self.user_params["open_network"] + + def setup_test(self): + super().setup_test() + for ad in self.android_devices: + wutils.wifi_toggle_state(ad, True) + self.dut.reboot() + time.sleep(WAIT_AFTER_REBOOT) + + def teardown_test(self): + super().teardown_test() + for ad in self.android_devices: + wutils.wifi_toggle_state(ad, True) + if self.dut.droid.wifiIsApEnabled(): + wutils.stop_wifi_tethering(self.dut) + self.dut.log.debug("Toggling Airplane mode OFF.") + asserts.assert_true(utils.force_airplane_mode(self.dut, False), + "Can not turn off airplane mode: %s" % self.dut.serial) + #reset coexcell setting + self.dut.adb.shell('cmd wifi reset-coex-cell-channels') + + """ Helper Functions """ + + 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]) + + def enable_softap(self, ad, band=None): + """ Enable SoftAp of the DUT + + Returns: + (freq1, freq2): Integer; a 2G frequency and a 5G frequency if DUT + support BridgedAp. + freq: Integer; a frequency from SoftAp. + None, bandwidth: Just a placeholder, won't be used. + """ + # Enable SoftAp + # Create SoftAp config. + config = wutils.create_softap_config() + # If DUT support BridgedAp, then two BridgedAp instances enabled. + if self.dut.droid.wifiIsBridgedApConcurrencySupported(): + wutils.save_wifi_soft_ap_config( + ad, + config, + bands=[WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G, + WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G]) + # If DUT does not support BridgedAp, 2G OR 5G SoftAp enabled. + else: + if self.init_softap_band == BAND_2G: + band = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G + if self.init_softap_band == BAND_5G: + band = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G + wutils.save_wifi_soft_ap_config(ad, + config, + band=band) + wutils.start_wifi_tethering_saved_config(ad) + time.sleep(BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS) + + # if DUT support BridgedAp: + if ad.droid.wifiIsBridgedApConcurrencySupported(): + callbackId = ad.droid.registerSoftApCallback() + infos = wutils.get_current_softap_infos(ad, callbackId, True) + ad.droid.unregisterSoftApCallback(callbackId) + # if DUT BridgedAp has two instances, return two frequencies. + if len(infos) == 2: + freq_1 = infos[0]["frequency"] + freq_2 = infos[1]["frequency"] + self.dut.log.info("DUT connected to AP on freq: {},{}, chan: {} ,{}". + format(freq_1, freq_2, WifiEnums.freq_to_channel[freq_1], + WifiEnums.freq_to_channel[freq_2])) + return freq_1, freq_2 + # if DUT BridgedAp has only one instances, return the frequency. + elif len(infos) == 1: + freq = infos[0]["frequency"] + self.dut.log.info("DUT connected to AP on freq: {}, chan: {}". + format(freq, WifiEnums.freq_to_channel[freq])) + return freq + else: + raise signals.TestFailure("There should be SoftAp instance.") + # if DUT does not support BridgedAp: + else: + # Return SoftAp frequency. + callbackId = ad.droid.registerSoftApCallback() + freq, bandwidth = wutils.get_current_softap_info(ad, + callbackId, + True) + ad.log.info("SoftAp freq: {}".format(freq)) + ad.droid.unregisterSoftApCallback(callbackId) + self.dut.log.info("DUT connected to AP on freq: {}, chan: {}". + format(freq, WifiEnums.freq_to_channel[freq])) + return freq, bandwidth + + """ Tests Begin """ + + def coex_unsafechannel_avoidance(self, test_item): + self.radio = test_item["radio"] + self.band = test_item["band"] + self.cellchannels = test_item["setcoexcellchannels"] + time.sleep(WAIT_AFTER_REBOOT) + wutils.set_wifi_country_code(self.dut, country_code='US') + asserts.skip_if(not self.dut.droid.isSdkAtLeastS(), + "Require SDK at least S to use wifi coex apis.") + self.dut.ed.clear_all_events() + #Listing the test coex setting from configuration + self.dut.log.info("DUT test cellcoex radio:{}, band:{}, channels setting:{}" + .format(self.radio, self.band, self.cellchannels)) + self.dut.adb.shell('cmd wifi set-coex-cell-channels %s %s %s' % (self.radio, self.band, + self.cellchannels)) + 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])) + unsafe_channels = [] + for i in range(len(prev_unsafe_channels)): + unsafe_channels.append(prev_unsafe_channels[i]['channel']) + self.dut.log.info("DUT unsafe channels:{}".format(unsafe_channels)) + freq1, freq2 = self.enable_softap(self.dut) + sapchan1, sapchan2 = WifiEnums.freq_to_channel[freq1], WifiEnums.freq_to_channel[freq2] + if sapchan1 in unsafe_channels or sapchan2 in unsafe_channels: + asserts.fail("devices hotspot's channel open on current unsafe channels " + + str(unsafe_channels)) + else: + pass + self.dut.droid.wifiUnregisterCoexCallback() + self.dut.adb.shell('cmd wifi reset-coex-cell-channels') + + """ Tests End """ + +if __name__ == "__main__": + pass |