def test_stress_pno_connection_to_2g(self):
"""Test PNO triggered autoconnect to a network for N times
Steps:
1. Save 2Ghz valid network configuration in the device.
2. Screen off DUT
3. Attenuate 5Ghz network and wait for a few seconds to trigger PNO.
4. Check the device connected to 2Ghz network automatically.
5. Repeat step 3-4
"""
for attenuator in self.attenuators:
attenuator.set_atten(95)
# add a saved network to DUT
networks = [self.reference_networks[0]['2g']]
self.add_networks(self.dut, networks)
self.dut.droid.wakeLockRelease()
self.dut.droid.goToSleepNow()
for count in range(self.stress_count):
self.connect_and_verify_connected_ssid(
self.reference_networks[0]['2g'], is_pno=True)
wutils.wifi_forget_network(self.dut,
networks[0][WifiEnums.SSID_KEY])
# move the DUT out of range
self.attenuators[0].set_atten(95)
time.sleep(10)
self.add_networks(self.dut, networks)
wutils.set_attns(self.attenuators, "default")
raise signals.TestPass(details="",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % (count + 1)
})
def test_stress_connect_traffic_disconnect_5g(self):
"""Test to connect and disconnect from a network for N times.
Steps:
1. Scan and connect to a network.
2. Run IPerf to upload data for few seconds.
3. Disconnect.
4. Repeat 1-3.
"""
for count in range(self.stress_count):
net_id = self.dut.droid.wifiAddNetwork(self.wpa_5g)
asserts.assert_true(net_id != -1,
"Add network %r failed" % self.wpa_5g)
self.dut.droid.wifiEnableNetwork(net_id, 0)
self.scan_and_connect_by_id(self.wpa_5g, net_id)
# Start IPerf traffic from phone to server.
# Upload data for 10s.
args = "-p {} -t {}".format(self.iperf_server.port, 10)
self.log.info("Running iperf client {}".format(args))
result, data = self.dut.run_iperf_client(self.iperf_server_address,
args)
if not result:
self.log.debug("Error occurred in iPerf traffic.")
raise signals.TestFailure(
"Error occurred in iPerf traffic. Current"
" WiFi state = %d" % self.dut.droid.wifiCheckState())
wutils.wifi_forget_network(self.dut,
self.wpa_5g[WifiEnums.SSID_KEY])
time.sleep(WAIT_BEFORE_CONNECTION)
def test_network_selector_reselect_after_forget_network(self):
"""
1. Add two 5G BSSIDs X and Y to the DUT. X has higher RSSI
than Y.
2. Connect the DUT to X.
3. Forget X.
5. Verify the DUT reselect and connect to Y.
"""
#add two saved networks to DUT
networks = [
self.reference_networks[AP_1]['5g'], self.reference_networks[AP_2][
'5g']
]
self.add_networks(self.dut, networks)
#make both AP_1 5G and AP_2 5G in range. AP_1 5G has stronger
#RSSI than AP_2 5G
self.attenuators[AP_1_5G_ATTENUATOR].set_atten(0)
self.attenuators[AP_2_5G_ATTENUATOR].set_atten(10)
#verify
self.connect_and_verify_connected_bssid(self.reference_networks[AP_1][
'5g']['bssid'])
#forget AP_1
wutils.wifi_forget_network(self.dut,
self.reference_networks[AP_1]['5g']['SSID'])
#verify
self.connect_and_verify_connected_bssid(self.reference_networks[AP_2][
'5g']['bssid'])
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")
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(30) #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"])
def test_forget_network(self):
self.test_add_network()
ssid = self.open_network[WifiEnums.SSID_KEY]
wutils.wifi_forget_network(self.dut, ssid)
configured_networks = self.dut.droid.wifiGetConfiguredNetworks()
for nw in configured_networks:
asserts.assert_true(
nw[WifiEnums.BSSID_KEY] != ssid,
"Found forgotten network %s in configured networks." % ssid)
def test_stress_wifi_failover(self):
"""This test does aggressive failover to several networks in list.
Steps:
1. Add and enable few networks.
2. Let device auto-connect.
3. Remove the connected network.
4. Repeat 2-3.
5. Device should connect to a network until all networks are
exhausted.
"""
for count in range(int(self.stress_count / 4)):
wutils.reset_wifi(self.dut)
ssids = list()
for network in self.networks:
ssids.append(network[WifiEnums.SSID_KEY])
ret = self.dut.droid.wifiAddNetwork(network)
asserts.assert_true(ret != -1,
"Add network %r failed" % network)
self.dut.droid.wifiEnableNetwork(ret, 0)
self.dut.droid.wifiStartScan()
time.sleep(WAIT_FOR_AUTO_CONNECT)
cur_network = self.dut.droid.wifiGetConnectionInfo()
cur_ssid = cur_network[WifiEnums.SSID_KEY]
self.log.info("Cur_ssid = %s" % cur_ssid)
for i in range(0, len(self.networks)):
self.log.debug("Forget network %s" % cur_ssid)
wutils.wifi_forget_network(self.dut, cur_ssid)
time.sleep(WAIT_FOR_AUTO_CONNECT)
cur_network = self.dut.droid.wifiGetConnectionInfo()
cur_ssid = cur_network[WifiEnums.SSID_KEY]
self.log.info("Cur_ssid = %s" % cur_ssid)
if i == len(self.networks) - 1:
break
if cur_ssid not in ssids:
raise signals.TestFailure("Device did not failover to the "
"expected network. SSID = %s" %
cur_ssid)
network_config = self.dut.droid.wifiGetConfiguredNetworks()
self.log.info("Network Config = %s" % network_config)
if len(network_config):
raise signals.TestFailure(
"All the network configurations were not "
"removed. Configured networks = %s" % network_config,
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % (count * 4)
})
raise signals.TestPass(details="",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % ((count + 1) * 4)
})
def delete_entries_for_ssid(self, ssid):
"""Delete all saved entries for an SSID.
@param ssid string of SSID for which to delete entries.
@return True on success, False otherwise.
"""
try:
wutils.wifi_forget_network(self.ad, ssid)
except Exception as e:
logging.error(e)
return False
return True
def _connect_disconnect_devices(self):
""" Randomly connect and disconnect devices from the
self.tethered_devices list to hotspot device
"""
device_connected = [False] * len(self.tethered_devices)
for _ in range(50):
dut_id = random.randint(0, len(self.tethered_devices) - 1)
dut = self.tethered_devices[dut_id]
# wait for 1 sec between connect & disconnect stress test
time.sleep(1)
if device_connected[dut_id]:
wutils.wifi_forget_network(dut, self.network["SSID"])
else:
wutils.wifi_connect(dut, self.network)
device_connected[dut_id] = not device_connected[dut_id]
def _connect_disconnect_android_device(self, dut_id, wifi_state):
""" Connect or disconnect wifi on android device depending on the
current wifi state
Args:
1. dut_id: tethered device to change the wifi state
2. wifi_state: current wifi state
"""
ad = self.tethered_devices[dut_id]
if wifi_state:
self.log.info("Disconnecting wifi on android device")
wutils.wifi_forget_network(ad, self.network["SSID"])
else:
self.log.info("Connecting to wifi on android device")
wutils.wifi_connect(ad, self.network)
def test_forget_network(self):
ssid = self.open_network[WifiEnums.SSID_KEY]
nId = self.dut.droid.wifiAddNetwork(self.open_network)
asserts.assert_true(nId > -1, "Failed to add network.")
configured_networks = self.dut.droid.wifiGetConfiguredNetworks()
self.log.debug(
("Configured networks after adding: %s" % configured_networks))
wutils.assert_network_in_list({WifiEnums.SSID_KEY: ssid},
configured_networks)
wutils.wifi_forget_network(self.dut, ssid)
configured_networks = self.dut.droid.wifiGetConfiguredNetworks()
for nw in configured_networks:
asserts.assert_true(
nw[WifiEnums.BSSID_KEY] != ssid,
"Found forgotten network %s in configured networks." % ssid)
def test_screenoff_wifi_wedge(self):
# Set attenuator to connect phone to both networks
self.log.info('Set attenuation to connect device to both APs')
self.set_attenuation(self.atten_level['zero_atten'])
# Connect to both APs
network_main = self.main_network[hc.BAND_2G]
network_aux = self.aux_network[hc.BAND_2G]
self.brconfigs_main = self.setup_ap_connection(network_main)
self.brconfigs_aux = self.setup_ap_connection(network_aux)
self.log.info('Forget network {}'.format(network_aux[wc.SSID]))
wutils.wifi_forget_network(self.dut, network_aux[wc.SSID])
self.log.info('Set attenuation to trigger wedge condition')
self.set_attenuation(self.atten_level[self.current_test_name])
self.dut.droid.goToSleepNow()
self.measure_power_and_validate()
def test_connection_to_new_networks(self):
"""Check if we can connect to new networks after Auto-update.
Steps:
1. Connect to a PSK network.
2. Connect to an open network.
3. Forget ntworks added in 1 & 2.
TODO: (@bmahadev) Add WEP network once it's ready.
"""
wutils.connect_to_wifi_network(self.dut, self.open_network[0]['5g'])
wutils.connect_to_wifi_network(self.dut,
self.reference_networks[0]['2g'])
wutils.wifi_forget_network(
self.dut, self.reference_networks[0]['2g'][WifiEnums.SSID_KEY])
wutils.wifi_forget_network(
self.dut, self.open_network[0]['5g'][WifiEnums.SSID_KEY])
def test_stress_connect_traffic_disconnect_5g(self):
"""Test to connect and disconnect from a network for N times.
Steps:
1. Scan and connect to a network.
2. Run IPerf to upload data for few seconds.
3. Disconnect.
4. Repeat 1-3.
"""
for count in range(self.stress_count):
try:
net_id = self.dut.droid.wifiAddNetwork(self.wpa_5g)
asserts.assert_true(net_id != -1,
"Add network %r failed" % self.wpa_5g)
self.scan_and_connect_by_id(self.wpa_5g, net_id)
# Start IPerf traffic from phone to server.
# Upload data for 10s.
args = "-p {} -t {}".format(self.iperf_server_port, 10)
self.log.info("Running iperf client {}".format(args))
result, data = self.dut.run_iperf_client(
self.iperf_server_address, args)
if not result:
self.log.debug("Error occurred in iPerf traffic.")
self.run_ping(10)
wutils.wifi_forget_network(self.dut,
self.wpa_5g[WifiEnums.SSID_KEY])
time.sleep(WAIT_BEFORE_CONNECTION)
except:
raise signals.TestFailure(
"Network connect-disconnect failed."
"Look at logs",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % count
})
raise signals.TestPass(details="",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % (count + 1)
})
def check_mac_persistence(self, network, condition):
"""Check if the MAC is persistent after carrying out specific operations
like forget WiFi, toggle WiFi, reboot device and AP.
Args:
network: dict, The network information.
condition: int, value to trigger certain operation on the device.
Raises:
TestFaikure is the MAC is not persistent.
"""
rand_mac1 = self.connect_to_network_and_verify_mac_randomization(
network)
if condition == FORGET:
wutils.wifi_forget_network(self.dut, network['SSID'])
elif condition == TOGGLE:
wutils.wifi_toggle_state(self.dut, False)
wutils.wifi_toggle_state(self.dut, True)
elif condition == REBOOT_DUT:
self.dut.reboot()
time.sleep(DEFAULT_TIMEOUT)
elif condition == REBOOT_AP:
wutils.turn_ap_off(self, 1)
time.sleep(DEFAULT_TIMEOUT)
wutils.turn_ap_on(self, 1)
time.sleep(DEFAULT_TIMEOUT)
rand_mac2 = self.connect_to_network_and_verify_mac_randomization(
network)
if rand_mac1 != rand_mac2:
raise signals.TestFailure('Randomized MAC is not persistent after '
'forgetting networ. Old MAC = %s New MAC'
' = %s' % (rand_mac1, rand_mac2))
def run_connect_disconnect(self, network, hostname, rpm_port, rpm_ip,
release_ap):
"""Run connect/disconnect to a given network in loop.
Args:
network: Dict, network information.
hostname: Hostanme of the AP to connect to.
rpm_port: Port number on the RPM for the AP.
rpm_ip: Port number on the RPM for the AP.
release_ap: Flag to determine if we should turn off the AP yet.
Raises: TestFailure if the network connection fails.
"""
for attempt in range(5):
try:
begin_time = time.time()
ssid = network[WifiEnums.SSID_KEY]
net_id = self.dut.droid.wifiAddNetwork(network)
asserts.assert_true(net_id != -1,
"Add network %s failed" % network)
self.log.info("Connecting to %s" % ssid)
self.scan_and_connect_by_id(network, net_id)
self.run_ping(10)
# TODO(b/133369482): uncomment once bug is resolved
# self.send_link_probes(network)
wutils.wifi_forget_network(self.dut, ssid)
time.sleep(WAIT_BEFORE_CONNECTION)
except Exception as e:
self.log.error("Connection to %s network failed on the %d "
"attempt with exception %s." %
(ssid, attempt, e))
# TODO:(bmahadev) Uncomment after scan issue is fixed.
# self.dut.take_bug_report(ssid, begin_time)
# self.dut.cat_adb_log(ssid, begin_time)
if release_ap:
self.unlock_and_turn_off_ap(hostname, rpm_port, rpm_ip)
raise signals.TestFailure("Failed to connect to %s" % ssid)
def setup_class(self):
"""It will setup the required dependencies from config file and configure
the required networks for auto-join testing. Configured networks will
not be removed. If networks are already configured it will skip
configuring the networks
Returns:
True if successfully configured the requirements for testing.
"""
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
req_params = ("reference_networks", "other_network", "atten_val",
"ping_addr", "max_bugreports")
self.unpack_userparams(req_params)
self.log.debug("Connect networks :: {}".format(self.other_network))
configured_networks = self.dut.droid.wifiGetConfiguredNetworks()
self.log.debug("Configured networks :: {}".format(configured_networks))
count_confnet = 0
result = False
if self.reference_networks[0]['2g']['ssid'] == self.reference_networks[
0]['5g']['ssid']:
self.ref_ssid_count = 1
else:
self.ref_ssid_count = 2 # Different SSID for 2g and 5g
for confnet in configured_networks:
if confnet[WifiEnums.
SSID_KEY] == self.reference_networks[0]['2g']['ssid']:
count_confnet += 1
elif confnet[WifiEnums.
SSID_KEY] == self.reference_networks[0]['5g']['ssid']:
count_confnet += 1
self.log.info("count_confnet {}".format(count_confnet))
if count_confnet == self.ref_ssid_count:
return
else:
self.log.info("Configured networks for testing")
self.attenuators[0].set_atten(0)
self.attenuators[1].set_atten(90)
self.attenuators[2].set_atten(90)
wait_time = 15
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, 1)
self.log.info(connect_result)
time.sleep(wait_time)
if self.ref_ssid_count == 2: #add 5g network as well
self.dut.droid.wifiConnectByConfig(
self.reference_networks[0]['5g'])
connect_result = self.dut.ed.pop_event(
wifi_constants.CONNECT_BY_CONFIG_SUCCESS, 1)
self.log.info(connect_result)
time.sleep(wait_time)
self.dut.droid.wifiConnectByConfig(self.other_network)
connect_result = self.dut.ed.pop_event(
wifi_constants.CONNECT_BY_CONFIG_SUCCESS)
self.log.info(connect_result)
wutils.track_connection(self.dut, self.other_network["ssid"],
1)
wutils.wifi_forget_network(self.dut,
self.other_network["ssid"])
time.sleep(wait_time)
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)
finally:
self.dut.droid.wifiLockRelease()
self.dut.droid.goToSleepNow()
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()
