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
