#!/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 base_test from acts import utils from acts.test_decorators import test_tracker_info from acts.test_utils.wifi import wifi_constants from acts.test_utils.wifi import wifi_test_utils as wutils from acts.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, controllers): WifiBaseTest.__init__(self, controllers) # 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): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) req_params = ("run_extended_test", "ping_addr", "max_bugreports", "dbs_supported_models") 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) 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.attenuators = wutils.group_attenuators(self.attenuators) self.attenuators[0].set_atten(0) self.attenuators[1].set_atten(0) def teardown_test(self): base_test.BaseTestClass.teardown_test(self) self.log.debug("Shut down all wifi scanner activities.") self.dut.droid.wifiScannerShutdown() def on_fail(self, test_name, begin_time): if self.max_bugreports > 0: self.dut.take_bug_report(test_name, begin_time) self.max_bugreports -= 1 self.dut.cat_adb_log(test_name, begin_time) 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 """