Snap for 8068644 from bf17d7046897cac823330c7e7935a532477b3328 to sc-v2-release
Change-Id: I05390e7b58357ea6adb4812ac18a917be37eac34
diff --git a/acts_tests/tests/google/wifi/WifiCellCoexChannelAvoidTest.py b/acts_tests/tests/google/wifi/WifiCellCoexChannelAvoidTest.py
new file mode 100644
index 0000000..6d47ddf
--- /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
