def teardown_class(self):
""" Reset settings to default """
for ad in self.android_devices:
sub_id = str(ad.droid.telephonyGetSubscriberId())
ad.droid.connectivityFactoryResetNetworkPolicies(sub_id)
ad.droid.connectivitySetDataWarningLimit(sub_id, -1)
wutils.reset_wifi(ad)
def teardown_class(self):
wutils.stop_wifi_tethering(self.dut)
wutils.reset_wifi(self.dut)
wutils.reset_wifi(self.dut_client)
if "AccessPoint" in self.user_params:
del self.user_params["reference_networks"]
del self.user_params["open_network"]
def setup_class(self):
self.hotspot_device = self.android_devices[0]
self.tethered_devices = self.android_devices[1:]
req_params = ("ssid", "password", "url")
self.unpack_userparams(req_params)
self.network = {"SSID": self.ssid, "password": self.password}
self.offset = 1 * 60
self.hz = 5000
self.duration = 9 * 60 + self.offset
self.mon_data_path = os.path.join(self.log_path, "Monsoon")
self.mon = self.monsoons[0]
self.mon.set_voltage(4.2)
self.mon.set_max_current(7.8)
self.mon.attach_device(self.hotspot_device)
asserts.assert_true(self.mon.usb("auto"),
"Failed to turn USB mode to auto on monsoon.")
set_location_service(self.hotspot_device, False)
set_adaptive_brightness(self.hotspot_device, False)
set_ambient_display(self.hotspot_device, False)
self.hotspot_device.adb.shell(
"settings put system screen_brightness 0")
set_auto_rotate(self.hotspot_device, False)
wutils.wifi_toggle_state(self.hotspot_device, False)
self.hotspot_device.droid.telephonyToggleDataConnection(True)
tel_utils.wait_for_cell_data_connection(self.log, self.hotspot_device,
True)
asserts.assert_true(
tel_utils.verify_http_connection(self.log, self.hotspot_device),
"HTTP verification failed on cell data connection")
for ad in self.tethered_devices:
wutils.reset_wifi(ad)
def setup_test(self):
self.dut.droid.wifiStartTrackingStateChange()
self.dut.droid.wakeLockAcquireBright()
self.dut.droid.wakeUpNow()
wutils.reset_wifi(self.dut)
self.dut.ed.clear_all_events()
return True
def setup_dut(self, testcase_params):
"""Sets up the DUT in the configuration required by the test.
Args:
testcase_params: dict containing AP and other test params
"""
# Check battery level before test
if not wputils.health_check(self.dut, 10):
asserts.skip('Battery level too low. Skipping test.')
# Turn screen off to preserve battery
self.dut.go_to_sleep()
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
if wputils.validate_network(self.dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
else:
wutils.wifi_toggle_state(self.dut, True)
wutils.reset_wifi(self.dut)
wutils.set_wifi_country_code(self.dut,
self.testclass_params['country_code'])
self.main_network[band]['channel'] = testcase_params['channel']
wutils.wifi_connect(self.dut,
testcase_params['test_network'],
num_of_tries=5,
check_connectivity=False)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def teardown_class(self):
if hasattr(self, "AccessPoint"):
self.ap.close()
reset_wifi(self.pri_ad)
wifi_toggle_state(self.pri_ad, False)
json_result = self.results.json_str()
xlsheet(self.pri_ad, json_result)
def teardown_test(self):
self.dut.droid.wakeLockRelease()
self.dut.droid.goToSleepNow()
self.dut.droid.wifiReleaseNetworkAll()
self.dut.droid.wifiDisconnect()
wutils.reset_wifi(self.dut)
self.dut.ed.clear_all_events()
def setup_dut(self, testcase_params):
"""Sets up the DUT in the configuration required by the test.
Args:
testcase_params: dict containing AP and other test params
"""
# Configure the right INI settings
if testcase_params['chain_mask'] != self.current_chain_mask:
self.log.info('Updating WiFi chain mask to: {}'.format(
testcase_params['chain_mask']))
self.current_chain_mask = testcase_params['chain_mask']
if testcase_params['chain_mask'] in ['0', '1']:
wputils.set_ini_single_chain_mode(
self.dut, int(testcase_params['chain_mask']))
else:
wputils.set_ini_two_chain_mode(self.dut)
# Check battery level before test
if not wputils.health_check(self.dut, 10):
asserts.skip('Battery level too low. Skipping test.')
# Turn screen off to preserve battery
self.dut.go_to_sleep()
if wputils.validate_network(self.dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
else:
wutils.reset_wifi(self.dut)
wutils.set_wifi_country_code(self.dut,
self.testclass_params['country_code'])
testcase_params['test_network']['channel'] = testcase_params[
'channel']
wutils.wifi_connect(self.dut,
testcase_params['test_network'],
num_of_tries=5,
check_connectivity=False)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def setup_test(self):
self.dut.droid.wifiStartTrackingStateChange()
self.dut.droid.wakeLockAcquireBright()
self.dut.droid.wakeUpNow()
wutils.reset_wifi(self.dut)
self.dut.ed.clear_all_events()
self.tcpdump_pid = start_tcpdump(self.dut, self.test_name)
def interop_base_test(self, ssid, hostname):
"""Base test for all the connect-disconnect interop tests.
Args:
ssid: string, SSID of the network to connect to.
hostname: string, hostname of the AP.
Steps:
1. Lock AP in datstore.
2. Turn on AP on the rpm switch.
3. Run connect-disconnect in loop.
4. Turn off AP on the rpm switch.
5. Unlock AP in datastore.
"""
network = {}
network['password'] = '******'
network['SSID'] = ssid
release_ap = False
wutils.reset_wifi(self.dut)
# Lock AP in datastore.
self.log.info("Lock AP in datastore")
ap_info = dutils.show_device(hostname)
# If AP is locked by a different test admin, then we skip.
if ap_info['lock_status'] and ap_info['locked_by'] != self.admin:
raise signals.TestSkip("AP %s is locked, skipping test" % hostname)
if not dutils.lock_device(hostname, self.admin):
self.log.warning("Failed to lock %s AP. Unlock AP in datastore"
" and try again.")
raise signals.TestFailure("Failed to lock AP")
band = SINGLE_BAND
if ('ssid_2g' in ap_info) and ('ssid_5g' in ap_info):
band = DUAL_BAND
if (band == SINGLE_BAND) or (band == DUAL_BAND and '5G' in ssid):
release_ap = True
# Get AP RPM attributes and Turn ON AP.
rpm_ip = ap_info['rpm_ip']
rpm_port = ap_info['rpm_port']
rutils.turn_on_ap(self.pcap, ssid, rpm_port, rpm_ip=rpm_ip)
self.log.info("Finished turning ON AP.")
# Experimental. Some APs take upto a min to come online.
time.sleep(60)
self.get_band_and_chan(ssid)
self.pcap.configure_monitor_mode(self.band, self.chan)
self.pcap_procs = wutils.start_pcap(self.pcap, self.band.lower(),
self.test_name)
self.run_connect_disconnect(network, hostname, rpm_port, rpm_ip,
release_ap)
# Un-lock only if it's a single band AP or we are running the last band.
if release_ap:
self.unlock_and_turn_off_ap(hostname, rpm_port, rpm_ip)
def setup_dut(self, testcase_params):
"""Sets up the DUT in the configuration required by the test.
Args:
testcase_params: dict containing AP and other test params
"""
# Check battery level before test
if not wputils.health_check(
self.dut, 20) and testcase_params['traffic_direction'] == 'UL':
asserts.skip('Overheating or Battery level low. Skipping test.')
# Turn screen off to preserve battery
self.dut.go_to_sleep()
if wputils.validate_network(self.dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
else:
wutils.reset_wifi(self.dut)
wutils.set_wifi_country_code(self.dut,
self.testclass_params['country_code'])
testcase_params['test_network']['channel'] = testcase_params[
'channel']
wutils.wifi_connect(self.dut,
testcase_params['test_network'],
num_of_tries=5,
check_connectivity=True)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def teardown_class(self):
wutils.reset_wifi(self.dut)
if hasattr(self, 'iperf_server'):
self.iperf_server.stop()
if "AccessPoint" in self.user_params:
del self.user_params["reference_networks"]
del self.user_params["open_network"]
def rvr_test(self, network):
"""Test function to run RvR.
The function runs an RvR test in the current device/AP configuration.
Function is called from another wrapper function that sets up the
testbed for the RvR test
Args:
params: Dictionary with network info
"""
wait_time = 5
utils.subprocess.check_output('adb root', shell=True, timeout=20)
self.ssid = network[WifiEnums.SSID_KEY]
self.log.info("Start rvr test")
for i in range(len(self.angle)):
self.setDG(self.T1, self.angle[i])
time.sleep(wait_time)
self.checkDG(self.T1, self.angle[i])
self.set_Three_Att_dB(self.ATT1, self.ATT2, self.ATT3, 0)
time.sleep(wait_time)
self.connect_to_wifi_network(network)
self.set_Three_Att_dB(self.ATT1, self.ATT2, self.ATT3, self.MindB)
for j in range(self.MindB, self.MaxdB + self.stepdB, self.stepdB):
self.DB = j
self.ag = i
self.set_Three_Att_dB(self.ATT1, self.ATT2, self.ATT3, self.DB)
self.iperf_test_func(network)
wutils.reset_wifi(self.dut)
def teardown_class(self):
wutils.reset_wifi(self.dut)
for a in self.attenuators:
a.set_atten(0)
if "AccessPoint" in self.user_params:
del self.user_params["reference_networks"]
del self.user_params["open_network"]
def test_private_dns_mode_strict_connectivity_toggle_networks(self):
""" Verify private DNS strict mode connectivity by toggling networks
Steps:
1. Set private DNS strict mode
2. DUT is connected to mobile network
3. Verify connectivity and DNS queries going to port 853
4. Switch to wifi network
5. Verify connectivity and DNS queries going to port 853
6. Switch back to mobile network
7. Verify connectivity and DNS queries going to port 853
8. Repeat steps 1-7 for TMO, VZW and different private DNS servers
"""
for ad in self.android_devices:
self.log.info("Carrier is: %s" % get_operator_name(self.log, ad))
for dns in self.private_dns_servers:
self.log.info("Setting strict mode private dns: %s" % dns)
# set private dns mode
cutils.set_private_dns(ad, cconst.PRIVATE_DNS_MODE_STRICT, dns)
# verify dns over tls on mobile network
self._test_private_dns_mode(
self.dut, None, None, True, dns)
# verify dns over tls on wifi network
self._test_private_dns_mode(
self.dut, self.ipv4_ipv6_network, None, True, dns)
# verify dns over tls on mobile network
wutils.reset_wifi(self.dut)
self._test_private_dns_mode(
self.dut, None, None, True, dns)
def _test_private_dns_mode(self, network, dns_mode, use_tls,
hostname = None):
""" Test private DNS mode """
# connect to wifi
wutils.reset_wifi(self.dut)
if network:
wutils.wifi_connect(self.dut, network)
time.sleep(1) # wait till lte network becomes active - network = None
# start tcpdump on the device
self._start_tcp_dump(self.dut)
# set private dns mode
if dns_mode == PRIVATE_DNS_MODE_OFF:
self.dut.droid.setPrivateDnsMode(False)
elif hostname:
self.dut.droid.setPrivateDnsMode(True, hostname)
else:
self.dut.droid.setPrivateDnsMode(True)
mode = self.dut.droid.getPrivateDnsMode()
asserts.assert_true(mode == dns_mode,
"Failed to set private DNS mode to %s" % dns_mode)
# ping hosts should pass
for host in self.ping_hosts:
self.log.info("Pinging %s" % host)
asserts.assert_true(wutils.validate_connection(self.dut, host),
"Failed to ping host %s" % host)
# stop tcpdump
pcap_file = self._stop_tcp_dump(self.dut)
self.log.info("TCPDUMP file is: %s" % pcap_file)
# verify DNS queries
self._verify_dns_queries_over_tls(pcap_file, use_tls)
def setup_dut(self, testcase_params):
"""Sets up the DUT in the configuration required by the test.
Args:
testcase_params: dict containing AP and other test params
"""
# Check battery level before test
if not wputils.health_check(self.dut, 10):
asserts.skip('Battery level too low. Skipping test.')
wutils.reset_wifi(self.dut)
wutils.set_wifi_country_code(self.dut,
self.testclass_params['country_code'])
(primary_net_id,
primary_net_config) = next(net for net in self.main_network.items()
if net[1]['roaming_label'] == 'primary')
network = primary_net_config.copy()
network.pop('BSSID', None)
self.dut.droid.wifiSetEnableAutoJoinWhenAssociated(1)
wutils.wifi_connect(self.dut,
network,
num_of_tries=5,
check_connectivity=False)
self.dut.droid.wifiSetEnableAutoJoinWhenAssociated(1)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
if testcase_params['screen_on']:
self.dut.wakeup_screen()
self.dut.droid.wakeLockAcquireBright()
time.sleep(MED_SLEEP)
def teardown_test(self):
self.dut.droid.wakeLockRelease()
self.dut.droid.goToSleepNow()
wutils.reset_wifi(self.dut)
if self.current_test_name and self.iot_test_prefix in self.current_test_name:
if "iperf_server_address" in self.user_params:
self.iperf_server.stop()
def setup_test(self):
# Default measurement time is 30min with an offset of 5min. Each test
# can overwrite this by setting self.duration and self.offset.
self.offset = 5 * 60
self.duration = 20 * 60 + self.offset
self.start_pmc()
wutils.reset_wifi(self.dut)
self.dut.ed.clear_all_events()
def teardown_test(self):
for ad in self.android_devices:
ad.droid.wakeLockRelease()
ad.droid.goToSleepNow()
self.turn_location_off_and_scan_toggle_off()
wutils.reset_wifi(self.dut)
if self.dut_client:
wutils.reset_wifi(self.dut_client)
def teardown_test(self):
self.dut.droid.wakeLockRelease()
self.dut.droid.goToSleepNow()
self.dut.droid.wifiRemoveNetworkSuggestions([])
self.dut.droid.wifiDisconnect()
wutils.reset_wifi(self.dut)
wutils.wifi_toggle_state(self.dut, False)
self.dut.ed.clear_all_events()
def teardown_test(self):
self.dut.droid.wakeLockRelease()
self.dut.droid.goToSleepNow()
wutils.stop_wifi_tethering(self.dut)
wutils.reset_wifi(self.dut)
wutils.reset_wifi(self.dut_client)
self.access_points[0].close()
del self.user_params["reference_networks"]
del self.user_params["open_network"]
def teardown_test(self):
if self.dut.droid.wifiIsApEnabled():
wutils.stop_wifi_tethering(self.dut)
self.dut.droid.wakeLockRelease()
self.dut.droid.goToSleepNow()
wutils.reset_wifi(self.dut)
self.dut_client.droid.wakeLockRelease()
self.dut_client.droid.goToSleepNow()
wutils.reset_wifi(self.dut_client)
def test_firmware_crash_softap_reconnect_stress(self):
"""Firmware crash stress test for softap mode
1. Turn off dut's Wi-Fi
2. Turn on dut's hotspot and connected by dut client
3. Trigger firmware crash
4. Check ssr happened
5. Check the connectivity of hotspot's client
6. Repeat step 3~5
"""
wutils.wifi_toggle_state(self.dut, False)
# Setup Soft AP
sap_config = wutils.create_softap_config()
wutils.start_wifi_tethering(self.dut,
sap_config[wutils.WifiEnums.SSID_KEY],
sap_config[wutils.WifiEnums.PWD_KEY],
wutils.WifiEnums.WIFI_CONFIG_APBAND_2G)
config = {
"SSID": sap_config[wutils.WifiEnums.SSID_KEY],
"password": sap_config[wutils.WifiEnums.PWD_KEY]
}
# DUT client connects to softap
wutils.wifi_toggle_state(self.dut_client, True)
wutils.connect_to_wifi_network(self.dut_client,
config,
check_connectivity=False)
# Ping the DUT
dut_addr = self.dut.droid.connectivityGetIPv4Addresses(
self.ap_iface)[0]
asserts.assert_true(
utils.adb_shell_ping(self.dut_client,
count=10,
dest_ip=dut_addr,
timeout=20),
"%s ping %s failed" % (self.dut_client.serial, dut_addr))
for count in range(self.stress_count):
self.log.info(
"%s: %d/%d" %
(self.current_test_name, count + 1, self.stress_count))
wutils.reset_wifi(self.dut_client)
# Trigger firmware crash
self.trigger_wifi_firmware_crash(self.dut)
# Connect DUT to Network
wutils.connect_to_wifi_network(self.dut_client,
config,
check_connectivity=False)
# Ping the DUT
server_addr = self.dut.droid.connectivityGetIPv4Addresses(
self.ap_iface)[0]
asserts.assert_true(
utils.adb_shell_ping(self.dut_client,
count=10,
dest_ip=server_addr,
timeout=20),
"%s ping %s failed" % (self.dut_client.serial, server_addr))
wutils.stop_wifi_tethering(self.dut)
def sap_rvr_test_func(self):
"""Main function to test Soft AP RvR.
The function sets up the phones in the correct soft ap and client mode
configuration and calls run_rvr to sweep attenuation and measure
throughput
Args:
channel: Specifies AP's channel
mode: Specifies AP's bandwidth/mode (11g, VHT20, VHT40, VHT80)
Returns:
rvr_result: dict containing rvr_results and meta data
"""
#Initialize RvR test parameters
num_atten_steps = int((self.test_params["rvr_atten_stop"] -
self.test_params["rvr_atten_start"]) /
self.test_params["rvr_atten_step"])
self.rvr_atten_range = [
self.test_params["rvr_atten_start"] +
x * self.test_params["rvr_atten_step"]
for x in range(0, num_atten_steps)
]
rvr_result = {}
# Reset WiFi on all devices
for dev in self.android_devices:
wutils.reset_wifi(dev)
dev.droid.wifiSetCountryCode(wutils.WifiEnums.CountryCode.US)
# Setup Soft AP
sap_config = wutils.create_softap_config()
wutils.start_wifi_tethering(self.android_devices[0],
sap_config[wutils.WifiEnums.SSID_KEY],
sap_config[wutils.WifiEnums.PWD_KEY],
self.sap_band_enum)
self.main_network = {
"SSID": sap_config[wutils.WifiEnums.SSID_KEY],
"password": sap_config[wutils.WifiEnums.PWD_KEY]
}
# Set attenuator to 0 dB
[self.attenuators[i].set_atten(0) for i in range(self.num_atten)]
# Connect DUT to Network
wutils.wifi_connect(self.android_devices[1],
self.main_network,
num_of_tries=5,
assert_on_fail=False)
connection_info = self.get_sap_connection_info()
self.test_params["iperf_server_address"] = connection_info[
"ap_ip_address"]
# Run RvR and log result
rvr_result["test_name"] = self.current_test_name
rvr_result["attenuation"] = list(self.rvr_atten_range)
rvr_result["fixed_attenuation"] = self.test_params[
"fixed_attenuation"][str(connection_info["channel"])]
rvr_result["throughput_receive"] = self.rvr_test()
self.testclass_results.append(rvr_result)
wutils.stop_wifi_tethering(self.android_devices[0])
return rvr_result
def setup_test(self):
#reset and clear all saved networks on the DUT
wutils.reset_wifi(self.dut)
#move the APs out of range
for attenuator in self.attenuators:
attenuator.set_atten(ATTENUATOR_INITIAL_SETTING)
#turn on the screen
self.dut.droid.wakeLockAcquireBright()
self.dut.droid.wakeUpNow()
self.dut.ed.clear_all_events()
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 on_retry(self):
"""Function to control test logic on retried tests.
This function is automatically executed on tests that are being
retried. In this case the function resets wifi, toggles it off and on
and sets a retry_flag to enable further tweaking the test logic on
second attempts.
"""
self.retry_flag = True
for dev in self.android_devices:
wutils.reset_wifi(dev)
wutils.toggle_wifi_off_and_on(dev)
def test_power_connected_5g_continuous_traffic(self):
try:
wutils.reset_wifi(self.dut)
self.dut.ed.clear_all_events()
wutils.wifi_connect(self.dut, self.network_5g)
self.iperf_server.start()
self.dut.adb.shell(pmc_start_iperf_client)
self.log.info("Started iperf traffic.")
self.measure_and_process_result()
finally:
self.iperf_server.stop()
self.log.info("Stopped iperf traffic.")
def verify_softap_full_on_off(self, network, softap_band):
softap_config = self.start_softap_and_verify(softap_band)
self.run_iperf_client((network, self.dut))
self.run_iperf_client((softap_config, self.dut_client))
if len(self.android_devices) > 2:
self.log.info(
"Testbed has extra android devices, do more validation")
self.verify_traffic_between_softap_clients(self.dut_client,
self.android_devices[2])
wutils.reset_wifi(self.dut_client)
if len(self.android_devices) > 2:
wutils.reset_wifi(self.android_devices[2])
wutils.stop_wifi_tethering(self.dut)
