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 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 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"]:
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 do_location_scan(self, num_times=1):
scan_settings = {
"band": wutils.WifiEnums.WIFI_BAND_BOTH,
"periodInMs": 0,
"reportEvents": wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN
}
wifi_chs = wutils.WifiChannelUS(self.dut.model)
stime_channel = 47 # dwell time plus 2ms
leeway = 10
for i in range(num_times):
self.log.info("Scan count: {}".format(i))
data = wutils.start_wifi_single_scan(self.dut, scan_settings)
idx = data["Index"]
scan_rt = data["ScanElapsedRealtime"]
self.log.debug(
"Wifi single shot scan started index: %s at real time: %s",
idx, scan_rt)
# generating event wait time from scan setting plus leeway
scan_time, scan_channels = wutils.get_scan_time_and_channels(
wifi_chs, scan_settings, stime_channel)
wait_time = int(scan_time / 1000) + leeway
# track number of result received
result_received = 0
try:
for _ in range(1, 3):
event_name = "{}{}onResults".format("WifiScannerScan", 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)
result_received += 1
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.
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)))
except queue.Empty as error:
raise AssertionError(
"Event did not triggered for single shot {}".format(error))
finally:
self.dut.droid.wifiScannerStopScan(idx)
def test_wifi_connection_while_single_scan(self):
"""Test configuring a connection parallel to wifi scanner single scan.
1. Start WifiScanner single scan for both band with default scan settings.
2. Configure a connection to reference network.
3. Verify that connection to reference network occurred.
2. Verify that scanner report single scan results.
"""
self.attenuators[ATTENUATOR].set_atten(0)
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))
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")
#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
validity = False
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"]
bssids, validity = self.proces_and_valid_batch_scan_result(
results, scan_rt, event["data"][KEY_RET],
self.default_scan_setting)
self.log.info("Scan number Buckets: {}\nTotal BSSID: {}".format(
len(results), bssids))
asserts.assert_true(
len(results) == 1 and bssids >= 1, EMPTY_RESULT)
except queue.Empty as error:
raise AssertionError(
"Event did not triggered for single scan {}".format(error))
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)
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()
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()