Snap for 8076125 from 4f76e405c39b135c196116e07df9c89fe0698a25 to mainline-resolv-release Change-Id: Ieb0294600046b7733791bfde3a5d27b40240568b
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
diff --git a/acts_tests/tests/google/wifi/WifiStaApConcurrencyStressTest.py b/acts_tests/tests/google/wifi/WifiStaApConcurrencyStressTest.py index 7a10f03..9fddb69 100755 --- a/acts_tests/tests/google/wifi/WifiStaApConcurrencyStressTest.py +++ b/acts_tests/tests/google/wifi/WifiStaApConcurrencyStressTest.py
@@ -16,6 +16,7 @@ import time import pprint +import acts from acts import asserts from acts import signals @@ -27,6 +28,7 @@ import acts_contrib.test_utils.wifi.wifi_test_utils as wutils WifiEnums = wutils.WifiEnums +DEFAULT_TIMEOUT = 10 # Channels to configure the AP for various test scenarios. WIFI_NETWORK_AP_CHANNEL_2G = 1 @@ -56,13 +58,35 @@ "test_stress_softap_5G_wifi_connection_2G", "test_stress_softap_2G_wifi_connection_5G", "test_stress_softap_2G_wifi_connection_5G_DFS", - "test_stress_softap_5G_wifi_connection_2G_with_location_scan_on") + "test_stress_softap_5G_wifi_connection_2G_with_location_scan_on", + "test_2g_sta_mode_and_hotspot_5g_on_off_stress_under_airplane_mode") def setup_class(self): super().setup_class() opt_param = ["stress_count"] self.unpack_userparams(opt_param_names=opt_param) + 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() + 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) + """Helper Functions""" def connect_to_wifi_network_and_verify(self, params): """Connection logic for open and psk wifi networks. @@ -254,3 +278,21 @@ for count in range(self.stress_count): self.log.info("Iteration %d", count+1) self.verify_wifi_full_on_off(self.open_2g, softap_config) + + @test_tracker_info(uuid="36c7f847-4b3e-4bb1-a280-cfe2b6afc903") + def test_2g_sta_mode_and_hotspot_5g_on_off_stress_under_airplane_mode(self): + """Tests connection to 2G network followed by bringing up SoftAp on 5G + under airplane mode + """ + 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) + self.configure_ap(channel_2g=WIFI_NETWORK_AP_CHANNEL_2G) + wutils.wifi_toggle_state(self.dut, True) + self.connect_to_wifi_network_and_verify((self.open_2g, self.dut)) + time.sleep(DEFAULT_TIMEOUT) + for count in range(self.stress_count): + self.log.info("Iteration %d", count+1) + self.verify_softap_full_on_off(self.open_2g, WIFI_CONFIG_APBAND_5G) \ No newline at end of file
diff --git a/acts_tests/tests/google/wifi/WifiWpa3AutoUpdateTest.py b/acts_tests/tests/google/wifi/WifiWpa3AutoUpdateTest.py new file mode 100644 index 0000000..60d8ebb --- /dev/null +++ b/acts_tests/tests/google/wifi/WifiWpa3AutoUpdateTest.py
@@ -0,0 +1,201 @@ +# !/usr/bin/env python3.4 +# +# Copyright 2017 - 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 re +from acts.libs.ota import ota_updater +import acts.signals as 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.WifiBaseTest import WifiBaseTest +import acts.utils as utils +from WifiAutoUpdateTest import WifiAutoUpdateTest + +WifiEnums = wutils.WifiEnums +SSID = WifiEnums.SSID_KEY +PWD = WifiEnums.PWD_KEY +NETID = WifiEnums.NETID_KEY +# Default timeout used for reboot, toggle WiFi and Airplane mode, +# for the system to settle down after the operation. +EAP = WifiEnums.Eap +Ent = WifiEnums.Enterprise +WPA3_SECURITY = "SUITE_B_192" + + +class WifiWpa3AutoUpdateTest(WifiAutoUpdateTest): + """Tests for APIs in Android's WifiManager class. + + Test Bed Requirement: + * One Android device + * Several Wi-Fi networks visible to the device, including an open Wi-Fi + network. + """ + + def __init__(self, configs): + super().__init__(configs) + self.tests = ( + "test_check_wpa3_wifi_state_after_au", + "test_verify_wpa3_networks_after_au", + "test_wpa3_configstore_after_au", + "test_all_wpa3_networks_connectable_after_au", + "test_check_wpa3_wifi_toggling_after_au", + "test_wpa3_connection_to_new_networks", + "test_reset_wpa3_wifi_after_au") + + def setup_class(self): + super(WifiBaseTest, self).setup_class() + ota_updater.initialize(self.user_params, self.android_devices) + self.dut = self.android_devices[0] + self.dut_client = self.android_devices[1] + wutils.wifi_test_device_init(self.dut) + wutils.wifi_toggle_state(self.dut, True) + + # configure APs + req_params = ["ec2_ca_cert", "ec2_client_cert", "ec2_client_key", "rsa3072_ca_cert", + "rsa3072_client_cert", "rsa3072_client_key", "wpa3_ec2_network", + "wpa3_rsa3072_network", "rsa2048_client_cert", "rsa2048_client_key", + "rsa3072_client_cert_expired", "rsa3072_client_cert_corrupted", + "rsa3072_client_cert_unsigned", "rsa3072_client_key_unsigned", + "wpa3_sae_gcmp_128", "wpa3_sae_gcmp_256","owe_networks", "sae_networks"] + self.unpack_userparams( + req_param_names=req_params + ) + self.owe_2g = self.owe_networks[0]["2g"] + self.owe_5g = self.owe_networks[0]["5g"] + self.wpa3_personal_2g = self.sae_networks[0]["2g"] + self.wpa3_personal_5g = self.sae_networks[0]["5g"] + + self.config_rsa3072_tls = { + Ent.EAP: int(EAP.TLS), + Ent.CA_CERT: self.rsa3072_ca_cert, + WifiEnums.SSID_KEY: self.wpa3_rsa3072_network[WifiEnums.SSID_KEY], + Ent.CLIENT_CERT: self.rsa3072_client_cert, + Ent.PRIVATE_KEY_ID: self.rsa3072_client_key, + WifiEnums.SECURITY: WPA3_SECURITY, + "identity": self.wpa3_rsa3072_network["identity"], + "domain_suffix_match": self.wpa3_rsa3072_network["domain"] + } + + # saved & connected networks, network suggestions + # and new networks + self.saved_networks = [self.wpa3_sae_gcmp_256] + self.network_suggestions = [self.owe_2g] + self.connected_networks = [self.config_rsa3072_tls, self.wpa3_personal_5g] + self.new_networks = [self.wpa3_personal_2g] + # add pre ota upgrade configuration + self.wifi_config_list = [] + self.pre_default_mac = {} + self.pre_random_mac = {} + self.pst_default_mac = {} + self.pst_random_mac = {} + self.add_pre_update_configuration() + + # Run OTA below, if ota fails then abort all tests. + try: + ota_updater.update(self.dut) + except Exception as e: + raise signals.TestAbortClass( + "Failed up apply OTA update. Aborting tests: %s" % e) + + ### Tests + + @test_tracker_info(uuid="4d17a21c-3db6-4336-84ac-f3317e4a7fca") + @WifiBaseTest.wifi_test_wrap + def test_check_wpa3_wifi_state_after_au(self): + """Check if the state of WiFi is enabled after Auto-update.""" + super().test_check_wifi_state_after_au() + + @test_tracker_info(uuid="4dd106b0-6390-47d2-9b6d-00f21a0535f1") + @WifiBaseTest.wifi_test_wrap + def test_verify_wpa3_networks_after_au(self): + """Check if the previously added networks are intact. + + Steps: + Number of networs should be the same and match each network. + + """ + super().test_verify_networks_after_au() + + @test_tracker_info(uuid="4e5107d1-17cc-4c4d-aee5-38052dec5ddd") + @WifiBaseTest.wifi_test_wrap + def test_wpa3_configstore_after_au(self): + """Verify DUT automatically connects to wifi networks after ota. + + Steps: + 1. Connect to two wifi networks pre ota. + 2. Verify DUT automatically connects to 1 after ota. + 3. Re-connect to the other wifi network. + """ + wifi_info = self.dut.droid.wifiGetConnectionInfo() + self.pst_default_mac[wifi_info[SSID]] = self.get_sta_mac_address() + self.pst_random_mac[wifi_info[SSID]] = \ + self.dut.droid.wifigetRandomizedMacAddress(wifi_info) + reconnect_to = self.get_enabled_network(self.wifi_config_list[1], + self.wifi_config_list[2]) + wutils.start_wifi_connection_scan_and_ensure_network_found( + self.dut, reconnect_to[SSID]) + + if reconnect_to[SSID] == self.connected_networks[0][SSID]: + wutils.wifi_connect(self.dut, self.connected_networks[0], num_of_tries=6) + else: + wutils.wifi_connect(self.dut, self.connected_networks[1], num_of_tries=6) + connect_data = self.dut.droid.wifiGetConnectionInfo() + connect_ssid = connect_data[SSID] + self.log.info("Expected SSID = %s" % reconnect_to[SSID]) + self.log.info("Connected SSID = %s" % connect_ssid) + if connect_ssid != reconnect_to[SSID]: + raise signals.TestFailure( + "Device failed to reconnect to the correct" + " network after reboot.") + self.pst_default_mac[wifi_info[SSID]] = self.get_sta_mac_address() + self.pst_random_mac[wifi_info[SSID]] = \ + self.dut.droid.wifigetRandomizedMacAddress(wifi_info) + + for network in self.connected_networks: + wutils.wifi_forget_network(self.dut, network[SSID]) + + @test_tracker_info(uuid="f1b59dde-b019-46c4-84b8-cf20f4afa08a") + @WifiBaseTest.wifi_test_wrap + def test_wpa3_connection_to_new_networks(self): + """Check if we can connect to new networks after Auto-update. + + Steps: + 1. Connect to a wpa3 network. + 2. Forget ntworks added in 1. + """ + super().test_connection_to_new_networks() + + + @test_tracker_info(uuid="542a39c3-eea0-445c-89ae-8c74c6afb0bf") + @WifiBaseTest.wifi_test_wrap + def test_all_wpa3_networks_connectable_after_au(self): + """Check if previously added networks are connectable. + + Steps: + 1. Connect to previously added wpa3 network using network id. + """ + super().test_all_networks_connectable_after_au() + + @test_tracker_info(uuid="68a34667-aca2-4630-b2fa-c25f1d234a92") + @WifiBaseTest.wifi_test_wrap + def test_check_wpa3_wifi_toggling_after_au(self): + """Check if WiFi can be toggled ON/OFF after auto-update.""" + super().test_check_wifi_toggling_after_au() + + @test_tracker_info(uuid="39ba98de-cb49-4475-a218-7470122af885") + @WifiBaseTest.wifi_test_wrap + def test_reset_wpa3_wifi_after_au(self): + """"Check if WiFi can be reset after auto-update.""" + super().test_reset_wifi_after_au()