#!/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 queue import time from acts import asserts from acts import base_test from acts import signals from acts.test_decorators import test_tracker_info from acts.test_utils.wifi import wifi_test_utils as wutils from acts.test_utils.wifi.WifiBaseTest import WifiBaseTest WifiChannelUS = wutils.WifiChannelUS WifiEnums = wutils.WifiEnums SCAN_EVENT_TAG = "WifiScannerScan" class WifiScanResultEvents(): """This class stores the setting of a scan, parameters generated from starting the scan, and events reported later from the scan for validation. Attributes: scan_setting: Setting used to perform the scan. scan_channels: Channels used for scanning. events: A list to store the scan result events. """ def __init__(self, scan_setting, scan_channels): self.scan_setting = scan_setting self.scan_channels = scan_channels self.results_events = [] def add_results_event(self, event): self.results_events.append(event) def check_interval(self, scan_result, scan_result_next): """Verifies that the time gap between two consecutive results is within expected range. Right now it is hard coded to be 20 percent of the interval specified by scan settings. This threshold can be imported from the configuration file in the future if necessary later. Note the scan result timestamps are in microseconds, but "periodInMs" in scan settings is in milliseconds. Args: scan_result: A dictionary representing a scan result for a BSSID. scan_result_next: A dictionary representing a scan result for a BSSID, whose scan happened after scan_result. """ actual_interval = scan_result_next["timestamp"] - scan_result[ "timestamp"] expected_interval = self.scan_setting['periodInMs'] * 1000 delta = abs(actual_interval - expected_interval) margin = expected_interval * 0.25 # 25% of the expected_interval asserts.assert_true( delta < margin, "The difference in time between scan %s and " "%s is %dms, which is out of the expected range %sms" % ( scan_result, scan_result_next, delta / 1000, self.scan_setting['periodInMs'])) def verify_one_scan_result(self, scan_result): """Verifies the scan result of a single BSSID. 1. Verifies the frequency of the network is within the range requested in the scan. Args: scan_result: A dictionary representing the scan result of a single BSSID. """ freq = scan_result["frequency"] asserts.assert_true( freq in self.scan_channels, "Frequency %d of result entry %s is out of the expected range %s." % (freq, scan_result, self.scan_channels)) # TODO(angli): add RSSI check. def verify_one_scan_result_group(self, batch): """Verifies a group of scan results obtained during one scan. 1. Verifies the number of BSSIDs in the batch is less than the threshold set by scan settings. 2. Verifies each scan result for individual BSSID. Args: batch: A list of dictionaries, each dictionary represents a scan result. """ scan_results = batch["ScanResults"] actual_num_of_results = len(scan_results) expected_num_of_results = self.scan_setting['numBssidsPerScan'] asserts.assert_true(actual_num_of_results <= expected_num_of_results, "Expected no more than %d BSSIDs, got %d." % (expected_num_of_results, actual_num_of_results)) for scan_result in scan_results: self.verify_one_scan_result(scan_result) def have_enough_events(self): """Check if there are enough events to properly validate the scan""" return len(self.results_events) >= 2 def check_scan_results(self): """Validate the reported scan results against the scan settings. Assert if any error detected in the results. 1. For each scan setting there should be no less than 2 events received. 2. For batch scan, the number of buffered results in each event should be exactly what the scan setting specified. 3. Each scan result should contain no more BBSIDs than what scan setting specified. 4. The frequency reported by each scan result should comply with its scan setting. 5. The time gap between two consecutive scan results should be approximately equal to the scan interval specified by the scan setting. A scan result looks like this: { 'data': { 'Type': 'onResults', 'ResultElapsedRealtime': 4280931, 'Index': 10, 'Results': [ { 'Flags': 0, 'Id': 4, 'ScanResults':[ { 'is80211McRTTResponder': False, 'channelWidth': 0, 'numUsage': 0, 'SSID': '"wh_ap1_2g"', 'timestamp': 4280078660, 'BSSID': '30:b5:c2:33:f9:05', 'frequency': 2412, 'distanceSdCm': 0, 'distanceCm': 0, 'centerFreq1': 0, 'centerFreq0': 0, 'venueName': '', 'seen': 0, 'operatorFriendlyName': '', 'level': -31, 'passpointNetwork': False, 'untrusted': False } ] } ] }, 'time': 1491744576383, 'name': 'WifiScannerScan10onResults' } """ num_of_events = len(self.results_events) asserts.assert_true( num_of_events >= 2, "Expected more than one scan result events, got %d." % num_of_events) for event_idx in range(num_of_events): batches = self.results_events[event_idx]["data"]["Results"] actual_num_of_batches = len(batches) if not actual_num_of_batches: raise signals.TestFailure("Scan returned empty Results list %s " "% batches") # For batch scan results. report_type = self.scan_setting['reportEvents'] if not (report_type & WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN): # Verifies that the number of buffered results matches the # number defined in scan settings. expected_num_of_batches = self.scan_setting['maxScansToCache'] asserts.assert_true( actual_num_of_batches <= expected_num_of_batches, "Expected to get at most %d batches in event No.%d, got %d." % (expected_num_of_batches, event_idx, actual_num_of_batches)) # Check the results within each event of batch scan for batch_idx in range(actual_num_of_batches): if not len(batches[batch_idx]["ScanResults"]): raise signals.TestFailure("Scan event %d returned empty" " scan results in batch %d" % (event_idx, batch_idx)) # Start checking interval from the second batch. if batch_idx >=1: self.check_interval( batches[batch_idx - 1]["ScanResults"][0], batches[batch_idx]["ScanResults"][0]) for batch in batches: self.verify_one_scan_result_group(batch) # Check the time gap between the first result of an event and # the last result of its previous event # Skip the very first event. if event_idx >= 1: previous_batches = self.results_events[event_idx - 1]["data"][ "Results"] self.check_interval(previous_batches[-1]["ScanResults"][0], batches[0]["ScanResults"][0]) class WifiScannerMultiScanTest(WifiBaseTest): """This class is the WiFi Scanner Multi-Scan Test suite. It collects a number of test cases, sets up and executes the tests, and validates the scan results. Attributes: tests: A collection of tests to excute. leeway: Scan interval drift time (in seconds). stime_channels: Dwell time plus 2ms. dut: Android device(s). wifi_chs: WiFi channels according to the device model. max_bugreports: Max number of bug reports allowed. """ def __init__(self, controllers): WifiBaseTest.__init__(self, controllers) self.tests = ( 'test_wifi_two_scans_at_same_interval', 'test_wifi_two_scans_at_different_interval', 'test_wifi_scans_24GHz_and_both', 'test_wifi_scans_5GHz_and_both', 'test_wifi_scans_batch_and_24GHz', 'test_wifi_scans_batch_and_5GHz', 'test_wifi_scans_24GHz_5GHz_full_result',) def setup_class(self): # If running in a setup with attenuators, set attenuation on all # channels to zero. if getattr(self, "attenuators", []): for a in self.attenuators: a.set_atten(0) self.leeway = 5 # seconds, for event wait time computation self.stime_channel = 47 #dwell time plus 2ms self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) asserts.assert_true(self.dut.droid.wifiIsScannerSupported(), "Device %s doesn't support WifiScanner, abort." % self.dut.model) """ Setup the required dependencies and fetch the user params from config file. """ req_params = ["max_bugreports"] 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() self.wifi_chs = WifiChannelUS(self.dut.model) 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 start_scan(self, scan_setting): data = wutils.start_wifi_background_scan(self.dut, scan_setting) idx = data["Index"] # Calculate 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) scan_period = scan_setting['periodInMs'] report_type = scan_setting['reportEvents'] if report_type & WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN: scan_time += scan_period else: max_scan = scan_setting['maxScansToCache'] scan_time += max_scan * scan_period wait_time = scan_time / 1000 + self.leeway return idx, wait_time, scan_channels def validate_scan_results(self, scan_results_dict): # Sanity check to make sure the dict is not empty asserts.assert_true(scan_results_dict, "Scan result dict is empty.") for scan_result_obj in scan_results_dict.values(): # Validate the results received for each scan setting scan_result_obj.check_scan_results() def wait_for_scan_events(self, wait_time_list, scan_results_dict): """Poll for WifiScanner events and record them""" # Compute the event wait time event_wait_time = min(wait_time_list) # Compute the maximum test time that guarantee that even the scan # which requires the most wait time will receive at least two # results. max_wait_time = max(wait_time_list) max_end_time = time.monotonic() + max_wait_time self.log.debug("Event wait time %s seconds", event_wait_time) try: # Wait for scan results on all the caller specified bands event_name = SCAN_EVENT_TAG while True: self.log.debug("Waiting for events '%s' for up to %s seconds", event_name, event_wait_time) events = self.dut.ed.pop_events(event_name, event_wait_time) for event in events: self.log.debug("Event received: %s", event) # Event name is the key to the scan results dictionary actual_event_name = event["name"] asserts.assert_true( actual_event_name in scan_results_dict, "Expected one of these event names: %s, got '%s'." % (scan_results_dict.keys(), actual_event_name)) # TODO validate full result callbacks also if event["name"].endswith("onResults"): # Append the event scan_results_dict[actual_event_name].add_results_event( event) # If we time out then stop waiting for events. if time.monotonic() >= max_end_time: break # If enough scan results have been returned to validate the # results then break early. have_enough_events = True for key in scan_results_dict: if not scan_results_dict[key].have_enough_events(): have_enough_events = False if have_enough_events: break except queue.Empty: asserts.fail("Event did not trigger for {} in {} seconds".format( event_name, event_wait_time)) def scan_and_validate_results(self, scan_settings): """Perform WifiScanner scans and check the scan results Procedures: * Start scans for each caller specified setting * Wait for at least two results for each scan * Check the results received for each scan """ # Awlays get a clean start self.dut.ed.clear_all_events() # Start scanning with the caller specified settings and # compute parameters for receiving events idx_list = [] wait_time_list = [] scan_results_dict = {} try: for scan_setting in scan_settings: self.log.debug( "Scan setting: band %s, interval %s, reportEvents " "%s, numBssidsPerScan %s", scan_setting["band"], scan_setting["periodInMs"], scan_setting["reportEvents"], scan_setting["numBssidsPerScan"]) idx, wait_time, scan_chan = self.start_scan(scan_setting) self.log.debug( "Scan started for band %s: idx %s, wait_time %ss, scan_channels %s", scan_setting["band"], idx, wait_time, scan_chan) idx_list.append(idx) wait_time_list.append(wait_time) report_type = scan_setting['reportEvents'] scan_results_events = WifiScanResultEvents(scan_setting, scan_chan) scan_results_dict["{}{}onResults".format( SCAN_EVENT_TAG, idx)] = scan_results_events if (scan_setting['reportEvents'] & WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT): scan_results_dict["{}{}onFullResult".format( SCAN_EVENT_TAG, idx)] = scan_results_events self.wait_for_scan_events(wait_time_list, scan_results_dict) # Validate the scan results self.validate_scan_results(scan_results_dict) finally: # Tear down and clean up for idx in idx_list: self.dut.droid.wifiScannerStopBackgroundScan(idx) self.dut.ed.clear_all_events() """ Helper Functions End """ """ Tests Begin """ @test_tracker_info(uuid="d490b146-5fc3-4fc3-9958-78ba0ad63211") @WifiBaseTest.wifi_test_wrap def test_wifi_two_scans_at_same_interval(self): """Perform two WifiScanner background scans, one at 2.4GHz and the other at 5GHz, the same interval and number of BSSIDs per scan. Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of BSSIDs doesn't exceed """ scan_settings = [{"band": WifiEnums.WIFI_BAND_24_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}, {"band": WifiEnums.WIFI_BAND_5_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="0ec9a554-f942-41a9-8096-6b0b400f60b0") @WifiBaseTest.wifi_test_wrap def test_wifi_two_scans_at_different_interval(self): """Perform two WifiScanner background scans, one at 2.4GHz and the other at 5GHz, different interval and number of BSSIDs per scan. Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of BSSIDs doesn't exceed """ scan_settings = [{"band": WifiEnums.WIFI_BAND_24_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 20}, {"band": WifiEnums.WIFI_BAND_5_GHZ, "periodInMs": 30000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="0d616591-0d32-4be6-8fd4-e4a5e9ccdce0") @WifiBaseTest.wifi_test_wrap def test_wifi_scans_24GHz_and_both(self): """Perform two WifiScanner background scans, one at 2.4GHz and the other at both 2.4GHz and 5GHz Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of BSSIDs doesn't exceed """ scan_settings = [{"band": WifiEnums.WIFI_BAND_BOTH, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}, {"band": WifiEnums.WIFI_BAND_24_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="ddcf959e-512a-4e86-b3d3-18cebd0b22a0") @WifiBaseTest.wifi_test_wrap def test_wifi_scans_5GHz_and_both(self): """Perform two WifiScanner scans, one at 5GHz and the other at both 2.4GHz and 5GHz Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of BSSIDs doesn't exceed """ scan_settings = [{"band": WifiEnums.WIFI_BAND_BOTH, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}, {"band": WifiEnums.WIFI_BAND_5_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="060469f1-fc6b-4255-ab6e-b1d5b54db53d") @WifiBaseTest.wifi_test_wrap def test_wifi_scans_24GHz_5GHz_and_DFS(self): """Perform three WifiScanner scans, one at 5GHz, one at 2.4GHz and the other at just 5GHz DFS channels Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of BSSIDs doesn't exceed """ scan_settings = [ {"band": WifiEnums.WIFI_BAND_5_GHZ_DFS_ONLY, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}, {"band": WifiEnums.WIFI_BAND_5_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}, {"band": WifiEnums.WIFI_BAND_24_GHZ, "periodInMs": 30000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24} ] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="14104e98-27a0-43d5-9525-b36b65ac3957") @WifiBaseTest.wifi_test_wrap def test_wifi_scans_batch_and_24GHz(self): """Perform two WifiScanner background scans, one in batch mode for both bands and the other in periodic mode at 2.4GHz Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of results in batch mode should match the setting * Number of BSSIDs doesn't exceed """ scan_settings = [{"band": WifiEnums.WIFI_BAND_BOTH, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL, "numBssidsPerScan": 24, "maxScansToCache": 2}, {"band": WifiEnums.WIFI_BAND_24_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="cd6064b5-840b-4334-8cd4-8320a6cda52f") @WifiBaseTest.wifi_test_wrap def test_wifi_scans_batch_and_5GHz(self): """Perform two WifiScanner background scans, one in batch mode for both bands and the other in periodic mode at 5GHz Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of results in batch mode should match the setting * Number of BSSIDs doesn't exceed """ scan_settings = [{"band": WifiEnums.WIFI_BAND_BOTH, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL, "numBssidsPerScan": 24, "maxScansToCache": 2}, {"band": WifiEnums.WIFI_BAND_5_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}] self.scan_and_validate_results(scan_settings) @test_tracker_info(uuid="9f48cb0c-de87-4cd2-9e50-857579d44079") @WifiBaseTest.wifi_test_wrap def test_wifi_scans_24GHz_5GHz_full_result(self): """Perform two WifiScanner background scans, one at 2.4GHz and the other at 5GHz. Report full scan results. Initial Conditions: * Set multiple APs broadcasting 2.4GHz and 5GHz. Expected Results: * DUT reports success for starting both scans * Scan results for each callback contains only the results on the frequency scanned * Wait for at least two scan results and confirm that separation between them approximately equals to the expected interval * Number of BSSIDs doesn't exceed """ scan_settings = [ {"band": WifiEnums.WIFI_BAND_24_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT | WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24}, {"band": WifiEnums.WIFI_BAND_5_GHZ, "periodInMs": 10000, # ms "reportEvents": WifiEnums.REPORT_EVENT_FULL_SCAN_RESULT | WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN, "numBssidsPerScan": 24} ] self.scan_and_validate_results(scan_settings) """ Tests End """