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_ap_connection(self,
network,
bandwidth=80,
connect=True,
ap=None):
"""Setup AP and connect DUT to it.
Args:
network: the network config for the AP to be setup
bandwidth: bandwidth of the WiFi network to be setup
connect: indicator of if connect dut to the network after setup
ap: access point object, default is None to find the main AP
Returns:
self.brconfigs: dict for bridge interface configs
"""
wutils.wifi_toggle_state(self.dut, True)
if not ap:
if hasattr(self, 'access_points'):
self.brconfigs = wputils.ap_setup(self.access_point,
network,
bandwidth=bandwidth)
else:
self.brconfigs = wputils.ap_setup(ap, network, bandwidth=bandwidth)
if connect:
wutils.wifi_connect(self.dut, network, num_of_tries=3)
if ap or (not ap and hasattr(self, 'access_points')):
return self.brconfigs
def test_mobile_data_usage_downlink(self):
""" Verify mobile data usage
Steps:
1. Get the current data usage of ConnUIDTest and Android OS apps
2. DUT is on LTE data
3. Download file of size xMB through ConnUIDTest app
4. Verify that data usage of Android OS app did not change
5. Verify that data usage of ConnUIDTest app increased by ~xMB
6. Verify that data usage of device also increased by ~xMB
"""
# disable wifi
wutils.wifi_toggle_state(self.dut, False)
# get pre mobile data usage
(aos_pre, app_pre,
total_pre) = self._get_data_usage(self.dut, cconst.TYPE_MOBILE)
# download file through app
self._download_data_through_app(self.dut)
# get new mobile data usage
(aos_pst, app_pst,
total_pst) = self._get_data_usage(self.dut, cconst.TYPE_MOBILE)
# verify data usage
aos_diff = aos_pst - aos_pre
app_diff = app_pst - app_pre
total_diff = total_pst - total_pre
self.log.info("Data usage of Android os increased by %s" % aos_diff)
self.log.info("Data usage of ConnUID app increased by %s" % app_diff)
self.log.info("Data usage on the device increased by %s" % total_diff)
return (aos_diff < DATA_ERR) and \
(self.file_size < app_diff < self.file_size + DATA_USG_ERR) and \
(self.file_size < total_diff < self.file_size + DATA_USG_ERR)
def setup_test(self):
self.dut.droid.wakeLockAcquireBright()
self.dut.droid.wakeUpNow()
self.remove_approvals()
self.clear_deleted_ephemeral_networks()
wutils.wifi_toggle_state(self.dut, True)
self.dut.ed.clear_all_events()
def setup_class(self):
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
req_params = []
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()
asserts.assert_true(
len(self.reference_networks) > 0,
"Need at least one reference network with psk.")
wutils.wifi_toggle_state(self.dut, True)
self.wpapsk_2g = self.reference_networks[0]["2g"]
self.wpapsk_5g = self.reference_networks[0]["5g"]
# install scapy
current_dir = os.path.dirname(os.path.realpath(__file__))
send_ra = os.path.join(current_dir, RA_SCRIPT)
send_scapy = os.path.join(current_dir, SCAPY)
self.access_points[0].install_scapy(send_scapy, send_ra)
self.tcpdump_pid = None
def test_tether_startup_while_connected_to_a_network(self):
"""Test full startup of wifi tethering in auto-band while the device
is connected to a network.
1. Connect to an open network.
2. Turn on AP mode (in auto band).
3. Verify SoftAP active.
4. Make a client connect to the AP.
5. Shutdown wifi tethering.
6. Ensure that the client disconnected.
"""
wutils.wifi_toggle_state(self.dut, True)
wutils.wifi_connect(self.dut, self.open_network)
config = self.create_softap_config()
wutils.start_wifi_tethering(self.dut,
config[wutils.WifiEnums.SSID_KEY],
config[wutils.WifiEnums.PWD_KEY],
WIFI_CONFIG_APBAND_AUTO)
asserts.assert_true(self.dut.droid.wifiIsApEnabled(),
"SoftAp is not reported as running")
# local hotspot may not have internet connectivity
self.confirm_softap_in_scan_results(config[wutils.WifiEnums.SSID_KEY])
wutils.wifi_connect(self.dut_client, config, check_connectivity=False)
wutils.stop_wifi_tethering(self.dut)
wutils.wait_for_disconnect(self.dut_client)
def setup_test(self):
required_params = ("lci_reference", "lcr_reference",
"rtt_reference_distance_mm",
"stress_test_min_iteration_count",
"stress_test_target_run_time_sec")
self.unpack_userparams(required_params)
# can be moved to JSON config file
self.rtt_reference_distance_margin_mm = 2000
self.rtt_max_failure_rate_two_sided_rtt_percentage = 20
self.rtt_max_failure_rate_one_sided_rtt_percentage = 50
self.rtt_max_margin_exceeded_rate_two_sided_rtt_percentage = 10
self.rtt_max_margin_exceeded_rate_one_sided_rtt_percentage = 50
self.rtt_min_expected_rssi_dbm = -100
for ad in self.android_devices:
utils.set_location_service(ad, True)
asserts.skip_if(
not ad.droid.doesDeviceSupportWifiRttFeature(),
"Device under test does not support Wi-Fi RTT - skipping test")
wutils.wifi_toggle_state(ad, True)
rtt_avail = ad.droid.wifiIsRttAvailable()
if not rtt_avail:
self.log.info('RTT not available. Waiting ...')
rutils.wait_for_event(ad, rconsts.BROADCAST_WIFI_RTT_AVAILABLE)
ad.ed.clear_all_events()
rutils.config_privilege_override(ad, False)
wutils.set_wifi_country_code(ad, wutils.WifiEnums.CountryCode.US)
ad.rtt_capabilities = rutils.get_rtt_capabilities(ad)
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 coex_test_phone_setup(self, Screen_status, WiFi_status, WiFi_band,
BT_status, BLE_status, Cellular_status,
Celluar_band):
"""Setup the phone in desired state for coex tests.
Args:
Screen_status: 'ON' or 'OFF'
WiFi_status: 'ON', 'Connected', 'Disconnected', or 'OFF'
WiFi_band: '2g', '5g' or None, the band of AP
BT_status: 'ON' or 'OFF'
BLE_status: 'ON' or 'OFF'
Cellular_status: 'ON' or 'OFF'
Celluar_band: 'Verizon', 'Tmobile', or 'ATT' for live network,
actual band for callbox setup; 'None' when celluar is OFF
"""
# Setup WiFi
if WiFi_status is 'ON':
wutils.wifi_toggle_state(self.dut, True)
elif WiFi_status is 'Connected':
self.setup_ap_connection(self.main_network[WiFi_band])
elif WiFi_status is 'Disconnected':
self.setup_ap_connection(self.main_network[WiFi_band],
connect=False)
# Setup BT/BLE
self.phone_setup_for_BT(BT_status, BLE_status, Screen_status)
# Setup Cellular
if Cellular_status is 'ON':
self.dut.droid.connectivityToggleAirplaneMode(False)
utils.set_mobile_data_always_on(self.dut, True)
def setup_class(self):
super().setup_class()
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
req_params = [
"iot_networks",
]
opt_params = ["open_network", "iperf_server_address"]
self.unpack_userparams(req_param_names=req_params,
opt_param_names=opt_params)
asserts.assert_true(
len(self.iot_networks) > 0,
"Need at least one iot network with psk.")
if getattr(self, 'open_network', False):
self.iot_networks.append(self.open_network)
wutils.wifi_toggle_state(self.dut, True)
if "iperf_server_address" in self.user_params:
self.iperf_server = self.iperf_servers[0]
self.iperf_server.start()
# create hashmap for testcase name and SSIDs
self.iot_test_prefix = "test_iot_connection_to_"
self.ssid_map = {}
for network in self.iot_networks:
SSID = network['SSID'].replace('-', '_')
self.ssid_map[SSID] = network
def test_stress_toggle_wifi_state_bluetooth_on(self):
"""Toggle WiFi state ON and OFF for N times when bluetooth ON."""
enable_bluetooth(self.dut.droid, self.dut.ed)
for count in range(self.stress_count):
"""Test toggling wifi"""
try:
self.log.debug("Going from on to off.")
wutils.wifi_toggle_state(self.dut, False)
self.log.debug("Going from off to on.")
startTime = time.time()
wutils.wifi_toggle_state(self.dut, True)
startup_time = time.time() - startTime
self.log.debug("WiFi was enabled on the device in %s s." %
startup_time)
except:
signals.TestFailure(details="",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % count
})
disable_bluetooth(self.dut.droid)
raise signals.TestPass(details="",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % (count + 1)
})
def stress_toggle_airplane_and_wifi(self, stress_count):
"""Toggle Airplane and WiFi modes in a loop.
Args:
stress_count: Number of times to perform Airplane mode ON, WiFi ON,
Airplane mode OFF, in a sequence.
"""
for count in range(stress_count):
self.log.debug("stress_toggle_airplane_and_wifi: Iteration %d" %
count)
self.log.debug("Toggling Airplane mode ON")
asserts.assert_true(
acts.utils.force_airplane_mode(self.dut, True),
"Can not turn on airplane mode on: %s" % self.dut.serial)
# Sleep for atleast 500ms so that, call to enable wifi is not deferred.
time.sleep(1)
self.log.debug("Toggling wifi ON")
wifi_utils.wifi_toggle_state(self.dut, True)
# Sleep for 1s before getting new WiFi state.
time.sleep(1)
if not self.dut.droid.wifiGetisWifiEnabled():
raise signals.TestFailure(
"WiFi did not turn on after turning ON"
" Airplane mode")
asserts.assert_true(
acts.utils.force_airplane_mode(self.dut, False),
"Can not turn on airplane mode on: %s" % self.dut.serial)
if not self.dut.droid.wifiGetisWifiEnabled():
raise signals.TestFailure("WiFi did not turn on after toggling it"
" %d times" % self.stress_count)
def setup_class(self):
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
# 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)
req_params = []
opt_param = [
"additional_energy_info_models", "additional_tdls_models",
"open_network", "reference_networks", "iperf_server_address"
]
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()
asserts.assert_true(
len(self.reference_networks) > 0,
"Need at least one reference network with psk.")
wutils.wifi_toggle_state(self.dut, True)
if "iperf_server_address" in self.user_params:
self.iperf_server = self.iperf_servers[0]
self.iot_test_prefix = "test_connection_to-"
self.wpapsk_2g = self.reference_networks[0]["2g"]
self.wpapsk_5g = self.reference_networks[0]["5g"]
self.open_network = self.open_network[0]["2g"]
def test_reconnect_wifi_network_suggestion(self):
"""Tests that Wifi Wake re-enables Wifi for app provided suggestion."""
self.dut.log.info("Adding network suggestions")
asserts.assert_true(
self.dut.droid.wifiAddNetworkSuggestions([self.ap_a]),
"Failed to add suggestions")
asserts.assert_true(
self.dut.droid.wifiAddNetworkSuggestions([self.ap_b]),
"Failed to add suggestions")
# Enable suggestions by the app.
self.dut.log.debug("Enabling suggestions from test")
self.dut.adb.shell("cmd wifi network-suggestions-set-user-approved" +
" " + SL4A_APK_NAME + " yes")
# Ensure network is seen in scan results & auto-connected to.
self.do_location_scan(2)
wutils.wait_for_connect(self.dut)
self.dut.ed.clear_all_events()
self.ap_a_off()
self.ap_b_off()
wutils.wait_for_disconnect(self.dut)
self.log.info("Wifi Disconnected")
time.sleep(LAST_DISCONNECT_TIMEOUT_SEC * 1.2)
wutils.wifi_toggle_state(self.dut, new_state=False)
time.sleep(PRESCAN_DELAY_SEC)
self.do_location_scan(CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT + 2)
self.ap_a_on()
self.do_location_scan()
asserts.assert_true(
self.dut.droid.wifiCheckState(),
"Expect Wifi Wake to enable Wifi, but Wifi is disabled.")
def test_reconnect_to_better_saved_network(self):
"""
2 saved APs, one attenuated, one unattenuated, Wifi Wake should connect
to the unattenuated AP
"""
wutils.wifi_connect(self.dut, self.ap_a, num_of_tries=5)
wutils.wifi_connect(self.dut, self.ap_b, num_of_tries=5)
self.dut.ed.clear_all_events()
self.ap_a_off()
self.ap_b_off()
wutils.wait_for_disconnect(self.dut)
self.log.info("Wifi Disconnected")
time.sleep(LAST_DISCONNECT_TIMEOUT_SEC * 1.2)
wutils.wifi_toggle_state(self.dut, new_state=False)
time.sleep(PRESCAN_DELAY_SEC)
self.do_location_scan(CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT + 2)
self.ap_a_on()
self.ap_b_on()
self.ap_a_atten.set_atten(30)
self.ap_b_atten.set_atten(0)
self.do_location_scan()
asserts.assert_true(
self.dut.droid.wifiCheckState(),
"Expect Wifi Wake to enable Wifi, but Wifi is disabled.")
expected_ssid = self.ap_b[wutils.WifiEnums.SSID_KEY]
actual_ssid = self.dut.droid.wifiGetConnectionInfo()[
wutils.WifiEnums.SSID_KEY]
asserts.assert_equal(
expected_ssid, actual_ssid,
("Expected to connect to SSID '{}', but actually connected to "
"'{}' instead.").format(expected_ssid, actual_ssid))
def setup_class(self):
super().setup_class()
self.WIFI_2G = "2g"
self.WIFI_5G = "5g"
self.PASSWORD = "******"
self.MIN_SIGNAL_LEVEL = -45
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
wutils.wifi_toggle_state(self.dut, True)
# Get reference networks as a list
opt_params = ["reference_networks"]
self.unpack_userparams(opt_param_names=opt_params)
if "AccessPoint" in self.user_params:
self.legacy_configure_ap_and_start(ap_count=2)
networks = []
for ref_net in self.reference_networks:
networks.append(ref_net[self.WIFI_2G])
networks.append(ref_net[self.WIFI_5G])
self.reference_networks = networks
asserts.assert_true(
len(self.reference_networks) == 4,
"Need at least 4 reference network with psk.")
def setup_class(self):
"""Setup required dependencies from config file and configure
the required networks for testing roaming.
Returns:
True if successfully configured the requirements for testing.
"""
super().setup_class()
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
req_params = ["roaming_attn", "roam_interval", "ping_addr",
"max_bugreports"]
opt_param = ["open_network", "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)
asserts.assert_true(
len(self.reference_networks) > 1,
"Need at least two psk networks for roaming.")
asserts.assert_true(
len(self.open_network) > 1,
"Need at least two open networks for roaming")
wutils.wifi_toggle_state(self.dut, True)
def setup_test(self):
required_params = ("aware_default_power_mode", )
self.unpack_userparams(required_params)
for ad in self.android_devices:
asserts.skip_if(
not ad.droid.doesDeviceSupportWifiAwareFeature(),
"Device under test does not support Wi-Fi Aware - skipping test"
)
wutils.wifi_toggle_state(ad, True)
ad.droid.wifiP2pClose()
utils.set_location_service(ad, True)
aware_avail = ad.droid.wifiIsAwareAvailable()
if not aware_avail:
self.log.info('Aware not available. Waiting ...')
autils.wait_for_event(ad,
aconsts.BROADCAST_WIFI_AWARE_AVAILABLE)
ad.ed.clear_all_events()
ad.aware_capabilities = autils.get_aware_capabilities(ad)
self.reset_device_parameters(ad)
self.reset_device_statistics(ad)
self.set_power_mode_parameters(ad)
wutils.set_wifi_country_code(ad, wutils.WifiEnums.CountryCode.US)
autils.configure_ndp_allow_any_override(ad, True)
# set randomization interval to 0 (disable) to reduce likelihood of
# interference in tests
autils.configure_mac_random_interval(ad, 0)
def _power_state_screen_on_wifi_off(self, apk_type):
"""
Args:
apk_type: SL4A APK type - 'Q' for android Q and 'P' for android P
Returns:
Result True if Pass, False if Fail.
"""
try:
self.ad.droid.wakeUpNow()
wifi_test_utils.wifi_toggle_state(
self.ad, new_state=False, assert_on_fail=True)
if apk_type == 'Q':
time_delta = self.request_cell_info_update_rate_limit(
CELL_INFO_UPDATE_WAIT_TIME_HIGH, 'high')
elif apk_type == 'P':
time_delta = self.get_all_cell_info_rate_limit(
CELL_INFO_UPDATE_WAIT_TIME_HIGH, 'high')
if int(time_delta) == RATE_LIMIT_HIGH:
return True
else:
return False
except Exception as e:
self.log.error(
"Exception during request_cell_info_update_rate_limit():" +
str(e))
return False
def setup_class(self):
super().setup_class()
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
wutils.wifi_toggle_state(self.dut, True)
self.dut_client = None
if len(self.android_devices) > 1:
self.dut_client = self.android_devices[1]
wutils.wifi_test_device_init(self.dut_client)
wutils.wifi_toggle_state(self.dut_client, True)
req_params = []
opt_param = [
"open_network", "reference_networks", "iperf_server_address",
"wpa_networks", "wep_networks", "iperf_server_port"
]
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(wpa_network=True, wep_network=True)
asserts.assert_true(
len(self.reference_networks) > 0,
"Need at least one reference network with psk.")
self.wpapsk_2g = self.reference_networks[0]["2g"]
self.wpapsk_5g = self.reference_networks[0]["5g"]
self.open_network_2g = self.open_network[0]["2g"]
self.open_network_5g = self.open_network[0]["5g"]
def setup_class(self):
""" Setup wi-fi connection and unpack params
"""
self.dut = self.android_devices[0]
required_params = dir(VPN_PARAMS)
required_params = [
x for x in required_params if not x.startswith('__')
] + ["wifi_network"]
self.unpack_userparams(req_param_names=required_params)
wutils.wifi_test_device_init(self.dut)
wutils.wifi_toggle_state(self.dut, True)
wutils.start_wifi_connection_scan_and_ensure_network_found(
self.dut, self.wifi_network["SSID"])
wutils.wifi_connect(self.dut, self.wifi_network)
time.sleep(3)
self.vpn_params = {
'vpn_username': self.vpn_username,
'vpn_password': self.vpn_password,
'psk_secret': self.psk_secret,
'client_pkcs_file_name': self.client_pkcs_file_name,
'cert_path_vpnserver': self.cert_path_vpnserver,
'cert_password': self.cert_password
}
def setup_test(self):
self.dut.droid.wakeLockAcquireBright()
self.dut.droid.wakeUpNow()
wutils.wifi_toggle_state(self.dut, True)
self.dut_client.droid.wakeLockAcquireBright()
self.dut_client.droid.wakeUpNow()
wutils.wifi_toggle_state(self.dut_client, True)
def setup_class(self):
self.dut = self.android_devices[0]
wutils.wifi_test_device_init(self.dut)
wutils.wifi_toggle_state(self.dut, True)
# Get reference networks as a list
req_params = ["reference_networks"]
self.unpack_userparams(req_param_names=req_params)
networks = []
for ref_net in self.reference_networks:
networks.append(ref_net[self.WIFI_2G])
networks.append(ref_net[self.WIFI_5G])
self.reference_networks = networks
asserts.assert_true(
len(self.reference_networks) == 4,
"Need at least 4 reference network with psk.")
# Set attenuation to 0 and verify reference
# networks show up in the scanned results
if getattr(self, "attenuators", []):
for a in self.attenuators:
a.set_atten(0)
self.target_networks = []
for ref_net in self.reference_networks:
self.target_networks.append({'BSSID': ref_net['bssid']})
result = self._find_reference_networks_no_attn()
if result:
self.log.error("Did not find or signal strength too low "
"for the following reference networks\n%s\n" %
result)
return False
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 test_toggle_wifi_reboot_configstore_reconnect(self):
"""Connect to multiple networks, disable WiFi, reboot, then
reconnect to previously connected network.
Steps:
1. Connect to a 2GHz network.
2. Connect to a 5GHz network.
3. Turn WiFi OFF.
4. Reboot device.
5. Turn WiFi ON.
4. Verify all networks are persistent after reboot.
5. Reconnect to the non-current network.
"""
network_list = self.connect_multiple_networks(self.dut)
self.log.debug("Toggling wifi OFF")
wutils.wifi_toggle_state(self.dut, False)
time.sleep(DEFAULT_TIMEOUT)
self.dut.reboot()
time.sleep(DEFAULT_TIMEOUT)
self.log.debug("Toggling wifi ON")
wutils.wifi_toggle_state(self.dut, True)
time.sleep(DEFAULT_TIMEOUT)
self.check_configstore_networks(network_list)
reconnect_to = self.get_enabled_network(network_list[BAND_2GHZ],
network_list[BAND_5GHZ])
reconnect = self.connect_to_wifi_network_with_id(
reconnect_to[WifiEnums.NETID_KEY],
reconnect_to[WifiEnums.SSID_KEY])
if not reconnect:
msg = ("Device failed to reconnect to the correct network after"
" toggling WiFi and rebooting.")
raise signals.TestFailure(msg)
def get_interference_rssi(self):
"""Function to read wifi interference RSSI level."""
bssids = []
self.interference_rssi = []
wutils.wifi_toggle_state(self.android_devices[0], True)
for item in self.wifi_int_pairs:
ssid = item.network['SSID']
bssid = item.ap.get_bssid_from_ssid(ssid, '2g')
bssids.append(bssid)
interference_rssi_dict = {
"ssid": ssid,
"bssid": bssid,
"chan": item.channel,
"rssi": 0
}
self.interference_rssi.append(interference_rssi_dict)
scaned_rssi = wpeutils.get_scan_rssi(self.android_devices[0],
bssids,
num_measurements=2)
for item in self.interference_rssi:
item['rssi'] = scaned_rssi[item['bssid']]['mean']
self.log.info('Interference RSSI at channel {} is {} dBm'.format(
item['chan'], item['rssi']))
wutils.wifi_toggle_state(self.android_devices[0], False)
def setup_class(self):
self.dut = self.android_devices[0]
req_params = [
'RemoteServer', 'RetailAccessPoints', 'rssi_test_params',
'main_network', 'testbed_params'
]
self.unpack_userparams(req_params)
self.testclass_params = self.rssi_test_params
self.num_atten = self.attenuators[0].instrument.num_atten
self.iperf_server = self.iperf_servers[0]
self.iperf_client = self.iperf_clients[0]
self.remote_server = ssh.connection.SshConnection(
ssh.settings.from_config(self.RemoteServer[0]['ssh_config']))
self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
self.log_path = os.path.join(logging.log_path, 'results')
os.makedirs(self.log_path, exist_ok=True)
self.log.info('Access Point Configuration: {}'.format(
self.access_point.ap_settings))
self.testclass_results = []
# Turn WiFi ON
if self.testclass_params.get('airplane_mode', 1):
self.log.info('Turning on airplane mode.')
asserts.assert_true(utils.force_airplane_mode(self.dut, True),
"Can not turn on airplane mode.")
wutils.wifi_toggle_state(self.dut, True)
def _do_bluetooth_tethering_then_disconnect(self, hotspot_device,
tethered_device):
"""Test bluetooth tethering.
Steps:
1. Enables Data Connection on hotspot device.
2. Verifies IPv6 tethering is supported
3. Execute Bluetooth tethering test
Args:
hotspot_device: device providing internet service
tethered_device: device receiving internet service
Returns:
True: if tethering test is successful
False: otherwise
"""
self.hotspot_device = hotspot_device
wutils.wifi_toggle_state(self.hotspot_device, False)
wutils.wifi_toggle_state(tethered_device, False)
self.hotspot_device.droid.telephonyToggleDataConnection(True)
time.sleep(20) # allowing time for Data Connection to stabilize
operator = nutils.get_operator_name(self.log, self.hotspot_device)
self.log.info("Carrier is %s" % operator)
self._verify_ipv6_tethering(self.hotspot_device)
return self._bluetooth_tethering_then_disconnect(
self.hotspot_device, tethered_device)
def setup_class(self):
self.dut = self.android_devices[-1]
req_params = [
'ping_test_params', 'testbed_params', 'main_network',
'RetailAccessPoints', 'RemoteServer'
]
opt_params = ['OTASniffer']
self.unpack_userparams(req_params, opt_params)
self.testclass_params = self.ping_test_params
self.num_atten = self.attenuators[0].instrument.num_atten
self.ping_server = ssh.connection.SshConnection(
ssh.settings.from_config(self.RemoteServer[0]['ssh_config']))
self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
if hasattr(self,
'OTASniffer') and self.testbed_params['sniffer_enable']:
self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
self.log.info('Access Point Configuration: {}'.format(
self.access_point.ap_settings))
self.log_path = os.path.join(logging.log_path, 'results')
os.makedirs(self.log_path, exist_ok=True)
self.atten_dut_chain_map = {}
self.testclass_results = []
# Turn WiFi ON
if self.testclass_params.get('airplane_mode', 1):
self.log.info('Turning on airplane mode.')
asserts.assert_true(utils.force_airplane_mode(self.dut, True),
"Can not turn on airplane mode.")
wutils.wifi_toggle_state(self.dut, True)
# Configure test retries
self.user_params['retry_tests'] = [self.__class__.__name__]
def test_scan_with_wifi_off_and_location_scan_on(self):
"""Put wifi in scan only mode"""
self.turn_location_on_and_scan_toggle_on()
wutils.wifi_toggle_state(self.dut, False)
"""Test wifi connection scan can start and find expected networks."""
ssid = self.open_network[WifiEnums.SSID_KEY]
wutils.start_wifi_connection_scan_and_ensure_network_found(
self.dut, ssid)
