def enable_wifi_hotspot(self): """Enable wifi hotspot.""" 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)
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 run_incompat_service_then_aware(self, is_p2p): """Validate that if an Aware-incompatible service is already up then any Aware operation fails""" dut = self.android_devices[0] # start other service if is_p2p: dut.droid.wifiP2pInitialize() else: wutils.start_wifi_tethering(dut, self.TETHER_SSID, password=None) # expect an announcement about Aware non-availability autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_NOT_AVAILABLE) # try starting anyway (expect failure) dut.droid.wifiAwareAttach() autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACH_FAILED) # stop other service if is_p2p: dut.droid.wifiP2pClose() else: wutils.stop_wifi_tethering(dut) # expect an announcement about Aware availability autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE) # try starting Aware dut.droid.wifiAwareAttach() autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
def test_randomized_mac_used_during_connection(self): """Verify that the randomized MAC address and not the factory MAC address is used during connection by checking the softap logs. Steps: 1. Set up softAP on dut_softap. 2. Have dut connect to the softAp. 3. Verify that only randomized MAC appears in softAp logs. """ self.dut_softap.adb.shell(LOG_CLEAR) config = wutils.create_softap_config() wutils.start_wifi_tethering(self.dut_softap, config[wutils.WifiEnums.SSID_KEY], config[wutils.WifiEnums.PWD_KEY], WIFI_CONFIG_APBAND_2G) # Internet validation fails when dut_softap does not have a valid sim # supporting softap. Since this test is not checking for internet # validation, we suppress failure signals. wutils.connect_to_wifi_network(self.dut, config, assert_on_fail=False) mac = self.get_current_mac_address(self.dut) wutils.stop_wifi_tethering(self.dut_softap) self.is_valid_randomized_mac_address(mac) log = self.dut_softap.adb.shell(LOG_GREP.format(mac)) asserts.assert_true(len(log) > 0, "Randomized MAC not in log.") log = self.dut_softap.adb.shell(LOG_GREP.format(self.dut_factory_mac)) asserts.assert_true(len(log) == 0, "Factory MAC is in log.")
def test_ipv6_tethering(self): """ IPv6 tethering test Steps: 1. Start wifi tethering on provider 2. Client connects to wifi tethering SSID 3. Verify IPv6 address on the client's link properties 4. Verify ping on client using ping6 which should pass 5. Disable mobile data on provider and verify that link properties does not have IPv6 address and default route """ # Start wifi tethering on the hotspot device self.log.info("Start tethering on provider: {}".format( self.hotspot_device.serial)) wifi_test_utils.start_wifi_tethering(self.hotspot_device, self.ssid, self.password) time.sleep(tel_defines.WAIT_TIME_ANDROID_STATE_SETTLING) asserts.assert_true( tel_data_utils.verify_http_connection(self.log, self.hotspot_device), "Could not verify http connection on the provider") # Verify link properties on hotspot device self.log.info("Check IPv6 properties on the hotspot device") self._verify_ipv6_tethering(self.hotspot_device) # Connect the client to the SSID asserts.assert_true( tel_test_utils.WifiUtils.wifi_connect(self.log, self.tethered_device, self.ssid, self.password), "Unable to connect to the hotspot SSID") # Need to wait atleast 2 seconds for IPv6 address to # show up in the link properties time.sleep(2) # Verify link properties on tethered device self.log.info("Check IPv6 properties on the tethered device") self._verify_ipv6_tethering(self.tethered_device) # Verify ping6 on tethered device ping_result = self.tethered_device.droid.pingHost( "www.google.com", 5, "ping6") if self._supports_ipv6_tethering(self.hotspot_device): asserts.assert_true(ping_result, "Ping6 failed on the client") else: asserts.assert_true(not ping_result, "Ping6 failed as expected") # Disable mobile data on hotspot device # and verify the link properties on tethered device self.log.info("Disabling mobile data on hotspot device") self.hotspot_device.droid.telephonyToggleDataConnection(False) asserts.assert_equal( self.hotspot_device.droid.telephonyGetDataConnectionState(), tel_defines.DATA_STATE_CONNECTED, "Could not disable cell data") time.sleep(2) # wait until the IPv6 is removed from link properties asserts.assert_true( not self._find_ipv6_default_route(self.tethered_device), "Found IPv6 default route in link properties - Data off")
def run_aware_then_incompat_service(self, is_p2p): """Run test to validate that a running Aware session terminates when an Aware-incompatible service is started. Args: is_p2p: True for p2p, False for SoftAP """ dut = self.android_devices[0] # start Aware id = dut.droid.wifiAwareAttach() autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED) # start other service if is_p2p: dut.droid.wifiP2pInitialize() else: wutils.start_wifi_tethering(dut, self.TETHER_SSID, password=None) # expect an announcement about Aware non-availability autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_NOT_AVAILABLE) # local clean-up if not is_p2p: wutils.stop_wifi_tethering(dut)
def _start_wifi_tethering(self, wifi_band): """ Start wifi tethering on hotspot device Args: 1. wifi_band: specifies the wifi band to start the hotspot on. The current options are 2G and 5G """ wutils.start_wifi_tethering(self.hotspot_device, self.ssid, self.password, wifi_band)
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 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 start_softap_and_verify(self, band): """Test startup of softap 1. Brinup AP mode. 2. Verify SoftAP active using the client device. """ config = self.create_softap_config() wutils.start_wifi_tethering(self.dut, config[wutils.WifiEnums.SSID_KEY], config[wutils.WifiEnums.PWD_KEY], band) self.confirm_softap_in_scan_results(config[wutils.WifiEnums.SSID_KEY])
def _start_wifi_tethering(self, wifi_band=WIFI_CONFIG_APBAND_2G): """ Start wifi tethering on hotspot device Args: 1. wifi_band: specifies the wifi band to start the hotspot on. The current options are 2G and 5G """ wutils.start_wifi_tethering(self.hotspot_device, self.network[wutils.WifiEnums.SSID_KEY], self.network[wutils.WifiEnums.PWD_KEY], wifi_band)
def test_wifi_tethering_open_network_5g(self): """ Steps: 1. Start wifi tethering with open network 5G band (Not allowed manually. b/72412729) 2. Connect tethered device to the SSID 3. Verify internet connectivity """ wutils.start_wifi_tethering( self.hotspot_device, self.open_network[wutils.WifiEnums.SSID_KEY], None, WIFI_CONFIG_APBAND_5G) wutils.wifi_connect(self.tethered_devices[0], self.open_network) wutils.stop_wifi_tethering(self.hotspot_device)
def validate_full_tether_startup(self, band=None, hidden=None, test_ping=False, test_clients=None): """Test full startup of wifi tethering 1. Report current state. 2. Switch to AP mode. 3. verify SoftAP active. 4. Shutdown wifi tethering. 5. verify back to previous mode. """ initial_wifi_state = self.dut.droid.wifiCheckState() initial_cell_state = tel_utils.is_sim_ready(self.log, self.dut) self.dut.log.info("current state: %s", initial_wifi_state) self.dut.log.info("is sim ready? %s", initial_cell_state) if initial_cell_state: self.check_cell_data_and_enable() config = self.create_softap_config() wutils.start_wifi_tethering(self.dut, config[wutils.WifiEnums.SSID_KEY], config[wutils.WifiEnums.PWD_KEY], band, hidden) if hidden: # First ensure it's not seen in scan results. self.confirm_softap_not_in_scan_results( config[wutils.WifiEnums.SSID_KEY]) # If the network is hidden, it should be saved on the client to be # seen in scan results. config[wutils.WifiEnums.HIDDEN_KEY] = True ret = self.dut_client.droid.wifiAddNetwork(config) asserts.assert_true(ret != -1, "Add network %r failed" % config) self.dut_client.droid.wifiEnableNetwork(ret, 0) self.confirm_softap_in_scan_results(config[wutils.WifiEnums.SSID_KEY]) if test_ping: self.validate_ping_between_softap_and_client(config) if test_clients: if hasattr(self, 'arduino_wifi_dongles'): self.validate_traffic_between_softap_clients(config) if len(self.android_devices) > 2: self.validate_ping_between_two_clients(config) wutils.stop_wifi_tethering(self.dut) asserts.assert_false(self.dut.droid.wifiIsApEnabled(), "SoftAp is still reported as running") if initial_wifi_state: wutils.wait_for_wifi_state(self.dut, True) elif self.dut.droid.wifiCheckState(): asserts.fail( "Wifi was disabled before softap and now it is enabled")
def test_full_tether_startup(self): """Test full startup of wifi tethering 1. Report current state. 2. Switch to AP mode. 3. verify SoftAP active. 4. Shutdown wifi tethering. 5. verify back to previous mode. """ success = True initial_wifi_state = self.dut.droid.wifiCheckState() initial_cell_state = is_sim_ready(self.log, self.dut) self.log.info("current state: %s", initial_wifi_state) self.log.info("is sim ready? %s", initial_cell_state) if initial_cell_state: self.check_cell_data_and_enable() config = self.create_softap_config() success = wutils.start_wifi_tethering(self.dut, config[wutils.WifiEnums.SSID_KEY], config[wutils.WifiEnums.PWD_KEY]) asserts.assert_true(success, "call to start_wifi_tethering returned false. Check config") self.confirm_softap_in_scan_results(config[wutils.WifiEnums.SSID_KEY]) wutils.stop_wifi_tethering(self.dut) asserts.assert_true(not self.dut.droid.wifiIsApEnabled(), "SoftAp is still reported as running") if initial_wifi_state: self.verify_return_to_wifi_enabled() elif not self.dut.droid.wifiCheckState(): asserts.fail("Wifi was disabled before softap and now it is enabled")
def start_softap_and_verify(self, band): """Bring-up softap and verify AP mode and in scan results. Args: band: The band to use for softAP. """ config = wutils.create_softap_config() wutils.start_wifi_tethering(self.dut, config[wutils.WifiEnums.SSID_KEY], config[wutils.WifiEnums.PWD_KEY], band=band) asserts.assert_true(self.dut.droid.wifiIsApEnabled(), "SoftAp is not reported as running") wutils.start_wifi_connection_scan_and_ensure_network_found( self.dut_client, config[wutils.WifiEnums.SSID_KEY]) return config
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_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_stress_softAP_startup_and_stop_5g(self): """Test to bring up softAP and down for N times. Steps: 1. Bring up softAP on 5G. 2. Check for softAP on teh client device. 3. Turn ON WiFi. 4. Verify softAP is turned down and WiFi is up. """ ap_ssid = "softap_" + utils.rand_ascii_str(8) ap_password = utils.rand_ascii_str(8) self.dut.log.info("softap setup: %s %s", ap_ssid, ap_password) config = {wutils.WifiEnums.SSID_KEY: ap_ssid} config[wutils.WifiEnums.PWD_KEY] = ap_password # Set country code explicitly to "US". wutils.set_wifi_country_code(self.dut, wutils.WifiEnums.CountryCode.US) wutils.set_wifi_country_code(self.dut_client, wutils.WifiEnums.CountryCode.US) for count in range(self.stress_count): initial_wifi_state = self.dut.droid.wifiCheckState() wutils.start_wifi_tethering(self.dut, ap_ssid, ap_password, WifiEnums.WIFI_CONFIG_APBAND_5G) wutils.start_wifi_connection_scan_and_ensure_network_found( self.dut_client, ap_ssid) wutils.stop_wifi_tethering(self.dut) asserts.assert_false(self.dut.droid.wifiIsApEnabled(), "SoftAp failed to shutdown!") # Give some time for WiFi to come back to previous state. time.sleep(2) cur_wifi_state = self.dut.droid.wifiCheckState() if initial_wifi_state != cur_wifi_state: raise signals.TestFailure( "Wifi state was %d before softAP and %d now!" % (initial_wifi_state, cur_wifi_state), extras={ "Iterations": "%d" % self.stress_count, "Pass": "******" % count }) raise signals.TestPass(details="", extras={ "Iterations": "%d" % self.stress_count, "Pass": "******" % (count + 1) })
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 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 test_firmware_crash_concurrent_reconnect_stress(self): """Firmware crash stress test for concurrent mode 1. Turn on dut's Wi-Fi and connect to access point 2. Turn on dut's hotspot and connected by dut client 3. Trigger firmware crash 4. Check ssr happened 5. Check dut can connect to access point 6. Check the connectivity of hotspot's client 7. Repeat step 3~6 """ if self.dut.model not in self.dbs_supported_models: raise signals.TestSkip("%s does not support dual interfaces" % self.dut.model) # Connect DUT to Network wutils.wifi_toggle_state(self.dut, True) wutils.connect_to_wifi_network(self.dut, self.network) # 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] } # Client connects to Softap wutils.wifi_toggle_state(self.dut_client, True) wutils.connect_to_wifi_network(self.dut_client, config) 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) wutils.reset_wifi(self.dut) # Trigger firmware crash self.trigger_wifi_firmware_crash(self.dut) wutils.connect_to_wifi_network(self.dut, self.network) wutils.connect_to_wifi_network(self.dut_client, config) wutils.stop_wifi_tethering(self.dut)
def start_softap_and_verify(self, band, check_connectivity=True): """Test startup of softap. 1. Bring up AP mode. 2. Verify SoftAP active using the client device. Args: band: wifi band to start soft ap on check_connectivity: If set, verify internet connectivity Returns: Softap config """ config = self.create_softap_config() wutils.start_wifi_tethering(self.dut, config[WifiEnums.SSID_KEY], config[WifiEnums.PWD_KEY], band) for ad in self.android_devices[1:]: wutils.connect_to_wifi_network( ad, config, check_connectivity=check_connectivity) return config
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 test_stress_softAP_startup_and_stop_5g(self): """Test to bring up softAP and down for N times. Steps: 1. Bring up softAP on 5G. 2. Check for softAP on teh client device. 3. Turn ON WiFi. 4. Verify softAP is turned down and WiFi is up. """ ap_ssid = "softap_" + utils.rand_ascii_str(8) ap_password = utils.rand_ascii_str(8) self.dut.log.info("softap setup: %s %s", ap_ssid, ap_password) config = {wutils.WifiEnums.SSID_KEY: ap_ssid} config[wutils.WifiEnums.PWD_KEY] = ap_password # Set country code explicitly to "US". self.dut.droid.wifiSetCountryCode(wutils.WifiEnums.CountryCode.US) self.dut_client.droid.wifiSetCountryCode( wutils.WifiEnums.CountryCode.US) for count in range(self.stress_count): initial_wifi_state = self.dut.droid.wifiCheckState() wutils.start_wifi_tethering(self.dut, ap_ssid, ap_password, WifiEnums.WIFI_CONFIG_APBAND_5G) wutils.start_wifi_connection_scan_and_ensure_network_found( self.dut_client, ap_ssid) # Toggle WiFi ON, which inturn calls softAP teardown. wutils.wifi_toggle_state(self.dut, True) time.sleep(TIMEOUT) asserts.assert_false(self.dut.droid.wifiIsApEnabled(), "SoftAp failed to shutdown!") time.sleep(TIMEOUT) cur_wifi_state = self.dut.droid.wifiCheckState() if initial_wifi_state != cur_wifi_state: raise signals.TestFailure( "Wifi state was %d before softAP and %d now!" % (initial_wifi_state, cur_wifi_state))
def test_rtt_in_and_after_softap_mode(self): """Verify behavior when a SoftAP is enabled and then disabled on the device: - SAP Enabled: depending on device characteristics RTT may succeed or fail. - SAP Disabled: RTT must now succeed. """ supp_required_params = ("dbs_supported_models", ) self.unpack_userparams(supp_required_params) dut = self.android_devices[0] rtt_supporting_aps = rutils.select_best_scan_results( rutils.scan_with_rtt_support_constraint(dut, True, repeat=10), select_count=1) dut.log.debug("RTT Supporting APs=%s", rtt_supporting_aps) # phase 1 (pre-SAP) events = rutils.run_ranging(dut, rtt_supporting_aps, self.NUM_ITER, self.TIME_BETWEEN_ITERATIONS) stats = rutils.analyze_results(events, self.rtt_reference_distance_mm, self.rtt_reference_distance_margin_mm, self.rtt_min_expected_rssi_dbm, self.lci_reference, self.lcr_reference) dut.log.debug("Stats Phase 1 (pre-SAP)=%s", stats) for bssid, stat in stats.items(): asserts.assert_true( stat['num_no_results'] == 0, "Phase 1 (pre-SAP) missing (timed-out) results", extras=stats) # phase 2 (SAP) wutils.start_wifi_tethering(dut, self.SOFT_AP_SSID, self.SOFT_AP_PASSWORD, band=WIFI_CONFIG_APBAND_5G, hidden=False) time.sleep(self.WAIT_FOR_CONFIG_CHANGES_SEC) if dut.model not in self.dbs_supported_models: rutils.wait_for_event(dut, rconsts.BROADCAST_WIFI_RTT_NOT_AVAILABLE) asserts.assert_false(dut.droid.wifiIsRttAvailable(), "RTT is available") events = rutils.run_ranging(dut, rtt_supporting_aps, self.NUM_ITER, self.TIME_BETWEEN_ITERATIONS) stats = rutils.analyze_results(events, self.rtt_reference_distance_mm, self.rtt_reference_distance_margin_mm, self.rtt_min_expected_rssi_dbm, self.lci_reference, self.lcr_reference) dut.log.debug("Stats Phase 2 (SAP)=%s", stats) for bssid, stat in stats.items(): if dut.model in self.dbs_supported_models: asserts.assert_true( stat['num_no_results'] == 0, "Phase 2 (SAP) missing (timed-out) results", extras=stats) else: asserts.assert_true( stat['num_success_results'] == 0, "Phase 2 (SAP) valid results - but unexpected in SAP!?", extras=stats) # phase 3 (post-SAP) # enabling Wi-Fi first: on some devices this will also disable SAP # (that's the scenario we're primarily testing). Additionally, # explicitly disable SAP (which may be a NOP on some devices). wutils.wifi_toggle_state(dut, True) time.sleep(self.WAIT_FOR_CONFIG_CHANGES_SEC) wutils.stop_wifi_tethering(dut) if dut.model not in self.dbs_supported_models: rutils.wait_for_event(dut, rconsts.BROADCAST_WIFI_RTT_AVAILABLE) asserts.assert_true(dut.droid.wifiIsRttAvailable(), "RTT is not available") events = rutils.run_ranging(dut, rtt_supporting_aps, self.NUM_ITER, self.TIME_BETWEEN_ITERATIONS) stats = rutils.analyze_results(events, self.rtt_reference_distance_mm, self.rtt_reference_distance_margin_mm, self.rtt_min_expected_rssi_dbm, self.lci_reference, self.lcr_reference) dut.log.debug("Stats Phase 3 (post-SAP)=%s", stats) for bssid, stat in stats.items(): asserts.assert_true( stat['num_no_results'] == 0, "Phase 3 (post-SAP) missing (timed-out) results", extras=stats)
def run_aware_then_connect_to_new_ap(self): """Validate interaction of Wi-Fi Aware and infra (STA) association with randomized MAC address. Such an association may trigger interface down and up - possibly disrupting a Wi-Fi Aware session. Test behavior: - Start Aware - Associate STA - Check if an Aware state change Broadcast received - If necessary (Broadcast received) restart Aware - Start publish - Start Subscribe on peer - Verify discovery """ dut = self.android_devices[0] dut_ap = self.android_devices[1] wutils.reset_wifi(dut) wutils.reset_wifi(dut_ap) p_config = autils.create_discovery_config( self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED) s_config = autils.create_discovery_config( self.SERVICE_NAME, aconsts.SUBSCRIBE_TYPE_PASSIVE) # create random SSID and start softAp on dut_ap ap_ssid = self.TETHER_SSID + utils.rand_ascii_str(8) ap_password = utils.rand_ascii_str(8) config = { wutils.WifiEnums.SSID_KEY: ap_ssid, wutils.WifiEnums.PWD_KEY: ap_password } wutils.start_wifi_tethering(dut_ap, ap_ssid, ap_password) asserts.assert_true(dut_ap.droid.wifiIsApEnabled(), "SoftAp is not reported as running") # dut start Aware attach and connect to softAp on dut_ap p_id = dut.droid.wifiAwareAttach() autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED) wutils.wifi_connect(dut, config, check_connectivity=False) autils.wait_for_event(dut, wconsts.WIFI_STATE_CHANGED) # Check if the WifiAwareState changes then restart the Aware try: dut.ed.pop_event(aconsts.BROADCAST_WIFI_AWARE_AVAILABLE, EVENT_TIMEOUT) dut.log.info(aconsts.BROADCAST_WIFI_AWARE_AVAILABLE) p_id = dut.droid.wifiAwareAttach() autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED) except queue.Empty: dut.log.info('WifiAware state was not changed') # dut start Publish p_disc_id = dut.droid.wifiAwarePublish(p_id, p_config) autils.wait_for_event(dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED) # dut_ap stop softAp and start Subscribe wutils.stop_wifi_tethering(dut_ap) autils.wait_for_event(dut_ap, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE) s_id = dut_ap.droid.wifiAwareAttach() autils.wait_for_event(dut_ap, aconsts.EVENT_CB_ON_ATTACHED) s_disc_id = dut_ap.droid.wifiAwareSubscribe(s_id, s_config) autils.wait_for_event(dut_ap, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED) # Check discovery session autils.wait_for_event(dut_ap, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
def _test_data_usage_limit_downlink(self, dut_a, dut_b, file_link, data_usage, tethering=False): """Verify data usage limit reached. Steps: 1. Set the data usage limit to current data usage + 10MB 2. If tested for tethered device, start wifi hotspot and connect DUT to it. 3. If tested for tethered device, download 20MB data from tethered device else download on the same DUT 4. Verify file download stops and data limit reached Args: dut_a: DUT on which data usage limit needs to be verified dut_b: DUT on which data needs to be downloaded file_link: specifies if the link is IPv4 or IPv6 data_usage: specifies if MOBILE or WIFI data usage tethering: if wifi hotspot should be enabled on dut_a """ sub_id = str(dut_a.droid.telephonyGetSubscriberId()) # enable hotspot and connect dut_b to it. if tethering: ssid = "hs_%s" % utils.rand_ascii_str(AP_SSID_LENGTH_2G) pwd = utils.rand_ascii_str(AP_PASSPHRASE_LENGTH_2G) network = {wutils.WifiEnums.SSID_KEY: ssid, wutils.WifiEnums.PWD_KEY: pwd} dut_b.droid.telephonyToggleDataConnection(False) wutils.start_wifi_tethering(dut_a, network[wutils.WifiEnums.SSID_KEY], network[wutils.WifiEnums.PWD_KEY]) self.hs_enabled.append(dut_a) wutils.start_wifi_connection_scan_and_ensure_network_found( dut_b, network[wutils.WifiEnums.SSID_KEY]) wutils.wifi_connect(dut_b, network) # get pre mobile data usage total_pre = self._get_total_data_usage_for_device(dut_a, data_usage) # set data usage limit to current usage limit + 10MB self.log.info("Set data usage limit to %sMB" % (total_pre + INC_DATA)) dut_a.droid.connectivitySetDataUsageLimit( sub_id, int((total_pre + INC_DATA) * BYTE_TO_MB_ANDROID)) # download file on dut_b and look for BlockedStatusChanged callback q = queue.Queue() t = threading.Thread(target=self._listen_for_network_callback, args=(dut_a, "BlockedStatusChanged", q)) t.daemon = True t.start() status = http_file_download_by_chrome( dut_b, file_link, self.file_size, True, TIMEOUT) t.join() cb_res = q.get() # verify file download fails and expected callback is recevied asserts.assert_true(cb_res, "Failed to verify blocked status network callback") asserts.assert_true(not status, "File download successful. Expected to fail")
def _test_data_usage_downlink(self, dut_a, dut_b, file_link, data_usage, tethering=False, connect_wifi=False, app_inc=True): """Verify data usage. Steps: 1. Get the current data usage of ConnUIDTest and Android OS apps 2. DUT is on LTE data (on wifi if connect_wifi is True) 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 Args: dut_a: DUT on which data usage need to be verified dut_b: DUT on which data is downloaded file_link: Link used to download data data_usage: specifies if MOBILE or WIFI data is calculated tethering: if True, enable hotspot on dut_a and connect dut_b to it connect_wifi: if True, connect dut_a to a wifi network app_inc: if True, verify app data usage on dut_a is increased """ if connect_wifi: dut_a.droid.telephonyToggleDataConnection(False) wutils.start_wifi_connection_scan_and_ensure_network_found( dut_a, self.wifi_network["SSID"]) wutils.wifi_connect(dut_a, self.wifi_network) # sleep for some time after connecting to wifi. some apps use wifi # data when connected initially. waiting after connecting to wifi # ensures correct wifi data usage calculation time.sleep(WIFI_SLEEP) if tethering: ssid = "hs_%s" % utils.rand_ascii_str(AP_SSID_LENGTH_2G) pwd = utils.rand_ascii_str(AP_PASSPHRASE_LENGTH_2G) network = {wutils.WifiEnums.SSID_KEY: ssid, wutils.WifiEnums.PWD_KEY: pwd} dut_b.droid.telephonyToggleDataConnection(False) wutils.start_wifi_tethering(dut_a, network[wutils.WifiEnums.SSID_KEY], network[wutils.WifiEnums.PWD_KEY]) self.hs_enabled.append(dut_a) wutils.start_wifi_connection_scan_and_ensure_network_found( dut_b, network[wutils.WifiEnums.SSID_KEY]) wutils.wifi_connect(dut_b, network) # sleep for some time after connecting to wifi. though wifi hotspot # is metered, some apps would still use wifi data when connected # initially. this ensures correct wifi data usage calculation time.sleep(WIFI_SLEEP) # get pre data usage (aos_pre, app_pre, total_pre) = self._get_data_usage(dut_a, data_usage) # download file through app status = self._download_data_through_app(dut_b, file_link) asserts.assert_true(status, "Failed to download file: %s" % file_link) # get new data usage aos_exp = DATA_ERR app_exp = self.file_size + DATA_USG_ERR file_size = self.file_size if not app_inc: app_exp = DATA_ERR file_size = 0 total_exp = self.file_size + DATA_USG_ERR # somtimes data usage is not increased immediately. # re-tries until the data usage is closed to expected value. curr_time = time.time() while time.time() < curr_time + TIMEOUT: (aos_pst, app_pst, total_pst) = self._get_data_usage(dut_a, data_usage) if total_pst - total_pre >= self.file_size and \ app_pst - app_pre >= file_size: # wait for some time to verify that data doesn't increase time.sleep(RETRY_SLEEP*2) break time.sleep(RETRY_SLEEP) # wait before retry (aos_pst, app_pst, total_pst) = self._get_data_usage(dut_a, data_usage) # verify data usage aos_diff = aos_pst - aos_pre app_diff = app_pst - app_pre total_diff = total_pst - total_pre self.log.info("Usage of Android OS increased: %sMB, expected: %sMB" % \ (aos_diff, aos_exp)) self.log.info("Usage of ConnUID app increased: %sMB, expected: %sMB" % \ (app_diff, app_exp)) self.log.info("Usage on the device increased: %sMB, expected: %sMB" % \ (total_diff, total_exp)) asserts.assert_true( (aos_diff < aos_exp) and (file_size <= app_diff < app_exp) and \ (self.file_size <= total_diff < total_exp), "Incorrect data usage count")
def test_rtt_to_soft_ap(self): """Set up a Soft AP on one device and try performing an RTT ranging to it from another device. The attempt must fail - RTT on Soft AP must be disabled.""" sap = self.android_devices[0] sap.pretty_name = "SoftAP" client = self.android_devices[1] client.pretty_name = "Client" # start Soft AP wutils.start_wifi_tethering(sap, self.SOFT_AP_SSID, self.SOFT_AP_PASSWORD, band=WIFI_CONFIG_APBAND_5G, hidden=False) try: # start scanning on the client wutils.start_wifi_connection_scan_and_ensure_network_found( client, self.SOFT_AP_SSID) scans = client.droid.wifiGetScanResults() scanned_softap = None for scanned_ap in scans: if scanned_ap[wutils.WifiEnums.SSID_KEY] == self.SOFT_AP_SSID: scanned_softap = scanned_ap break asserts.assert_false(scanned_softap == None, "Soft AP not found in scan!", extras=scans) # validate that Soft AP does not advertise 802.11mc support asserts.assert_false( rconsts.SCAN_RESULT_KEY_RTT_RESPONDER in scanned_softap and scanned_softap[rconsts.SCAN_RESULT_KEY_RTT_RESPONDER], "Soft AP advertises itself as supporting 802.11mc!", extras=scanned_softap) # falsify the SoftAP's support for IEEE 802.11 so we try a 2-sided RTT scanned_softap[ rconsts.SCAN_RESULT_KEY_RTT_RESPONDER] = True # falsify # actually try ranging to the Soft AP events = rutils.run_ranging(client, [scanned_softap], self.NUM_ITER, 0) stats = rutils.analyze_results( events, self.rtt_reference_distance_mm, self.rtt_reference_distance_margin_mm, self.rtt_min_expected_rssi_dbm, self.lci_reference, self.lcr_reference) asserts.assert_equal( stats[scanned_ap[wutils.WifiEnums.BSSID_KEY]]['num_failures'], self.NUM_ITER, "Some RTT operations to Soft AP succeed!?", extras=stats) asserts.explicit_pass("SoftAP + RTT validation done", extras=events) finally: wutils.stop_wifi_tethering(sap)