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_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 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 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 test_discover_paramrequestlist_rev(self):
# RFC2132 #9.8: "The DHCP server is not required to return the options
# in the requested order, but MUST try to insert the requested options
# in the order requested"
asserts.skip('legacy behavior not compliant: fixed order used')
self._run_discover_paramrequestlist(
['name_server', 'router', 'broadcast_address', 'subnet_mask'],
unwanted_params=[])
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)
# 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.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 = ["AccessPoint", "dbs_supported_models", "stress_count"]
opt_param = ["iperf_server_address"]
self.unpack_userparams(req_param_names=req_params,
opt_param_names=opt_param)
if self.dut.model not in self.dbs_supported_models:
asserts.skip(("Device %s does not support dual interfaces.") %
self.dut.model)
if "iperf_server_address" in self.user_params:
self.iperf_server = self.iperf_servers[0]
if hasattr(self, 'iperf_server'):
self.iperf_server.start()
# Set the client wifi state to on before the test begins.
wutils.wifi_toggle_state(self.dut_client, True)
# Init extra devices
if len(self.android_devices) > 2:
wutils.wifi_test_device_init(self.android_devices[2])
utils.sync_device_time(self.android_devices[2])
wutils.set_wifi_country_code(self.android_devices[2],
wutils.WifiEnums.CountryCode.US)
self.android_devices[2].droid.wifiEnableVerboseLogging(1)
asserts.assert_equal(
self.android_devices[2].droid.wifiGetVerboseLoggingLevel(), 1,
"Failed to enable WiFi verbose logging on the client dut.")
def logic(self, setting, arg, special_arg=None):
asserts.assert_true(
setting in itrs,
("%s is not in acceptable settings range %s") % (setting,
itrs))
asserts.assert_true(arg == static_arg,
"Expected %s, got %s" % (static_arg, arg))
asserts.assert_true(arg == static_arg, "Expected %s, got %s" %
(static_kwarg, special_arg))
if setting == "pass":
asserts.explicit_pass(
MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)
elif setting == "fail":
asserts.fail(MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)
elif setting == "skip":
asserts.skip(MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)
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_energy_info(self):
"""Verify the WiFi energy info reporting feature.
Steps:
1. Check that the WiFi energy info reporting support on this device
is as expected (support or not).
2. If the device does not support energy info reporting as
expected, skip the test.
3. Call API to get WiFi energy info.
4. Verify the values of "ControllerEnergyUsed" and
"ControllerIdleTimeMillis" in energy info don't decrease.
5. Repeat from Step 3 for 10 times.
"""
# Check if dut supports energy info reporting.
actual_support = self.dut.droid.wifiIsEnhancedPowerReportingSupported()
model = self.dut.model
expected_support = model in self.energy_info_models
msg = "Expect energy info support to be %s on %s, got %s." % (
expected_support, model, actual_support)
asserts.assert_true(actual_support == expected_support, msg)
if not actual_support:
asserts.skip(
("Device %s does not support energy info reporting as "
"expected.") % model)
# Verify reported values don't decrease.
self.log.info(("Device %s supports energy info reporting, verify that "
"the reported values don't decrease.") % model)
energy = 0
idle_time = 0
for i in range(10):
info = self.dut.droid.wifiGetControllerActivityEnergyInfo()
self.log.debug("Iteration %d, got energy info: %s" % (i, info))
new_energy = info["ControllerEnergyUsed"]
new_idle_time = info["ControllerIdleTimeMillis"]
asserts.assert_true(
new_energy >= energy,
"Energy value decreased: previous %d, now %d" %
(energy, new_energy))
energy = new_energy
asserts.assert_true(
new_idle_time >= idle_time,
"Idle time decreased: previous %d, now %d" %
(idle_time, new_idle_time))
idle_time = new_idle_time
wutils.start_wifi_connection_scan(self.dut)
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()
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]
if testcase_params['channel'] not in self.atten_dut_chain_map.keys():
self.atten_dut_chain_map[testcase_params[
'channel']] = wputils.get_current_atten_dut_chain_map(
self.attenuators, self.dut, self.ping_server)
self.log.info("Current Attenuator-DUT Chain Map: {}".format(
self.atten_dut_chain_map[testcase_params['channel']]))
for idx, atten in enumerate(self.attenuators):
if self.atten_dut_chain_map[testcase_params['channel']][
idx] == testcase_params['attenuated_chain']:
atten.offset = atten.instrument.max_atten
else:
atten.offset = 0
def run_rvr_test(self, testcase_params):
"""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:
testcase_params: dict containing test-specific parameters
Returns:
rvr_result: dict containing rvr_results and meta data
"""
self.log.info('Start running RvR')
# Refresh link layer stats before test
llstats_obj = wputils.LinkLayerStats(self.dut)
zero_counter = 0
throughput = []
llstats = []
rssi = []
for atten in testcase_params['atten_range']:
for dev in self.android_devices:
if not wputils.health_check(dev, 5, 50):
asserts.skip('DUT health check failed. Skipping test.')
# Set Attenuation
for attenuator in self.attenuators:
attenuator.set_atten(atten, strict=False)
# Refresh link layer stats
llstats_obj.update_stats()
# Setup sniffer
if self.testbed_params['sniffer_enable']:
self.sniffer.start_capture(
network=testcase_params['test_network'],
chan=int(testcase_params['channel']),
bw=int(testcase_params['mode'][3:]),
duration=self.testclass_params['iperf_duration'] / 5)
# Start iperf session
self.iperf_server.start(tag=str(atten))
rssi_future = wputils.get_connected_rssi_nb(
self.dut, self.testclass_params['iperf_duration'] - 1, 1, 1)
client_output_path = self.iperf_client.start(
testcase_params['iperf_server_address'],
testcase_params['iperf_args'], str(atten),
self.testclass_params['iperf_duration'] + self.TEST_TIMEOUT)
server_output_path = self.iperf_server.stop()
rssi_result = rssi_future.result()
current_rssi = {
'signal_poll_rssi': rssi_result['signal_poll_rssi']['mean'],
'chain_0_rssi': rssi_result['chain_0_rssi']['mean'],
'chain_1_rssi': rssi_result['chain_1_rssi']['mean']
}
rssi.append(current_rssi)
# Stop sniffer
if self.testbed_params['sniffer_enable']:
self.sniffer.stop_capture(tag=str(atten))
# Parse and log result
if testcase_params['use_client_output']:
iperf_file = client_output_path
else:
iperf_file = server_output_path
try:
iperf_result = ipf.IPerfResult(iperf_file)
curr_throughput = numpy.mean(iperf_result.instantaneous_rates[
self.testclass_params['iperf_ignored_interval']:-1]
) * 8 * (1.024**2)
except:
self.log.warning(
'ValueError: Cannot get iperf result. Setting to 0')
curr_throughput = 0
throughput.append(curr_throughput)
llstats_obj.update_stats()
curr_llstats = llstats_obj.llstats_incremental.copy()
llstats.append(curr_llstats)
self.log.info(
('Throughput at {0:.2f} dB is {1:.2f} Mbps. '
'RSSI = {2:.2f} [{3:.2f}, {4:.2f}].').format(
atten, curr_throughput, current_rssi['signal_poll_rssi'],
current_rssi['chain_0_rssi'],
current_rssi['chain_1_rssi']))
if curr_throughput == 0 and (
current_rssi['signal_poll_rssi'] < -80
or numpy.isnan(current_rssi['signal_poll_rssi'])):
zero_counter = zero_counter + 1
else:
zero_counter = 0
if zero_counter == self.MAX_CONSECUTIVE_ZEROS:
self.log.info(
'Throughput stable at 0 Mbps. Stopping test now.')
throughput.extend(
[0] *
(len(testcase_params['atten_range']) - len(throughput)))
break
for attenuator in self.attenuators:
attenuator.set_atten(0, strict=False)
# Compile test result and meta data
rvr_result = collections.OrderedDict()
rvr_result['test_name'] = self.current_test_name
rvr_result['testcase_params'] = testcase_params.copy()
rvr_result['ap_settings'] = self.access_point.ap_settings.copy()
rvr_result['fixed_attenuation'] = self.testbed_params[
'fixed_attenuation'][str(testcase_params['channel'])]
rvr_result['attenuation'] = list(testcase_params['atten_range'])
rvr_result['total_attenuation'] = [
att + rvr_result['fixed_attenuation']
for att in rvr_result['attenuation']
]
rvr_result['rssi'] = rssi
rvr_result['throughput_receive'] = throughput
rvr_result['llstats'] = llstats
return rvr_result
def test_request_initreboot_nolease(self):
# RFC2131 #4.3.2
asserts.skip("legacy behavior not compliant")
addr = NETADDR_PREFIX + '123'
resp = self._get_response(self._make_request(self.hwaddr, addr, None))
asserts.assert_equal(resp, None)
def test_discover_paramrequestlist_unwanted(self):
asserts.skip('legacy behavior always sends all parameters')
self._run_discover_paramrequestlist(
['router', 'name_server'],
unwanted_params=['broadcast_address', 'subnet_mask'])
def test_func(self):
asserts.skip(MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)
never_call()
