acts_tests/tests/google/wifi/WifiChannelSwitchStressTest.py

#!/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)