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_class(self): super().setup_class() self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] wutils.wifi_test_device_init(self.dut) wutils.wifi_test_device_init(self.dut_client) utils.require_sl4a((self.dut, self.dut_client)) utils.sync_device_time(self.dut) utils.sync_device_time(self.dut_client) # 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) # Enable verbose logging on the duts self.dut.droid.wifiEnableVerboseLogging(1) asserts.assert_equal( self.dut.droid.wifiGetVerboseLoggingLevel(), 1, "Failed to enable WiFi verbose logging on the softap dut.") self.dut_client.droid.wifiEnableVerboseLogging(1) asserts.assert_equal( self.dut_client.droid.wifiGetVerboseLoggingLevel(), 1, "Failed to enable WiFi verbose logging on the client dut.") req_params = [] opt_param = [ "iperf_server_address", "reference_networks", "iperf_server_port" ] self.unpack_userparams(req_param_names=req_params, opt_param_names=opt_param) self.chan_map = { v: k for k, v in hostapd_constants.CHANNEL_MAP.items() } self.pcap_procs = None
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 setup_class(self): self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] wutils.wifi_test_device_init(self.dut) wutils.wifi_test_device_init(self.dut_client) utils.require_sl4a((self.dut, self.dut_client)) utils.sync_device_time(self.dut) utils.sync_device_time(self.dut_client) # Set country code explicitly to "US". self.dut.droid.wifiSetCountryCode(wutils.WifiEnums.CountryCode.US) self.dut_client.droid.wifiSetCountryCode(wutils.WifiEnums.CountryCode.US) # Enable verbose logging on the duts self.dut.droid.wifiEnableVerboseLogging(1) asserts.assert_equal(self.dut.droid.wifiGetVerboseLoggingLevel(), 1, "Failed to enable WiFi verbose logging on the softap dut.") self.dut_client.droid.wifiEnableVerboseLogging(1) asserts.assert_equal(self.dut_client.droid.wifiGetVerboseLoggingLevel(), 1, "Failed to enable WiFi verbose logging on the client dut.") req_params = [] opt_param = ["iperf_server_address", "reference_networks"] self.unpack_userparams( req_param_names=req_params, opt_param_names=opt_param) if "iperf_server_address" in self.user_params: self.iperf_server = self.iperf_servers[0] if hasattr(self, 'iperf_server'): self.iperf_server.start()
def setup_class(self): self.dut = self.android_devices[0] self.dut_softap = self.android_devices[1] wutils.wifi_test_device_init(self.dut) wutils.wifi_test_device_init(self.dut_softap) self.reset_mac_address_to_factory_mac() self.dut.adb.shell(TURN_ON_MAC_RANDOMIZATION) asserts.assert_equal( self.dut.adb.shell(GET_MAC_RANDOMIZATION_STATUS), "1", "Failed to enable Connected MAC Randomization on dut.") req_params = ["reference_networks"] opt_param = [] 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( self.reference_networks[0]["2g"], "Need at least 1 2.4Ghz reference network with psk.") asserts.assert_true( self.reference_networks[0]["5g"], "Need at least 1 5Ghz reference network with psk.") self.wpapsk_2g = self.reference_networks[0]["2g"] self.wpapsk_5g = self.reference_networks[0]["5g"]
def setup_class(self): super().setup_class() self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] # Do a simple version of init - mainly just sync the time and enable # verbose logging. This test will fail if the DUT has a sim and cell # data is disabled. We would also like to test with phones in less # constrained states (or add variations where we specifically # constrain). utils.require_sl4a(self.android_devices) for ad in self.android_devices: wutils.wifi_test_device_init(ad) utils.sync_device_time(ad) # Set country code explicitly to "US". wutils.set_wifi_country_code(ad, WifiEnums.CountryCode.US) # Enable verbose logging on the duts. ad.droid.wifiEnableVerboseLogging(1) req_params = [ "dbs_supported_models", "iperf_server_address", "iperf_server_port" ] self.unpack_userparams(req_param_names=req_params, ) asserts.abort_class_if( self.dut.model not in self.dbs_supported_models, "Device %s does not support dual interfaces." % self.dut.model)
def setup_class(self): super().setup_class() self.dut = self.android_devices[0] # Note that test_stress_softAP_startup_and_stop_5g will always fail # when testing with a single device. if len(self.android_devices) > 1: self.dut_client = self.android_devices[1] else: self.dut_client = None wutils.wifi_test_device_init(self.dut) req_params = [] opt_param = [ "open_network", "reference_networks", "iperf_server_address", "stress_count", "stress_hours", "attn_vals", "pno_interval", "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(ap_count=2) asserts.assert_true( len(self.reference_networks) > 0, "Need at least one reference network with psk.") self.wpa_2g = self.reference_networks[0]["2g"] self.wpa_5g = self.reference_networks[0]["5g"] self.open_2g = self.open_network[0]["2g"] self.open_5g = self.open_network[0]["5g"] self.networks = [self.wpa_2g, self.wpa_5g, self.open_2g, self.open_5g]
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 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): self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] wutils.wifi_test_device_init(self.dut) req_params = [] opt_param = [ "open_network", "reference_networks", "iperf_server_address", "stress_count", "stress_hours" ] 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) > 0, "Need at least one reference network with psk.") self.wpa_2g = self.reference_networks[0]["2g"] self.wpa_5g = self.reference_networks[0]["5g"] self.open_2g = self.open_network[0]["2g"] self.open_5g = self.open_network[0]["5g"] self.networks = [self.wpa_2g, self.wpa_5g, self.open_2g, self.open_5g] if "iperf_server_address" in self.user_params: self.iperf_server = self.iperf_servers[0] if hasattr(self, 'iperf_server'): self.iperf_server.start()
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): # 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) self.leeway = 5 # seconds, for event wait time computation self.stime_channel = 47 #dwell time plus 2ms self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) asserts.assert_true( self.dut.droid.wifiIsScannerSupported(), "Device %s doesn't support WifiScanner, abort." % self.dut.model) """ Setup the required dependencies and fetch the user params from config file. """ req_params = ["max_bugreports"] 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() self.wifi_chs = WifiChannelUS(self.dut.model)
def setup_class(self): self.hz = 10 self.offset = 5 * 60 self.duration = 30 * 60 + self.offset self.scan_interval = 15 # Continuosly download self.download_interval = 0 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.dut = self.android_devices[0] self.mon.attach_device(self.dut) asserts.assert_true(self.mon.usb("auto"), "Failed to turn USB mode to auto on monsoon.") required_userparam_names = ( # These two params should follow the format of # {"SSID": <SSID>, "password": <Password>} "network_2g", "network_5g") self.unpack_userparams(required_userparam_names, threshold=None) wutils.wifi_test_device_init(self.dut) # Start pmc app. self.dut.adb.shell(start_pmc_cmd) self.dut.adb.shell("setprop log.tag.PMC VERBOSE")
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 setup_class(self): self.tag = 0 self.iperf_result = {} self.thread_list = [] self.log_files = [] 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"] self.unpack_userparams(req_params, opt_params) if hasattr(self, "RelayDevice"): self.audio_receiver = self.relay_devices[0] self.audio_receiver.power_on() else: self.log.warning("Missing Relay config file.") self.path = self.pri_ad.log_path if hasattr(self, "AccessPoint"): self.ap = self.access_points[0] configure_and_start_ap(self.ap, self.network) elif hasattr(self, "RetailAccessPoints"): self.access_points = retail_ap.create(self.RetailAccessPoints) self.access_point = self.access_points[0] band = self.access_point.band_lookup_by_channel( self.network["channel"]) self.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)
def setup_class(self): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) req_params = ("run_extended_test", "ping_addr", "max_bugreports") 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() self.leeway = 10 self.stime_channel = SCAN_TIME_PASSIVE self.default_scan_setting = { "band": wutils.WifiEnums.WIFI_BAND_BOTH, "periodInMs": SCANTIME, "reportEvents": wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN } self.default_batch_scan_setting = { "band": wutils.WifiEnums.WIFI_BAND_BOTH, "periodInMs": SCANTIME, "reportEvents": wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL } self.log.debug("Run extended test: {}".format(self.run_extended_test)) self.wifi_chs = wutils.WifiChannelUS(self.dut.model) asserts.assert_true( self.dut.droid.wifiIsScannerSupported(), "Device %s doesn't support WifiScanner, abort." % self.dut.model) self.attenuators = wutils.group_attenuators(self.attenuators) self.attenuators[0].set_atten(0) self.attenuators[1].set_atten(0)
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 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 set_attenuation_and_run_iperf(self, called_func=None): """Sets attenuation and runs iperf for Attenuation max value. Args: called_func : Function object to run. Returns: True if Pass False if Fail """ self.attenuators[self.num_atten - 1].set_atten(0) self.rvr["bt_attenuation"] = [] self.rvr["test_name"] = self.current_test_name self.rvr["bt_gap_analysis"] = {} self.rvr["bt_range"] = [] status_flag = True for bt_atten in self.bt_atten_range: self.rvr[bt_atten] = {} self.rvr[bt_atten]["fixed_attenuation"] = ( self.test_params["fixed_attenuation"][str( self.network["channel"])]) self.log.info('Setting bt attenuation to: {} dB'.format(bt_atten)) self.attenuators[self.num_atten - 1].set_atten(bt_atten) for i in range(self.num_atten - 1): self.attenuators[i].set_atten(0) if not wifi_connection_check(self.pri_ad, self.network["SSID"]): wifi_test_device_init(self.pri_ad) wifi_connect(self.pri_ad, self.network, num_of_tries=5) adb_rssi_results = self.pri_ad.search_logcat(RSSI_RESULTS) if adb_rssi_results: self.log.debug(adb_rssi_results[-1]) self.log.info('Android device: {}'.format( (adb_rssi_results[-1]['log_message']).split(',')[5])) (self.rvr[bt_atten]["throughput_received"], self.rvr[bt_atten]["a2dp_packet_drop"], status_flag) = self.rvr_throughput(bt_atten, called_func) self.wifi_max_atten_metric.metric_value = max( self.rvr[bt_atten]["attenuation"]) self.wifi_min_atten_metric.metric_value = min( self.rvr[bt_atten]["attenuation"]) if self.rvr[bt_atten]["throughput_received"]: for i, atten in enumerate(self.rvr[bt_atten]["attenuation"]): if self.rvr[bt_atten]["throughput_received"][i] < 1.0: self.wifi_range_metric.metric_value = ( self.rvr[bt_atten]["attenuation"][i - 1]) break else: self.wifi_range_metric.metric_value = max( self.rvr[bt_atten]["attenuation"]) else: self.wifi_range_metric.metric_value = max( self.rvr[bt_atten]["attenuation"]) if self.a2dp_streaming: if not any(x > 0 for x in self.a2dp_dropped_list): self.rvr[bt_atten]["a2dp_packet_drop"] = [] if not self.rvr["bt_range"]: self.rvr["bt_range"].append(0) return status_flag
def setup_class(self): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) required_params = ("support_models", "stress_num", "vht80_5g", "actual_distance") self.unpack_userparams(required_params) asserts.assert_true( self.actual_distance >= 5, "Actual distance should be no shorter than 5 meters.") self.visible_networks = (self.vht80_5g, ) self.default_rtt_params = { RttParam.request_type: RttType.TYPE_TWO_SIDED, RttParam.device_type: RttPeerType.PEER_TYPE_AP, RttParam.preamble: RttPreamble.PREAMBLE_HT, RttParam.bandwidth: RttBW.BW_80_SUPPORT } # Expected capability for devices that don't support RTT. rtt_cap_neg = { 'lcrSupported': False, 'bwSupported': 0, 'twoSided11McRttSupported': False, 'preambleSupported': 0, 'oneSidedRttSupported': False, 'lciSupported': False } rtt_cap_shamu = { 'lcrSupported': False, 'bwSupported': 0x1C, 'twoSided11McRttSupported': True, 'preambleSupported': 6, 'oneSidedRttSupported': False, 'lciSupported': False } rtt_cap_bullhead = { 'lcrSupported': True, 'bwSupported': 0x1C, 'twoSided11McRttSupported': True, 'preambleSupported': 7, 'oneSidedRttSupported': True, 'lciSupported': True } rtt_cap_angler = { 'lcrSupported': True, 'bwSupported': 0x1C, 'twoSided11McRttSupported': True, 'preambleSupported': 6, 'oneSidedRttSupported': False, 'lciSupported': True } self.rtt_cap_table = { "hammerhead": rtt_cap_neg, "shamu": rtt_cap_shamu, "volantis": rtt_cap_neg, "volantisg": rtt_cap_neg, "bullhead": rtt_cap_bullhead, "angler": rtt_cap_angler }
def setup_class(self): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) req_params = ("attn_vals", "pno_network_a", "pno_network_b", "pno_interval") self.unpack_userparams(req_params) self.attenuators = wutils.group_attenuators(self.attenuators) self.attn_a = self.attenuators[0] self.attn_b = self.attenuators[1] self.set_attns("default")
def setup_class(self): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) req_params = [] 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)
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('__')] self.unpack_userparams(required_params) wifi_test_utils.wifi_test_device_init(self.dut) wifi_test_utils.wifi_connect(self.dut, self.wifi_network) time.sleep(3)
def setup_class(self): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) req_params = ("passpoint_networks", ) self.unpack_userparams(req_params) asserts.assert_true( len(self.passpoint_networks) > 0, "Need at least one Passpoint network.") wutils.wifi_toggle_state(self.dut, True) self.unknown_fqdn = UNKNOWN_FQDN
def setup_class(self): """It will setup the required dependencies from config file and configure the required networks for auto-join testing. Configured networks will not be removed. If networks are already configured it will skip configuring the networks 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 = ("atten_val", "ping_addr", "max_bugreports") 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(ap_count=2) configured_networks = self.dut.droid.wifiGetConfiguredNetworks() self.log.debug("Configured networks :: {}".format(configured_networks)) count_confnet = 0 result = False if self.reference_networks[0]['2g']['SSID'] == self.reference_networks[ 0]['5g']['SSID']: self.ref_ssid_count = 1 else: self.ref_ssid_count = 2 # Different SSID for 2g and 5g for confnet in configured_networks: if confnet[WifiEnums. SSID_KEY] == self.reference_networks[0]['2g']['SSID']: count_confnet += 1 elif confnet[WifiEnums. SSID_KEY] == self.reference_networks[0]['5g']['SSID']: count_confnet += 1 self.log.info("count_confnet {}".format(count_confnet)) if count_confnet == self.ref_ssid_count: return else: self.log.info("Configured networks for testing") self.attenuators[0].set_atten(0) self.attenuators[1].set_atten(0) self.attenuators[2].set_atten(90) self.attenuators[3].set_atten(90) wait_time = 15 self.dut.droid.wakeLockAcquireBright() self.dut.droid.wakeUpNow() # Add and enable all networks. for network in self.reference_networks: self.add_network_and_enable(network['2g']) self.add_network_and_enable(network['5g']) self.dut.droid.wifiLockRelease() self.dut.droid.goToSleepNow()
def init_test_network_state(self): """Create a clean slate for tests with respect to remembered networks. @return True iff operation succeeded, False otherwise. """ try: utils.wifi_test_device_init(self.ad) except AssertionError as e: logging.error(str(e)) return False return True
def setup_class(self): self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) asserts.assert_true(self.dut.droid.wifiIsScannerSupported(), "Device %s doesn't support WifiScanner, abort." % self.dut.model) """ Setup the required dependencies and fetch the user params from config file. """ req_params = ("bssid_2g", "bssid_5g", "bssid_dfs", "max_bugreports") self.wifi_chs = WifiChannelUS(self.dut.model) self.unpack_userparams(req_params)
def setup_class(self): self.dut = self.android_devices[0] self.admin = 'admin' + str(random.randint(1000001, 12345678)) wutils.wifi_test_device_init(self.dut) # Set country code explicitly to "US". wutils.set_wifi_country_code(self.dut, wutils.WifiEnums.CountryCode.US) asserts.assert_true( self.lock_pcap(), "Could not lock a Packet Capture. Aborting Interop test.") wutils.wifi_toggle_state(self.dut, True)
def setup_class(self): """ Setup devices for tests and unpack params """ self.dut = self.android_devices[0] req_params = ("proxy_pac", "proxy_server", "proxy_port", "bypass_host", "non_bypass_host", "wifi_network") self.unpack_userparams(req_param_names=req_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) self.tcpdump_pid = None self.proxy_port = int(self.proxy_port)
def init_test_network_state(self): """Create a clean slate for tests with respect to remembered networks. @return True iff operation succeeded, False otherwise. """ self.test_begin_time = logger.get_log_line_timestamp() try: wutils.wifi_test_device_init(self.ad) self.ad.ed.clear_all_events() except AssertionError as e: logging.error(e) return False return True