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_stress_wifi_roaming(self): AP1_network = self.reference_networks[0]["5g"] AP2_network = self.reference_networks[1]["5g"] wutils.set_attns(self.attenuators, "AP1_on_AP2_off") wutils.wifi_connect(self.dut, AP1_network) # Reduce iteration to half because each iteration does two roams. for count in range(self.stress_count / 2): self.log.info("Roaming iteration %d, from %s to %s", count, AP1_network, AP2_network) wutils.trigger_roaming_and_validate(self.dut, self.attenuators, "AP1_off_AP2_on", AP2_network) self.log.info("Roaming iteration %d, from %s to %s", count, AP2_network, AP1_network) wutils.trigger_roaming_and_validate(self.dut, self.attenuators, "AP1_on_AP2_off", AP1_network)
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 test_wifi_tethering_5ghz_ping_hotspot_interfaces(self): """ Steps: 1. Start wifi hotspot with 5ghz band 2. Connect tethered device to hotspot device 3. Ping 'wlan0' and 'rmnet_data' interface's IPv4 and IPv6 interfaces on hotspot device from tethered device """ wutils.toggle_wifi_off_and_on(self.hotspot_device) self._start_wifi_tethering(WIFI_CONFIG_APBAND_5G) wutils.wifi_connect(self.tethered_devices[0], self.network) result = self._ping_hotspot_interfaces_from_tethered_device( self.tethered_devices[0]) wutils.stop_wifi_tethering(self.hotspot_device) return result
def test_multipath_preference_data_download(self): """ Verify multipath preference when large file is downloaded Steps: 1. DUT has WiFi and LTE data 2. WiFi is active network 3. Download large file over cell network 4. Verify multipath preference on cell network is 0 """ # set vars ad = self.android_devices[1] self.dut = ad self._clear_netstats(ad) utils.sync_device_time(ad) self.tcpdump_pid = nutils.start_tcpdump(ad, self.test_name) cell_network = ad.droid.connectivityGetActiveNetwork() self.log.info("cell network %s" % cell_network) wutils.wifi_connect(ad, self.wifi_network) wifi_network = ad.droid.connectivityGetActiveNetwork() self.log.info("wifi network %s" % wifi_network) # verify multipath preference for wifi and cell networks self._verify_multipath_preferences(ad, RELIABLE, RELIABLE, wifi_network, cell_network) # download file with cell network ad.droid.connectivityNetworkOpenConnection(cell_network, self.download_file) file_folder, file_name = _generate_file_directory_and_file_name( self.download_file, DOWNLOAD_PATH) file_path = os.path.join(file_folder, file_name) self.log.info("File path: %s" % file_path) if _check_file_existance(ad, file_path): self.log.info("File exists. Removing file %s" % file_name) ad.adb.shell("rm -rf %s%s" % (DOWNLOAD_PATH, file_name)) # verify multipath preference values curr_time = time.time() while time.time() < curr_time + TIMEOUT: try: self._verify_multipath_preferences(ad, RELIABLE, NONE, wifi_network, cell_network) return True except signals.TestFailure as e: self.log.debug("%s" % e) time.sleep(1) return False
def test_private_dns_mode_strict_invalid_hostnames(self): """ Verify that invalid hostnames are not saved for strict mode Steps: 1. Set private DNS to strict mode with invalid hostname 2. Verify that invalid hostname is not saved """ invalid_hostnames = ["!%@&!*", "12093478129", "9.9.9.9", "sdkfjhasdf"] for hostname in invalid_hostnames: self.dut.droid.setPrivateDnsMode(True, hostname) mode = self.dut.droid.getPrivateDnsMode() specifier = self.dut.droid.getPrivateDnsSpecifier() wutils.wifi_connect(self.dut, self.wifi_network_no_dns_tls) asserts.assert_true( mode == PRIVATE_DNS_MODE_STRICT and specifier != hostname, "Able to set invalid private DNS strict mode")
def connect_to_wifi(self, ad, network): """Connection logic for open and psk wifi networks. Args: ad: Android device object. network: A JSON dict of the WiFi network configuration. """ ad.ed.clear_all_events() wifi_utils.start_wifi_connection_scan(ad) scan_results = ad.droid.wifiGetScanResults() wifi_utils.assert_network_in_list( {WifiEnums.SSID_KEY: self.wifi_network_ssid}, scan_results) wifi_utils.wifi_connect(ad, network) self.log.debug("Connected to %s network on %s device" % (network[WifiEnums.SSID_KEY], ad.serial))
def setup_sap_rvr_test(self, testcase_params): """Function that gets devices ready for the test. Args: testcase_params: dict containing test-specific parameters """ for dev in self.android_devices: if not wputils.health_check(dev, 20): asserts.skip('DUT health check failed. Skipping test.') # Reset WiFi on all devices for dev in self.android_devices: self.dut.go_to_sleep() wutils.reset_wifi(dev) wutils.set_wifi_country_code(dev, wutils.WifiEnums.CountryCode.US) # Setup Soft AP sap_config = wutils.create_softap_config() self.log.info('SoftAP Config: {}'.format(sap_config)) wutils.start_wifi_tethering(self.android_devices[0], sap_config[wutils.WifiEnums.SSID_KEY], sap_config[wutils.WifiEnums.PWD_KEY], testcase_params['sap_band_enum']) # Set attenuator to 0 dB for attenuator in self.attenuators: attenuator.set_atten(0, strict=False) # Connect DUT to Network testcase_params['test_network'] = { 'SSID': sap_config[wutils.WifiEnums.SSID_KEY], 'password': sap_config[wutils.WifiEnums.PWD_KEY] } wutils.wifi_connect(self.android_devices[1], testcase_params['test_network'], num_of_tries=5, check_connectivity=False) # Compile meta data self.access_point = AccessPointTuple(sap_config) testcase_params['connection_info'] = self.get_sap_connection_info() testcase_params['channel'] = testcase_params['connection_info'][ 'channel'] testcase_params['test_network']['channel'] = testcase_params[ 'connection_info']['channel'] if testcase_params['channel'] < 13: testcase_params['mode'] = 'VHT20' else: testcase_params['mode'] = 'VHT80' testcase_params['iperf_server_address'] = testcase_params[ 'connection_info']['ap_ip_address']
def test_multipath_preference_low_data_limit(self): """ Verify multipath preference when mobile data limit is low Steps: 1. DUT has WiFi and LTE data 2. Set mobile data usage limit to low value 3. Verify that multipath preference is 0 for cell network """ # set vars ad = self.android_devices[0] self.dut = ad self._clear_netstats(ad) utils.sync_device_time(ad) self.tcpdump_pid = nutils.start_tcpdump(ad, self.test_name) sub_id = str(ad.droid.telephonyGetSubscriberId()) cell_network = ad.droid.connectivityGetActiveNetwork() self.log.info("cell network %s" % cell_network) wutils.wifi_connect(ad, self.wifi_network) wifi_network = ad.droid.connectivityGetActiveNetwork() self.log.info("wifi network %s" % wifi_network) # verify mulipath preference values self._verify_multipath_preferences(ad, RELIABLE, RELIABLE, wifi_network, cell_network) # set low data limit on mobile data total_pre = self._get_total_data_usage_for_device(ad, 0, sub_id) self.log.info("Setting data usage limit to %sMB" % (total_pre + 5)) ad.droid.connectivitySetDataUsageLimit( sub_id, int((total_pre + 5) * 1000.0 * 1000.0)) self.log.info("Setting data warning limit to %sMB" % (total_pre + 5)) ad.droid.connectivitySetDataWarningLimit( sub_id, int((total_pre + 5) * 1000.0 * 1000.0)) # verify multipath preference values curr_time = time.time() while time.time() < curr_time + TIMEOUT: try: self._verify_multipath_preferences(ad, RELIABLE, NONE, wifi_network, cell_network) return True except signals.TestFailure as e: self.log.debug("%s" % e) time.sleep(1) return False
def setup_class(self): super().setup_class() self.pri_ad = self.android_devices[0] if len(self.android_devices) == 2: self.sec_ad = self.android_devices[1] elif len(self.android_devices) == 3: self.third_ad = self.android_devices[2] self.ssh_config = None self.counter = 0 self.thread_list = [] if not setup_multiple_devices_for_bt_test(self.android_devices): self.log.error('Failed to setup devices for bluetooth test') return False req_params = ['network', 'iperf'] opt_params = [ 'AccessPoint', 'RetailAccessPoints', 'RelayDevice', 'required_devices' ] self.unpack_userparams(req_params, opt_params) self.iperf_server = self.iperf_servers[0] self.iperf_client = self.iperf_clients[0] if hasattr(self, 'RelayDevice'): self.audio_receiver = self.relay_devices[0] self.audio_receiver.power_on() self.headset_mac_address = self.audio_receiver.mac_address else: self.log.warning('Missing Relay config file.') if hasattr(self, 'AccessPoint'): self.ap = self.access_points[0] configure_and_start_ap(self.ap, self.network) elif hasattr(self, 'RetailAccessPoints'): self.retail_access_points = retail_ap.create( self.RetailAccessPoints) self.retail_access_point = self.retail_access_points[0] band = self.retail_access_point.band_lookup_by_channel( self.network['channel']) self.retail_access_point.set_channel(band, self.network['channel']) else: self.log.warning('config file have no access point information') wifi_test_device_init(self.pri_ad) wifi_connect(self.pri_ad, self.network, num_of_tries=5)
def test_dns_server_link_properties_strict_mode(self): """ Verify DNS server in the link properties when set in strict mode Steps: 1. Set DNS server hostname in Private DNS settings (stict mode) 2. Verify that DNS server set in settings is in link properties 3. Verify for WiFi as well as LTE """ # start tcpdump on device self._start_tcp_dump(self.dut) # set private DNS to strict mode cutils.set_private_dns( self.dut, cconst.PRIVATE_DNS_MODE_STRICT, cconst.DNS_GOOGLE) # connect DUT to wifi network wutils.start_wifi_connection_scan_and_ensure_network_found( self.dut, self.ipv4_ipv6_network[SSID]) wutils.wifi_connect(self.dut, self.ipv4_ipv6_network) for host in self.ping_hosts: wutils.validate_connection(self.dut, host) # DNS server in link properties for wifi network link_prop = self.dut.droid.connectivityGetActiveLinkProperties() wifi_dns_servers = link_prop['PrivateDnsServerName'] self.log.info("Link prop: %s" % wifi_dns_servers) # DUT is on LTE data wutils.reset_wifi(self.dut) time.sleep(1) # wait till lte network becomes active for host in self.ping_hosts: wutils.validate_connection(self.dut, host) # DNS server in link properties for cell network link_prop = self.dut.droid.connectivityGetActiveLinkProperties() lte_dns_servers = link_prop['PrivateDnsServerName'] self.log.info("Link prop: %s" % lte_dns_servers) # stop tcpdump on device pcap_file = self._stop_tcp_dump(self.dut) # Verify DNS server in link properties asserts.assert_true(cconst.DNS_GOOGLE in wifi_dns_servers, "Hostname not in link properties - wifi network") asserts.assert_true(cconst.DNS_GOOGLE in lte_dns_servers, "Hostname not in link properites - cell network")
def setup_ap_connection(self, network, bandwidth=80, connect=True): """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 Returns: self.brconfigs: dict for bridge interface configs """ wutils.wifi_toggle_state(self.dut, True) self.brconfigs = wputils.ap_setup(self.access_point, network, bandwidth=bandwidth) if connect: wutils.wifi_connect(self.dut, network) return self.brconfigs
def test_wifi_tethering_data_usage_limit_downlink(self): """ Verify connectivity when data usage limit reached Steps: 1. Set the data usage limit to current data usage + 10MB 2. Start wifi tethering and connect a dut to the SSID 3. Download 20MB data on tethered device 4. File download stops and data limit reached 5. Verify data usage limit """ # connect device to wifi hotspot ad = self.tethered_devices[0] wutils.toggle_wifi_off_and_on(self.dut) wutils.start_wifi_tethering(self.dut, self.network[wutils.WifiEnums.SSID_KEY], self.network[wutils.WifiEnums.PWD_KEY], ttutils.WIFI_CONFIG_APBAND_2G) wutils.wifi_connect(ad, self.network) # get pre mobile data usage total_pre = self._get_total_data_usage_for_device(cconst.TYPE_MOBILE) # set data usage limit to current usage limit + 10MB self.log.info("Setting data usage limit to %sMB" % (total_pre + INC_DATA)) self.dut.droid.connectivitySetDataUsageLimit( self.sub_id, str(int((total_pre + INC_DATA) * BYTE_TO_MB_ANDROID))) # download file from tethered device http_file_download_by_chrome(ad, self.download_file, self.file_size, timeout=120) total_pst = self._get_total_data_usage_for_device(cconst.TYPE_MOBILE) # verify data usage connectivity_status = wutils.validate_connection(ad) self.dut.droid.connectivityFactoryResetNetworkPolicies(self.sub_id) wutils.stop_wifi_tethering(self.dut) self.log.info("Expected data usage: %s" % (total_pre + INC_DATA)) self.log.info("Actual data usage: %s" % total_pst) asserts.assert_true( not connectivity_status, "Device has internet connectivity after reaching data limit") return total_pst - total_pre - INC_DATA < DATA_USG_ERR
def _test_traffic_between_two_tethered_devices(self, ad, wd): """ Verify pinging interfaces of one DUT from another Args: 1. ad - android device 2. wd - wifi dongle """ wutils.wifi_connect(ad, self.network) dutils.connect_wifi(wd, self.network) local_ip = ad.droid.connectivityGetIPv4Addresses('wlan0')[0] remote_ip = wd.ip_address() port = 8888 time.sleep(6) # wait until UDP packets method is invoked socket = sutils.open_datagram_socket(ad, local_ip, port) sutils.send_recv_data_datagram_sockets(ad, ad, socket, socket, remote_ip, port) sutils.close_datagram_socket(ad, socket)
def test_reconnect_wifi_move_back_in_range(self): """ Tests that Wifi Wake re-enables Wifi if the device moves out of range of the AP then came back. """ wutils.wifi_connect(self.dut, self.ap_a, num_of_tries=5) wutils.wifi_toggle_state(self.dut, new_state=False) time.sleep(PRESCAN_DELAY_SEC) # init Wakeup Lock with AP A self.do_location_scan(CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT + 2) self.ap_a_off() # evict AP A from Wakeup Lock 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_if_both_ap_evicted_from_wakeup_lock(self): """ 2 APs in Wakeup Lock, user moves out of range of both APs, should reconnect when user moves back in range of either 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) 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_off() self.ap_b_off() 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 eap_connect_toggle_wifi(self, config, *args): """Connects to an enterprise network, toggles wifi state and ensures that the device reconnects. This logic expect the enterprise network to have Internet access. Args: config: A dict representing a wifi enterprise configuration. args: args to be passed to |wutils.eap_connect|. Returns: True if the connection is successful and Internet access works. """ ad = args[0] wutils.wifi_connect(ad, config) wutils.toggle_wifi_and_wait_for_reconnection(ad, config, num_of_tries=5)
def connect_wlan_profile(pri_ad, network): """Disconnect and Connect to AP. Args: pri_ad: An android device. network: Network to which AP to be connected. Returns: True if successful, False otherwise. """ reset_wifi(pri_ad) wifi_toggle_state(pri_ad, False) wifi_test_device_init(pri_ad) wifi_connect(pri_ad, network) if not wifi_connection_check(pri_ad, network["SSID"]): pri_ad.log.error("Wifi connection does not exist.") return False return True
def test_no_reconnect_if_exists_ap_in_wakeup_lock(self): """ 2 APs in Wakeup Lock, user moves out of range of one AP but stays in range of the other, should not reconnect when user moves back in range of both. """ wutils.wifi_connect(self.dut, self.ap_a, num_of_tries=5) wutils.wifi_connect(self.dut, self.ap_b, num_of_tries=5) 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_b_off() self.do_location_scan(CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT + 2) self.ap_b_on() self.do_location_scan(CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT + 2) asserts.assert_false( self.dut.droid.wifiCheckState(), "Expect Wifi Wake to not enable Wifi, but Wifi was enabled.")
def power_tel_tethering_test(self): """ Measure power and throughput during data transmission. Starts WiFi tethering in the DUT and connects a second device. Then the iPerf client is hosted in the second android device. """ # Country Code set to 00 after toggling airplane mode. # We need to set this right before we setup a hotspot # Set country codes on both devices to US to connect to 5GHz country_code = "US" hotspot_dut = self.dut slave_dut = self.android_devices[1] for dut in [hotspot_dut, slave_dut]: self.log.info("Setting Country Code to %s for SN:%s" % (country_code, dut.serial)) wutils.set_wifi_country_code(dut, country_code) # Setup tethering wutils.start_wifi_tethering(self.dut, self.network[wutils.WifiEnums.SSID_KEY], self.network[wutils.WifiEnums.PWD_KEY], self.wifi_band) wutils.wifi_connect(self.android_devices[1], self.network, check_connectivity=False) # Start data traffic iperf_helpers = self.start_tel_traffic(self.android_devices[1]) # Measure power result = self.collect_power_data() # Wait for iPerf to finish time.sleep(self.IPERF_MARGIN + 2) # Collect throughput measurement self.iperf_results = self.get_iperf_results(self.android_devices[1], iperf_helpers) # Checks if power is below the required threshold. self.pass_fail_check(result.average_current)
def setup_hotspot(self, connect_client=False): """Configure Hotspot and connects client device. Args: connect_client: Connects (or not) the client device to the Hotspot """ try: if self.test_configs.band == self.PARAM_2G_BAND: wifi_band_id = WIFI_CONFIG_APBAND_2G elif self.test_configs.band == self.PARAM_5G_BAND: wifi_band_id = WIFI_CONFIG_APBAND_5G else: raise ValueError() except ValueError: self.log.error( "The test name has to include parameter {} followed by " "either {} or {}.".format(self.PARAM_WIFI_BAND, self.PARAM_2G_BAND, self.PARAM_5G_BAND)) return False # Turn WiFi ON for DUT (hotspot) and connect to AP (WiFiSharing) # Hotspot needs airplane mode OFF self.dut.droid.connectivityToggleAirplaneMode(False) time.sleep(2) if self.test_configs.wifi_sharing == 'OFF': wutils.wifi_toggle_state(self.dut, True) time.sleep(2) else: self.setup_ap_connection( self.main_network[self.test_configs.wifi_sharing]) # Setup tethering on dut wutils.start_wifi_tethering(self.dut, self.network[wutils.WifiEnums.SSID_KEY], self.network[wutils.WifiEnums.PWD_KEY], wifi_band_id) # Connect client device to Hotspot if connect_client: wutils.wifi_connect(self.android_devices[1], self.network, check_connectivity=False)
def roaming_from_AP1_and_AP2(self, AP1_network, AP2_network): """Test roaming between two APs. Args: AP1_network: AP-1's network information. AP2_network: AP-2's network information. Steps: 1. Make AP1 visible, AP2 not visible. 2. Connect to AP1's ssid. 3. Make AP1 not visible, AP2 visible. 4. Expect DUT to roam to AP2. 5. Validate connection information and ping. """ wutils.set_attns(self.attenuators, "AP1_on_AP2_off") wutils.wifi_connect(self.dut, AP1_network) self.log.info("Roaming from %s to %s", AP1_network, AP2_network) wutils.trigger_roaming_and_validate(self.dut, self.attenuators, "AP1_off_AP2_on", AP2_network)
def test_reconnect_wifi_disabled_after_disconnecting(self): """ Tests that Wifi Wake reconnects to a network if Wifi was disabled long after disconnecting from a network. """ wutils.wifi_connect(self.dut, self.ap_a, num_of_tries=5) self.dut.ed.clear_all_events() self.ap_a_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_no_reconnect_to_flaky_ap(self): """ Tests that Wifi Wake does not reconnect to flaky networks. If a network sporadically connects and disconnects, and the user turns off Wifi even during the disconnected phase, Wifi Wake should not re-enable Wifi for that network. """ wutils.wifi_connect(self.dut, self.ap_a, num_of_tries=5) self.ap_a_off() time.sleep(LAST_DISCONNECT_TIMEOUT_SEC * 0.4) 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(2 * CONSECUTIVE_MISSED_SCANS_REQUIRED_TO_EVICT + 2) asserts.assert_false( self.dut.droid.wifiCheckState(), "Expect Wifi Wake to not enable Wifi, but Wifi was enabled.")
def test_wifi_tethering_mobile_data_usage_downlink(self): """ Verify mobile data usage with tethered device Steps: 1. Start wifi hotspot and connect tethered device to it 2. Get the data usage on hotspot device 3. Download data on tethered device 4. Get the new data usage on hotspot device 5. Verify that hotspot device's data usage increased by downloaded file size """ # connect device to wifi hotspot ad = self.tethered_devices[0] wutils.start_wifi_tethering(self.dut, self.network[wutils.WifiEnums.SSID_KEY], self.network[wutils.WifiEnums.PWD_KEY], ttutils.WIFI_CONFIG_APBAND_2G) wutils.wifi_connect(ad, self.network) # 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(ad) # get new mobile data usage (aos_pst, app_pst, total_pst) = self._get_data_usage(self.dut, cconst.TYPE_MOBILE) # stop wifi hotspot wutils.stop_wifi_tethering(self.dut) # 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 (app_diff < DATA_ERR) and \ (self.file_size < total_diff < self.file_size + DATA_USG_ERR)
def setup_dut(self, testcase_params): """Sets up the DUT in the configuration required by the test.""" # 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.wifi_toggle_state(self.dut, True) wutils.reset_wifi(self.dut) self.main_network[testcase_params['band']][ 'channel'] = testcase_params['channel'] wutils.set_wifi_country_code(self.dut, self.testclass_params['country_code']) wutils.wifi_connect(self.dut, self.main_network[testcase_params['band']], num_of_tries=5) self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def test_wifi_framework_crash_reconnect(self): """Connect to a network, crash framework, then ensure we connect back to the previously connected network. Steps: 1. Connect to a network. 2. Restart framework. 3. Reconnect to the previous network. """ wutils.wifi_connect(self.dut, self.network, num_of_tries=3) # Restart framework self.log.info("Crashing framework") self.dut.restart_runtime() # We won't get the disconnect broadcast because framework crashed. # wutils.wait_for_disconnect(self.dut) time.sleep(DEFAULT_TIMEOUT) wifi_info = self.dut.droid.wifiGetConnectionInfo() if wifi_info[WifiEnums.SSID_KEY] != self.network[WifiEnums.SSID_KEY]: raise signals.TestFailure("Device did not connect to the" " network after crashing framework.")
def test_wpa_supplicant_crash_reconnect(self): """Connect to a network, crash wpa_supplicant, then ensure we connect back to the previously connected network. Steps: 1. Connect to a network. 2. Crash wpa_supplicant. 3. Ensure we get a disconnect. 4. Ensure we reconnect to the previous network. """ wutils.wifi_connect(self.dut, self.network, num_of_tries=3) # Restart wificond self.log.info("Crashing wpa_supplicant") self.dut.adb.shell(SUPPLICANT_KILL_SHELL_COMMAND) wutils.wait_for_disconnect(self.dut) time.sleep(DEFAULT_TIMEOUT) wifi_info = self.dut.droid.wifiGetConnectionInfo() if wifi_info[WifiEnums.SSID_KEY] != self.network[WifiEnums.SSID_KEY]: raise signals.TestFailure("Device did not connect to the" " network after crashing wpa_supplicant.")
def test_change_wifi_hotspot_ssid_when_hotspot_enabled(self): """ Steps: 1. Start wifi tethering 2. Verify wifi Ap configuration 3. Change the SSID of the wifi hotspot while hotspot is on 4. Verify the new SSID in wifi ap configuration 5. Restart tethering and verify that the tethered device is able to connect to the new SSID """ wutils.toggle_wifi_off_and_on(self.hotspot_device) dut = self.hotspot_device # start tethering and verify the wifi ap configuration settings self._start_wifi_tethering() wifi_ap = dut.droid.wifiGetApConfiguration() asserts.assert_true( wifi_ap[wutils.WifiEnums.SSID_KEY] == \ self.network[wutils.WifiEnums.SSID_KEY], "Configured wifi hotspot SSID did not match with the expected SSID") wutils.wifi_connect(self.tethered_devices[0], self.network) # update the wifi ap configuration with new ssid config = {wutils.WifiEnums.SSID_KEY: self.new_ssid} config[wutils.WifiEnums.PWD_KEY] = self.network[ wutils.WifiEnums.PWD_KEY] config[wutils.WifiEnums.APBAND_KEY] = WIFI_CONFIG_APBAND_2G self._save_wifi_softap_configuration(dut, config) # start wifi tethering with new wifi ap configuration wutils.stop_wifi_tethering(dut) self._turn_on_wifi_hotspot(dut) # verify dut can connect to new wifi ap configuration new_network = {wutils.WifiEnums.SSID_KEY: self.new_ssid, wutils.WifiEnums.PWD_KEY: \ self.network[wutils.WifiEnums.PWD_KEY]} wutils.wifi_connect(self.tethered_devices[0], new_network) wutils.stop_wifi_tethering(self.hotspot_device)
def eap_negative_connect_logic(self, config, ad): """Tries to connect to an enterprise network with invalid credentials and expect a failure. Args: config: A dict representing an invalid EAP credential. Returns: True if connection failed as expected, False otherwise. """ with asserts.assert_raises(signals.TestFailure, extras=config): verdict = wutils.wifi_connect(ad, config) asserts.explicit_pass("Connection failed as expected.")