| #!/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 itertools |
| import queue |
| import time |
| import traceback |
| |
| from acts import asserts |
| from acts import utils |
| 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 |
| |
| SCANTIME = 10000 #framework support only 10s as minimum scan interval |
| NUMBSSIDPERSCAN = 8 |
| EVENT_TAG = "WifiScannerScan" |
| SCAN_TIME_PASSIVE = 47 # dwell time plus 2ms |
| SCAN_TIME_ACTIVE = 32 # dwell time plus 2ms |
| SHORT_TIMEOUT = 30 |
| NETWORK_ID_ERROR = "Network don't have ID" |
| NETWORK_ERROR = "Device is not connected to reference network" |
| INVALID_RESULT = "Test fail because scan result reported are not valid" |
| EMPTY_RESULT = "Test fail because empty scan result reported" |
| KEY_RET = "ResultElapsedRealtime" |
| ATTENUATOR = 0 |
| |
| class WifiScannerScanError(Exception): |
| pass |
| |
| |
| class WifiScannerScanTest(WifiBaseTest): |
| def __init__(self, configs): |
| super().__init__(configs) |
| self.enable_packet_log = True |
| # TODO(angli): Remove this list. |
| # There are order dependencies among these tests so we'll have to leave |
| # it here for now. :( |
| self.tests = ( |
| "test_available_channels_band_1", |
| "test_available_channels_band_2", |
| "test_available_channels_band_3", |
| "test_available_channels_band_4", |
| "test_available_channels_band_6", |
| "test_available_channels_band_7", |
| "test_wifi_scanner_single_scan_channel_sanity", |
| "test_wifi_scanner_with_wifi_off", |
| "test_single_scan_report_each_scan_for_channels_with_enumerated_params", |
| "test_single_scan_report_each_scan_for_band_with_enumerated_params", |
| "test_single_scan_report_full_scan_for_channels_with_enumerated_params", |
| "test_single_scan_report_full_scan_for_band_with_enumerated_params", |
| "test_single_scan_while_pno", |
| "test_wifi_scanner_single_scan_in_isolated", |
| "test_wifi_scanner_with_invalid_numBssidsPerScan", |
| "test_wifi_scanner_dual_radio_low_latency", |
| "test_wifi_scanner_dual_radio_low_power", |
| "test_wifi_scanner_dual_radio_high_accuracy") |
| |
| def setup_class(self): |
| super().setup_class() |
| self.dut = self.android_devices[0] |
| wutils.wifi_test_device_init(self.dut) |
| req_params = ("run_extended_test", "ping_addr", "dbs_supported_models", |
| "support_addition_channel") |
| 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(ap_count=2, mirror_ap=False) |
| elif "OpenWrtAP" in self.user_params: |
| self.configure_openwrt_ap_and_start(open_network=True, |
| wpa_network=True, |
| ap_count=2) |
| |
| self.leeway = 10 |
| self.stime_channel = SCAN_TIME_PASSIVE |
| self.default_scan_setting = { |
| "band": wutils.WifiEnums.WIFI_BAND_BOTH, |
| "periodInMs": SCANTIME, |
| "reportEvents": wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN |
| } |
| self.default_batch_scan_setting = { |
| "band": wutils.WifiEnums.WIFI_BAND_BOTH, |
| "periodInMs": SCANTIME, |
| "reportEvents": wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL |
| } |
| self.log.debug("Run extended test: {}".format(self.run_extended_test)) |
| self.wifi_chs = wutils.WifiChannelUS(self.dut.model, self.support_addition_channel) |
| self.attenuators = wutils.group_attenuators(self.attenuators) |
| self.attenuators[0].set_atten(0) |
| self.attenuators[1].set_atten(0) |
| |
| def teardown_test(self): |
| super().teardown_test() |
| self.log.debug("Shut down all wifi scanner activities.") |
| self.dut.droid.wifiScannerShutdown() |
| |
| def teardown_class(self): |
| if "AccessPoint" in self.user_params: |
| del self.user_params["reference_networks"] |
| del self.user_params["open_network"] |
| |
| """ Helper Functions Begin """ |
| |
| def wifi_generate_scanner_scan_settings(self, extended, scan_type, |
| report_result): |
| """Generates all the combinations of different scan setting parameters. |
| |
| Args: |
| extended: True for extended setting |
| scan_type: key for type of scan |
| report_result: event type of report scan results |
| |
| Returns: |
| A list of dictionaries each representing a set of scan settings. |
| """ |
| base_scan_time = [SCANTIME * 2] |
| if scan_type == "band": |
| scan_types_setting = [wutils.WifiEnums.WIFI_BAND_BOTH] |
| else: |
| scan_types_setting = [self.wifi_chs.MIX_CHANNEL_SCAN] |
| num_of_bssid = [NUMBSSIDPERSCAN * 4] |
| max_scan_cache = [0] |
| if extended: |
| base_scan_time.append(SCANTIME) |
| if scan_type == "band": |
| scan_types_setting.extend( |
| [wutils.WifiEnums.WIFI_BAND_24_GHZ, |
| wutils.WifiEnums.WIFI_BAND_5_GHZ_WITH_DFS, |
| wutils.WifiEnums.WIFI_BAND_BOTH_WITH_DFS]) |
| else: |
| scan_types_setting.extend( |
| [self.wifi_chs.NONE_DFS_5G_FREQUENCIES, self.wifi_chs. |
| ALL_2G_FREQUENCIES, self.wifi_chs.DFS_5G_FREQUENCIES, |
| self.wifi_chs.ALL_5G_FREQUENCIES]) |
| num_of_bssid.append(NUMBSSIDPERSCAN * 3) |
| max_scan_cache.append(5) |
| # Generate all the combinations of report types and scan types |
| if report_result == wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT: |
| report_types = {"reportEvents": report_result} |
| setting_combinations = list(itertools.product(scan_types_setting, |
| base_scan_time)) |
| # Create scan setting strings based on the combinations |
| scan_settings = [] |
| for combo in setting_combinations: |
| s = dict(report_types) |
| s[scan_type] = combo[0] |
| s["periodInMs"] = combo[1] |
| scan_settings.append(s) |
| else: |
| report_types = {"reportEvents": report_result} |
| setting_combinations = list( |
| itertools.product(scan_types_setting, base_scan_time, |
| num_of_bssid, max_scan_cache)) |
| # Create scan setting strings based on the combinations |
| scan_settings = [] |
| for combo in setting_combinations: |
| s = dict(report_types) |
| s[scan_type] = combo[0] |
| s["periodInMs"] = combo[1] |
| s["numBssidsPerScan"] = combo[2] |
| s["maxScansToCache"] = combo[3] |
| scan_settings.append(s) |
| return scan_settings |
| |
| def proces_and_valid_batch_scan_result(self, scan_resutls, scan_rt, |
| result_rt, scan_setting): |
| """This function process scan results and validate against settings used |
| while starting the scan. |
| |
| There are two steps for the verification. First it checks that all the |
| wifi networks in results are of the correct frequencies set by scan setting |
| params. Then it checks that the delta between the batch of scan results less |
| than the time required for scanning channel set by scan setting params. |
| |
| Args: |
| scan_results: scan results reported. |
| scan_rt: Elapsed real time on start scan. |
| result_rt: Elapsed ral time on results reported. |
| scan_setting: The params for the single scan. |
| |
| Returns: |
| bssids: total number of bssids scan result have |
| validity: True if the all scan result are valid. |
| """ |
| bssids = 0 |
| validity = True |
| scan_time_mic = 0 |
| scan_channels = [] |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, scan_setting, self.stime_channel) |
| scan_time_mic = scan_time * 1000 |
| for i, batch in enumerate(scan_resutls, start=1): |
| asserts.assert_true( |
| batch["ScanResults"], |
| "At least one scan result is required to validate") |
| max_scan_interval = batch["ScanResults"][0][ |
| "timestamp"] + scan_time_mic |
| self.log.debug("max_scan_interval: %s", max_scan_interval) |
| for result in batch["ScanResults"]: |
| # Though the tests are run in shield box, there are leakes |
| # from outside environment. This would ignore any such SSIDs |
| ssid = result["SSID"] |
| if not ssid.startswith("2g_") or not ssid.startswith("5g_"): |
| continue |
| if (result["frequency"] not in scan_channels or |
| result["timestamp"] > max_scan_interval or |
| result["timestamp"] < scan_rt * 1000 or |
| result["timestamp"] > result_rt * 1000): |
| self.log.error("Result didn't match requirement: %s", |
| result) |
| validity = False |
| self.log.info("Number of scan result in batch %s: %s", i, |
| len(batch["ScanResults"])) |
| bssids += len(batch["ScanResults"]) |
| return bssids, validity |
| |
| def pop_scan_result_events(self, event_name): |
| """Function to pop all the scan result events. |
| |
| Args: |
| event_name: event name. |
| |
| Returns: |
| results: list of scan result reported in events |
| """ |
| results = [] |
| try: |
| events = self.dut.ed.pop_all(event_name) |
| for event in events: |
| results.append(event["data"]["Results"]) |
| except queue.Empty as error: |
| self.log.debug("Number of Full scan results %s", len(results)) |
| return results |
| |
| def wifi_scanner_single_scan(self, scan_setting): |
| """Common logic for an enumerated wifi scanner single scan test case. |
| |
| 1. Start WifiScanner single scan for scan_setting. |
| 2. Wait for the scan result event, wait time depend on scan settings |
| parameter. |
| 3. Verify that scan results match with scan settings parameters. |
| 4. Also verify that only one scan result event trigger. |
| |
| Args: |
| scan_setting: The params for the single scan. |
| """ |
| data = wutils.start_wifi_single_scan(self.dut, scan_setting) |
| idx = data["Index"] |
| scan_rt = data["ScanElapsedRealtime"] |
| self.log.info( |
| "Wifi single shot scan started index: %s at real time: %s", idx, |
| scan_rt) |
| results = [] |
| #generating event wait time from scan setting plus leeway |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, scan_setting, self.stime_channel) |
| wait_time = int(scan_time / 1000) + self.leeway |
| validity = False |
| #track number of result received |
| result_received = 0 |
| try: |
| for snumber in range(1, 3): |
| event_name = "{}{}onResults".format(EVENT_TAG, idx) |
| self.log.debug("Waiting for event: %s for time %s", event_name, |
| wait_time) |
| event = self.dut.ed.pop_event(event_name, wait_time) |
| self.log.debug("Event received: %s", event) |
| results = event["data"]["Results"] |
| result_received += 1 |
| bssids, validity = self.proces_and_valid_batch_scan_result( |
| results, scan_rt, event["data"][KEY_RET], scan_setting) |
| asserts.assert_equal( |
| len(results), 1, |
| "Test fail because number of scan result %s" % |
| len(results)) |
| asserts.assert_true(bssids > 0, EMPTY_RESULT) |
| asserts.assert_true(validity, INVALID_RESULT) |
| self.log.info("Scan number Buckets: %s\nTotal BSSID: %s", |
| len(results), bssids) |
| except queue.Empty as error: |
| asserts.assert_true( |
| result_received >= 1, |
| "Event did not triggered for single shot {}".format(error)) |
| finally: |
| self.dut.droid.wifiScannerStopScan(idx) |
| #For single shot number of result received and length of result should be one |
| asserts.assert_true( |
| result_received == 1, |
| "Test fail because received result {}".format(result_received)) |
| |
| def wifi_scanner_single_scan_full(self, scan_setting): |
| """Common logic for single scan test case for full scan result. |
| |
| 1. Start WifiScanner single scan with scan_setting for full scan result. |
| 2. Wait for the scan result event, wait time depend on scan settings |
| parameter. |
| 3. Pop all full scan result events occurred earlier. |
| 4. Verify that full scan results match with normal scan results. |
| 5. If the scan type is included in scan_setting, verify that the |
| radioChainInfos length. |
| |
| Args: |
| scan_setting: The parameters for the single scan. |
| """ |
| self.dut.ed.clear_all_events() |
| data = wutils.start_wifi_single_scan(self.dut, scan_setting) |
| idx = data["Index"] |
| scan_rt = data["ScanElapsedRealtime"] |
| self.log.info("Wifi single shot scan started with index: %s", idx) |
| #generating event wait time from scan setting plus leeway |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, scan_setting, self.stime_channel) |
| wait_time = int(scan_time / 1000) + self.leeway |
| results = [] |
| validity = False |
| try: |
| event_name = "%s%sonResults" % (EVENT_TAG, idx) |
| self.log.debug("Waiting for event: %s for time %s", event_name, |
| wait_time) |
| event = self.dut.ed.pop_event(event_name, wait_time) |
| self.log.info("Event received: %s", event) |
| bssids, validity = (self.proces_and_valid_batch_scan_result( |
| event["data"]["Results"], scan_rt, event["data"][KEY_RET], |
| scan_setting)) |
| asserts.assert_true(bssids > 0, EMPTY_RESULT) |
| asserts.assert_true(validity, INVALID_RESULT) |
| event_name = "{}{}onFullResult".format(EVENT_TAG, idx) |
| results = self.pop_scan_result_events(event_name) |
| asserts.assert_true( |
| len(results) >= bssids, |
| "Full single shot result don't match {}".format(len(results))) |
| if 'type' in scan_setting.keys(): |
| for item in results: |
| self.verify_radio_chain_length(scan_setting['type'], item) |
| except queue.Empty as error: |
| raise AssertionError( |
| "Event did not triggered for single shot {}".format(error)) |
| finally: |
| self.dut.droid.wifiScannerStopScan(idx) |
| |
| def verify_radio_chain_length(self, scan_setting_type, scan_result): |
| llen = len(scan_result[0]["radioChainInfos"]) |
| if scan_setting_type == wutils.WifiEnums.SCAN_TYPE_LOW_LATENCY \ |
| or scan_setting_type == wutils.WifiEnums.SCAN_TYPE_LOW_POWER: |
| asserts.assert_true(llen == 1, |
| "radioChainInfos len expected:{} " |
| "actual:{}".format(1, llen)) |
| else: |
| asserts.assert_true(llen == 2, |
| "radioChainInfos len expected:{} " |
| "actual:{}".format(2, llen)) |
| |
| def wifi_scanner_batch_scan_full(self, scan_setting): |
| """Common logic for batch scan test case for full scan result. |
| |
| 1. Start WifiScanner batch scan with scan_setting for full scan result. |
| 2. Wait for the scan result event, wait time depend on scan settings |
| parameter. |
| 3. Pop all full scan result events occurred earlier. |
| 4. Verify that full scan results match with scan results. |
| |
| Args: |
| scan_setting: The params for the batch scan. |
| """ |
| self.dut.ed.clear_all_events() |
| data = wutils.start_wifi_background_scan(self.dut, scan_setting) |
| idx = data["Index"] |
| scan_rt = data["ScanElapsedRealtime"] |
| self.log.info("Wifi batch shot scan started with index: %s", idx) |
| #generating event wait time from scan setting plus leeway |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, scan_setting, self.stime_channel) |
| # multiply scan period by two to account for scheduler changing period |
| scan_time += scan_setting[ |
| 'periodInMs'] * 2 #add scan period delay for next cycle |
| wait_time = scan_time / 1000 + self.leeway |
| validity = False |
| try: |
| for snumber in range(1, 3): |
| results = [] |
| event_name = "%s%sonResults" % (EVENT_TAG, idx) |
| self.log.debug("Waiting for event: %s for time %s", event_name, |
| wait_time) |
| event = self.dut.ed.pop_event(event_name, wait_time) |
| self.log.debug("Event received: %s", event) |
| bssids, validity = self.proces_and_valid_batch_scan_result( |
| event["data"]["Results"], scan_rt, event["data"][KEY_RET], |
| scan_setting) |
| event_name = "%s%sonFullResult" % (EVENT_TAG, idx) |
| results = self.pop_scan_result_events(event_name) |
| asserts.assert_true( |
| len(results) >= bssids, |
| "Full single shot result don't match %s" % len(results)) |
| asserts.assert_true(bssids > 0, EMPTY_RESULT) |
| asserts.assert_true(validity, INVALID_RESULT) |
| except queue.Empty as error: |
| raise AssertionError("Event did not triggered for batch scan %s" % |
| error) |
| finally: |
| self.dut.droid.wifiScannerStopBackgroundScan(idx) |
| self.dut.ed.clear_all_events() |
| |
| def wifi_scanner_batch_scan(self, scan_setting): |
| """Common logic for an enumerated wifi scanner batch scan test case. |
| |
| 1. Start WifiScanner batch scan for given scan_setting. |
| 2. Wait for the scan result event, wait time depend on scan settings |
| parameter. |
| 3. Verify that scan results match with scan settings parameters. |
| 4. Also verify that multiple scan result events trigger. |
| |
| Args: |
| scan_setting: The parameters for the batch scan. |
| """ |
| data = wutils.start_wifi_background_scan(self.dut, scan_setting) |
| idx = data["Index"] |
| scan_rt = data["ScanElapsedRealtime"] |
| self.log.info( |
| "Wifi background scan started with index: %s real time %s", idx, |
| scan_rt) |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, scan_setting, self.stime_channel) |
| #generating event wait time from scan setting plus leeway |
| time_cache = 0 |
| number_bucket = 1 #bucket for Report result on each scan |
| check_get_result = False |
| if scan_setting[ |
| 'reportEvents'] == wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL: |
| check_get_result = True |
| if ('maxScansToCache' in scan_setting and |
| scan_setting['maxScansToCache'] != 0): |
| time_cache = (scan_setting['maxScansToCache'] * |
| scan_setting['periodInMs']) |
| number_bucket = scan_setting['maxScansToCache'] |
| else: |
| time_cache = 10 * scan_setting['periodInMs' |
| ] #10 as default max scan cache |
| number_bucket = 10 |
| else: |
| time_cache = scan_setting[ |
| 'periodInMs' |
| ] #need while waiting for seconds resutls |
| # multiply cache time by two to account for scheduler changing period |
| wait_time = (time_cache * 2 + scan_time) / 1000 + self.leeway |
| validity = False |
| try: |
| for snumber in range(1, 3): |
| event_name = "%s%sonResults" % (EVENT_TAG, idx) |
| self.log.info("Waiting for event: %s for time %s", event_name, |
| wait_time) |
| event = self.dut.ed.pop_event(event_name, wait_time) |
| self.log.debug("Event received: %s", event) |
| results = event["data"]["Results"] |
| bssids, validity = (self.proces_and_valid_batch_scan_result( |
| results, scan_rt, event["data"][KEY_RET], scan_setting)) |
| self.log.info("Scan number: %s\n Buckets: %s\n BSSID: %s", |
| snumber, len(results), bssids) |
| asserts.assert_equal( |
| len(results), number_bucket, |
| "Test fail because number_bucket %s" % len(results)) |
| asserts.assert_true(bssids >= 1, EMPTY_RESULT) |
| asserts.assert_true(validity, INVALID_RESULT) |
| if snumber % 2 == 1 and check_get_result: |
| self.log.info("Get Scan result using GetScanResult API") |
| time.sleep(wait_time / number_bucket) |
| if self.dut.droid.wifiScannerGetScanResults(): |
| event = self.dut.ed.pop_event(event_name, 1) |
| self.log.debug("Event onResults: %s", event) |
| results = event["data"]["Results"] |
| bssids, validity = self.proces_and_valid_batch_scan_result( |
| results, scan_rt, event["data"][KEY_RET], |
| scan_setting) |
| self.log.info("Got Scan result number: %s BSSID: %s", |
| snumber, bssids) |
| asserts.assert_true(bssids >= 1, EMPTY_RESULT) |
| asserts.assert_true(validity, INVALID_RESULT) |
| else: |
| self.log.error("Error while fetching the scan result") |
| except queue.Empty as error: |
| raise AssertionError("Event did not triggered for batch scan %s" % |
| error) |
| finally: |
| self.dut.droid.wifiScannerStopBackgroundScan(idx) |
| self.dut.ed.clear_all_events() |
| |
| def start_wifi_scanner_single_scan_expect_failure(self, scan_setting): |
| """Common logic to test wif scanner single scan with invalid settings |
| or environment |
| |
| 1. Start WifiScanner batch scan for setting parameters. |
| 2. Verify that scan is not started. |
| |
| Args: |
| scan_setting: The params for the single scan. |
| """ |
| try: |
| idx = self.dut.droid.wifiScannerStartScan(scan_setting) |
| event = self.dut.ed.pop_event( |
| "{}{}onFailure".format(EVENT_TAG, idx), SHORT_TIMEOUT) |
| except queue.Empty as error: |
| raise AssertionError("Did not get expected onFailure {}".format( |
| error)) |
| |
| def start_wifi_scanner_background_scan_expect_failure(self, scan_setting): |
| """Common logic to test wif scanner batch scan with invalid settings |
| or environment |
| |
| 1. Start WifiScanner batch scan for setting parameters. |
| 2. Verify that scan is not started. |
| |
| Args: |
| scan_setting: The params for the single scan. |
| """ |
| try: |
| idx = self.dut.droid.wifiScannerStartBackgroundScan(scan_setting) |
| event = self.dut.ed.pop_event( |
| "{}{}onFailure".format(EVENT_TAG, idx), SHORT_TIMEOUT) |
| except queue.Empty as error: |
| raise AssertionError("Did not get expected onFailure {}".format( |
| error)) |
| |
| def check_get_available_channels_with_one_band(self, band): |
| """Common logic to check available channels for a band. |
| |
| 1. Get available channels for band. |
| 2. Verify that channels match with supported channels for band. |
| |
| Args: |
| band: wifi band.""" |
| |
| r = self.dut.droid.wifiScannerGetAvailableChannels(band) |
| self.log.info("Band: %s" % band) |
| self.log.info("Available channels: %s" % r) |
| expected = self.wifi_chs.band_to_freq(band) |
| self.log.info("Expected channels: %s" % expected) |
| asserts.assert_equal(set(r), set(expected), "Band %s failed." % band) |
| |
| def connect_to_reference_network(self): |
| """Connect to reference network and make sure that connection happen""" |
| self.dut.droid.wakeLockAcquireBright() |
| self.dut.droid.wakeUpNow() |
| try: |
| self.dut.droid.wifiConnectByConfig(self.reference_networks[0]["2g"]) |
| connect_result = self.dut.ed.pop_event( |
| wifi_constants.CONNECT_BY_CONFIG_SUCCESS, SHORT_TIMEOUT) |
| self.log.info(connect_result) |
| return wutils.track_connection(self.dut, |
| self.reference_networks[0]["2g"]["SSID"], 1) |
| except Exception as error: |
| self.log.exception(traceback.format_exc()) |
| self.log.error("Connection to network fail because %s", error) |
| return False |
| finally: |
| self.dut.droid.wifiLockRelease() |
| self.dut.droid.goToSleepNow() |
| |
| """ Helper Functions End """ |
| """ Tests Begin """ |
| |
| # Test channels |
| """ Test available channels for different bands. |
| |
| 1. Get available channels for different bands. |
| 2. Verify that channels match with supported channels for respective band. |
| """ |
| @test_tracker_info(uuid="7cca8142-529f-4951-ab6f-cd03b359b3cc") |
| def test_available_channels_band_1(self): |
| self.check_get_available_channels_with_one_band(1) |
| |
| @test_tracker_info(uuid="612afda1-0d74-4d2f-bc37-72ef2b98310a") |
| def test_available_channels_band_2(self): |
| self.check_get_available_channels_with_one_band(2) |
| |
| @test_tracker_info(uuid="a9275bb9-afa7-4dd4-b2e0-60296ffd33bb") |
| def test_available_channels_band_3(self): |
| self.check_get_available_channels_with_one_band(3) |
| |
| @test_tracker_info(uuid="5413632e-ce72-4ecc-bf9b-33ac9e4bf3fc") |
| def test_available_channels_band_4(self): |
| self.check_get_available_channels_with_one_band(4) |
| |
| @test_tracker_info(uuid="a8f40b4f-d79d-4d2f-bed8-3b139a082f6c") |
| def test_available_channels_band_6(self): |
| self.check_get_available_channels_with_one_band(6) |
| |
| @test_tracker_info(uuid="84cdfc25-8e64-42c7-b7f9-0a04e45d78b6") |
| def test_available_channels_band_7(self): |
| self.check_get_available_channels_with_one_band(7) |
| |
| @test_tracker_info(uuid="95069244-b76c-4834-b3a6-96b0d8da98d8") |
| def test_single_scan_report_each_scan_for_channels_with_enumerated_params( |
| self): |
| """Test WiFi scanner single scan for channels with enumerated settings. |
| |
| 1. Start WifiScanner single scan for different channels with enumerated |
| scan settings. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "channels", |
| wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN) |
| self.log.debug("Scan settings: %s\n%s", len(scan_settings), |
| scan_settings) |
| self.wifi_scanner_single_scan(scan_settings[0]) |
| |
| @test_tracker_info(uuid="5595ebe5-6d91-4379-a606-be59967e5ec9") |
| def test_single_scan_report_each_scan_for_band_with_enumerated_params( |
| self): |
| """Test WiFi scanner single scan for bands with enumerated settings. |
| |
| 1. Start WifiScanner single scan for different bands with enumerated |
| scan settings. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "band", |
| wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN) |
| self.log.debug("Scan settings:%s\n%s", len(scan_settings), |
| scan_settings) |
| self.wifi_scanner_single_scan(scan_settings[0]) |
| |
| @test_tracker_info(uuid="44989f93-e63b-4c2e-a90a-a483477303bb") |
| def test_batch_scan_report_buffer_full_for_channels_with_enumerated_params( |
| self): |
| """Test WiFi scanner batch scan using channels with enumerated settings |
| to report buffer full scan results. |
| |
| 1. Start WifiScanner batch scan using different channels with enumerated |
| scan settings to report buffer full scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "channels", |
| wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL) |
| self.log.debug("Scan settings:%s\n%s", len(scan_settings), |
| scan_settings) |
| self.wifi_scanner_batch_scan(scan_settings[0]) |
| |
| @test_tracker_info(uuid="63538df6-388a-4c16-964f-e9c19b750e07") |
| def test_batch_scan_report_buffer_full_for_band_with_enumerated_params( |
| self): |
| """Test WiFi scanner batch scan using band with enumerated settings |
| to report buffer full scan results. |
| |
| 1. Start WifiScanner batch scan using different bands with enumerated |
| scan settings to report buffer full scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "band", |
| wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL) |
| self.log.debug("Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_batch_scan(scan_settings[0]) |
| |
| @test_tracker_info(uuid="bd4e8c53-16c8-4ed6-b680-55c1ba688ad8") |
| def test_batch_scan_report_each_scan_for_channels_with_enumerated_params( |
| self): |
| """Test WiFi scanner batch scan using channels with enumerated settings |
| to report each scan results. |
| |
| 1. Start WifiScanner batch scan using different channels with enumerated |
| scan settings to report each scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "channels", |
| wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN) |
| self.log.debug("Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_batch_scan(scan_settings[0]) |
| |
| @test_tracker_info(uuid="d11e8c09-97d0-49c1-bf09-b9ec672c2fa6") |
| def test_batch_scan_report_each_scan_for_band_with_enumerated_params(self): |
| """Test WiFi scanner batch scan using band with enumerated settings |
| to report each scan results. |
| |
| 1. Start WifiScanner batch scan using different bands with enumerated |
| scan settings to report each scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "band", |
| wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN) |
| self.log.debug("Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_batch_scan(scan_settings[0]) |
| |
| @test_tracker_info(uuid="7f967b0e-82fe-403e-9d74-0dee7f09a21d") |
| def test_single_scan_report_full_scan_for_channels_with_enumerated_params( |
| self): |
| """Test WiFi scanner single scan using channels with enumerated settings |
| to report full scan results. |
| |
| 1. Start WifiScanner single scan using different channels with enumerated |
| scan settings to report full scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "channels", |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT) |
| self.log.debug("Full Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_single_scan_full(scan_settings[0]) |
| |
| @test_tracker_info(uuid="34d09f60-31bf-4952-8fb3-03fc93ec98fa") |
| def test_single_scan_report_full_scan_for_band_with_enumerated_params( |
| self): |
| """Test WiFi scanner single scan using band with enumerated settings |
| to report full scan results. |
| |
| 1. Start WifiScanner single scan using different bands with enumerated |
| scan settings to report full scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "band", |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT) |
| self.log.debug("Full Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_single_scan_full(scan_settings[0]) |
| |
| @test_tracker_info(uuid="0ddccf2e-b518-45a7-ae75-96924070b841") |
| def test_batch_scan_report_full_scan_for_channels_with_enumerated_params( |
| self): |
| """Test WiFi scanner batch scan using channels with enumerated settings |
| to report full scan results. |
| |
| 1. Start WifiScanner batch scan using different channels with enumerated |
| scan settings to report full scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "channels", |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT) |
| self.log.debug("Full Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_batch_scan_full(scan_settings[0]) |
| |
| @test_tracker_info(uuid="0685b667-8470-43a0-923d-dee71428f8ce") |
| def test_batch_scan_report_full_scan_for_band_with_enumerated_params(self): |
| """Test WiFi scanner batch scan using channels with enumerated settings |
| to report full scan results. |
| |
| 1. Start WifiScanner batch scan using different channels with enumerated |
| scan settings to report full scan results. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_settings = self.wifi_generate_scanner_scan_settings( |
| self.run_extended_test, "band", |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT) |
| self.log.debug("Full Scan settings:{}\n{}".format( |
| len(scan_settings), scan_settings)) |
| self.wifi_scanner_batch_scan_full(scan_settings[0]) |
| |
| @test_tracker_info(uuid="e9a7cfb5-21c4-4c40-8169-8d88b65a1dee") |
| @WifiBaseTest.wifi_test_wrap |
| def test_single_scan_while_pno(self): |
| """Test wifi scanner single scan parallel to PNO connection. |
| |
| 1. Check device have a saved network. |
| 2. Trigger PNO by attenuate the signal to move out of range. |
| 3. Start WifiScanner single scan for both band with default scan settings. |
| 4. Verify that scanner report single scan results. |
| 5. Attenuate the signal to move in range. |
| 6. Verify connection occurred through PNO. |
| """ |
| self.log.info("Check connection through PNO for reference network") |
| self.attenuators[ATTENUATOR].set_atten(0) |
| asserts.assert_true(self.connect_to_reference_network(), NETWORK_ERROR) |
| time.sleep(10) #wait for connection to be active |
| asserts.assert_true( |
| wutils.validate_connection(self.dut, self.ping_addr), |
| "Error, No internet connection for current network") |
| |
| current_network = self.dut.droid.wifiGetConnectionInfo() |
| self.log.info("Current network: {}".format(current_network)) |
| asserts.assert_true('network_id' in current_network, NETWORK_ID_ERROR) |
| asserts.assert_true(current_network['network_id'] >= 0, NETWORK_ERROR) |
| self.log.info("Kicking PNO for reference network") |
| self.attenuators[ATTENUATOR].set_atten(90) |
| time.sleep(10) #wait for PNO to be kicked |
| self.log.info("Starting single scan while PNO") |
| self.wifi_scanner_single_scan(self.default_scan_setting) |
| self.attenuators[ATTENUATOR].set_atten(0) |
| self.log.info("Check connection through PNO for reference network") |
| time.sleep(60) #wait for connection through PNO |
| current_network = self.dut.droid.wifiGetConnectionInfo() |
| self.log.info("Current network: {}".format(current_network)) |
| asserts.assert_true('network_id' in current_network, NETWORK_ID_ERROR) |
| asserts.assert_true(current_network['network_id'] >= 0, NETWORK_ERROR) |
| time.sleep(10) #wait for IP to be assigned |
| asserts.assert_true( |
| wutils.validate_connection(self.dut, self.ping_addr), |
| "Error, No internet connection for current network") |
| wutils.wifi_forget_network(self.dut, |
| self.reference_networks[0]["2g"]["SSID"]) |
| |
| @test_tracker_info(uuid="fc18d947-0b5a-42b4-98f3-dd1f2b52a7af") |
| def test_wifi_connection_and_pno_while_batch_scan(self): |
| """Test configuring a connection and PNO connection parallel to wifi |
| scanner batch scan. |
| |
| 1. Start WifiScanner batch scan with default batch scan settings. |
| 2. Wait for scan result event for a time depend on scan settings. |
| 3. Verify reported batch scan results. |
| 4. Configure a connection to reference network. |
| 5. Verify that connection to reference network occurred. |
| 6. Wait for scan result event for a time depend on scan settings. |
| 7. Verify reported batch scan results. |
| 8. Trigger PNO by attenuate the signal to move out of range. |
| 9. Wait for scan result event for a time depend on scan settings. |
| 10. Verify reported batch scan results. |
| 11. Attenuate the signal to move in range. |
| 12. Verify connection occurred through PNO. |
| """ |
| self.attenuators[ATTENUATOR].set_atten(0) |
| data = wutils.start_wifi_background_scan( |
| self.dut, self.default_batch_scan_setting) |
| idx = data["Index"] |
| scan_rt = data["ScanElapsedRealtime"] |
| self.log.info( |
| "Wifi background scan started with index: {} rt {}".format( |
| idx, scan_rt)) |
| #generating event wait time from scan setting plus leeway |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, self.default_batch_scan_setting, self.stime_channel) |
| #default number buckets |
| number_bucket = 10 |
| time_cache = self.default_batch_scan_setting[ |
| 'periodInMs'] * number_bucket #default cache |
| #add 2 seconds extra time for switch between the channel for connection scan |
| #multiply cache time by two to account for scheduler changing period |
| wait_time = (time_cache * 2 + scan_time) / 1000 + self.leeway + 2 |
| result_flag = 0 |
| try: |
| for snumber in range(1, 7): |
| event_name = "{}{}onResults".format(EVENT_TAG, idx) |
| self.log.info("Waiting for event: {}".format(event_name)) |
| event = self.dut.ed.pop_event(event_name, wait_time) |
| self.log.debug("Event onResults: {}".format(event)) |
| results = event["data"]["Results"] |
| bssids, validity = self.proces_and_valid_batch_scan_result( |
| results, scan_rt, event["data"][KEY_RET], |
| self.default_batch_scan_setting) |
| self.log.info( |
| "Scan number: {}\n Buckets: {}\n BSSID: {}".format( |
| snumber, len(results), bssids)) |
| asserts.assert_true(bssids >= 1, |
| "Not able to fetch scan result") |
| if snumber == 1: |
| self.log.info( |
| "Try to connect AP while waiting for event: {}".format( |
| event_name)) |
| asserts.assert_true(self.connect_to_reference_network(), |
| NETWORK_ERROR) |
| time.sleep(10) #wait for connection to be active |
| asserts.assert_true( |
| wutils.validate_connection(self.dut, self.ping_addr), |
| "Error, No internet connection for current network") |
| elif snumber == 3: |
| self.log.info("Kicking PNO for reference network") |
| self.attenuators[ATTENUATOR].set_atten(90) |
| elif snumber == 4: |
| self.log.info("Bring back device for PNO connection") |
| current_network = self.dut.droid.wifiGetConnectionInfo() |
| self.log.info("Current network: {}".format( |
| current_network)) |
| asserts.assert_true('network_id' in current_network, |
| NETWORK_ID_ERROR) |
| asserts.assert_true( |
| current_network['network_id'] == -1, |
| "Device is still connected to network {}".format( |
| current_network[wutils.WifiEnums.SSID_KEY])) |
| self.attenuators[ATTENUATOR].set_atten(0) |
| time.sleep( |
| 10 |
| ) #wait for connection to take place before waiting for scan result |
| elif snumber == 6: |
| self.log.info( |
| "Check connection through PNO for reference network") |
| current_network = self.dut.droid.wifiGetConnectionInfo() |
| self.log.info("Current network: {}".format( |
| current_network)) |
| asserts.assert_true('network_id' in current_network, |
| NETWORK_ID_ERROR) |
| asserts.assert_true(current_network['network_id'] >= 0, |
| NETWORK_ERROR) |
| time.sleep(10) #wait for connection to be active |
| asserts.assert_true( |
| wutils.validate_connection(self.dut, self.ping_addr), |
| "Error, No internet connection for current network") |
| wutils.wifi_forget_network(self.dut, |
| self.reference_networks[0]["2g"]["SSID"]) |
| except queue.Empty as error: |
| raise AssertionError( |
| "Event did not triggered for batch scan {}".format(error)) |
| finally: |
| self.dut.droid.wifiScannerStopBackgroundScan(idx) |
| self.dut.ed.clear_all_events() |
| |
| @test_tracker_info(uuid="7c25ce32-0fae-4a68-a7cb-fdf6d4d03caf") |
| def test_wifi_scanner_single_scan_channel_sanity(self): |
| """Test WiFi scanner single scan for mix channel with default setting |
| parameters. |
| |
| 1. Start WifiScanner single scan for mix channels with default setting |
| parameters. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_setting = {"channels": self.wifi_chs.MIX_CHANNEL_SCAN, |
| "periodInMs": SCANTIME, |
| "reportEvents": |
| wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN} |
| self.wifi_scanner_single_scan(scan_setting) |
| |
| @test_tracker_info(uuid="7c8da0c4-dec7-4d04-abd4-f8ea467a5c6d") |
| @WifiBaseTest.wifi_test_wrap |
| def test_wifi_scanner_dual_radio_low_latency(self): |
| """Test WiFi scanner single scan for mix channel with default setting |
| parameters. |
| |
| 1. Start WifiScanner single scan for type = SCAN_TYPE_LOW_LATENCY. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| if self.dut.model not in self.dbs_supported_models: |
| asserts.skip( |
| ("Device %s does not support dual radio scanning.") |
| % self.dut.model) |
| scan_setting = {"channels": self.wifi_chs.MIX_CHANNEL_SCAN, |
| "periodInMs": SCANTIME, |
| "reportEvents": |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT, |
| "type": wutils.WifiEnums.SCAN_TYPE_LOW_LATENCY} |
| self.wifi_scanner_single_scan_full(scan_setting) |
| |
| @test_tracker_info(uuid="58b49b01-851b-4e45-b218-9fd27c0be921") |
| @WifiBaseTest.wifi_test_wrap |
| def test_wifi_scanner_dual_radio_low_power(self): |
| """Test WiFi scanner single scan for mix channel with default setting |
| parameters. |
| |
| 1. Start WifiScanner single scan for type = SCAN_TYPE_LOW_POWER. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| if self.dut.model not in self.dbs_supported_models: |
| asserts.skip( |
| ("Device %s does not support dual radio scanning.") |
| % self.dut.model) |
| scan_setting = {"channels": self.wifi_chs.MIX_CHANNEL_SCAN, |
| "periodInMs": SCANTIME, |
| "reportEvents": |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT, |
| "type": wutils.WifiEnums.SCAN_TYPE_LOW_POWER} |
| self.wifi_scanner_single_scan_full(scan_setting) |
| |
| @test_tracker_info(uuid="3e7288bc-45e4-497c-bf3a-977eec4e896e") |
| @WifiBaseTest.wifi_test_wrap |
| def test_wifi_scanner_dual_radio_high_accuracy(self): |
| """Test WiFi scanner single scan for mix channel with default setting |
| parameters. |
| |
| 1. Start WifiScanner single scan for type = SCAN_TYPE_HIGH_ACCURACY. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| if self.dut.model not in self.dbs_supported_models: |
| asserts.skip( |
| ("Device %s does not support dual radio scanning.") |
| % self.dut.model) |
| scan_setting = {"channels": self.wifi_chs.MIX_CHANNEL_SCAN, |
| "periodInMs": SCANTIME, |
| "reportEvents": |
| wutils.WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT, |
| "type": wutils.WifiEnums.SCAN_TYPE_HIGH_ACCURACY} |
| self.wifi_scanner_single_scan_full(scan_setting) |
| |
| @test_tracker_info(uuid="e9f3aaad-4af3-4c54-9829-65dc1d6d4987") |
| def test_wifi_scanner_batch_scan_channel_sanity(self): |
| """Test WiFi scanner batch scan for mix channel with default setting |
| parameters to report the result on buffer full. |
| |
| 1. Start WifiScanner batch scan for mix channels with default setting |
| parameters. |
| 2. Verify that scan results match with respective scan settings. |
| """ |
| scan_setting = {"channels": self.wifi_chs.MIX_CHANNEL_SCAN, |
| "periodInMs": SCANTIME, |
| "reportEvents": |
| wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL} |
| self.wifi_scanner_batch_scan(scan_setting) |
| |
| @test_tracker_info(uuid="49ba245a-52e2-4c9b-90ad-a2fbc97e3d9f") |
| def test_wifi_scanner_batch_scan_period_too_short(self): |
| """Test WiFi scanner batch scan for band with too short period time. |
| |
| 1. Start WifiScanner batch scan for both band with interval period as 5s. |
| 2. Verify that scan is not started.""" |
| scan_setting = {"band": wutils.WifiEnums.WIFI_BAND_BOTH_WITH_DFS, |
| "periodInMs": 5000, |
| "reportEvents": |
| wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL} |
| self.start_wifi_scanner_background_scan_expect_failure(scan_setting) |
| |
| @test_tracker_info(uuid="6fe45cd7-4fac-4ddd-a950-b9431e68f735") |
| def test_wifi_scanner_single_scan_in_isolated(self): |
| """Test WiFi scanner in isolated environment with default scan settings. |
| |
| 1. Created isolated environment by attenuating the single by 90db |
| 2. Start WifiScanner single scan for mix channels with default setting |
| parameters. |
| 3. Verify that empty scan results reported. |
| """ |
| self.attenuators[0].set_atten(90) |
| self.attenuators[1].set_atten(90) |
| data = wutils.start_wifi_single_scan(self.dut, |
| self.default_scan_setting) |
| idx = data["Index"] |
| scan_rt = data["ScanElapsedRealtime"] |
| self.log.info("Wifi single shot scan started with index: {}".format( |
| idx)) |
| results = [] |
| #generating event wait time from scan setting plus leeway |
| scan_time, scan_channels = wutils.get_scan_time_and_channels( |
| self.wifi_chs, self.default_scan_setting, self.stime_channel) |
| wait_time = int(scan_time / 1000) + self.leeway |
| try: |
| event_name = "{}{}onResults".format(EVENT_TAG, idx) |
| self.log.debug("Waiting for event: {} for time {}".format( |
| event_name, wait_time)) |
| event = self.dut.ed.pop_event(event_name, wait_time) |
| self.log.debug("Event received: {}".format(event)) |
| results = event["data"]["Results"] |
| for batch in results: |
| asserts.assert_false(batch["ScanResults"], |
| "Test fail because report scan " |
| "results reported are not empty") |
| except queue.Empty as error: |
| raise AssertionError( |
| "Event did not triggered for in isolated environment {}".format( |
| error)) |
| finally: |
| self.dut.ed.clear_all_events() |
| self.attenuators[0].set_atten(0) |
| self.attenuators[1].set_atten(0) |
| |
| @test_tracker_info(uuid="46f817b9-97a3-455e-af2c-56f9aea64f7e") |
| def test_wifi_scanner_with_wifi_off(self): |
| """Test WiFi scanner single scan when wifi is off. |
| |
| 1. Toggle wifi state to off. |
| 2. Start WifiScanner single scan for both band with default scan settings. |
| 3. Verify that scan is not started. |
| """ |
| self.log.debug("Make sure wifi is off.") |
| wutils.wifi_toggle_state(self.dut, False) |
| self.start_wifi_scanner_single_scan_expect_failure( |
| self.default_scan_setting) |
| self.log.debug("Turning wifi back on.") |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| @test_tracker_info(uuid="257ad734-c21f-49f4-b448-3986b70eba3d") |
| def test_wifi_scanner_with_invalid_numBssidsPerScan(self): |
| """Test WiFi scanner single scan with invalid number of bssids reported |
| per scan. |
| |
| 1. Start WifiScanner single scan with invalid number of bssids reported |
| per scan. |
| 2. Verify that scan results triggered for default supported number of |
| bssids per scan. |
| """ |
| scan_setting = { |
| "band": wutils.WifiEnums.WIFI_BAND_BOTH_WITH_DFS, |
| "periodInMs": SCANTIME, |
| "reportEvents": wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, |
| 'numBssidsPerScan': 33 |
| } |
| self.wifi_scanner_single_scan(scan_setting) |
| |
| """ Tests End """ |
