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)