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