309 lines
13 KiB
Python
309 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Copyright 2020 - The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import time
|
|
import random
|
|
import re
|
|
import logging
|
|
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
|
|
import acts_contrib.test_utils.tel.tel_test_utils as tel_utils
|
|
import acts.utils as utils
|
|
from acts import asserts
|
|
from acts.test_decorators import test_tracker_info
|
|
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
|
|
from acts import signals
|
|
from acts.controllers import packet_capture
|
|
from acts.controllers.ap_lib.hostapd_constants import BAND_2G
|
|
from acts.controllers.ap_lib.hostapd_constants import BAND_5G
|
|
|
|
|
|
WifiEnums = wutils.WifiEnums
|
|
|
|
|
|
class WifiChannelSwitchStressTest(WifiBaseTest):
|
|
|
|
def setup_class(self):
|
|
super().setup_class()
|
|
self.dut = self.android_devices[0]
|
|
self.dut_client = self.android_devices[1]
|
|
utils.require_sl4a((self.dut, self.dut_client))
|
|
|
|
if hasattr(self, 'packet_capture'):
|
|
self.packet_capture = self.packet_capture[0]
|
|
|
|
req_params = ["dbs_supported_models"]
|
|
opt_param = ["stress_count", "cs_count"]
|
|
self.unpack_userparams(
|
|
req_param_names=req_params, opt_param_names=opt_param)
|
|
|
|
self.AP_IFACE = 'wlan0'
|
|
if self.dut.model in self.dbs_supported_models:
|
|
self.AP_IFACE = 'wlan1'
|
|
|
|
for ad in self.android_devices:
|
|
wutils.wifi_test_device_init(ad)
|
|
utils.sync_device_time(ad)
|
|
wutils.set_wifi_country_code(ad, WifiEnums.CountryCode.US)
|
|
|
|
def setup_test(self):
|
|
super().setup_test()
|
|
for ad in self.android_devices:
|
|
ad.droid.wakeLockAcquireBright()
|
|
ad.droid.wakeUpNow()
|
|
try:
|
|
if self.dut.droid.wifiIsApEnabled():
|
|
wutils.stop_wifi_tethering(self.dut)
|
|
except signals.TestFailure:
|
|
pass
|
|
wutils.wifi_toggle_state(self.dut_client, True)
|
|
init_sim_state = tel_utils.is_sim_ready(self.log, self.dut)
|
|
if init_sim_state:
|
|
self.check_cell_data_and_enable()
|
|
self.config = wutils.create_softap_config()
|
|
self.channel_list_2g = self.generate_random_list(
|
|
WifiEnums.ALL_2G_FREQUENCIES)
|
|
self.channel_list_5g = self.generate_random_list(
|
|
WifiEnums.NONE_DFS_5G_FREQUENCIES)
|
|
|
|
def teardown_test(self):
|
|
super().teardown_test()
|
|
for ad in self.android_devices:
|
|
ad.droid.wakeLockRelease()
|
|
ad.droid.goToSleepNow()
|
|
wutils.reset_wifi(ad)
|
|
try:
|
|
wutils.stop_wifi_tethering(self.dut)
|
|
except signals.TestFailure:
|
|
pass
|
|
|
|
def on_fail(self, test_name, begin_time):
|
|
try:
|
|
wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
|
|
except signals.TestFailure:
|
|
pass
|
|
super().on_fail(test_name, begin_time)
|
|
|
|
def check_cell_data_and_enable(self):
|
|
"""Make sure that cell data is enabled if there is a sim present.
|
|
|
|
If a sim is active, cell data needs to be enabled to allow provisioning
|
|
checks through (when applicable). This is done to relax hardware
|
|
requirements on DUTs - without this check, running this set of tests
|
|
after other wifi tests may cause failures.
|
|
"""
|
|
if not self.dut.droid.telephonyIsDataEnabled():
|
|
self.dut.log.info("need to enable data")
|
|
self.dut.droid.telephonyToggleDataConnection(True)
|
|
asserts.assert_true(self.dut.droid.telephonyIsDataEnabled(),
|
|
"Failed to enable cell data for dut.")
|
|
|
|
def get_wlan0_link(self, dut):
|
|
""" get wlan0 interface status"""
|
|
get_wlan0 = 'wpa_cli -iwlan0 -g@android:wpa_wlan0 IFNAME=wlan0 status'
|
|
out = dut.adb.shell(get_wlan0)
|
|
out = dict(re.findall(r'(\S+)=(".*?"|\S+)', out))
|
|
asserts.assert_true("ssid" in out,
|
|
"Client doesn't connect to any network")
|
|
return out
|
|
|
|
def get_wlan1_status(self, dut):
|
|
""" get wlan1 interface status"""
|
|
get_wlan1 = 'hostapd_cli status'
|
|
out_wlan1 = dut.adb.shell(get_wlan1)
|
|
out_wlan1 = dict(re.findall(r'(\S+)=(".*?"|\S+)', out_wlan1))
|
|
return out_wlan1
|
|
|
|
def generate_random_list(self, lst):
|
|
"""Generate a list where
|
|
the previous and subsequent items
|
|
do not repeat"""
|
|
channel_list = []
|
|
num = random.choice(lst)
|
|
channel_list.append(num)
|
|
for i in range(1, self.stress_count):
|
|
num = random.choice(lst)
|
|
while num == channel_list[-1]:
|
|
num = random.choice(lst)
|
|
channel_list.append(num)
|
|
return channel_list
|
|
|
|
def conf_packet_capture(self, band, channel):
|
|
"""Configure packet capture on necessary channels."""
|
|
freq_to_chan = wutils.WifiEnums.freq_to_channel[int(channel)]
|
|
logging.info("Capturing packets from "
|
|
"frequency:{}, Channel:{}".format(channel, freq_to_chan))
|
|
result = self.packet_capture.configure_monitor_mode(band, freq_to_chan)
|
|
if not result:
|
|
logging.error("Failed to configure channel "
|
|
"for {} band".format(band))
|
|
self.pcap_procs = wutils.start_pcap(
|
|
self.packet_capture, band, self.test_name)
|
|
|
|
time.sleep(5)
|
|
|
|
@test_tracker_info(uuid="b1a8b00e-eca8-4eba-99e9-c7a3beb2a009")
|
|
def test_softap_channel_switch_stress_2g(self):
|
|
"""
|
|
1. Disable DUT's Wi-Fi
|
|
2. Enable CLIENT's Wi-Fi
|
|
3. Check DUT's sim is ready or not
|
|
4. Enable DUT's mobile data
|
|
5. Bring up DUT's softap in 2g
|
|
6. CLIENT connect to DUT
|
|
7. DUT switch to different 2g channel
|
|
8. Verify CLIENT follow the change
|
|
9, Repeat step 7 and 8
|
|
"""
|
|
wutils.start_wifi_tethering(self.dut,
|
|
self.config[wutils.WifiEnums.SSID_KEY],
|
|
self.config[wutils.WifiEnums.PWD_KEY],
|
|
WifiEnums.WIFI_CONFIG_APBAND_2G)
|
|
wutils.connect_to_wifi_network(self.dut_client, self.config)
|
|
time.sleep(10)
|
|
for count in range(len(self.channel_list_2g)):
|
|
self.dut.log.info("2g channel switch iteration : {}".format(count+1))
|
|
channel_2g = str(self.channel_list_2g[count])
|
|
# Configure sniffer before set SoftAP channel
|
|
if hasattr(self, 'packet_capture'):
|
|
self.conf_packet_capture(BAND_2G, channel_2g)
|
|
# Set SoftAP channel
|
|
wutils.set_softap_channel(self.dut,
|
|
self.AP_IFACE,
|
|
self.cs_count, channel_2g)
|
|
time.sleep(10)
|
|
softap_frequency = int(self.get_wlan1_status(self.dut)['freq'])
|
|
self.dut.log.info('softap frequency : {}'.format(softap_frequency))
|
|
client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"])
|
|
self.dut_client.log.info(
|
|
"client frequency : {}".format(client_frequency))
|
|
asserts.assert_true(
|
|
softap_frequency == client_frequency,
|
|
"hotspot frequency != client frequency")
|
|
if hasattr(self, 'packet_capture'):
|
|
wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
|
|
|
|
@test_tracker_info(uuid="3411cb7c-2609-433a-97b6-202a096dc71b")
|
|
def test_softap_channel_switch_stress_5g(self):
|
|
"""
|
|
1. Disable DUT's Wi-Fi
|
|
2. Enable CLIENT's Wi-Fi
|
|
3. Check DUT's sim is ready or not
|
|
4. Enable DUT's mobile data
|
|
5. Bring up DUT's softap in 5g
|
|
6. CLIENT connect to DUT
|
|
7. DUT switch to different 5g channel
|
|
8. Verify CLIENT follow the change
|
|
9, Repeat step 7 and 8
|
|
"""
|
|
wutils.start_wifi_tethering(self.dut,
|
|
self.config[wutils.WifiEnums.SSID_KEY],
|
|
self.config[wutils.WifiEnums.PWD_KEY],
|
|
WifiEnums.WIFI_CONFIG_APBAND_5G)
|
|
wutils.connect_to_wifi_network(self.dut_client, self.config)
|
|
time.sleep(10)
|
|
for count in range(len(self.channel_list_5g)):
|
|
self.dut.log.info("5g channel switch iteration : {}".format(count+1))
|
|
channel_5g = str(self.channel_list_5g[count])
|
|
# Configure sniffer before set SoftAP channel
|
|
if hasattr(self, 'packet_capture'):
|
|
self.conf_packet_capture(BAND_5G, channel_5g)
|
|
# Set SoftAP channel
|
|
wutils.set_softap_channel(self.dut,
|
|
self.AP_IFACE,
|
|
self.cs_count, channel_5g)
|
|
time.sleep(10)
|
|
softap_frequency = int(self.get_wlan1_status(self.dut)['freq'])
|
|
self.dut.log.info('softap frequency : {}'.format(softap_frequency))
|
|
client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"])
|
|
self.dut_client.log.info(
|
|
"client frequency : {}".format(client_frequency))
|
|
asserts.assert_true(
|
|
softap_frequency == client_frequency,
|
|
"hotspot frequency != client frequency")
|
|
if hasattr(self, 'packet_capture'):
|
|
wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
|
|
|
|
@test_tracker_info(uuid="0f279058-119f-49fc-b8d6-fb2991cc35aa")
|
|
def test_softap_channel_switch_stress_2g_5g(self):
|
|
"""
|
|
1. Disable DUT's Wi-Fi
|
|
2. Enable CLIENT's Wi-Fi
|
|
3. Check DUT's sim is ready or not
|
|
4. Enable DUT's mobile data
|
|
5. Bring up DUT's softap in 2g
|
|
6. CLIENT connect to DUT
|
|
7. DUT switch to different 2g channel
|
|
8. Verify CLIENT follow the change
|
|
9. DUT switch to 5g channel
|
|
10. Verify CLIENT follow the change
|
|
11. Repeat step 7 to 10
|
|
"""
|
|
for count in range(self.stress_count):
|
|
self.log.info("2g 5g channel switch iteration : {}".format(count+1))
|
|
wutils.start_wifi_tethering(self.dut,
|
|
self.config[wutils.WifiEnums.SSID_KEY],
|
|
self.config[wutils.WifiEnums.PWD_KEY],
|
|
WifiEnums.WIFI_CONFIG_APBAND_2G)
|
|
wutils.connect_to_wifi_network(self.dut_client, self.config)
|
|
self.log.info("wait 10 secs for client reconnect to dut")
|
|
time.sleep(10)
|
|
channel_2g = self.channel_list_2g[count]
|
|
if hasattr(self, 'packet_capture'):
|
|
self.conf_packet_capture(BAND_2G, channel_2g)
|
|
wutils.set_softap_channel(self.dut,
|
|
self.AP_IFACE,
|
|
self.cs_count, channel_2g)
|
|
time.sleep(10)
|
|
softap_frequency = int(self.get_wlan1_status(self.dut)['freq'])
|
|
self.dut.log.info('softap frequency : {}'.format(softap_frequency))
|
|
client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"])
|
|
self.dut_client.log.info(
|
|
"client frequency : {}".format(client_frequency))
|
|
asserts.assert_true(
|
|
softap_frequency == client_frequency,
|
|
"hotspot frequency != client frequency")
|
|
wutils.stop_wifi_tethering(self.dut)
|
|
if hasattr(self, 'packet_capture'):
|
|
wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
|
|
self.dut.log.info('switch to SoftAP 5g')
|
|
|
|
# switch to SoftAp 5g
|
|
wutils.start_wifi_tethering(self.dut,
|
|
self.config[wutils.WifiEnums.SSID_KEY],
|
|
self.config[wutils.WifiEnums.PWD_KEY],
|
|
WifiEnums.WIFI_CONFIG_APBAND_5G)
|
|
wutils.connect_to_wifi_network(self.dut_client, self.config)
|
|
self.log.info("wait 10 secs for client reconnect to dut")
|
|
time.sleep(10)
|
|
channel_5g = self.channel_list_5g[count]
|
|
if hasattr(self, 'packet_capture'):
|
|
self.conf_packet_capture(BAND_5G, channel_5g)
|
|
wutils.set_softap_channel(self.dut,
|
|
self.AP_IFACE,
|
|
self.cs_count, channel_5g)
|
|
time.sleep(10)
|
|
softap_frequency = int(self.get_wlan1_status(self.dut)['freq'])
|
|
self.dut.log.info('softap frequency : {}'.format(softap_frequency))
|
|
client_frequency = int(self.get_wlan0_link(self.dut_client)["freq"])
|
|
self.dut_client.log.info(
|
|
"client frequency : {}".format(client_frequency))
|
|
asserts.assert_true(
|
|
softap_frequency == client_frequency,
|
|
"hotspot frequency != client frequency")
|
|
wutils.stop_wifi_tethering(self.dut)
|
|
if hasattr(self, 'packet_capture'):
|
|
wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
|