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_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 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):
"""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_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)